kextsock.h

/*
 *  This file is part of the KDE libraries
 *  Copyright (C) 2000-2004 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 KEXTSOCK_H
#define KEXTSOCK_H
 
#include "tdelibs_export.h"
 
#ifdef Q_OS_UNIX
 
#include <sys/time.h>
 
#include <tqstring.h>
#include <tqptrlist.h>
#include <tqiodevice.h>
 
#include "kbufferedio.h"
#include "ksockaddr.h"
 
/* External reference to netdb.h */
struct addrinfo;
struct kde_addrinfo;
class KAddressInfo;     /* our abstraction of it */
class TQSocketNotifier;
 
/*
 * This is extending TQIODevice's error codes
 *
 * According to tqiodevice.h, the last error is IO_UnspecifiedError
 * These errors will never occur in functions declared in TQIODevice
 * (except open, but you shouldn't call open)
 */
#define IO_ListenError      (IO_UnspecifiedError+1)
#define IO_AcceptError      (IO_UnspecifiedError+2)
#define IO_LookupError      (IO_UnspecifiedError+3)
 
class KExtendedSocketPrivate;
class TDECORE_EXPORT KExtendedSocket: public TDEBufferedIO // public TQObject, public TQIODevice
{
  TQ_OBJECT
  
 
public:
  enum Flags
  {
    /* socket address families */
    /*
     * NOTE: if you change this, you have to change function valid_socket() as well
     * These values are hard coded!
     */
    anySocket = 0x00,
    knownSocket = 0x01,
    unixSocket = knownSocket | 0x02,
    inetSocket = knownSocket | 0x04,
    ipv4Socket = inetSocket | 0x100,
    ipv6Socket = inetSocket | 0x200,
 
    passiveSocket = 0x1000, /* passive socket (i.e., one that accepts connections) */
    canonName = 0x2000,     /* request that the canon name be found */
    noResolve = 0x4000,     /* do not attempt to resolve, treat as numeric host */
 
    streamSocket = 0x8000,  /* request a streaming socket (e.g., TCP) */
    datagramSocket = 0x10000,   /* request a datagram socket (e.g., UDP) */
    rawSocket = 0x20000,    /* request a raw socket. This probably requires privileges */
 
    inputBufferedSocket = 0x200000, /* buffer input in this socket */
    outputBufferedSocket = 0x400000, /* buffer output in this socket */
    bufferedSocket = 0x600000   /* make this a fully buffered socket */
  };
 
  enum SockStatus
  {
    // the numbers are scattered so that we leave room for future expansion
    error = -1,         // invalid status!
 
    nothing = 0,        // no status, the class has just been created
 
    lookupInProgress = 50,  // lookup is in progress. Signals will be sent
    lookupDone = 70,        // lookup has been done. Flags cannot be changed
                // from this point on
 
    created = 100,      // ::socket() has been called, a socket exists
    bound = 140,        // socket has been bound
 
    connecting = 200,       // socket is connecting (not passiveSocket)
    connected = 220,        // socket has connected (not passiveSocket)
 
    listening = 200,        // socket is listening (passiveSocket)
    accepting = 220,        // socket is accepting (passiveSocket)
 
    closing = 350,      // socket is closing (delayed close)
 
    done = 400          // socket has been closed
  };
 
public:
  KExtendedSocket();
 
  KExtendedSocket(const TQString& host, int port, int flags = 0);
 
  KExtendedSocket(const TQString& host, const TQString& service, int flags = 0);
 
  virtual ~KExtendedSocket();
 
  void reset();
 
  /*
   * --- status, flags and internal variables --- *
   */
 
  int socketStatus() const;
 
  int systemError() const;
 
  int setSocketFlags(int flags);
 
  int socketFlags() const;
 
  bool setHost(const TQString& host);
 
  TQString host() const;
 
  bool setPort(int port);
 
  bool setPort(const TQString& port);
 
  TQString port() const;
 
  bool setAddress(const TQString& host, int port);
 
  bool setAddress(const TQString& host, const TQString& serv);
 
  bool setBindHost(const TQString& host);
 
  bool unsetBindHost();
 
  TQString bindHost() const;
 
  bool setBindPort(int port);
 
  bool setBindPort(const TQString& service);
 
  bool unsetBindPort();
 
  TQString bindPort() const;
 
  bool setBindAddress(const TQString& host, int port);
 
  bool setBindAddress(const TQString& host, const TQString& service);
 
  bool unsetBindAddress();
 
  bool setTimeout(int secs, int usecs = 0);
 
  timeval timeout() const;
 
  bool setBlockingMode(bool enable);
 
  bool blockingMode();
 
  bool setAddressReusable(bool enable);
 
  bool addressReusable();
 
  bool setIPv6Only(bool enable);
 
  bool isIPv6Only();
 
  virtual bool setBufferSize(int rsize, int wsize = -2);
 
  const ::TDESocketAddress *localAddress();
 
  const ::TDESocketAddress *peerAddress();
 
  inline int fd() const
  { return sockfd; }
 
  /*
   * -- socket creation -- *
   */
 
  virtual int lookup();
 
  virtual int startAsyncLookup();
 
  virtual void cancelAsyncLookup();
 
  virtual int listen(int N = 5); // 5 is arbitrary
 
  virtual int accept(KExtendedSocket *&sock);
 
  virtual int connect();
 
  virtual int startAsyncConnect();
 
  virtual void cancelAsyncConnect();
 
  virtual bool open(int mode = (int)(IO_Raw | IO_ReadWrite));
 
  virtual void close();
 
  virtual void closeNow();
 
  virtual void release();
 
  /*
   * -- I/O --
   */
 
  virtual void flush();
 
  virtual inline TQ_ULONG size() const
  { return 0; }
 
  virtual inline TQ_ULONG at() const
  { return 0; }
 
  virtual inline bool at(int i)
  { Q_UNUSED(i);return true; }
 
  virtual inline bool atEnd() const
  { return false; }
 
  virtual TQ_LONG readBlock(char *data, TQ_ULONG maxlen);
 
  virtual TQ_LONG writeBlock(const char *data, TQ_ULONG len);
 
  virtual int peekBlock(char *data, uint maxlen);
 
  virtual int unreadBlock(const char *data, uint len);
 
  virtual int bytesAvailable() const;
 
  virtual int waitForMore(int msec);
 
  virtual int getch();
 
  virtual int putch(int ch);
 
  virtual int ungetch(int)
  { return -1; }
 
  virtual void enableRead(bool enable);
 
  virtual void enableWrite(bool enable);
 
signals:
  void lookupFinished(int count);
 
  void connectionSuccess();
 
  void connectionFailed(int error);
 
  void readyAccept();
 
protected:
  int sockfd;           // file descriptor of the socket
 
protected slots:
 
  void socketActivityRead();
  void socketActivityWrite();
  void dnsResultsReady();
  void startAsyncConnectSlot();
  void connectionEvent();
 
protected:
 
  TQSocketNotifier *readNotifier();
  TQSocketNotifier *writeNotifier();
 
private:
 
  // protection against accidental use
  KExtendedSocket(KExtendedSocket&);
  KExtendedSocket& operator=(KExtendedSocket&);
 
  static int doLookup(const TQString& host, const TQString& serv, addrinfo& hint,
              kde_addrinfo** result);
 
protected:
  void setError(int errorkind, int error);
 
  inline void cleanError()
  { setError(IO_Ok, 0); }
 
  void setSocketStatus(int status);
 
public:
  static int resolve(sockaddr* sock, ksocklen_t len, TQString& host, TQString& port, int flags = 0) TDE_DEPRECATED;
 
  static int resolve(::TDESocketAddress* sock, TQString& host, TQString& port, int flags = 0) TDE_DEPRECATED;
 
  static TQPtrList<KAddressInfo> lookup(const TQString& host, const TQString& port, int flags = 0, int *error = 0) TDE_DEPRECATED;
 
  static ::TDESocketAddress *localAddress(int fd) TDE_DEPRECATED;
 
  static ::TDESocketAddress *peerAddress(int fd) TDE_DEPRECATED;
 
  static TQString strError(int code, int syserr);
 
  static bool setAddressReusable(int fd, bool enable) TDE_DEPRECATED;
 
protected:
  virtual void virtual_hook( int id, void* data );
private:
  KExtendedSocketPrivate *d;
 
  friend class TDESocket;
  friend class TDEServerSocket;
};
 
class TDECORE_EXPORT KAddressInfo
{
private:
  addrinfo *ai;
  ::TDESocketAddress *addr;
 
  inline KAddressInfo() : ai(0), addr(0)
  { }
 
  //  KAddressInfo(addrinfo *ai);
  KAddressInfo(KAddressInfo&) { }
  KAddressInfo& operator=(KAddressInfo&) { return *this; }
 
public:
  ~KAddressInfo();
 
  inline TDE_DEPRECATED operator const ::TDESocketAddress*() const 
  { return addr; }
 
  inline TDE_DEPRECATED operator const addrinfo&() const
  { return *ai; }
 
  inline TDE_DEPRECATED operator const addrinfo*() const
  { return ai; }
 
  inline TDE_DEPRECATED const ::TDESocketAddress* address() const
  { return addr; }
 
  int flags() const TDE_DEPRECATED;
 
  int family() const TDE_DEPRECATED;
 
  int socktype() const TDE_DEPRECATED;
 
  int protocol() const TDE_DEPRECATED;
 
 
  const char* canonname() const TDE_DEPRECATED;
 
  inline int length() const
  { if (addr) return addr->size(); return 0; }
 
  friend class KExtendedSocket;
};
 
#endif //Q_OS_UNIX
 
#endif // KEXTSOCK_H