/builddir/build/BUILD/libutil++-1.4.0/src/sella/net/DNS.h

/*
** libutil++
** $Id: DNS.h 1197 2014-10-14 22:26:11Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

#ifndef __libutilxx__sella__net__DNS_H__
#define __libutilxx__sella__net__DNS_H__

#include "../../common.h"
#include "DNSException.h"
#include "DNSCallback.h"
#include "IPAddress.h"
#include "../util/Task.h"

#include <sys/socket.h>
#include <stdint.h>
#include <udns.h>

#include <string>
#include <memory>
#include <mutex>

namespace sella {
        namespace net {
                class DNS;
        }

        namespace util {
                class ThreadPool;
        }
}

class sella::net::DNS {
        public:
                typedef std::shared_ptr<DNS> shared;
                typedef DNS *ptr;

        public:
                static const uint64_t DefaultInterval = 5000;

                static const int        AnyProtocol   = 0x00;
                static const int        IPv4Preferred = 0x01;
                static const int        IPv4Required  = 0x03;

                static const int        IPv6Preferred = 0x04;
                static const int        IPv6Required  = 0x12;

                static const std::vector<std::string> empty;

        public:
                DNS(const std::vector<std::string> &nameservers = empty, const std::vector<std::string> &searches = empty) throw (DNSException);
                DNS(sella::util::ThreadPool *pool, const std::vector<std::string> &nameservers = empty, const std::vector<std::string> &searches = empty) throw (DNSException);
                virtual ~DNS() throw ();

        public:
                /* Sync Functions */
                static std::vector<IPAddress> resolve(const std::string &name, int protocol = IPv4Preferred) throw (DNSException);

                /* Async Functions */
                DNSCallback* resolve(DNSCallback *callback, const std::string &name, int protocol = IPv4Preferred) throw (DNSException);
                bool receive(time_t delay = 0, time_t now = 0) throw (); /* Process incoming packets. Used with non-thread pool constructor. */

                void setInterval(uint64_t usec) throw ();
                void setNoSearch(bool on = true) throw (); /* Not working with udns 0.9.9-5 */
                void setNoRecursion(bool on = true) throw (); /* Not working with udns 0.0.9-5 */
                void setAuthoritativeOnly(bool on = true) throw (); /* Not working with udns 0.0.9-5 */
                void setTimeout(int seconds = 5) throw ();
                void setRetries(int retries = 2) throw ();
                void setDots(int ndots = 1) throw ();
                void setUDPSize(int bytes = 4096) throw ();
                void setUDPPort(short port = 53) throw ();

                int getActive() throw ();
                int getSocket() throw ();

                static const DNS::shared shared_ptr() throw ();

        protected:
                static void callback_a(struct dns_ctx *context, void  *result, void *argument);
                static void callback_aaaa(struct dns_ctx *context, void *result, void *argument);

        private:
                sella::util::ThreadPool *pool;
                sella::util::Task::shared task;
                std::mutex mutex;
                struct dns_ctx *context;
                int flags;
                int interval;

                void init(const std::vector<std::string> &nameservers, const std::vector<std::string> &searches);
};

#endif

/*
** vim: noet ts=3 sw=3
*/

---