kresolver.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.
 */
 
#ifndef KRESOLVER_H
#define KRESOLVER_H

// Needed includes
#include <tqvaluelist.h>
#include <tqobject.h>
#include "tdesocketaddress.h"
 

// Forward declarations
struct sockaddr;
class TQString;
class TQCString;
class TQStrList;

// Our definitions
 
namespace KNetwork {
 
  namespace Internal { class KResolverManager; }
 
class KResolverEntryPrivate;
class TDECORE_EXPORT KResolverEntry
{
public:
  KResolverEntry();

  KResolverEntry(const TDESocketAddress& addr, int socktype, int protocol,
        const TQString& canonName = TQString::null,
        const TQCString& encodedName = TQCString());

  KResolverEntry(const struct sockaddr *sa, TQ_UINT16 salen, int socktype,
        int protocol, const TQString& canonName = TQString::null,
        const TQCString& encodedName = TQCString());

  KResolverEntry(const KResolverEntry &other);

  ~KResolverEntry();

  TDESocketAddress address() const;

  TQ_UINT16 length() const;

  int family() const;

  TQString canonicalName() const;

  TQCString encodedName() const;

  int socketType() const;

  int protocol() const;

  KResolverEntry& operator=(const KResolverEntry& other);
 
private:
  KResolverEntryPrivate* d;
};
 
class KResolverResultsPrivate;
class TDECORE_EXPORT KResolverResults: public TQValueList<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);

  TQString nodeName() const;

  TQString serviceName() const;

  void setAddress(const TQString& host, const TQString& service);
 
protected:
  virtual void virtual_hook( int id, void* data );
private:
  KResolverResultsPrivate* d;
};
 
class KResolverPrivate;
class TDECORE_EXPORT KResolver: public TQObject
{
  TQ_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,
      UseSrv = 0x20
    };

  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(TQObject * = 0L, const char * = 0L);

  KResolver(const TQString& nodename, const TQString& servicename = TQString::null,
        TQObject * = 0L, const char * = 0L);

  virtual ~KResolver();

  int status() const;

  int error() const;

  int systemError() const;

  inline TQString errorString() const
  { return errorString(error(), systemError()); }

  bool isRunning() const;

  TQString nodeName() const;

  TQString serviceName() const;

  void setNodeName(const TQString& nodename);

  void setServiceName(const TQString& service);

  void setAddress(const TQString& node, const TQString& 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(TQEvent*);
 
signals:
  // signals

  void finished(KResolverResults results);
 
private:
  void emitFinished();
 
public:
  // Static functions

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

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

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

  static TQCString domainToAscii(const TQString& unicodeDomain);

  static TQString domainToUnicode(const TQCString& asciiDomain);

  static TQString domainToUnicode(const TQString& asciiDomain);

  static TQString normalizeDomain(const TQString& domain);

  static TQStrList protocolName(int protonum);

  static TQStrList protocolName(const char *protoname);

  static int protocolNumber(const char *protoname);

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

  static TQStrList serviceName(const char *servname, const char *protoname);

  static TQStrList serviceName(int port, const char *protoname);

  static TQString localHostName();
 
protected:

  void setError(int errorcode, int systemerror = 0);
 
  virtual void virtual_hook( int id, void* data );
private:
  KResolverPrivate* d;
  friend class KResolverResults;
  friend class ::KNetwork::Internal::KResolverManager;
  
  static TQStringList *idnDomains;
};
 
}               // namespace KNetwork
 
#endif