k3socketaddress.h

Go to the documentation of this file.

//krazy:excludeall=dpointer,inline (lightweight classes; kde3 support)
/*  -*- C++ -*-
 *  Copyright (C) 2003,2005 Thiago Macieira <thiago@kde.org>
 *
 *
 *  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 KSOCKETADDRESS_H
#define KSOCKETADDRESS_H

#include <kdecore_export.h>
#include <QtCore/QByteArray>

struct sockaddr;
struct sockaddr_in;
struct sockaddr_in6;
struct sockaddr_un;

namespace KNetwork {

class KIpAddress;
class KSocketAddress;
class KInetSocketAddress;
class KUnixSocketAddress;

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

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

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

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

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

  inline KIpAddress(quint32 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 QString& address);

  bool setAddress(const char* address);

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

  QString toString() const;

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

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

  /*-- 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 : (IPv4Addr() & 0x80000000) == 0; }

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

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

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

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

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

  inline bool isSiteLocal() const
  {
    if (version() != 6) return false;
    quint8* addr = (quint8*)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;
    quint32* addr = (quint32*)this->addr();
    return addr[0] == 0 && addr[1] == 0 &&
      ((quint16*)&addr[2])[0] == 0 &&
      ((quint16*)&addr[2])[1] == 0xffff;
  }

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

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

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

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

  inline bool isMulticastGlobal() const
  { return version() == 6 && isMulticast() && (((quint32*)addr())[0] & 0xf) == 0xe; }

protected:
  quint32 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 KSocketAddressData;
class KDECORE_EXPORT KSocketAddress //krazy:exclude=dpointer (we got one, just not called Private)
{
public:
  KSocketAddress();

  KSocketAddress(const sockaddr* sa, quint16 len);

  KSocketAddress(const KSocketAddress& other);

  virtual ~KSocketAddress();

  KSocketAddress& operator =(const KSocketAddress& other);

  const sockaddr* address() const;

  sockaddr* address();

  KSocketAddress& setAddress(const sockaddr *sa, quint16 len);

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

  quint16 length() const;

  KSocketAddress& setLength(quint16 len);

  int family() const;

  virtual KSocketAddress& setFamily(int family);

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

  virtual QString nodeName() const;

  virtual QString serviceName() const;

  virtual QString toString() const;

  KInetSocketAddress& asInet();

  KInetSocketAddress asInet() const;

  KUnixSocketAddress& asUnix();

  KUnixSocketAddress asUnix() const;

protected:
  KSocketAddressData *d;

  KSocketAddress(KSocketAddressData* d);

public:             // static
  static int ianaFamily(int af);

  static int fromIanaFamily(int iana);
};


class KDECORE_EXPORT KInetSocketAddress: public KSocketAddress
{
  friend class KSocketAddress;
public:
  KInetSocketAddress();

  KInetSocketAddress(const sockaddr* sa, quint16 len);

  KInetSocketAddress(const KIpAddress& host, quint16 port);

  KInetSocketAddress(const KInetSocketAddress& other);

  KInetSocketAddress(const KSocketAddress& 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);

  quint16 port() const;

  KInetSocketAddress& setPort(quint16 port);

  KInetSocketAddress& makeIPv4();

  KInetSocketAddress& makeIPv6();

  quint32 flowinfo() const;

  KInetSocketAddress& setFlowinfo(quint32 flowinfo);

  int scopeId() const;

  KInetSocketAddress& setScopeId(int scopeid);

protected:
  KInetSocketAddress(KSocketAddressData* d);

private:
  void update();
};

/*
 * External definition
 */

class KDECORE_EXPORT KUnixSocketAddress: public KSocketAddress
{
  friend class KSocketAddress;
public:
  KUnixSocketAddress();

  KUnixSocketAddress(const sockaddr* sa, quint16 len);

  KUnixSocketAddress(const KUnixSocketAddress& other);

  KUnixSocketAddress(const QString& pathname);

  virtual ~KUnixSocketAddress();

  KUnixSocketAddress& operator =(const KUnixSocketAddress& other);

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

  QString pathname() const;

  KUnixSocketAddress& setPathname(const QString& path);

protected:
  KUnixSocketAddress(KSocketAddressData* d);
};

}               // namespace KNetwork

#endif