ipsock.h

Go to the documentation of this file.

/*
 * ipsock.h
 *
 * Internet Protocol socket I/O channel class.
 *
 * Portable Tools Library
 *
 * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
 *
 * 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 Equivalence Pty. Ltd.
 *
 * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
 * All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 31479 $
 * $Author: rjongbloed $
 * $Date: 2014-02-15 19:32:46 +1100 (Sat, 15 Feb 2014) $
 */

#ifndef PTLIB_IPSOCKET_H
#define PTLIB_IPSOCKET_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib/socket.h>


class PIPSocket : public PSocket
{
  PCLASSINFO(PIPSocket, PSocket);
  protected:
    PIPSocket();

  public:
    class Address : public PObject {
        PCLASSINFO_WITH_CLONE(Address, PObject);
      public:


        Address();

        explicit Address(const PString & dotNotation);

        Address(PINDEX len, const BYTE * bytes, int scope = 0);

        Address(BYTE b1, BYTE b2, BYTE b3, BYTE b4);

        Address(DWORD dw);

        Address(const in_addr & addr);

#if P_HAS_IPV6

        Address(const in6_addr & addr);
        Address(const in6_addr & addr, int scope);
#endif

        Address(const int ai_family, const int ai_addrlen,struct sockaddr *ai_addr);

#ifdef __NUCLEUS_NET__
        Address(const struct id_struct & addr);
        Address & operator=(const struct id_struct & addr);
#endif

        Address & operator=(const in_addr & addr);

#if P_HAS_IPV6

        Address & AssignIPV6(const in6_addr & addr, int scope);
#endif

        Address & operator=(const PString & dotNotation);

        Address & operator=(DWORD dw);

        Comparison Compare(const PObject & obj) const;
        bool operator==(const Address & addr) const { return Compare(addr) == EqualTo; }
        bool operator!=(const Address & addr) const { return Compare(addr) != EqualTo; }
#if P_HAS_IPV6
        bool operator ==(in6_addr & addr) const;
        bool operator !=(in6_addr & addr) const { return !operator==(addr); }

        bool EqualIPV6(in6_addr & addr, int scope) const;
        bool NotEqualIPV6(in6_addr & addr, int scope) const { return !EqualIPV6(addr, scope); }
#endif
        bool operator==(in_addr & addr) const;
        bool operator!=(in_addr & addr) const { return !operator==(addr); }
        bool operator==(DWORD dw) const;
        bool operator!=(DWORD dw) const   { return !operator==(dw); }
#ifdef P_VXWORKS
        bool operator==(long unsigned int u) const { return  operator==((DWORD)u); }
        bool operator!=(long unsigned int u) const { return !operator==((DWORD)u); }
#endif
#ifdef _WIN32
        bool operator==(unsigned u) const { return  operator==((DWORD)u); }
        bool operator!=(unsigned u) const { return !operator==((DWORD)u); }
#endif
#ifdef P_RTEMS
        bool operator==(u_long u) const { return  operator==((DWORD)u); }
        bool operator!=(u_long u) const { return !operator==((DWORD)u); }
#endif
#ifdef P_BEOS
        bool operator==(in_addr_t a) const { return  operator==((DWORD)a); }
        bool operator!=(in_addr_t a) const { return !operator==((DWORD)a); }
#endif
        bool operator==(int i) const      { return  operator==((DWORD)i); }
        bool operator!=(int i) const      { return !operator==((DWORD)i); }

#if P_HAS_IPV6
        bool operator*=(const Address & addr) const;
#else
        bool operator*=(const Address & addr) const { return operator==(addr); }
#endif

        PString AsString(
          bool bracketIPv6 = false,  
          bool excludeScope = false  
        ) const;

        PBoolean FromString(
          const PString & str
        );

        operator PString() const;

        operator in_addr() const;

#if P_HAS_IPV6

        operator in6_addr() const;

        int GetIPV6Scope() const { return m_scope6; }
#endif

        operator DWORD() const;

        BYTE Byte1() const;

        BYTE Byte2() const;

        BYTE Byte3() const;

        BYTE Byte4() const;

