DNSCallback.h

/*
** libutil++
** $Id: DNSCallback.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__DNSCallback_H__
#define __libutilxx__sella__net__DNSCallback_H__

#include "../../common.h"
#include "DNSException.h"
#include "DNS.h"
#include "IPAddress.h"
#include "../util/String.h"

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

#include <map>
#include <string>
#include <memory>
#include <vector>
#include <algorithm>

namespace sella {
        namespace net {
                class DNSCallback;
                class StoreDNSCallback;
                class SharedStoreDNSCallback;
        }
}

class sella::net::DNSCallback {
        friend class DNS;

        public:
                typedef std::shared_ptr<DNSCallback> shared;
                typedef DNSCallback *ptr;
                enum Error : int { None = DNS_E_NOERROR, Temporary = DNS_E_TEMPFAIL, Protocol = DNS_E_PROTOCOL, NXDomain = DNS_E_NXDOMAIN, NoData = DNS_E_NODATA, NoMemory = DNS_E_NOMEM, BadQuery = DNS_E_BADQUERY };

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

        public:
                DNSCallback() : protocol(0), flags(0) { };

                virtual void success(const std::string &qname, const std::string &cname, int ttl, const std::vector<std::string> &response = empty) throw () = 0;
                virtual void failure(const std::string &qname, Error error) throw () = 0;

                const std::string& getQname(void) const throw () {
                        return qname;
                }

                int getRecord(void) const throw () {
                        return record;
                }

                int getProtocol(void) const throw () {
                        return protocol;
                }

                int getFlags(void) const throw () {
                        return flags;
                }

                virtual void clear(void) throw () {
                        qname.clear();
                        record = -1;
                        protocol = -1;
                        flags = 0;
                }

                static const char* getErrorDetail(Error error) {
                        return ::dns_strerror((int) error);
                }

                static const char* getErrorName(Error error) {
                        switch (error) {
                                case None:
                                        return "None";
                                case Temporary:
                                        return "Temporary";
                                case Protocol:
                                        return "Protocol";
                                case NXDomain:
                                        return "NXDomain";
                                case NoData:
                                        return "NoData";
                                case NoMemory:
                                        return "NoMemory";
                                case BadQuery:
                                        return "BadQuery";
                        }

                        return "Unknown";
                }

        protected:
                std::string qname;
                int record;
                int protocol;
                int flags;
};

class sella::net::StoreDNSCallback : public DNSCallback {
        public:
                StoreDNSCallback() : ttl(-1), error(None) { }

                virtual void success(const std::string &qname, const std::string &cname, int ttl, const std::vector<std::string> &responses = empty) throw () { /* Supports multiple calls for the same qname. */
                        if (this->cname.empty()) {
                                this->cname = cname;
                        }

                        if (this->ttl < 0) {
                                this->ttl = ttl;
                        }

                        this->responses.insert(this->responses.end(), responses.begin(), responses.end()); /* Handle DNS::AnyProtocol properly */
                std::sort(this->responses.begin(), this->responses.end());
                this->responses.erase(std::unique(this->responses.begin(), this->responses.end()), this->responses.end());
                        
                        this->error = None;
                }

                virtual void failure(const std::string &qname, Error error) throw () {
                        clear();

                        this->error = error;
                }

                const std::string& getCname(void) const throw () {
                        return cname;
                }

                int getTTL(void) const throw () {
                        return ttl;
                }

                const std::vector<std::string>& getResponses(void) const throw () {
                        return responses;
                }

                Error getError(void) const throw () {
                        return error;
                }

                const char* getErrorName(void) const throw () {
                        return DNSCallback::getErrorName(error);
                }

                virtual void clear(void) throw () {
                        DNSCallback::clear();
                        cname.clear();
                        ttl = -1;
                        responses.clear();
                        error = None;
                }

        protected:
                std::string cname;
                int ttl;
                std::vector<std::string> responses;
                Error error;
};

class sella::net::SharedStoreDNSCallback : public DNSCallback {
        public:
                struct result_t {
                        std::string cname;
                        int ttl;
                        std::vector<std::string> responses;
                        int record;
                        int protocol;
                        Error error;
                };

        public:
                SharedStoreDNSCallback(std::map<std::string, result_t> &results) : DNSCallback(), results(results) { }

                virtual void success(const std::string &qname, const std::string &cname, int ttl, const std::vector<std::string> &responses = empty) throw () {
                        std::string query = qname;
                        std::string alias = cname;

                        try {
                                query = IPAddress(DNS::convertArpa(qname)).str();
                                alias = qname;
                        } catch (...) { }

                        if (!this->results.count(query)) {
                                this->results[query] = { alias, ttl, responses, record, protocol, None };
                        } else { /* Supports multiple calls for the same query. */
                                result_t &result = this->results[query];

                                if (ttl > result.ttl) {
                                        result.ttl = ttl;
                                }

                                result.responses.insert(result.responses.end(), responses.begin(), responses.end());
                                std::sort(result.responses.begin(), result.responses.end());
                                result.responses.erase(std::unique(result.responses.begin(), result.responses.end()), result.responses.end());
                                result.error = None;
                        }
                }

                virtual void failure(const std::string &qname, Error error) throw () {
                        std::string query = qname;
                        std::string alias;

                        try {
                                query = IPAddress(DNS::convertArpa(qname)).str();
                                alias = qname;
                        } catch (...) { }

                        this->results[query] = { alias, -1, empty, record, protocol, error };
                }

                const std::map<std::string, result_t>& getResults(void) const throw () {
                        return results;
                }

                virtual void clear(void) throw () {
                        DNSCallback::clear();
                        results.erase(qname);
                }

        protected:
                std::map<std::string, result_t> &results;
};

#endif

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