HostnameResolver.h

#ifndef __ARC_HOSTNAMERESOLVER_H__
#define __ARC_HOSTNAMERESOLVER_H__

#include <string>
#include <list>

#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>

#include <glibmm.h>

namespace Arc {

  class Run;


  class HostnameResolver {
  public:


   class SockAddr {
   friend class HostnameResolver;
   public:
     SockAddr();
     SockAddr(SockAddr const& other);
     SockAddr& operator=(SockAddr const& other);
     ~SockAddr();
     int Family() const { return family; }
     sockaddr const* Addr() const { return addr; }
     socklen_t Length() const { return length; }
   private:
     int family;
     socklen_t length;
     sockaddr *addr; 
   };

    HostnameResolver(void);
    ~HostnameResolver(void);
    static HostnameResolver* Acquire(void);
    static void Release(HostnameResolver* fa);
    bool ping(void);
    int hr_resolve(std::string const& node, std::string const& service, bool local, std::list<SockAddr>& addrs);
    int geterrno() { return errno_; };
    operator bool(void) { return (hostname_resolver_ != NULL); };
    bool operator!(void) { return (hostname_resolver_ == NULL); };
    static void testtune(void);
  private:
    Glib::Mutex lock_;
    Run* hostname_resolver_;
    int errno_;
  public:
    typedef struct {
      unsigned int size;
      unsigned int cmd;
    } header_t;
  };


  class HostnameResolverContainer {
  public:
    HostnameResolverContainer(unsigned int minval, unsigned int maxval);
    HostnameResolverContainer(void);
    ~HostnameResolverContainer(void);

    HostnameResolver* Acquire(void);

    void Release(HostnameResolver* hr);
    void SetMin(unsigned int val);
    void SetMax(unsigned int val);
  private:
    Glib::Mutex lock_;
    unsigned int min_;
    unsigned int max_;
    std::list<HostnameResolver*> hrs_;
    void KeepRange(void);
  };

} // namespace Arc 

#endif // __ARC_HOSTNAMERESOLVER_H__