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