DNS.h

/*
** libutil++
** $Id: DNS.h 1653 2016-02-28 19:54:59Z sella $
** Copyright (c) 2011-2016 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 "IPAddress.h"
#include "../util/Task.h"
#include "../variant/Variant.h"

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

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

/* Forward declarations */
struct dns_ctx;
struct dns_rr_ptr;

namespace sella {
        namespace net {
                class DNS;
                class DNSCallback;
        }

        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 int        A   = 0x20;
                static const int        PTR = 0x21;
#if 0 /* Not implemented yet */
                static const int        MX  = 0x22;
                static const int        TXT = 0x23;
                static const int        SRV = 0x24;
#endif

                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 */
                std::vector<std::string> resolve(const std::string &name, int record = A, int protocol = AnyProtocol) throw (DNSException);
                sella::variant::Variant resolve(const std::vector<std::string> &names, int record = A, int protocol = AnyProtocol) throw (DNSException); /* Grouped by name */
                std::vector<std::string> bulkResolve(const std::vector<std::string> &names, int record = A, int protocol = AnyProtocol) throw (DNSException); /* Non-grouped aggregate */

                /* Static Sync Functions */
                static std::vector<std::string> sresolve(const std::string &name, int protocol = AnyProtocol) throw (DNSException); /* Will not use settings. */
                static std::vector<IPAddress> sresolve_ip(const std::string &name, int protocol = AnyProtocol) throw (DNSException); /* Will not use settings. */

                /* Async Functions */
                DNSCallback* resolve(DNSCallback *callback, const std::string &name, int record = A, int protocol = AnyProtocol) throw (DNSException);
                bool receive(uint64_t usec = 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 getFD() throw ();

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

                static const IPAddress convertArpa(const std::string &qname) throw (DNSException);

        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);
                static void callback_ptr(struct dns_ctx *context, dns_rr_ptr *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
*/