psockbun.h

Go to the documentation of this file.

/*
 * psockbun.h
 *
 * Socket and interface bundle code
 *
 * Portable Windows Library
 *
 * Copyright (C) 2007 Post Increment
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Post Increment
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 21695 $
 * $Author: rjongbloed $
 * $Date: 2008-12-04 02:01:41 +0000 (Thu, 04 Dec 2008) $
 */

#ifndef _PSOCKBUN_H
#define _PSOCKBUN_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif


#include <ptlib.h>
#include <ptlib/ipsock.h>
#include <ptlib/sockets.h>
#include <ptlib/safecoll.h>
#include <list>


class PNatMethod;
class PInterfaceMonitorClient;
class PInterfaceFilter;


#define PINTERFACE_MONITOR_FACTORY_NAME "InterfaceMonitor"



class PInterfaceMonitor : public PProcessStartup
{
  PCLASSINFO(PInterfaceMonitor, PProcessStartup);
  public: 
    enum {
      DefaultRefreshInterval = 60000
    };

    PInterfaceMonitor(
      unsigned refreshInterval = DefaultRefreshInterval,
      bool runMonitorThread = true
    );
    virtual ~PInterfaceMonitor();

    static PInterfaceMonitor & GetInstance();
    
    void SetRefreshInterval (unsigned refresh);
    
    void SetRunMonitorThread (bool runMonitorThread);

    void Start();

    void Stop();

    typedef PIPSocket::InterfaceEntry InterfaceEntry;

    PStringArray GetInterfaces(
      bool includeLoopBack = false,  
      const PIPSocket::Address & destination = PIPSocket::GetDefaultIpAny()
    );

    bool IsValidBindingForDestination(
      const PIPSocket::Address & binding,
      const PIPSocket::Address & destination
    );

    bool GetInterfaceInfo(
      const PString & iface,  
      InterfaceEntry & info   
    );
    
    static bool IsMatchingInterface(
      const PString & iface,        
      const InterfaceEntry & entry  
    );
    
    void SetInterfaceFilter(PInterfaceFilter * filter);
    bool HasInterfaceFilter() const { return m_interfaceFilter != NULL; }
    
    virtual void RefreshInterfaceList();
    
    void OnRemoveNatMethod(const PNatMethod * natMethod);

  protected:
    virtual void OnShutdown();

    void UpdateThreadMain();

    void AddClient(PInterfaceMonitorClient *);
    void RemoveClient(PInterfaceMonitorClient *);
    
    virtual void OnInterfacesChanged(const PIPSocket::InterfaceTable & addedInterfaces, const PIPSocket::InterfaceTable & removedInterfaces);

    typedef PSmartPtr<PInterfaceMonitorClient> ClientPtr;

    typedef std::list<PInterfaceMonitorClient *> ClientList_T;
    ClientList_T m_clients;
    PMutex       m_clientsMutex;

    PIPSocket::InterfaceTable m_interfaces;
    PMutex                    m_interfacesMutex;

    bool           m_runMonitorThread;
    PTimeInterval  m_refreshInterval;
    PMutex         m_threadMutex;
    PThread      * m_updateThread;
    PSyncPoint     m_signalUpdate;
    bool           m_threadRunning;
    
    PInterfaceFilter * m_interfaceFilter;

  friend class PInterfaceMonitorClient;
};



class PInterfaceMonitorClient : public PSafeObject
{
  PCLASSINFO(PInterfaceMonitorClient, PSafeObject);
  public:
    enum {
      DefaultPriority = 50,
    };
    PInterfaceMonitorClient(PINDEX priority = DefaultPriority);
    ~PInterfaceMonitorClient();

    typedef PIPSocket::InterfaceEntry InterfaceEntry;

    virtual PStringArray GetInterfaces(
      bool includeLoopBack = false,  
      const PIPSocket::Address & destination = PIPSocket::GetDefaultIpAny() 
    );

    virtual PBoolean GetInterfaceInfo(
      const PString & iface,  
      InterfaceEntry & info   
    );
    
    PINDEX GetPriority() const { return priority; }

  protected:
    virtual void OnAddInterface(const InterfaceEntry & entry) = 0;

    virtual void OnRemoveInterface(const InterfaceEntry & entry) = 0;
    
    virtual void OnRemoveNatMethod(const PNatMethod * /*natMethod*/) { }
    
    PINDEX priority;

  friend class PInterfaceMonitor;
};



class PInterfaceFilter : public PObject {
  PCLASSINFO(PInterfaceFilter, PObject);
  
  public:
    virtual PIPSocket::InterfaceTable FilterInterfaces(const PIPSocket::Address & destination,
                                                       PIPSocket::InterfaceTable & interfaces) const = 0;
};



class PMonitoredSockets : public PInterfaceMonitorClient
{
  PCLASSINFO(PMonitoredSockets, PInterfaceMonitorClient);
  protected:
    PMonitoredSockets(
      bool reuseAddr,
      PNatMethod * natMethod
    );

  public:
    virtual PBoolean Open(
      WORD port
    ) = 0;

    PBoolean IsOpen() const { return opened; }

    virtual PBoolean Close() = 0;

    WORD GetPort() const { return localPort; }

    virtual PBoolean GetAddress(
      const PString & iface,        
      PIPSocket::Address & address, 
      WORD & port,                  
      PBoolean usingNAT                 
    ) const = 0;

    virtual PChannel::Errors WriteToBundle(
      const void * buffer,              
      PINDEX length,                    
      const PIPSocket::Address & addr,  
      WORD port,                        
      const PString & iface,            
      PINDEX & lastWriteCount
    ) = 0;

    virtual PChannel::Errors ReadFromBundle(
      void * buffer,                
      PINDEX length,                
      PIPSocket::Address & addr,    
      WORD & port,                  
      PString & iface,              
      PINDEX & lastReadCount,       
      const PTimeInterval & timeout 
    ) = 0;

    void SetNatMethod(
      PNatMethod * method
    ) { natMethod = method; }


    // Get the current NAT method, eg STUN client pointer
    PNatMethod * GetNatMethod() const { return natMethod; }

    static PMonitoredSockets * Create(
      const PString & iface,            
      bool reuseAddr = false,           
      PNatMethod * natMethod = NULL     
    );

  protected:
    virtual void OnRemoveNatMethod(
      const PNatMethod * natMethod
    );

    struct SocketInfo {
      SocketInfo()
        : socket(NULL)
        , inUse(false)
      { }
      PUDPSocket * socket;
      bool         inUse;
    };

    bool CreateSocket(
      SocketInfo & info,
      const PIPSocket::Address & binding
    );
    bool DestroySocket(SocketInfo & info);
    bool GetSocketAddress(
      const SocketInfo & info,
      PIPSocket::Address & address,
      WORD & port,
      bool usingNAT
    ) const;

    PChannel::Errors WriteToSocket(
      const void * buf,
      PINDEX len,
      const PIPSocket::Address & addr,
      WORD port,
      const SocketInfo & info,
      PINDEX & lastWriteCount
    );
    PChannel::Errors ReadFromSocket(
      SocketInfo & info,
      void * buf,
      PINDEX len,
      PIPSocket::Address & addr,
      WORD & port,
      PINDEX & lastReadCount,
      const PTimeInterval & timeout
    );
    PChannel::Errors ReadFromSocket(
      PSocket::SelectList & readers,
      PUDPSocket * & socket,
      void * buf,
      PINDEX len,
      PIPSocket::Address & addr,
      WORD & port,
      PINDEX & lastReadCount,
      const PTimeInterval & timeout
    );

    WORD          localPort;
    bool          reuseAddress;
    PNatMethod  * natMethod;

    bool          opened;
    PUDPSocket    interfaceAddedSignal;
};

typedef PSafePtr<PMonitoredSockets> PMonitoredSocketsPtr;



class PMonitoredSocketChannel : public PChannel
{
  PCLASSINFO(PMonitoredSocketChannel, PChannel);
  public:

    PMonitoredSocketChannel(
      const PMonitoredSocketsPtr & sockets,  
      bool shared                            
    );

    virtual PBoolean IsOpen() const;
    virtual PBoolean Close();

    virtual PBoolean Read(
      void * buffer,
      PINDEX length
    );

    virtual PBoolean Write(
      const void * buffer,
      PINDEX length
    );

    void SetInterface(
      const PString & iface   
    );

    PString GetInterface();

    bool GetLocal(
      PIPSocket::Address & address, 
      WORD & port,                  
      bool usingNAT                 
    );

    void SetRemote(
      const PIPSocket::Address & address, 
      WORD port                           
    );

    void SetRemote(
      const PString & hostAndPort 
    );

    void GetRemote(
      PIPSocket::Address & addr,  
      WORD & port                 
    ) const { addr = remoteAddress; port = remotePort; }

    void SetPromiscuous(
      bool flag   
    ) { promiscuousReads = flag; }

    bool GetPromiscuous() { return promiscuousReads; }

    void GetLastReceived(
      PIPSocket::Address & addr,  
      WORD & port                 
    ) const { addr = lastReceivedAddress; port = lastReceivedPort; }

    PString GetLastReceivedInterface() const { return lastReceivedInterface; }

    const PMonitoredSocketsPtr & GetMonitoredSockets() const { return socketBundle; }

  protected:
    PMonitoredSocketsPtr socketBundle;
    bool                 sharedBundle;
    PString              currentInterface;
    bool                 promiscuousReads;
    PIPSocket::Address   remoteAddress;
    bool                 closing;
    WORD                 remotePort;
    PIPSocket::Address   lastReceivedAddress;
    WORD                 lastReceivedPort;
    PString              lastReceivedInterface;
    PMutex               mutex;
};



class PMonitoredSocketBundle : public PMonitoredSockets
{
  PCLASSINFO(PMonitoredSocketBundle, PMonitoredSockets);
  public:
    PMonitoredSocketBundle(
      bool reuseAddr = false,
      PNatMethod  * natMethod = NULL
    );
    ~PMonitoredSocketBundle();

    virtual PBoolean Open(
      WORD port
    );

    virtual PBoolean Close();

    virtual PBoolean GetAddress(
      const PString & iface,        
      PIPSocket::Address & address, 
      WORD & port,                  
      PBoolean usingNAT                 
    ) const;

    virtual PChannel::Errors WriteToBundle(
      const void * buf,
      PINDEX len,
      const PIPSocket::Address & addr,
      WORD port,
      const PString & iface,
      PINDEX & lastWriteCount
    );

    virtual PChannel::Errors ReadFromBundle(
      void * buf,
      PINDEX len,
      PIPSocket::Address & addr,
      WORD & port,
      PString & iface,
      PINDEX & lastReadCount,
      const PTimeInterval & timeout
    );

  protected:
    virtual void OnAddInterface(const InterfaceEntry & entry);

    virtual void OnRemoveInterface(const InterfaceEntry & entry);

    typedef std::map<std::string, SocketInfo> SocketInfoMap_T;

    void OpenSocket(const PString & iface);
    void CloseSocket(SocketInfoMap_T::iterator iterSocket);

    SocketInfoMap_T socketInfoMap;
};



class PSingleMonitoredSocket : public PMonitoredSockets
{
  PCLASSINFO(PSingleMonitoredSocket, PMonitoredSockets);
  public:
    PSingleMonitoredSocket(
      const PString & theInterface,
      bool reuseAddr = false,
      PNatMethod  * natMethod = NULL
    );
    ~PSingleMonitoredSocket();

    virtual PStringArray GetInterfaces(
      PBoolean includeLoopBack = false,  
      const PIPSocket::Address & destination = PIPSocket::GetDefaultIpAny()
    );

    virtual PBoolean Open(
      WORD port
    );

    virtual PBoolean Close();

    virtual PBoolean GetAddress(
      const PString & iface,        
      PIPSocket::Address & address, 
      WORD & port,                  
      PBoolean usingNAT                 
    ) const;

    virtual PChannel::Errors WriteToBundle(
      const void * buf,
      PINDEX len,
      const PIPSocket::Address & addr,
      WORD port,
      const PString & iface,
      PINDEX & lastWriteCount
    );

    virtual PChannel::Errors ReadFromBundle(
      void * buf,
      PINDEX len,
      PIPSocket::Address & addr,
      WORD & port,
      PString & iface,
      PINDEX & lastReadCount,
      const PTimeInterval & timeout
    );


  protected:
    virtual void OnAddInterface(const InterfaceEntry & entry);

    virtual void OnRemoveInterface(const InterfaceEntry & entry);

    bool IsInterface(const PString & iface) const;

    PString        theInterface;
    InterfaceEntry theEntry;
    SocketInfo     theInfo;
};

#endif

---