        BYTE operator[](PINDEX idx) const;

        PINDEX GetSize() const;

        const char * GetPointer() const { return (const char *)&m_v; }

        unsigned GetVersion() const { return m_version; }

        bool IsValid() const { return m_version == 4 || m_version == 6; }
        bool IsAny() const;

        bool IsLoopback() const;

        bool IsBroadcast() const;

        bool IsMulticast() const;

        bool IsRFC1918() const ;

#if P_HAS_IPV6

        bool IsV4Mapped() const;

        bool IsLinkLocal() const;

        bool IsSiteLocal() const;
#endif

        static const Address & GetLoopback(unsigned version = 4);
        static const Address & GetAny(unsigned version = 4);
        static const Address GetBroadcast(unsigned version = 4);

      protected:
        union {
          in_addr m_four;
#if P_HAS_IPV6
          in6_addr m_six;
#endif
        } m_v;
        unsigned m_version;
        int      m_scope6;

      friend ostream & operator<<(ostream & s, const Address & a);

      friend istream & operator>>(istream & s, Address & a);
    };

    class AddressAndPort
    {
      public:
        AddressAndPort(
          char separator = ':'
        );
        AddressAndPort(
          WORD defaultPort,
          char separator = ':'
        );
        AddressAndPort(
          const PString & str,
          WORD defaultPort = 0,
          char separator = ':',
          const char * proto = NULL
        );
        AddressAndPort(
          const PIPSocket::Address & addr,
          WORD defaultPort = 0,
          char separator = ':'
        );
        AddressAndPort(
          struct sockaddr *ai_addr,
          const int ai_addrlen
        );

        bool Parse(
          const PString & str,
          WORD defaultPort = 0,
          char separator = ':',
          const char * proto = NULL
        );

        PString AsString(char separator = 0) const;

        const PIPSocket::Address & GetAddress() const { return m_address; }

        void SetAddress(
          const PIPSocket::Address & addr,
          WORD port = 0
        );

        WORD GetPort() const { return m_port; }

        void SetPort(
          WORD port
        ) { m_port = port; }

        bool IsValid() const
        {
          return m_address.IsValid() && m_port != 0;
        }

        bool operator==(const AddressAndPort & obj) const
        {
          return m_port == obj.m_port && m_address == obj.m_address;
        }

        bool operator!=(const AddressAndPort & obj) const
        {
          return m_port != obj.m_port || m_address != obj.m_address;
        }

        friend ostream & operator<<(ostream & strm, const AddressAndPort & ap)
        {
          return strm << ap.AsString();
        }

        bool MatchWildcard(
          const AddressAndPort & wild
        ) const;

      protected:
        PIPSocket::Address m_address;
        WORD               m_port;
        char               m_separator;
    };


    //**@name Overrides from class PChannel */

    virtual PString GetName() const;

    static int GetDefaultIpAddressFamily();
    static void SetDefaultIpAddressFamily(int ipAdressFamily); // PF_INET, PF_INET6
    static void SetDefaultIpAddressFamilyV4(); // PF_INET
#if P_HAS_IPV6
    static void SetDefaultIpAddressFamilyV6(); // PF_INET6
    static PBoolean IsIpAddressFamilyV6Supported();
#endif
    static const PIPSocket::Address & GetDefaultIpAny();
    static const PIPSocket::Address & GetInvalidAddress();

    static void SetSuppressCanonicalName(bool suppress);

    static bool GetSuppressCanonicalName();

    virtual PBoolean OpenSocket(
      int ipAdressFamily=PF_INET
    ) = 0;

    class PortRange {
      public:
        PortRange(WORD basePort = 0, WORD maxPort = 0);

        void Set(
          unsigned newBase,       
          unsigned newMax,        
          unsigned dfltRange = 0, 
          unsigned dfltBase = 0   
        );

        bool IsValid() const { return m_base != 0 && m_base <= m_max; }
        friend ostream & operator<<(ostream & strm, const PortRange & pr) { return strm << pr.m_base << '-' << pr.m_max; }

        bool Connect(
          PIPSocket & socket,         
          const Address & addr,       
          const Address & binding = GetDefaultIpAny() 
        );

