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: 19008 $
 * $Author: rjongbloed $
 * $Date: 2007-11-29 09:17:41 +0000 (Thu, 29 Nov 2007) $
 */

#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,
      PBoolean runMonitorThread = PTrue
    );
    virtual ~PInterfaceMonitor();

    static PInterfaceMonitor & GetInstance();

    PBoolean Start();

    void Stop();

    typedef PIPSocket::InterfaceEntry InterfaceEntry;

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

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

    PBoolean GetInterfaceInfo(
      const PString & iface,  
      InterfaceEntry & info   
    );
    
    static PBoolean IsMatchingInterface(
      const PString & iface,        
      const InterfaceEntry & entry  
    );
    
    void SetInterfaceFilter(PInterfaceFilter * filter);
    
    virtual void RefreshInterfaceList();
    
    void OnRemoveSTUNClient(const PSTUNClient *stun);

  protected:
    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              currentClients;
    PIPSocket::InterfaceTable currentInterfaces;

    PBoolean runMonitorThread;
    PTimeInterval  refreshInterval;
    PMutex         mutex;
    PThread      * updateThread;
    PSyncPoint     threadRunning;
    
    PInterfaceFilter * 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(
      PBoolean includeLoopBack = PFalse,  
      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 OnRemoveSTUNClient(const PSTUNClient * /*stun*/) { }
    
    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(
      PBoolean reuseAddr,
      PSTUNClient * stunClient
    );

  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 SetSTUN(
      PSTUNClient * stunClient
    ) { stun = stunClient; }

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

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

  protected:
    virtual void OnRemoveSTUNClient(const PSTUNClient *stun);
    struct SocketInfo {
      SocketInfo()
        : socket(NULL)
        , inUse(false)
      { }
      PUDPSocket * socket;
      bool         inUse;
    };

    PBoolean CreateSocket(
      SocketInfo & info,
      const PIPSocket::Address & binding
    );
    PBoolean DestroySocket(SocketInfo & info);
    PBoolean GetSocketAddress(
      const SocketInfo & info,
      PIPSocket::Address & address,
      WORD & port,
      PBoolean 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;
    PBoolean          reuseAddress;
    PSTUNClient * stun;

    bool          opened;
    PUDPSocket    interfaceAddedSignal;
};

typedef PSafePtr<PMonitoredSockets> PMonitoredSocketsPtr;



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

    PMonitoredSocketChannel(
      const PMonitoredSocketsPtr & sockets,  
      PBoolean 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   
    );

    const PString & GetInterface();

    PBoolean GetLocal(
      PIPSocket::Address & address, 
      WORD & port,                  
      PBoolean 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(
      PBoolean 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;
    PBoolean                 sharedBundle;
    PString              currentInterface;
    PBoolean                 promiscuousReads;
    PIPSocket::Address   remoteAddress;
    PBoolean                 closing;
    WORD                 remotePort;
    PIPSocket::Address   lastReceivedAddress;
    WORD                 lastReceivedPort;
};



class PMonitoredSocketBundle : public PMonitoredSockets
{
  PCLASSINFO(PMonitoredSocketBundle, PMonitoredSockets);
  public:
    PMonitoredSocketBundle(
      PBoolean reuseAddr = PFalse,
      PSTUNClient * stunClient = 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(const SocketInfoMap_T::iterator & iterSocket);

    SocketInfoMap_T socketInfoMap;
};



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

    virtual PStringArray GetInterfaces(
      PBoolean includeLoopBack = PFalse,  
      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);

    PBoolean IsInterface(const PString & iface) const;

    PString        theInterface;
    InterfaceEntry theEntry;
    SocketInfo     theInfo;
};

#endif

---