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: 24177 $
 * $Author: rjongbloed $
 * $Date: 2010-04-05 06:52:04 -0500 (Mon, 05 Apr 2010) $
 */

#ifndef PTLIB_IPSOCKET_H
#define PTLIB_IPSOCKET_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib/socket.h>

#if P_QOS
#ifdef _WIN32
#ifdef P_KNOCKOUT_WINSOCK2
   #include "IPExport.h"
#endif // KNOCKOUT_WINSOCK2
#endif // _WIN32
#endif // P_QOS


class PIPSocketAddressAndPort;



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

  public:
    class Address : public PObject {
      public:


        Address();

        Address(const PString & dotNotation);

        Address(PINDEX len, const BYTE * bytes);

        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);
#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 & operator=(const in6_addr & addr);
#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); }
#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 
        ) const;

        PBoolean FromString(
          const PString & str
        );

        operator PString() const;

        operator in_addr() const;

#if P_HAS_IPV6
        operator in6_addr() const;
#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 *)&v; }

        unsigned GetVersion() const { return version; }

        PBoolean IsValid() const;
        PBoolean IsAny() const;

        PBoolean IsLoopback() const;

        PBoolean IsBroadcast() const;

        PBoolean IsMulticast() const;

        PBoolean IsRFC1918() const ;

#if P_HAS_IPV6
        PBoolean IsV4Mapped() const;
#endif

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

      protected:
        union {
          in_addr four;
#if P_HAS_IPV6
          in6_addr six;
#endif
        } v;
        unsigned version;

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

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

    //**@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();

        static void SetDefaultV6ScopeId(int scopeId); // local-link adresses require one
    static int GetDefaultV6ScopeId(); 
#endif
    static PIPSocket::Address GetDefaultIpAny();

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

    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 
    );
    virtual PBoolean Listen(
      const Address & bind,     
      unsigned queueSize = 5,   
      WORD port = 0,            
      Reusability reuse = AddressIsExclusive 
    );

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

    virtual PString GetLocalAddress();
    virtual PBoolean GetLocalAddress(
      Address & addr    
    );
    virtual PBoolean GetLocalAddress(
      PIPSocketAddressAndPort & addr    
    );
    virtual PBoolean GetLocalAddress(
      Address & addr,    
      WORD & port        
    );

    virtual PString GetPeerAddress();
    virtual PBoolean GetPeerAddress(
      Address & addr    
    );
    virtual PBoolean GetPeerAddress(
      PIPSocketAddressAndPort & addr    
    );
    virtual PBoolean GetPeerAddress(
      Address & addr,    
      WORD & port        
    );

    PString GetLocalHostName();

    PString GetPeerHostName();

    static void ClearNameCache();

    static PBoolean GetGatewayAddress(
      Address & addr,     
          int version = 4     
    );

    static PString GetGatewayInterface(int version = 4);

    static PIPSocket::Address GetRouteInterfaceAddress(PIPSocket::Address remoteAddress);

#ifdef _WIN32

    static PIPSocket::Address GetGatewayInterfaceAddress(int version = 4);

    static PIPSocket::Address GetRouteAddress(PIPSocket::Address RemoteAddress);

    static unsigned AsNumeric(Address addr);

    static PBoolean IsAddressReachable(PIPSocket::Address LocalIP,
                                   PIPSocket::Address LocalMask,
                                   PIPSocket::Address RemoteIP);

    static PString GetInterface(PIPSocket::Address addr);
 #endif

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

      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
#if P_HAS_IPV6
          , const PString & ip6Addr = PString::Empty()
#endif
        );

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

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

        Address GetAddress() const { return ipAddr; }

        PBoolean HasIP6Address() const
#if ! P_HAS_IPV6
        { return false;}
#else
        { return !ip6Addr.IsEmpty();}

        Address GetIP6Address() const { return ip6Addr; }
#endif

        Address GetNetMask() const { return netMask; }

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

      protected:
        PString name;
        Address ipAddr;
        Address netMask;
        PString macAddr;
#if P_HAS_IPV6
        PString ip6Addr;
#endif
    };

    PARRAY(InterfaceTable, InterfaceEntry);

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

    static PBoolean GetNetworkInterface(PIPSocket::Address & addr);

#if P_HAS_RECVMSG

    PBoolean SetCaptureReceiveToAddress()
    { if (!SetOption(IP_PKTINFO, 1, SOL_IP)) return false; catchReceiveToAddr = true; return true; }

    PIPSocket::Address GetLastReceiveToAddress() const
    { return lastReceiveToAddr; }

  protected:
    void SetLastReceiveAddr(void * addr, int addrLen)
    { if (addrLen == sizeof(in_addr)) lastReceiveToAddr = *(in_addr *)addr; }

    PIPSocket::Address lastReceiveToAddr;

#else

    PBoolean SetCaptureReceiveToAddress()
    { return false; }

    PIPSocket::Address GetLastReceiveToAddress() const
    { return PIPSocket::Address(); }

#endif

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

class PIPSocketAddressAndPort
{
  public:
    PIPSocketAddressAndPort()
      : m_port(0), m_separator(':')
      { }

    PIPSocketAddressAndPort(char separator)
      : m_port(0), m_separator(separator)
      { }

    PIPSocketAddressAndPort(const PString & str, WORD defaultPort = 0, char separator = ':')
      : m_port(defaultPort), m_separator(separator)
      { Parse(str, defaultPort, m_separator); }

    PBoolean Parse(const PString & str, WORD defaultPort = 0, char separator = ':');

    PString AsString(char separator = 0) const
      { return m_address.AsString() + (separator ? separator : m_separator) + PString(PString::Unsigned, m_port); }

    void SetAddress(
      const PIPSocket::Address & addr,
      WORD port = 0
    );
    const PIPSocket::Address & GetAddress() const { return m_address; }
    WORD GetPort() const { return m_port; }
    void SetPort(
      WORD port
    ) { m_port = port; }

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

typedef std::vector<PIPSocketAddressAndPort> PIPSocketAddressAndPortVector;


#endif // PTLIB_IPSOCKET_H


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

---