• Skip to content
• Skip to link menu

KDE 3.5 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

KDECore

kextsock.h

Go to the documentation of this file.

/*
 *  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 "kdelibs_export.h"

#ifdef Q_OS_UNIX

#include <sys/time.h>

#include <qstring.h>
#include <qptrlist.h>
#include <qiodevice.h>

#include "kbufferedio.h"
#include "ksockaddr.h"

/* External reference to netdb.h */
struct addrinfo;
struct kde_addrinfo;
class KAddressInfo;     /* our abstraction of it */
class QSocketNotifier;

/*
 * This is extending QIODevice's error codes
 *
 * According to qiodevice.h, the last error is IO_UnspecifiedError
 * These errors will never occur in functions declared in QIODevice
 * (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 KDECORE_EXPORT KExtendedSocket: public KBufferedIO // public QObject, public QIODevice
{
  Q_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 QString& host, int port, int flags = 0);

  KExtendedSocket(const QString& host, const QString& 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 QString& host);

  QString host() const;

  bool setPort(int port);

  bool setPort(const QString& port);

  QString port() const;

  bool setAddress(const QString& host, int port);

  bool setAddress(const QString& host, const QString& serv);

  bool setBindHost(const QString& host);

  bool unsetBindHost();

  QString bindHost() const;

  bool setBindPort(int port);

  bool setBindPort(const QString& service);

  bool unsetBindPort();

  QString bindPort() const;

  bool setBindAddress(const QString& host, int port);

  bool setBindAddress(const QString& host, const QString& 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 ::KSocketAddress *localAddress();

  const ::KSocketAddress *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 = IO_Raw | IO_ReadWrite);

  virtual void close();

  virtual void closeNow();

  virtual void release();

  /*
   * -- I/O --
   */

  virtual void flush();

  virtual inline Q_ULONG size() const
  { return 0; }

  virtual inline Q_ULONG at() const
  { return 0; }

  virtual inline bool at(int i)
  { Q_UNUSED(i);return true; }

  virtual inline bool atEnd() const
  { return false; }

  virtual Q_LONG readBlock(char *data, Q_ULONG maxlen);

  virtual Q_LONG writeBlock(const char *data, Q_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:

  QSocketNotifier *readNotifier();
  QSocketNotifier *writeNotifier();

private:

  // protection against accidental use
  KExtendedSocket(KExtendedSocket&);
  KExtendedSocket& operator=(KExtendedSocket&);

  static int doLookup(const QString& host, const QString& 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, QString& host, QString& port, int flags = 0) KDE_DEPRECATED;

  static int resolve(::KSocketAddress* sock, QString& host, QString& port, int flags = 0) KDE_DEPRECATED;

  static QPtrList<KAddressInfo> lookup(const QString& host, const QString& port, int flags = 0, int *error = 0) KDE_DEPRECATED;

  static ::KSocketAddress *localAddress(int fd) KDE_DEPRECATED;

  static ::KSocketAddress *peerAddress(int fd) KDE_DEPRECATED;

  static QString strError(int code, int syserr);

  static bool setAddressReusable(int fd, bool enable) KDE_DEPRECATED;

protected:
  virtual void virtual_hook( int id, void* data );
private:
  KExtendedSocketPrivate *d;

  friend class KSocket;
  friend class KServerSocket;
};

class KDECORE_EXPORT KAddressInfo
{
private:
  addrinfo *ai;
  ::KSocketAddress *addr;

  inline KAddressInfo() : ai(0), addr(0)
  { }

  //  KAddressInfo(addrinfo *ai);
  KAddressInfo(KAddressInfo&) { }
  KAddressInfo& operator=(KAddressInfo&) { return *this; }

public:
  ~KAddressInfo();

  inline KDE_DEPRECATED operator const ::KSocketAddress*() const 
  { return addr; }

  inline KDE_DEPRECATED operator const addrinfo&() const
  { return *ai; }

  inline KDE_DEPRECATED operator const addrinfo*() const
  { return ai; }

  inline KDE_DEPRECATED const ::KSocketAddress* address() const
  { return addr; }

  int flags() const KDE_DEPRECATED;

  int family() const KDE_DEPRECATED;

  int socktype() const KDE_DEPRECATED;

  int protocol() const KDE_DEPRECATED;


  const char* canonname() const KDE_DEPRECATED;

  inline int length() const
  { if (addr) return addr->size(); return 0; }

  friend class KExtendedSocket;
};

#endif //Q_OS_UNIX

#endif // KEXTSOCK_H

KDECore

Skip menu "KDECore"

• Main Page
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

API Reference

Skip menu "API Reference"

• dcop
• DNSSD
• interfaces
• Kate
• kconf_update
• KDECore
• KDED
• kdefx
• KDEsu
• kdeui
• KDocTools
• KHTML
• KImgIO
• KInit
• kio
• kioslave
• KJS
• KNewStuff
• KParts
• KUtils

Generated for API Reference by doxygen 1.5.9
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal