tdesocketaddress.h

/*
 *  Copyright (C) 2003 Thiago Macieira <thiago.macieira@kdemail.net>
 *
 *
 *  Permission is hereby granted, free of charge, to any person obtaining
 *  a copy of this software and associated documentation files (the
 *  "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so, subject to
 *  the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included 
 *  in all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
#ifndef TDESOCKETADDRESS_H
#define TDESOCKETADDRESS_H
 
#include <tqstring.h>
#include <tqcstring.h>
 
#include <tdelibs_export.h>
 
struct sockaddr;
struct sockaddr_in;
struct sockaddr_in6;
struct sockaddr_un;
 
namespace KNetwork {
 
class KIpAddress;
class TDESocketAddress;
class KInetSocketAddress;
class KUnixSocketAddress;

class TDECORE_EXPORT KIpAddress
{
public:
  inline KIpAddress() : m_version(0)
  { }

  inline KIpAddress(const KIpAddress& other)
  { *this = other; }

  inline KIpAddress(const TQString& addr)
  { setAddress(addr); }

  inline KIpAddress(const char* addr)
  { setAddress(addr); }

  inline KIpAddress(const void* addr, int version = 4)
  { setAddress(addr, version); }

  inline KIpAddress(TQ_UINT32 ip4addr)
  { setAddress(&ip4addr, 4); }

  inline ~KIpAddress()
  { }

  KIpAddress& operator =(const KIpAddress& other);

  inline bool operator ==(const KIpAddress& other) const
  { return compare(other, true); }

  bool compare(const KIpAddress& other, bool checkMapped = true) const;

  inline int version() const
  { return m_version; }

  inline bool isIPv4Addr() const
  { return version() == 4; }

  inline bool isIPv6Addr() const
  { return version() == 6; }

  bool setAddress(const TQString& address);

  bool setAddress(const char* address);

  bool setAddress(const void* raw, int version = 4);

  TQString toString() const;

  inline const void *addr() const
  { return m_data; }

  inline TQ_UINT32 IPv4Addr(bool convertMapped = true) const
  {
    return (convertMapped && isV4Mapped()) ? m_data[3] : m_data[0];
  }

  TQ_UINT32 hostIPv4Addr(bool convertMapped = true) const;
 
public:
  /*-- tests --*/

  inline bool isUnspecified() const
  { return version() == 0 ? true : (*this == anyhostV4 || *this == anyhostV6); }

  inline bool isLocalhost() const
  { return version() == 0 ? false : (*this == localhostV4 || *this == localhostV6); }

  inline bool isLoopback() const
  { return isLocalhost(); }

  inline bool isClassA() const
  { return version() != 4 ? false : (hostIPv4Addr() & 0x80000000) == 0; }

  inline bool isClassB() const
  { return version() != 4 ? false : (hostIPv4Addr() & 0xc0000000) == 0x80000000; }

  inline bool isClassC() const
  { return version() != 4 ? false : (hostIPv4Addr() & 0xe0000000) == 0xc0000000; }

  inline bool isClassD() const
  { return version() != 4 ? false : (hostIPv4Addr() & 0xf0000000) == 0xe0000000; }

  inline bool isMulticast() const
  {
    if (version() == 4) return isClassD();
    if (version() == 6) return ((TQ_UINT8*)addr())[0] == 0xff;
    return false;
  }

  inline bool isLinkLocal() const
  { 
    if (version() != 6) return false;
    TQ_UINT8* addr = (TQ_UINT8*)this->addr();
    return (addr[0] & 0xff) == 0xfe &&
      (addr[1] & 0xc0) == 0x80;
  }

  inline bool isSiteLocal() const
  {
    if (version() != 6) return false;
    TQ_UINT8* addr = (TQ_UINT8*)this->addr();
    return (addr[0] & 0xff) == 0xfe &&
      (addr[1] & 0xc0) == 0xc0;
  }

  inline bool isGlobal() const
  { return version() != 6 ? false : !(isMulticast() || isLinkLocal() || isSiteLocal()); }

  inline bool isV4Mapped() const
  {
    if (version() != 6) return false;
    TQ_UINT32* addr = (TQ_UINT32*)this->addr();
    return addr[0] == 0 && addr[1] == 0 &&
      ((TQ_UINT16*)&addr[2])[0] == 0 &&
      ((TQ_UINT16*)&addr[2])[1] == 0xffff;
  }

  inline bool isV4Compat() const
  {
    if (version() != 6 || isLocalhost()) return false;
    TQ_UINT32* addr = (TQ_UINT32*)this->addr();
    return addr[0] == 0 && addr[1] == 0 && addr[2] == 0 && addr[3] != 0;
  }

  inline bool isMulticastNodeLocal() const
  { return version() == 6 && isMulticast() && (((TQ_UINT32*)addr())[0] & 0xf) == 0x1; }

  inline bool isMulticastLinkLocal() const
  { return version() == 6 && isMulticast() && (((TQ_UINT32*)addr())[0] & 0xf) == 0x2; }
      
  inline bool isMulticastSiteLocal() const
  { return version() == 6 && isMulticast() && (((TQ_UINT32*)addr())[0] & 0xf) == 0x5; }

  inline bool isMulticastOrgLocal() const
  { return version() == 6 && isMulticast() && (((TQ_UINT32*)addr())[0] & 0xf) == 0x8; }

  inline bool isMulticastGlobal() const
  { return version() == 6 && isMulticast() && (((TQ_UINT32*)addr())[0] & 0xf) == 0xe; }
 
