k3resolver.h

Go to the documentation of this file.

/*  -*- mode: C++; coding: utf-8; -*-
 *  Copyright (C) 2003,2005 Thiago Macieira <thiago@kde.org>
 *
 *
 *  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.
 */

#ifndef KRESOLVER_H
#define KRESOLVER_H

// Needed includes
#include <QtCore/QList>
#include <QtCore/QObject>
#include <QtCore/QSharedDataPointer>
#include "k3socketaddress.h"


// Forward declarations
struct sockaddr;
class QString;
class QByteArray;
template<typename T> class QSet;

// Our definitions

namespace KNetwork {

  namespace Internal { class KResolverManager; }

class KResolverEntryPrivate;
class KDECORE_EXPORT KResolverEntry
{
public:
  KResolverEntry();

  KResolverEntry(const KSocketAddress& addr, int socktype, int protocol,
        const QString& canonName = QString(),
        const QByteArray& encodedName = QByteArray());

  KResolverEntry(const struct sockaddr *sa, quint16 salen, int socktype,
        int protocol, const QString& canonName = QString(),
        const QByteArray& encodedName = QByteArray());

  KResolverEntry(const KResolverEntry &other);

  ~KResolverEntry();

  KSocketAddress address() const;

  quint16 length() const;

  int family() const;

  QString canonicalName() const;

  QByteArray encodedName() const;

  int socketType() const;

  int protocol() const;

  KResolverEntry& operator=(const KResolverEntry& other);

#ifdef MAKE_KDECORE_LIB

  KDE_DUMMY_COMPARISON_OPERATOR(KResolverEntry)
#endif

private:
  QSharedDataPointer<KResolverEntryPrivate> d;
};

#ifdef MAKE_KDECORE_LIB
KDE_DUMMY_QHASH_FUNCTION(KResolverEntry)
#endif

class KResolverResultsPrivate;
class KDECORE_EXPORT KResolverResults: public QList<KResolverEntry>
{
public:
  KResolverResults();

  KResolverResults(const KResolverResults& other);

  virtual ~KResolverResults();

  KResolverResults& operator=(const KResolverResults& other);

  int error() const;

  int systemError() const;

  void setError(int errorcode, int systemerror = 0);

  QString nodeName() const;

  QString serviceName() const;

  void setAddress(const QString& host, const QString& service);

protected:
  virtual void virtual_hook( int id, void* data );
private:
  QSharedDataPointer<KResolverResultsPrivate> d;
};

class KResolverPrivate;
class KDECORE_EXPORT KResolver: public QObject
{
  Q_OBJECT

public:

  enum SocketFamilies
  {
    UnknownFamily = 0x0001,

    UnixFamily = 0x0002,
    LocalFamily = UnixFamily,

    IPv4Family = 0x0004,
    IPv6Family = 0x0008,
    InternetFamily = IPv4Family | IPv6Family,
    InetFamily = InternetFamily,

    KnownFamily = ~UnknownFamily,
    AnyFamily = KnownFamily | UnknownFamily
  };

  enum Flags
    {
      Passive = 0x01,
      CanonName = 0x02,
      NoResolve = 0x04,
      NoSrv = 0x08,
      Multiport = 0x10
    };

  enum ErrorCodes
    {
      // note: if you change this enum, take a look at KResolver::errorString
      NoError = 0,
      AddrFamily = -1,
      TryAgain = -2,
      NonRecoverable = -3,
      BadFlags = -4,
      Memory = -5,
      NoName = -6,
      UnsupportedFamily = -7,
      UnsupportedService = -8,
      UnsupportedSocketType = -9,
      UnknownError = -10,
      SystemError = -11,
      Canceled = -100
    };

  enum StatusCodes
    {
      Idle = 0,
      Queued = 1,
      InProgress = 5,
      PostProcessing = 6,
      Success = 10,
      //Canceled = -100,    // already defined above
      Failed = -101
    };

  KResolver(QObject *parent = 0L);

  explicit KResolver(const QString& nodename, const QString& servicename = QString(),
        QObject *parent = 0L);

  virtual ~KResolver();

  int status() const;

  int error() const;

  int systemError() const;

  QString errorString() const;

  bool isRunning() const;

  QString nodeName() const;

  QString serviceName() const;

  void setNodeName(const QString& nodename);

  void setServiceName(const QString& service);

  void setAddress(const QString& node, const QString& service);

  int flags() const;

  int setFlags(int flags);

  void setFamily(int families);

  void setSocketType(int type);

  void setProtocol(int protonum, const char *name = 0L);

  bool start();

  bool wait(int msec = 0);

  void cancel(bool emitSignal = true);

  KResolverResults results() const;

  virtual bool event(QEvent*);

Q_SIGNALS:
  // signals

  void finished(const KNetwork::KResolverResults& results);

private:
  void emitFinished();

public:
  // Static functions

  static QString errorString(int errorcode, int syserror = 0);

  static KResolverResults resolve(const QString& host, const QString& service,
                 int flags = 0, int families = KResolver::InternetFamily);

  static bool resolveAsync(QObject* userObj, const char *userSlot,
               const QString& host, const QString& service,
               int flags = 0, int families = KResolver::InternetFamily);

  static QByteArray domainToAscii(const QString& unicodeDomain);

  static QString domainToUnicode(const QByteArray& asciiDomain);

  static QString domainToUnicode(const QString& asciiDomain);

  static QString normalizeDomain(const QString& domain);

  static QList<QByteArray> protocolName(int protonum);

  static QList<QByteArray> protocolName(const char *protoname);

  static int protocolNumber(const char *protoname);

  static int servicePort(const char *servname, const char *protoname);

  static QList<QByteArray> serviceName(const char *servname, const char *protoname);

  static QList<QByteArray> serviceName(int port, const char *protoname);

  static QString localHostName();

protected:

  void setError(int errorcode, int systemerror = 0);

  virtual void virtual_hook( int id, void* data );
private:
  KResolverPrivate* const d;
  friend class KResolverResults;
  friend class ::KNetwork::Internal::KResolverManager;
};

}               // namespace KNetwork

#endif