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): ______________________________________.
 *
 * $Log: psockbun.h,v $
 * Revision 1.14  2007/10/12 03:52:15  rjongbloed
 * Fixed broken virtual by someone changing base class function signature,
 *   and the override is silently not called. pet hate #1 about C++!
 *
 * Revision 1.13  2007/10/07 07:35:30  rjongbloed
 * Changed bundled sockets so does not return error if interface goes away it just
 *   blocks reads till the interface comes back, or is explicitly closed.
 * Also return error codes, rather than just a BOOL.
 *
 * Revision 1.12  2007/09/28 09:59:16  hfriederich
 * Allow to use PInterfaceMonitor without running monitor thread
 *
 * Revision 1.11  2007/09/25 14:27:51  hfriederich
 * Don't use STUN if interface filter is in use and STUN server is not
 * reachable through local binding. This avoids unnecessary timeouts.
 *
 * Revision 1.10  2007/09/22 04:32:03  rjongbloed
 * Fixed lock up on exit whena  gatekeeper is used.
 * Also fixed fatal "read error" (ECONNRESET) when send packet to a machine which
 *   is not listening on the specified port. No error is lgged but does not stop listener.
 *
 * Revision 1.9  2007/08/26 20:01:58  hfriederich
 * Allow to filter interfaces based on remote address
 *
 * Revision 1.8  2007/07/22 04:03:32  rjongbloed
 * Fixed issues with STUN usage in socket bundling, now OpalTransport indicates
 *   if it wants local or NAT address/port for inclusion to outgoing PDUs.
 *
 * Revision 1.7  2007/07/03 08:55:17  rjongbloed
 * Fixed various issues with handling interfaces going up, eg not being added
 *   to currently active ReadFrom().
 * Added more logging.
 *
 * Revision 1.6  2007/06/25 05:44:01  rjongbloed
 * Fixed numerous issues with "bound" managed socket, ie associating
 *   listeners to a specific named interface.
 *
 * Revision 1.5  2007/06/14 00:43:04  csoutheren
 * Removed warnings on Linux
 * Fixed Makefiles for new socket bundle code
 *
 * Revision 1.4  2007/06/10 06:26:50  rjongbloed
 * Major enhancements to the "socket bundling" feature:
 *   singleton thread for monitoring network interfaces
 *   a generic API for anything to be informed of interface changes
 *   PChannel derived class for reading/writing to bundled sockets
 *   many new API functions
 *
 * Revision 1.3  2007/05/22 11:50:47  csoutheren
 * Further implementation of socket bundle
 *
 * Revision 1.2  2007/05/21 06:35:37  csoutheren
 * Changed to be descended off PSafeObject
 *
 * Revision 1.1  2007/05/21 06:06:56  csoutheren
 * Add new socket bundle code to be used to OpalUDPListener
 *
 */

#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 PSTUNClient;
class PInterfaceMonitorClient;
class PInterfaceFilter;



class PInterfaceMonitor : public PObject
{
  PCLASSINFO(PInterfaceMonitor, PObject);
  public: 
    enum {
      DefaultRefreshInterval = 5000
    };

    PInterfaceMonitor(
      unsigned refreshInterval = DefaultRefreshInterval,
      BOOL runMonitorThread = TRUE
    );
    virtual ~PInterfaceMonitor();

    static PInterfaceMonitor & GetInstance();

    BOOL 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   
    );
    
    void SetInterfaceFilter(PInterfaceFilter * filter);
    
    virtual void RefreshInterfaceList();

  protected:
    void UpdateThreadMain();

    void AddClient(PInterfaceMonitorClient *);
    void RemoveClient(PInterfaceMonitorClient *);

    virtual void OnAddInterface(const InterfaceEntry & entry);
    virtual void OnRemoveInterface(const InterfaceEntry & entry);


    typedef PSmartPtr<PInterfaceMonitorClient> ClientPtr;

    typedef std::list<PInterfaceMonitorClient *> ClientList_T;
    ClientList_T              currentClients;
    PIPSocket::InterfaceTable currentInterfaces;

    BOOL runMonitorThread;
    PTimeInterval  refreshInterval;
    PMutex         mutex;
    PThread      * updateThread;
    PSyncPoint     threadRunning;
    
    PInterfaceFilter * interfaceFilter;

  friend class PInterfaceMonitorClient;
};



class PInterfaceMonitorClient : public PSafeObject
{
  PCLASSINFO(PInterfaceMonitorClient, PSafeObject);
  public:
    PInterfaceMonitorClient();
    ~PInterfaceMonitorClient();

    typedef PIPSocket::InterfaceEntry InterfaceEntry;

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

    virtual BOOL GetInterfaceInfo(
      const PString & iface,  
      InterfaceEntry & info   
    );

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

    virtual void OnRemoveInterface(const InterfaceEntry & entry) = 0;

  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,
      PSTUNClient * stunClient
    );

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

    BOOL IsOpen() const { return opened; }

    virtual BOOL Close() = 0;

    WORD GetPort() const { return localPort; }

    virtual BOOL GetAddress(
      const PString & iface,        
      PIPSocket::Address & address, 
      WORD & port,                  
      BOOL 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 SetSTUN(
      PSTUNClient * stunClient
    ) { stun = stunClient; }

    // Get the current STUN server
    PSTUNClient * GetSTUN() const { return stun; }

    static PMonitoredSockets * Create(
      const PString & iface,            
      BOOL reuseAddr = FALSE,           
      PSTUNClient * stunClient = NULL   
    );

  protected:
    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
    );

    WORD          localPort;
    BOOL          reuseAddress;
    PSTUNClient * stun;

    bool          opened;
    PUDPSocket    interfaceAddedSignal;
};

typedef PSafePtr<PMonitoredSockets> PMonitoredSocketsPtr;



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

    PMonitoredSocketChannel(
      const PMonitoredSocketsPtr & sockets,  
      BOOL shared                            
    );

    virtual BOOL IsOpen() const;
    virtual BOOL Close();

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

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

    void SetInterface(
      const PString & iface   
    );

    const 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; }

    // Get the IP address and port of the last received UDP data.
    void GetLastReceived(
      PIPSocket::Address & addr,  
      WORD & port                 
    ) const { addr = lastReceivedAddress; port = lastReceivedPort; }

    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;
};



class PMonitoredSocketBundle : public PMonitoredSockets
{
  PCLASSINFO(PMonitoredSocketBundle, PMonitoredSockets);
  public:
    PMonitoredSocketBundle(
      BOOL reuseAddr = FALSE,
      PSTUNClient * stunClient = NULL
    );
    ~PMonitoredSocketBundle();

    virtual BOOL Open(
      WORD port
    );

    virtual BOOL Close();

    virtual BOOL GetAddress(
      const PString & iface,        
      PIPSocket::Address & address, 
      WORD & port,                  
      BOOL 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(const SocketInfoMap_T::iterator & iterSocket);

    SocketInfoMap_T socketInfoMap;
};



class PSingleMonitoredSocket : public PMonitoredSocketBundle
{
  PCLASSINFO(PSingleMonitoredSocket, PMonitoredSocketBundle);
  public:
    PSingleMonitoredSocket(
      const PString & theInterface,
      BOOL reuseAddr = FALSE,
      PSTUNClient * stunClient = NULL
    );
    ~PSingleMonitoredSocket();

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

    virtual BOOL Open(
      WORD port
    );

    virtual BOOL Close();

    virtual BOOL GetAddress(
      const PString & iface,        
      PIPSocket::Address & address, 
      WORD & port,                  
      BOOL 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

---