protected:
  TQ_UINT32 m_data[4];         // 16 bytes, needed for an IPv6 address
 
  char m_version;
 
public:
  static const KIpAddress localhostV4;
  static const KIpAddress anyhostV4;

  static const KIpAddress localhostV6;
  static const KIpAddress anyhostV6;
};
 
 
class TDESocketAddressData;
class TDECORE_EXPORT TDESocketAddress
{
public:
  TDESocketAddress();

  TDESocketAddress(const sockaddr* sa, TQ_UINT16 len);

  TDESocketAddress(const TDESocketAddress& other);

  virtual ~TDESocketAddress();

  TDESocketAddress& operator =(const TDESocketAddress& other);

  const sockaddr* address() const;

  sockaddr* address();

  TDESocketAddress& setAddress(const sockaddr *sa, TQ_UINT16 len);

  inline operator const sockaddr*() const
  { return address(); }

  TQ_UINT16 length() const;

  TDESocketAddress& setLength(TQ_UINT16 len);

  int family() const;

  virtual TDESocketAddress& setFamily(int family);

  inline int ianaFamily() const
  { return ianaFamily(family()); }
  
  bool operator ==(const TDESocketAddress& other) const;

  virtual TQString nodeName() const;

  virtual TQString serviceName() const;

  virtual TQString toString() const;

  KInetSocketAddress& asInet();

  KInetSocketAddress asInet() const;

  KUnixSocketAddress& asUnix();

  KUnixSocketAddress asUnix() const;
 
protected:
  TDESocketAddressData *d;

  TDESocketAddress(TDESocketAddressData* d);
 
public:             // static
  static int ianaFamily(int af);

  static int fromIanaFamily(int iana);
};
 

class TDECORE_EXPORT KInetSocketAddress: public TDESocketAddress
{
  friend class TDESocketAddress;
public:
  KInetSocketAddress();

  KInetSocketAddress(const sockaddr* sa, TQ_UINT16 len);

  KInetSocketAddress(const KIpAddress& host, TQ_UINT16 port);

  KInetSocketAddress(const KInetSocketAddress& other);

  KInetSocketAddress(const TDESocketAddress& other);

  virtual ~KInetSocketAddress();

  KInetSocketAddress& operator =(const KInetSocketAddress& other);

  inline operator const sockaddr_in*() const
  { return (const sockaddr_in*)address(); }

  inline operator const sockaddr_in6*() const
  { return (const sockaddr_in6*)address(); }

  int ipVersion() const;

  KIpAddress ipAddress() const;

  KInetSocketAddress& setHost(const KIpAddress& addr);

  TQ_UINT16 port() const;

  KInetSocketAddress& setPort(TQ_UINT16 port);

  KInetSocketAddress& makeIPv4();

  KInetSocketAddress& makeIPv6();

  TQ_UINT32 flowinfo() const;

  KInetSocketAddress& setFlowinfo(TQ_UINT32 flowinfo);

  int scopeId() const;

  KInetSocketAddress& setScopeId(int scopeid);
 
protected:
  KInetSocketAddress(TDESocketAddressData* d);
 
private:
  void update();
};
 
/*
 * External definition
 */

class TDECORE_EXPORT KUnixSocketAddress: public TDESocketAddress
{
  friend class TDESocketAddress;
public:
  KUnixSocketAddress();

  KUnixSocketAddress(const sockaddr* sa, TQ_UINT16 len);

  KUnixSocketAddress(const KUnixSocketAddress& other);

  KUnixSocketAddress(const TQString& pathname);

  virtual ~KUnixSocketAddress();

  KUnixSocketAddress& operator =(const KUnixSocketAddress& other);

  inline operator const sockaddr_un*() const
  { return (const sockaddr_un*)address(); }

  TQString pathname() const;

  KUnixSocketAddress& setPathname(const TQString& path);
 
protected:
  KUnixSocketAddress(TDESocketAddressData* d);
};
 
}               // namespace KNetwork
 
#endif