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: 32091 $
 * $Author: rjongbloed $
 * $Date: 2014-06-06 20:45:36 +1000 (Fri, 06 Jun 2014) $
 */

#ifndef PTLIB_PSOCKBUN_H
#define PTLIB_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 <ptclib/pnat.h>
#include <map>


#define PINTERFACE_MONITOR_FACTORY_NAME "InterfaceMonitor"



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



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

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

    PFACTORY_GET_SINGLETON(PProcessStartupFactory, PInterfaceMonitor);
    
    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   
    ) const;
    
    static bool IsMatchingInterface(
      const PString & iface,        
      const InterfaceEntry & entry  
    );

    struct InterfaceChange : public InterfaceEntry
    {
      InterfaceChange(const InterfaceEntry & entry, bool added)
        : InterfaceEntry(entry)
        , m_added(added)
        { }

      const bool m_added;
    };

    typedef PNotifierTemplate<InterfaceChange> Notifier;

    #define PDECLARE_InterfaceNotifier(cls, fn) PDECLARE_NOTIFIER2(PInterfaceMonitor, cls, fn, PInterfaceMonitor::InterfaceChange)

    #define PCREATE_InterfaceNotifier(fn) PCREATE_NOTIFIER2(fn, PInterfaceMonitor::InterfaceChange)

    enum {
      DefaultPriority = 50,
    };

    void AddNotifier(
      const Notifier & notifier,   
      unsigned priority = DefaultPriority   
    );
    void RemoveNotifier(
      const Notifier & notifier    
    );

    void SetInterfaceFilter(PInterfaceFilter * filter);
    bool HasInterfaceFilter() const { return m_interfaceFilter != NULL; }

  protected:
    virtual void OnShutdown();

    void UpdateThreadMain();

    virtual void RefreshInterfaceList();
    virtual void OnInterfacesChanged(const PIPSocket::InterfaceTable & addedInterfaces, const PIPSocket::InterfaceTable & removedInterfaces);

    typedef std::multimap<unsigned, Notifier> Notifiers;
    Notifiers m_notifiers;
    PMutex    m_notifiersMutex;

    PIPSocket::InterfaceTable m_interfaces;
    PMutex                    m_interfacesMutex;

    bool           m_runMonitorThread;
    PTimeInterval  m_refreshInterval;
    PMutex         m_threadMutex;
    PThread      * m_updateThread;

    PInterfaceFilter * m_interfaceFilter;
    PIPSocket::RouteTableDetector * m_changedDetector;

  friend class PInterfaceMonitorClient;
};



class PMonitoredSockets : public PSafeObject
{
    PCLASSINFO(PMonitoredSockets, PSafeObject);
  protected:
    PMonitoredSockets(
      bool reuseAddr    
      P_NAT_PARAM(PNatMethods * natMethods)  
    );

  public:
    typedef PIPSocket::InterfaceEntry InterfaceEntry;

    virtual PBoolean Open(
      WORD port
    ) = 0;

    PBoolean IsOpen() const { return m_opened; }

    virtual PBoolean Close() = 0;

    WORD GetPort() const { return m_localPort; }

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

    struct BundleParams {
      BundleParams()
        : m_buffer(NULL)
        , m_length(0)
        , m_addr(0)
        , m_port(0)
        , m_lastCount(0)
        , m_errorCode(PChannel::NoError)
        , m_errorNumber(0)
      { }

      void * m_buffer;              
      PINDEX m_length;              
      PIPSocket::Address m_addr;    
      WORD m_port;                  
      PString m_iface;              
      PINDEX m_lastCount;           
      PTimeInterval m_timeout;      
      PChannel::Errors m_errorCode; 
      int m_errorNumber;            
    };

    virtual void WriteToBundle(
      BundleParams & param 
    ) = 0;

    virtual void ReadFromBundle(
      BundleParams & param 
    ) = 0;

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

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

    static PMonitoredSockets * Create(
      const PString & iface,              
      bool reuseAddr = false              
      P_NAT_PARAM(PNatMethods * natMethods = NULL)     
    );

  protected:
    struct SocketInfo {
      SocketInfo()
        : socket(NULL)
        , inUse(false)
      { }
      void Read(PMonitoredSockets & bundle, BundleParams & param);
      void Write(BundleParams & param);

