ksockaddr.h

/*
 *  This file is part of the KDE libraries
 *  Copyright (C) 2000-2003 Thiago Macieira <thiago.macieira@kdemail.net>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public License
 *  along with this library; see the file COPYING.LIB.  If not, write to
 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA 02110-1301, USA.
 */
#ifndef KSOCKADDR_H
#define KSOCKADDR_H
 
#include <tqobject.h>
#include <tqcstring.h>
#include <tqstring.h>
#include "tdelibs_export.h"
 
/*
 * This file defines a class that envelopes most, if not all, socket addresses
 */
typedef unsigned ksocklen_t;
 
struct sockaddr;
 
class KExtendedSocket;      // No need to define it fully
 
class TDESocketAddressPrivate;
class TDECORE_EXPORT TDESocketAddress: public TQObject
{
  TQ_OBJECT
protected:
  TDESocketAddress() { init(); }

  TDESocketAddress(const sockaddr* sa, ksocklen_t size);
 
public:
  virtual ~TDESocketAddress();

  virtual TQString pretty() const;

  const sockaddr* address() const
  { return data; }

  virtual ksocklen_t size() const
  { return datasize; }

  operator const sockaddr*() const
  { return data; }

  int family() const;

  inline int ianaFamily() const
  { return ianaFamily(family()); }

  virtual bool isEqual(const TDESocketAddress& other) const;
  bool isEqual(const TDESocketAddress* other) const
  { return isEqual(*other); }

  bool operator==(const TDESocketAddress& other) const
  { return isEqual(other); }

  bool isCoreEqual(const TDESocketAddress& other) const;

  bool isCoreEqual(const TDESocketAddress* other) const
  { return isCoreEqual(*other); }

  virtual TQString nodeName() const;

  virtual TQString serviceName() const;
 
protected:
  sockaddr* data;
  ksocklen_t    datasize;
  bool      owndata;
 
private:
  void init();
  /* No copy constructor */
  TDESocketAddress(TDESocketAddress&);
  TDESocketAddress& operator=(TDESocketAddress&);
 
public:
  static TDESocketAddress* newAddress(const struct sockaddr *sa, ksocklen_t size);

  static int ianaFamily(int af);

  static int fromIanaFamily(int iana);
 
  friend class KExtendedSocket;
protected:
  virtual void virtual_hook( int id, void* data );
private:
  TDESocketAddressPrivate* d;
};
 
/*
 * External definitions
 * We need these for KInetSocketAddress
 */
struct sockaddr_in;
struct sockaddr_in6;
struct in_addr;
struct in6_addr;
 
class KInetSocketAddressPrivate;
class TDECORE_EXPORT KInetSocketAddress: public ::TDESocketAddress
{
  TQ_OBJECT
public:
  KInetSocketAddress();

  KInetSocketAddress(const KInetSocketAddress&);

  KInetSocketAddress(const sockaddr_in* sin, ksocklen_t len);

  KInetSocketAddress(const sockaddr_in6* sin6, ksocklen_t len);

  KInetSocketAddress(const in_addr& addr, unsigned short port);

  KInetSocketAddress(const in6_addr& addr, unsigned short port);

  KInetSocketAddress(const TQString& addr, unsigned short port, int family = -1);

  virtual ~KInetSocketAddress();

  bool setAddress(const KInetSocketAddress& ksa);

  bool setAddress(const sockaddr_in* sin, ksocklen_t len);

  bool setAddress(const sockaddr_in6* sin6, ksocklen_t len);

  bool setAddress(const in_addr& addr, unsigned short port);

  bool setAddress(const in6_addr& addr, unsigned short port);

  bool setAddress(const TQString& addr, unsigned short port, int family = -1);

  bool setHost(const in_addr& addr);

  bool setHost(const in6_addr& addr);

  bool setHost(const TQString& addr, int family = -1);

  bool setPort(unsigned short port);

  bool setFamily(int family);

  bool setFlowinfo(TQ_UINT32 flowinfo);

  bool setScopeId(int scopeid);

  virtual TQString pretty() const;

  virtual TQString nodeName() const;
  //  TQString prettyHost() const;

  virtual TQString serviceName() const;

  const sockaddr_in* addressV4() const;

  const sockaddr_in6* addressV6() const;

  in_addr hostV4() const;

  in6_addr hostV6() const;

  unsigned short port() const;

  TQ_UINT32 flowinfo() const;

  int scopeId() const;

  virtual ksocklen_t size() const; // should be socklen_t
 
  /* comparation */
  static bool areEqualInet(const TDESocketAddress &s1, const TDESocketAddress &s2, bool coreOnly);

  static bool areEqualInet6(const TDESocketAddress &s1, const TDESocketAddress &s2, bool coreOnly);
 
  /* operators */

  operator const sockaddr_in*() const
  { return addressV4(); }

  operator const sockaddr_in6*() const
  { return addressV6(); }

  KInetSocketAddress& operator=(const KInetSocketAddress &other)
  { setAddress(other); return *this; }
 
private:
 
  void fromV4();
  void fromV6();
 
public:
  static TQString addrToString(int family, const void *addr);

  static bool stringToAddr(int family, const char *text, void *dest);
 
  friend class KExtendedSocket;
protected:
  virtual void virtual_hook( int id, void* data );
private:
  KInetSocketAddressPrivate* d;
};
 
extern const ::KInetSocketAddress addressAny, addressLoopback;
 
/*
 * External definition KUnixSocketAddress
 */
struct sockaddr_un;
 
class KUnixSocketAddressPrivate;
class TDECORE_EXPORT KUnixSocketAddress: public ::TDESocketAddress
{
  TQ_OBJECT
public:
  KUnixSocketAddress();

  KUnixSocketAddress(const sockaddr_un* raw_data, ksocklen_t size);

  KUnixSocketAddress(TQCString pathname);

  virtual ~KUnixSocketAddress();

  bool setAddress(const sockaddr_un* socket_address, ksocklen_t size);

  bool setAddress(TQCString path);

  TQCString pathname() const;

  virtual TQString pretty() const;
 
  /*
   * Returns the path in the form of a TQString.
   * This can be fed into KExtendedSocket.
   * @return the path (can be TQString::null).
   * @see pathname()
   */
  virtual TQString serviceName() const;

  const sockaddr_un* address() const;

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

  static bool areEqualUnix(const TDESocketAddress &s1, const TDESocketAddress &s2, bool coreOnly);
 
private:
  void init();
 
  friend class KExtendedSocket;
protected:
  virtual void virtual_hook( int id, void* data );
private:
  KUnixSocketAddressPrivate* d;
};
 
#endif // KSOCKADDR_H