        bool Listen(
          PIPSocket & socket,                          
          const Address & binding = GetDefaultIpAny(), 
          unsigned queueSize = 5,                      
          Reusability reuse = AddressIsExclusive       
        );
        bool Listen(
          PIPSocket ** sockets,                        
          PINDEX numSockets = 1,                       
          const Address & binding = GetDefaultIpAny(), 
          unsigned queueSize = 5,                      
          Reusability reuse = AddressIsExclusive       
        );

        WORD GetBase() const { return m_base; }

        WORD GetMax() const { return m_max; }

      protected:
        PMutex m_mutex;
        WORD   m_base;
        WORD   m_max;
    };

    virtual PBoolean Connect(
      const PString & address   
    );
    virtual PBoolean Connect(
      const Address & addr      
    );
    virtual PBoolean Connect(
      WORD localPort,           
      const Address & addr      
    );
    virtual PBoolean Connect(
      const Address & iface,    
      const Address & addr      
    );
    virtual PBoolean Connect(
      const Address & iface,    
      WORD localPort,           
      const Address & addr      
    );

    virtual PBoolean Listen(
      unsigned queueSize = 5,  
      WORD port = 0,           
      Reusability reuse = AddressIsExclusive 
    ) { return InternalListen(GetDefaultIpAny(), queueSize, port, reuse); }

    virtual PBoolean Listen(
      const Address & bind,     
      unsigned queueSize = 5,   
      WORD port = 0,            
      Reusability reuse = AddressIsExclusive 
    ) { return InternalListen(bind, queueSize, port, reuse); }

    static PString GetHostName();
    static PString GetHostName(
      const PString & hostname  
    );
    static PString GetHostName(
      const Address & addr    
    );

    static PBoolean GetHostAddress(
      Address & addr    
    );
    static PBoolean GetHostAddress(
      const PString & hostname,
      Address & addr    
    );

    static PStringArray GetHostAliases(
      const PString & hostname
    );
    static PStringArray GetHostAliases(
      const Address & addr    
      /* Name of host to get address for. This may be either a domain name or
         an IP number in "dot" format.
       */
    );

    static PBoolean IsLocalHost(
      const PString & hostname
    );

    PString GetLocalAddress() const;
    bool GetLocalAddress(
      Address & addr    
    ) const;
    bool GetLocalAddress(
      Address & addr,    
      WORD & port        
    ) const;
    bool GetLocalAddress(
      AddressAndPort & addr    
    ) const;

    PString GetPeerAddress() const;
    bool GetPeerAddress(
      Address & addr    
      ) const;
    bool GetPeerAddress(
      Address & addr,    
      WORD & port        
      ) const;
    bool GetPeerAddress(
      AddressAndPort & addr    
    ) const;

    PString GetLocalHostName();

    PString GetPeerHostName();

    static void ClearNameCache();

    class RouteEntry : public PObject
    {
      PCLASSINFO(RouteEntry, PObject);
      public:
        RouteEntry(const Address & addr) : network(addr) { }

        Address GetNetwork() const { return network; }

        Address GetNetMask() const { return net_mask; }

        Address GetDestination() const { return destination; }

        const PString & GetInterface() const { return interfaceName; }

        long GetMetric() const { return metric; }

        void PrintOn(ostream & strm) const;

      protected:
        Address network;
        Address net_mask;
        Address destination;
        PString interfaceName;
        long    metric;

      friend class PIPSocket;
    };

    PARRAY(RouteTable, RouteEntry);

    static PBoolean GetRouteTable(
      RouteTable & table      
    );

    class RouteTableDetector
    {
      public:
        virtual ~RouteTableDetector() { }
        virtual bool Wait(
          const PTimeInterval & timeout 
        ) = 0;
        virtual void Cancel() = 0;
    };

    static RouteTableDetector * CreateRouteTableDetector();

    class InterfaceEntry : public PObject
    {
      PCLASSINFO(InterfaceEntry, PObject)

      public:
        InterfaceEntry();
        InterfaceEntry(
          const PString & name,
          const Address & addr,
          const Address & mask,
          const PString & macAddr
        );

