Actually move the kde files that were renamed in the last commit

1 files changed, 683 insertions, 0 deletions

diff --git a/tdecore/ksockaddr.h b/tdecore/ksockaddr.h
new file mode 100644
index 000000000..04ae350aa
--- /dev/null
+++ b/tdecore/ksockaddr.h
@@ -0,0 +1,683 @@
+/*
+ *  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 "kdelibs_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 KSocketAddressPrivate;
+/**
+ * A socket address.
+ *
+ * This class envelopes almost if not all socket addresses.
+ *
+ * @author Thiago Macieira <thiago.macieira@kdemail.net>
+ * @short a socket address.
+ */
+class KDECORE_EXPORT KSocketAddress: public TQObject
+{
+  Q_OBJECT
+protected:
+  /**
+   * Creates an empty class
+   */
+  KSocketAddress() { init(); }
+
+  /**
+   * Creates with given data
+   * @param sa a sockaddr structure
+   * @param size the size of @p sa
+   */
+  KSocketAddress(const sockaddr* sa, ksocklen_t size);
+
+public:
+  /**
+   * Destructor.
+   */
+  virtual ~KSocketAddress();
+
+  /**
+   * Returns a string representation of this socket.
+   * @return a pretty string representation
+   */
+  virtual TQString pretty() const;
+
+  /**
+   * Returns a sockaddr structure, for passing down to library functions.
+   * @return the sockaddr structure, can be 0
+   */
+  const sockaddr* address() const
+  { return data; }
+
+  /**
+   * Returns sockaddr structure size.
+   * @return the size of the sockaddr structre, 0 if there is none.
+   */
+  virtual ksocklen_t size() const
+  { return datasize; }
+
+  /**
+   * Returns a sockaddr structure, for passing down to library functions.
+   * @return the sockaddr structure, can be 0.
+   * @see address()
+   */
+  operator const sockaddr*() const
+  { return data; }
+
+  /**
+   * Returns the family of this address.
+   * @return the family of this address, AF_UNSPEC if it's undefined
+   */
+  int family() const;
+
+  /**
+   * Returns the IANA family number of this address.
+   * @return the IANA family number of this address (1 for AF_INET.
+   *         2 for AF_INET6, otherwise 0)
+   */
+  inline int ianaFamily() const
+  { return ianaFamily(family()); }
+
+  /**
+   * Returns true if this equals the other socket.
+   * @param other	the other socket
+   * @return true if both sockets are equal
+   */
+  virtual bool isEqual(const KSocketAddress& other) const;
+  bool isEqual(const KSocketAddress* other) const
+  { return isEqual(*other); }
+
+  /**
+   * Overloaded == operator.
+   * @see isEqual()
+   */
+  bool operator==(const KSocketAddress& other) const
+  { return isEqual(other); }
+
+  /**
+   * Some sockets may differ in such things as services or port numbers,
+   * like Internet sockets. This function compares only the core part
+   * of that, if possible.
+   *
+   * If not possible, like the default implementation, this returns
+   * the same as isEqual.
+   * @param other	the other socket
+   * @return true if the code part is equal
+   */
+  bool isCoreEqual(const KSocketAddress& other) const;
+
+  /**
+   * Some sockets may differ in such things as services or port numbers,
+   * like Internet sockets. This function compares only the core part
+   * of that, if possible.
+   *
+   * If not possible, like the default implementation, this returns
+   * the same as isEqual.
+   * @param other	the other socket
+   * @return true if the code part is equal
+   */
+  bool isCoreEqual(const KSocketAddress* other) const
+  { return isCoreEqual(*other); }
+
+  /**
+   * Returns the node name of this socket, as KExtendedSocket::lookup expects
+   * as the first argument.
+   * In the case of Internet sockets, this is the hostname.
+   * The default implementation returns TQString::null.
+   * @return the node name, can be TQString::null
+   */
+  virtual TQString nodeName() const;
+
+  /**
+   * Returns the service name for this socket, as KExtendedSocket::lookup expects
+   * as the service argument.
+   * In the case of Internet sockets, this is the port number.
+   * The default implementation returns TQString::null.
+   * @return the service name, can be TQString::null
+   */
+  virtual TQString serviceName() const;
+
+protected:
+  sockaddr*	data;
+  ksocklen_t	datasize;
+  bool		owndata;
+
+private:
+  void init();
+  /* No copy constructor */
+  KSocketAddress(KSocketAddress&);
+  KSocketAddress& operator=(KSocketAddress&);
+
+public:
+  /**
+   * Creates a new KSocketAddress or descendant class from given
+   * raw socket address.
+   * @param sa		new socket address
+   * @param size	new socket address's length
+   * @return the new KSocketAddress, or 0 if the function failed
+   */
+  static KSocketAddress* newAddress(const struct sockaddr *sa, ksocklen_t size);
+
+  /**
+   * Returns the IANA family number of the given address family.
+   * Returns 0 if there is no corresponding IANA family number.
+   * @param af		the address family, in AF_* constants
+   * @return the IANA family number of this address (1 for AF_INET.
+   *         2 for AF_INET6, otherwise 0)
+   */
+  static int ianaFamily(int af);
+
+  /**
+   * Returns the address family of the given IANA family number.
+   * @return the address family, AF_UNSPEC for unknown IANA family numbers
+   */
+  static int fromIanaFamily(int iana);
+
+  friend class KExtendedSocket;
+protected:
+  virtual void virtual_hook( int id, void* data );
+private:
+  KSocketAddressPrivate* d;
+};
+
+/*
+ * External definitions
+ * We need these for KInetSocketAddress
+ */
+struct sockaddr_in;
+struct sockaddr_in6;
+struct in_addr;
+struct in6_addr;
+
+class KInetSocketAddressPrivate;
+/**
+ * An Inet (IPv4 or IPv6) socket address
+ *
+ * This is an IPv4 or IPv6 address of the Internet
+ *
+ * This class inherits most of the functionality from KSocketAddress, but
+ * is targeted specifically to Internet addresses
+ *
+ * @author Thiago Macieira <thiago.macieira@kdemail.net>
+ * @short an Internet socket address
+ */
+class KDECORE_EXPORT KInetSocketAddress: public ::KSocketAddress
+{
+  Q_OBJECT
+public:
+  /**
+   * Default constructor. Does nothing
+   */
+  KInetSocketAddress();
+
+  /**
+   * Copy constructor
+   */
+  KInetSocketAddress(const KInetSocketAddress&);
+
+  /**
+   * Creates an IPv4 socket from raw sockaddr_in.
+   * @param sin		a sockaddr_in structure to copy from
+   * @param len		the socket address length
+   */
+  KInetSocketAddress(const sockaddr_in* sin, ksocklen_t len);
+
+  /**
+   * Creates an IPv6 socket from raw sockaddr_in6.
+   * @param sin6       	a sockaddr_in6 structure to copy from
+   * @param len		the socket address length
+   */
+  KInetSocketAddress(const sockaddr_in6* sin6, ksocklen_t len);
+
+  /**
+   * Creates a socket from information.
+   * @param addr	a binary address
+   * @param port	a port number
+   */
+  KInetSocketAddress(const in_addr& addr, unsigned short port);
+
+  /**
+   * Creates a socket from information.
+   * @param addr	a binary address
+   * @param port	a port number
+   */
+  KInetSocketAddress(const in6_addr& addr, unsigned short port);
+
+  /**
+   * Creates a socket from text representation.
+   *
+   * @param addr	a text representation of the address
+   * @param port	a port number
+   * @param family	the family for this address. Use -1 to guess the
+   *                    family type
+   * @see setAddress
+   */
+  KInetSocketAddress(const TQString& addr, unsigned short port, int family = -1);
+
+  /**
+   * Destructor
+   */
+  virtual ~KInetSocketAddress();
+
+  /**
+   * Sets this socket to given socket.
+   * @param ksa		the other socket
+   * @return true if successful, false otherwise
+   */
+  bool setAddress(const KInetSocketAddress& ksa);
+
+  /**
+   * Sets this socket to given raw socket.
+   * @param sin		the raw socket
+   * @param len		the socket address length
+   * @return true if successful, false otherwise
+   */
+  bool setAddress(const sockaddr_in* sin, ksocklen_t len);
+
+  /**
+   * Sets this socket to given raw socket.
+   *
+   * Note: this function does not clear the scope ID and flow info values
+   * @param sin6	the raw socket
+   * @param len		the socket address length
+   * @return true if successful, false otherwise
+   */
+  bool setAddress(const sockaddr_in6* sin6, ksocklen_t len);
+
+  /**
+   * Sets this socket to raw address and port.
+   * @param addr	the address
+   * @param port	the port number
+   * @return true if successful, false otherwise
+   */
+  bool setAddress(const in_addr& addr, unsigned short port);
+
+  /**
+   * Sets this socket to raw address and port.
+   * @param addr	the address
+   * @param port	the port number
+   * @return true if successful, false otherwise
+   */
+  bool setAddress(const in6_addr& addr, unsigned short port);
+
+  /**
+   * Sets this socket to text address and port
+   *
+   * You can use the @p family parameter to specify what kind of socket
+   * you want this to be. It could be AF_INET or AF_INET6 or -1.
+   *
+   * If the value is -1 (default), this function will make an effort to
+   * discover what is the family. That isn't too hard, actually, and it
+   * works in all cases. But, if you want to be sure that your socket
+   * is of the type you want, use this parameter.
+   *
+   * This function returns false if the socket address was not valid.
+   * @param addr	the address
+   * @param port	the port number
+   * @param family	the address family, -1 for any
+   * @return true if successful, false otherwise
+   */
+  bool setAddress(const TQString& addr, unsigned short port, int family = -1);
+
+  /**
+   * Sets this socket's host address to given raw address.
+   * @param addr	the address
+   * @return true if successful, false otherwise
+   */
+  bool setHost(const in_addr& addr);
+
+  /**
+   * Sets this socket's host address to given raw address.
+   * @param addr	the address
+   * @return true if successful, false otherwise
+   */
+  bool setHost(const in6_addr& addr);
+
+  /**
+   * Sets this socket's host address to given text representation.
+   * @param addr	the address
+   * @param family	the address family, -1 to guess the family
+   * @return true if successful, false otherwise
+   */
+  bool setHost(const TQString& addr, int family = -1);
+
+  /**
+   * Sets this socket's port number to given port number.
+   * @param port	the port number
+   * @return true if successful, false otherwise
+   */
+  bool setPort(unsigned short port);
+
+  /**
+   * Turns this into an IPv4 or IPv6 address.
+   *
+   * @param family the new address family
+   * @return false if this is v6 and information was lost. That doesn't
+   * mean the conversion was unsuccessful.
+   */
+  bool setFamily(int family);
+
+  /**
+   * Sets flowinfo information for this socket address if this is IPv6.
+   * @param flowinfo	flowinfo
+   * @return true if successful, false otherwise
+   */
+  bool setFlowinfo(TQ_UINT32 flowinfo);
+
+  /**
+   * Sets the scope id for this socket if this is IPv6.
+   * @param scopeid	the scope id
+   * @return true if successful, false otherwise
+   */
+  bool setScopeId(int scopeid);
+
+  /**
+   * Returns a pretty representation of this address.
+   * @return a pretty representation
+   */
+  virtual TQString pretty() const;
+
+  /**
+   * Returns the text representation of the host address.
+   * @return a text representation of the host address
+   */
+  virtual TQString nodeName() const;
+  //  TQString prettyHost() const;
+
+  /**
+   * Returns the text representation of the port number.
+   * @return the name of the service (a number)
+   */
+  virtual TQString serviceName() const;
+
+  /**
+   * Returns the socket address.
+   *
+   * This will be NULL if this is a non-convertible v6.
+   * This function will return an IPv4 socket if this IPv6
+   * socket is a v4-mapped address. That is, if it's really
+   * an IPv4 address, but in v6 disguise.
+   * @return the sockaddr_in struct, can be 0.
+   */
+  const sockaddr_in* addressV4() const;
+
+  /**
+   * Returns the socket address in IPv6
+   * @return the sockaddr_in struct, can be 0 if IPv6 is unsupported.
+   */
+  const sockaddr_in6* addressV6() const;
+
+  /**
+   * Returns the host address.
+   * Might be empty.
+   * @return the host address
+   */
+  in_addr hostV4() const;
+
+  /**
+   * Returns the host address.
+   *
+   * WARNING: this function is not defined if there is no IPv6 support
+   * @return the host address
+   */
+  in6_addr hostV6() const;
+
+  /**
+   * Returns the port number.
+   * @return the port number
+   */
+  unsigned short port() const;
+
+  /**
+   * Returns flowinfo for IPv6 socket.
+   * @return the flowinfo, 0 if unsupported
+   */
+  TQ_UINT32 flowinfo() const;
+
+  /**
+   * Returns the scope id for this IPv6 socket.
+   * @return the scope id
+   */
+  int scopeId() const;
+
+  /**
+   * Returns the socket length.
+   * Will be either sizeof(sockaddr_in) or sizeof(sockaddr_in6)
+   * @return the length of the socket
+   */
+  virtual ksocklen_t size() const; // should be socklen_t
+
+  /* comparation */
+  /**
+   * Compares two IPv4 addresses.
+   * @param s1 the first address to compare
+   * @param s2 the second address to compare
+   * @param coreOnly true if only core parts should be compared (only
+   *                 the address)
+   * @return true if the given addresses are equal.
+   * @see areEqualInet6()
+   * @see KSocketAddress::isEqual()
+   * @see KSocketAddress::isCoreEqual()
+   */
+  static bool areEqualInet(const KSocketAddress &s1, const KSocketAddress &s2, bool coreOnly);
+
+  /**
+   * Compares two IPv6 addresses.
+   * @param s1 the first address to compare
+   * @param s2 the second address to compare
+   * @param coreOnly true if only core parts should be compared (only
+   *                 the address)
+   * @return true if the given addresses are equal.
+   * @see areEqualInet()
+   * @see KSocketAddress::isEqual()
+   * @see KSocketAddress::isCoreEqual()
+   */
+  static bool areEqualInet6(const KSocketAddress &s1, const KSocketAddress &s2, bool coreOnly);
+
+  /* operators */
+
+  /**
+   * Returns the socket address.
+   * This will be NULL if this is a non-convertible v6.
+   * @return the sockaddr_in structure, can be 0 if v6.
+   * @see addressV4()
+   */
+  operator const sockaddr_in*() const
+  { return addressV4(); }
+
+  /**
+   * Returns the socket address.
+   * @return the sockaddr_in structure, can be 0 if v6 is unsupported.
+   * @see addressV6()
+   */
+  operator const sockaddr_in6*() const
+  { return addressV6(); }
+
+  /**
+   * Sets this object to be the same as the other.
+   */
+  KInetSocketAddress& operator=(const KInetSocketAddress &other)
+  { setAddress(other); return *this; }
+
+private:
+
+  void fromV4();
+  void fromV6();
+
+public:
+  /**
+   * Convert s the given raw address into text form.
+   * This function returns TQString::null if the address cannot be converted.
+   * @param family	the family of the address
+   * @param addr	the address, in raw form
+   * @return the converted address, or TQString::null if not possible.
+   */
+  static TQString addrToString(int family, const void *addr);
+
+  /**
+   * Converts the address given in text form into raw form.
+   * The size of the destination buffer @p dest is supposed to be
+   * large enough to hold the address of the given family.
+   * @param family	the family of the address
+   * @param text	the text representation of the address
+   * @param dest	the destination buffer of the address
+   * @return true if convertion was successful.
+   */
+  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;
+/**
+ * A Unix socket address
+ *
+ * This is a Unix socket address.
+ *
+ * This class expects TQCString instead of TQString values, which means the
+ * filenames should be encoded in whatever form locale/system deems necessary
+ * before passing down to the function
+ *
+ * @author Thiago Macieira <thiago.macieira@kdemail.net>
+ * @short a Unix socket address
+ */
+class KDECORE_EXPORT KUnixSocketAddress: public ::KSocketAddress
+{
+  Q_OBJECT
+public:
+  /**
+   * Default constructor
+   */
+  KUnixSocketAddress();
+
+  /**
+   * Constructor from raw data.
+   * @param raw_data	raw data
+   * @param size	data length
+   */
+  KUnixSocketAddress(const sockaddr_un* raw_data, ksocklen_t size);
+
+  /**
+   * Constructor from pathname.
+   * @param pathname	pathname
+   */
+  KUnixSocketAddress(TQCString pathname);
+
+  /**
+   * Destructor
+   */
+  virtual ~KUnixSocketAddress();
+
+  /**
+   * Sets this to given sockaddr_un.
+   * @param socket_address socket address
+   * @param size	the socket length
+   * @return true if successful, false otherwise
+   */
+  bool setAddress(const sockaddr_un* socket_address, ksocklen_t size);
+
+  /**
+   * Sets this to given pathname.
+   * @param path	pathname
+   * @return true if successful, false otherwise
+   */
+  bool setAddress(TQCString path);
+
+  /**
+   * Returns the pathname.
+   * @return the pathname, can be TQCString::null if uninitialized, or
+   *         "" if unknown
+   */
+  TQCString pathname() const;
+
+  /**
+   * Returns pretty representation of this socket.
+   * @return a pretty text representation of the socket.
+   */
+  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;
+
+  /**
+   * Returns raw socket address.
+   * @return the raw socket address (can be 0 if uninitialized)
+   */
+  const sockaddr_un* address() const;
+
+  /**
+   * Returns raw socket address.
+   * @return the raw socket address (can be 0 if uninitialized)
+   * @see address()
+   */
+  operator const sockaddr_un*() const
+  { return address(); }
+
+  /**
+   * Compares two unix socket addresses.
+   * @param s1 the first address to compare
+   * @param s2 the second address to compare
+   * @param coreOnly true if only core parts should be compared (currently
+   *                 unused)
+   * @return true if the given addresses are equal.
+   * @see KSocketAddress::isEqual()
+   * @see KSocketAddress::isCoreEqual()
+   */
+  static bool areEqualUnix(const KSocketAddress &s1, const KSocketAddress &s2, bool coreOnly);
+
+private:
+  void init();
+
+  friend class KExtendedSocket;
+protected:
+  virtual void virtual_hook( int id, void* data );
+private:
+  KUnixSocketAddressPrivate* d;
+};
+
+#endif // KSOCKADDR_H