tdesocketbase.h

/*
 *  Copyright (C) 2003,2005 Thiago Macieira <thiago.macieira@kdemail.net>
 *
 *
 *  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.
 */
 
/*
 * Even before our #ifdef, clean up the namespace
 */
#ifdef socket
#undef socket
#endif
 
#ifdef bind
#undef bind
#endif
 
#ifdef listen
#undef listen
#endif
 
#ifdef connect
#undef connect
#endif
 
#ifdef accept
#undef accept
#endif
 
#ifdef getpeername
#undef getpeername
#endif
 
#ifdef getsockname
#undef getsockname
#endif
 
#ifndef TDESOCKETBASE_H
#define TDESOCKETBASE_H
 
#include <tqiodevice.h>
#include <tqstring.h>
 
#include "tdesocketaddress.h"
#include <tdelibs_export.h>
 
/*
 * 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)
#define IO_SocketCreateError    (IO_UnspecifiedError+4)
#define IO_BindError        (IO_UnspecifiedError+5)
 
class TQMutex;
 
namespace KNetwork {
 
class KResolverEntry;
class TDESocketDevice;
 
class TDESocketBasePrivate;
class TDECORE_EXPORT TDESocketBase
{
public:
  enum SocketOptions
    {
      Blocking = 0x01,
      AddressReuseable = 0x02,
      IPv6Only = 0x04,
      Keepalive = 0x08,
      Broadcast = 0x10
    };
 
  enum SocketError
    {
      NoError = 0,
      LookupFailure,
      AddressInUse,
      AlreadyCreated,
      AlreadyBound,
      AlreadyConnected,
      NotConnected,
      NotBound,
      NotCreated,
      WouldBlock,
      ConnectionRefused,
      ConnectionTimedOut,
      InProgress,
      NetFailure,
      NotSupported,
      Timeout,
      UnknownError,
      RemotelyDisconnected
    };
 
public:
  TDESocketBase();
 
  virtual ~TDESocketBase();
 
  /*
   * The following functions are shared by all descended classes and will have
   * to be reimplemented.
   */
 
protected:
  virtual bool setSocketOptions(int opts);
 
  virtual int socketOptions() const;
 
public:
  virtual bool setBlocking(bool enable);
 
  bool blocking() const;
 
  virtual bool setAddressReuseable(bool enable);
 
  bool addressReuseable() const;
 
  virtual bool setIPv6Only(bool enable);
 
  bool isIPv6Only() const;
 
  virtual bool setBroadcast(bool enable);
 
  bool broadcast() const;
 
  TDESocketDevice* socketDevice() const;
 
  virtual void setSocketDevice(TDESocketDevice* device);
 
  int setRequestedCapabilities(int add, int remove = 0);
 
protected:
  bool hasDevice() const;
 
  void setError(SocketError error);
 
public:
  SocketError error() const;
 
  inline TQString errorString() const
  { return errorString(error()); }
 
  TQMutex* mutex() const;
 
public:
  static TQString errorString(SocketError code);
 
  static bool isFatalError(int code);
 
private:
  void unsetSocketDevice();
 
  TDESocketBase(const TDESocketBase&);
  TDESocketBase& operator =(const TDESocketBase&);
 
  TDESocketBasePrivate *d;
 
  friend class TDESocketDevice;
};
 
class TDECORE_EXPORT KActiveSocketBase: public TQIODevice, virtual public TDESocketBase
{
public:
  KActiveSocketBase();
 
  virtual ~KActiveSocketBase();
 
  virtual bool bind(const KResolverEntry& address) = 0;
 
  virtual bool connect(const KResolverEntry& address) = 0;
 
  virtual bool disconnect() = 0;
 
  virtual Offset size() const
  { return 0; }
 
  virtual Offset at() const
  { return 0; }
 
  virtual bool at(Offset)
  { return false; }
 
  virtual bool atEnd() const
  { return true; }
 
  virtual TQ_LONG bytesAvailable() const = 0;
 
  virtual TQ_LONG waitForMore(int msecs, bool *timeout = 0L) = 0;
 
  virtual TQ_LONG readBlock(char *data, TQ_ULONG len) = 0;
 
  virtual TQ_LONG readBlock(char *data, TQ_ULONG maxlen, TDESocketAddress& from) = 0;
 
  virtual TQ_LONG peekBlock(char *data, TQ_ULONG maxlen) = 0;
 
  virtual TQ_LONG peekBlock(char *data, TQ_ULONG maxlen, TDESocketAddress& from) = 0;
 
  virtual TQ_LONG writeBlock(const char *data, TQ_ULONG len) = 0;
 
  virtual TQ_LONG writeBlock(const char *data, TQ_ULONG len, const TDESocketAddress& to) = 0;
 
  virtual int getch();
 
  virtual int putch(int ch);
 
  virtual int ungetch(int)
  { return -1; }
 
  virtual TDESocketAddress localAddress() const = 0;
 
  virtual TDESocketAddress peerAddress() const = 0;
 
  // FIXME KDE 4.0:
  // enable this function
#if 0
  virtual TDESocketAddress externalAddress() const = 0;
#endif
 
protected:
  void setError(int status, SocketError error);
 
  void resetError();
};
 
class TDECORE_EXPORT KPassiveSocketBase: virtual public TDESocketBase
{
public:
  KPassiveSocketBase();
 
  virtual ~KPassiveSocketBase();
 
  virtual bool bind(const KResolverEntry& address) = 0;
 
  virtual bool listen(int backlog) = 0;
 
  virtual void close() = 0;
 
  virtual KActiveSocketBase* accept() = 0;
 
  virtual TDESocketAddress localAddress() const = 0;
 
  virtual TDESocketAddress externalAddress() const = 0;
 
private:
  KPassiveSocketBase(const KPassiveSocketBase&);
  KPassiveSocketBase& operator = (const KPassiveSocketBase&);
};
 
}               // namespace KNetwork
 
#endif