        virtual void PrintOn(
          ostream &strm   // Stream to print the object into.
        ) const;

        const PString & GetName() const { return m_name; }

        Address GetAddress() const { return m_ipAddress; }

        Address GetNetMask() const { return m_netMask; }

        const PString & GetMACAddress() const { return m_macAddress; }

        static void SanitiseName(PString & name);

      protected:
        PString m_name;
        Address m_ipAddress;
        Address m_netMask;
        PString m_macAddress;

      friend class PIPSocket;
    };

    PARRAY(InterfaceTable, InterfaceEntry);

    static PBoolean GetInterfaceTable(
      InterfaceTable & table,      
      PBoolean includeDown = false     
    );

    static PString GetInterface(
      const Address & addr    
    );

    static Address GetInterfaceAddress(
      const PString & ifName,   
      unsigned version = 4      
    );

    static PString GetInterfaceMACAddress(
      const char * ifName = NULL   
    );

    static Address GetNetworkInterface(
      unsigned version = 4  
    );

    static Address GetGatewayAddress(
      unsigned version = 4  
    );

    static PString GetGatewayInterface(
      unsigned version = 4  
    );

    static Address GetGatewayInterfaceAddress(
      unsigned version = 4  
    );

    static Address GetRouteInterfaceAddress(
      const Address & remoteAddress    
    );

    P_DECLARE_ENUM(QoSType,
      BackgroundQoS,        
      BestEffortQoS,        
      ExcellentEffortQoS,   
      CriticalQoS,          
      VideoQoS,             
      VoiceQoS,             
      ControlQoS            
    );
    struct QoS
    {
      QoS(QoSType type = BestEffortQoS);
      QoS(const PString & str);

      QoSType m_type;
      int     m_dscp; // If between 0 and 63, is used instead of default for QoSType.

      AddressAndPort m_remote;

      struct Flow {
        Flow() { memset(this, 0, sizeof(*this)); }
        unsigned m_maxBandwidth;    // bits/second, includes IP overhead
        unsigned m_maxPacketSize;   // Bytes, includes IP overhead
        unsigned m_maxLatency;      // Microseconds
        unsigned m_maxJitter;       // Microseconds
      } m_transmit, m_receive;

      friend ostream & operator<<(ostream & strm, const PIPSocket::QoS & qos);
      friend istream & operator>>(istream & strm, PIPSocket::QoS & qos);
    };

    virtual bool SetQoS(
      const QoS & qos   
    );

    const QoS & GetQoS() const { return m_qos; }

    virtual bool InternalGetLocalAddress(AddressAndPort & addrAndPort);
    virtual bool InternalGetPeerAddress(AddressAndPort & addrAndPort);
    virtual bool InternalListen(const Address & bind, unsigned queueSize, WORD port, Reusability reuse);

// Include platform dependent part of class
#ifdef _WIN32
#include "msos/ptlib/ipsock.h"
#else
#include "unix/ptlib/ipsock.h"
#endif

  protected:
    QoS m_qos;

    class sockaddr_wrapper
    {
      public:
        sockaddr_wrapper();
        sockaddr_wrapper(const AddressAndPort & ipPort);
        sockaddr_wrapper(const Address & ip, WORD port);

        sockaddr* operator->() const { return addr; }
        operator sockaddr*()   const { return addr; }
        socklen_t GetSize() const;

        PIPSocket::Address GetIP() const;
        WORD GetPort() const;

      private:
        void Construct(const Address & ip, WORD port);

        sockaddr_storage storage;
        union {
          sockaddr_storage * ptr;
          sockaddr         * addr;
          sockaddr_in      * addr4;
    #if P_HAS_IPV6
          sockaddr_in6     * addr6;
    #endif
        };
    };
};

typedef PIPSocket::Address        PIPAddress;
typedef PIPSocket::AddressAndPort PIPAddressAndPort;
typedef PIPSocket::AddressAndPort PIPSocketAddressAndPort;

typedef std::vector<PIPSocket::AddressAndPort> PIPSocketAddressAndPortVector;


#endif // PTLIB_IPSOCKET_H


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