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