ipsock.h

Go to the documentation of this file.

/*
 * ipsock.h
 *
 * Internet Protocol socket I/O channel class.
 *
 * Portable Windows 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: 20405 $
 * $Author: rjongbloed $
 * $Date: 2008-06-05 06:10:42 +0000 (Thu, 05 Jun 2008) $
 */

#ifndef _PIPSOCKET
#define _PIPSOCKET

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib/socket.h>

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

class PIPSocket : public PSocket
{
  PCLASSINFO(PIPSocket, PSocket);
  protected:
    /* Create a new Internet Protocol socket based on the port number
       specified.
     */
    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 __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() 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;

        // Check if the remote address is a private address.
        // For IPV4 this is specified RFC 1918 as the following ranges:
        //    10.0.0.0    - 10.255.255.255.255
        //    172.16.0.0  - 172.31.255.255
        //    192.168.0.0 - 192.168.255.255
        // For IPV6 this is specified as any address having "1111 1110 1” for the first nine bits
        PBoolean IsRFC1918() const ;

#if P_HAS_IPV6
        PBoolean IsV4Mapped() const;
#endif
        
        static const Address & GetLoopback();
#if P_HAS_IPV6
        static const Address & GetLoopback6();
        static const Address & GetAny6();
#endif
        static const Address & GetBroadcast();

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

  // Overrides from class PChannel
    virtual PString GetName() const;

    // Set the default IP address familly.
    // Needed as lot of IPv6 stack are not able to receive IPv4 packets in IPv6 sockets
    // They are not RFC 2553, chapter 7.3, compliant.
    // As a concequence, when opening a socket to listen to port 1720 (for exemple) from any remot host
    // one must decide whether this an IPv4 or an IPv6 socket...
    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 PIPSocket::Address GetDefaultIpAny();

    // Open an IPv4 or IPv6 socket
    virtual PBoolean OpenSocket(
      int ipAdressFamily=PF_INET
    ) = 0;


  // Overrides from class PSocket.
    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 
    );


  // New functions for class
    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,
      /* Name of host to get address for. This may be either a domain name or
         an IP number in "dot" format.
       */
      Address & addr    
    );

    static PStringArray GetHostAliases(
      const PString & hostname
      /* Name of host to get address for. This may be either a domain name or
         an IP number in "dot" format.
       */
    );
    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
      /* Name of host to get address for. This may be either a domain name or
         an IP number in "dot" format.
       */
    );

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

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

    PString GetLocalHostName();

    PString GetPeerHostName();

    static void ClearNameCache();

    static PBoolean GetGatewayAddress(
      Address & addr     
    );

    static PString GetGatewayInterface();

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

#ifdef _WIN32

    static PIPSocket::Address GetGatewayInterfaceAddress();

    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 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 PFalse;}
#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 = PFalse     
    );

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

#if P_HAS_RECVMSG

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

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

    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()
      : port(0), sep(':')
    { }

    PIPSocketAddressAndPort(char _sep)
      : port(0), sep(_sep)
    { }

    PIPSocketAddressAndPort(const PString & str, WORD defaultPort = 0, char _sep = ':')
      : port(defaultPort), sep(_sep)
    { Parse(str, defaultPort, sep); }

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

    PString AsString(char _sep = 0) const
    { return address.AsString() + (_sep ? _sep : sep) + PString(PString::Unsigned, port); }

    PIPSocket::Address address;
    WORD port;
    char sep;
};

typedef std::vector<PIPSocketAddressAndPort> PIPSocketAddressAndPortVector;

#endif


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

---