dns.hpp

#pragma once


#include <utility>
#include <memory>
#include <string>
#include <uv.h>
#include "request.hpp"
#include "util.hpp"
#include "loop.hpp"


namespace uvw {


struct AddrInfoEvent {
    using Deleter = void(*)(addrinfo *);

    AddrInfoEvent(std::unique_ptr<addrinfo, Deleter> addr)
        : data{std::move(addr)}
    {}

    std::unique_ptr<addrinfo, Deleter> data;
};


struct NameInfoEvent {
    NameInfoEvent(const char *host, const char *serv)
        : hostname{host}, service{serv}
    {}

    const char * hostname;

    const char * service;
};


class GetAddrInfoReq final: public Request<GetAddrInfoReq, uv_getaddrinfo_t> {
    static void addrInfoCallback(uv_getaddrinfo_t *req, int status, addrinfo *res) {
        auto ptr = reserve(req);

        if(status) {
            ptr->publish(ErrorEvent{status});
        } else {
            auto data = std::unique_ptr<addrinfo, void(*)(addrinfo *)>{
                res, [](addrinfo *addr){ uv_freeaddrinfo(addr); }};

            ptr->publish(AddrInfoEvent{std::move(data)});
        }
    }

    void nodeAddrInfo(const char *node, const char *service, addrinfo *hints = nullptr) {
        invoke(&uv_getaddrinfo, parent(), get(), &addrInfoCallback, node, service, hints);
    }

    auto nodeAddrInfoSync(const char *node, const char *service, addrinfo *hints = nullptr) {
        auto req = get();
        auto err = uv_getaddrinfo(parent(), req, nullptr, node, service, hints);
        auto data = std::unique_ptr<addrinfo, void(*)(addrinfo *)>{req->addrinfo, [](addrinfo *addr){ uv_freeaddrinfo(addr); }};
        return std::make_pair(!err, std::move(data));
    }

public:
    using Deleter = void(*)(addrinfo *);

    using Request::Request;

    void nodeAddrInfo(std::string node, addrinfo *hints = nullptr) {
        nodeAddrInfo(node.data(), nullptr, hints);
    }

    std::pair<bool, std::unique_ptr<addrinfo, Deleter>>
    nodeAddrInfoSync(std::string node, addrinfo *hints = nullptr) {
        return nodeAddrInfoSync(node.data(), nullptr, hints);
    }

    void serviceAddrInfo(std::string service, addrinfo *hints = nullptr) {
        nodeAddrInfo(nullptr, service.data(), hints);
    }

    std::pair<bool, std::unique_ptr<addrinfo, Deleter>>
    serviceAddrInfoSync(std::string service, addrinfo *hints = nullptr) {
        return nodeAddrInfoSync(nullptr, service.data(), hints);
    }

    void addrInfo(std::string node, std::string service, addrinfo *hints = nullptr) {
        nodeAddrInfo(node.data(), service.data(), hints);
    }

    std::pair<bool, std::unique_ptr<addrinfo, Deleter>>
    addrInfoSync(std::string node, std::string service, addrinfo *hints = nullptr) {
        return nodeAddrInfoSync(node.data(), service.data(), hints);
    }
};


class GetNameInfoReq final: public Request<GetNameInfoReq, uv_getnameinfo_t> {
    static void nameInfoCallback(uv_getnameinfo_t *req, int status, const char *hostname, const char *service) {
        auto ptr = reserve(req);
        if(status) { ptr->publish(ErrorEvent{status}); }
        else { ptr->publish(NameInfoEvent{hostname, service}); }
    }

public:
    using Request::Request;

    template<typename I = IPv4>
    void nameInfo(std::string ip, unsigned int port, int flags = 0) {
        typename details::IpTraits<I>::Type addr;
        details::IpTraits<I>::addrFunc(ip.data(), port, &addr);
        auto saddr = reinterpret_cast<const sockaddr *>(&addr);
        invoke(&uv_getnameinfo, parent(), get(), &nameInfoCallback, saddr, flags);
    }

    template<typename I = IPv4>
    void nameInfo(Addr addr, int flags = 0) {
        nameInfo<I>(addr.ip, addr.port, flags);
    }

    template<typename I = IPv4>
    std::pair<bool, std::pair<const char *, const char *>>
    nameInfoSync(std::string ip, unsigned int port, int flags = 0) {
        typename details::IpTraits<I>::Type addr;
        details::IpTraits<I>::addrFunc(ip.data(), port, &addr);
        auto req = get();
        auto saddr = reinterpret_cast<const sockaddr *>(&addr);
        auto err = uv_getnameinfo(parent(), req, nullptr, saddr, flags);
        return std::make_pair(!err, std::make_pair(req->host, req->service));
    }

    template<typename I = IPv4>
    std::pair<bool, std::pair<const char *, const char *>>
    nameInfoSync(Addr addr, int flags = 0) {
        return nameInfoSync<I>(addr.ip, addr.port, flags);
    }
};


}