      PUDPSocket * socket;
      bool         inUse;
    };
    friend struct SocketInfo;

    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;

    void ReadFromSocketList(
      PSocket::SelectList & readers,
      PUDPSocket * & socket,
      BundleParams & param
    );

    WORD          m_localPort;
    bool          m_reuseAddress;
#if P_NAT
    PNatMethods * m_natMethods;
#endif

    bool          m_opened;
    PUDPSocket    m_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                 
    );
    bool GetLocal(
      PIPSocket::AddressAndPort & ap, 
      bool usingNAT                 
    );

    void SetRemote(
      const PIPSocket::Address & address, 
      WORD port                           
    ) { m_remoteAP.SetAddress(address, port); }
    void SetRemote(
      const PIPSocket::AddressAndPort & ap 
    ) { m_remoteAP = ap; }

    void SetRemote(
      const PString & hostAndPort 
    );

    void GetRemote(
      PIPSocket::Address & addr,  
      WORD & port                 
    ) const { addr = m_remoteAP.GetAddress(); port = m_remoteAP.GetPort(); }
    void GetRemote(
      PIPSocketAddressAndPort & ap  
    ) const { ap = m_remoteAP; }

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

    bool GetPromiscuous() { return m_promiscuousReads; }

    void GetLastReceived(
      PIPSocket::Address & addr,  
      WORD & port                 
    ) const { addr = m_lastReceivedAP.GetAddress(); port = m_lastReceivedAP.GetPort(); }
    void GetLastReceived(
      PIPSocketAddressAndPort & ap  
    ) const { ap = m_lastReceivedAP; }

    PString GetLastReceivedInterface() const { return m_lastReceivedInterface; }

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

  protected:
    PMonitoredSocketsPtr    m_socketBundle;
    bool                    m_sharedBundle;
    PString                 m_currentInterface;
    bool                    m_promiscuousReads;
    bool                    m_closing;
    PIPSocketAddressAndPort m_remoteAP;
    PIPSocketAddressAndPort m_lastReceivedAP;
    PString                 m_lastReceivedInterface;
    PMutex                  m_mutex;
};



class PMonitoredSocketBundle : public PMonitoredSockets
{
  PCLASSINFO(PMonitoredSocketBundle, PMonitoredSockets);
  public:
    PMonitoredSocketBundle(
      const PString & fixedInterface, 
      unsigned ipVersion,             
      bool reuseAddr                  
      P_NAT_PARAM(PNatMethods * natMethods = NULL)  
    );
    ~PMonitoredSocketBundle();

    virtual PStringArray GetInterfaces(
      bool 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 void WriteToBundle(
      BundleParams & param 
    );

    virtual void ReadFromBundle(
      BundleParams & param 
    );

  protected:
    PDECLARE_InterfaceNotifier(PMonitoredSocketBundle, OnInterfaceChange);
    PInterfaceMonitor::Notifier m_onInterfaceChange;

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

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

    SocketInfoMap_T m_socketInfoMap;
    PCaselessString m_fixedInterface;
    unsigned        m_ipVersion;
};



class PSingleMonitoredSocket : public PMonitoredSockets
{
  PCLASSINFO(PSingleMonitoredSocket, PMonitoredSockets);
  public:
    PSingleMonitoredSocket(
      const PString & theInterface, 
      bool reuseAddr    
      P_NAT_PARAM(PNatMethods * natMethods = NULL)  
    );
    ~PSingleMonitoredSocket();

    virtual PStringArray GetInterfaces(
      bool 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 void WriteToBundle(
      BundleParams & param 
    );

    virtual void ReadFromBundle(
      BundleParams & param 
    );


  protected:
    PDECLARE_InterfaceNotifier(PSingleMonitoredSocket, OnInterfaceChange);
    PInterfaceMonitor::Notifier m_onInterfaceChange;

    bool IsInterface(const PString & iface) const;

    PString        m_interface;
    InterfaceEntry m_entry;
    SocketInfo     m_info;
};


#endif // PTLIB_PSOCKBUN_H


// End Of File ///////////////////////////////////////////////////////////////