[pingcheck] / src / dns / dnsresolver.cpp

/*
 The software in this package is distributed under the GNU General
 Public License version 2 (with a special exception described below).

 A copy of GNU General Public License (GPL) is included in this distribution,
 in the file COPYING.GPL.

 As a special exception, if other files instantiate templates or use macros
 or inline functions from this file, or you compile this file and link it
 with other works to produce a work based on this file, this file
 does not by itself cause the resulting work to be covered
 by the GNU General Public License.

 However the source code for this file must still be made available
 in accordance with section (3) of the GNU General Public License.

 This exception does not invalidate any other reasons why a work based
 on this file might be covered by the GNU General Public License.

 Christian Herdtweck, Intra2net AG 2015

 with code copied from boost::net::dns::resolve.hpp
 by Andreas Haberstroh (andreas at ibusy dot com)
    from https://github.com/softwareace/Boost.DNS
 */

#include "dns/dnsresolver.h"

#include <stdint.h>
#include <sstream>

#include <boost/foreach.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/net/dns.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_io.hpp>

#include <logfunc.hpp>

using I2n::Logger::GlobalLogger;
using boost::posix_time::seconds;
using boost::posix_time::minutes;

namespace Config
{
    const int ResolveTimeoutSeconds = 5;
    const int PauseBeforeRetrySeconds = 10;
    const int StaleDataLongtermMinutes = 15;
    const int DNS_PORT = 53;
}

DnsResolver::DnsResolver(IoServiceItem &io_serv,
                         const std::string &hostname,
                         const DnsIpProtocol &protocol,
                         const DnsCacheItem cache,
                         const boost::asio::ip::address &name_server)
    : ResolverBase( io_serv, hostname, cache )
    , Socket( *io_serv, ip::udp::endpoint(ip::udp::v4(), 0))
        // just connect to anything, will specify sender/receiver later
    , ReceiveBuffer()
    , RequestBuffer()
    , Protocol( protocol )
    , NameServer( name_server, Config::DNS_PORT )
    , ResolveTimeoutTimer( *io_serv )
    , PauseBeforeRetryTimer( *io_serv )
    , StaleDataLongtermTimer( *io_serv )
    , NextIpIndex( 0 )
    , RetryCount( 0 )
    , IsResolving( false )
    , LogPrefix( "DnsResolver" )
    , RandomIdGenerator()
    , RequestId( 0 )
{
    std::stringstream temp;
    temp << "Dns(" << ResolverBase::Hostname << "): ";
    LogPrefix = temp.str();

}

DnsResolver::~DnsResolver()
{
    boost::system::error_code error;
    Socket.shutdown(boost::asio::ip::udp::socket::shutdown_both, error);
    if ( error )
        GlobalLogger.warning() << LogPrefix << "Received error " << error
                               << " when shutting down socket for DNS";
    // in IcmpPinger always gave an error system:9
    // (probably EBADF: Bad file descriptor)

    Socket.close(error);
    if ( error )
        GlobalLogger.warning() << LogPrefix << "Received error " << error
                               << " when closing socket for DNS";
}


//==============================================================================
// ASYNC RESOLVE
//==============================================================================

/**
 * copied here code from boost::net::dns::resolve.hpp, since want async
 * operation and that is used only internally, there
 */
void DnsResolver::do_resolve()
{
    // check if resolving already
    if (IsResolving)
    {
        GlobalLogger.info() << LogPrefix
            << "Call to do_resolve ignored since resolving already";
        return;
    }
    IsResolving = true;

    GlobalLogger.info() << LogPrefix << "start resolving";

    // just to be sure: cancel timers
    ResolveTimeoutTimer.cancel();
    PauseBeforeRetryTimer.cancel();
    StaleDataLongtermTimer.cancel();

    // create DNS request
    boost::net::dns::message dns_message( ResolverBase::Hostname,
                                          boost::net::dns::type_a); //all ); DEBUG
    dns_message.recursive(false);
    dns_message.action(boost::net::dns::message::query);
    dns_message.opcode(boost::net::dns::message::squery);

    // create random ID for message
    boost::uuids::uuid message_id = RandomIdGenerator();
    memcpy( &RequestId, message_id.data, sizeof(RequestId) );
    dns_message.id( RequestId );
    GlobalLogger.debug() << LogPrefix << "Request has ID "
                               << std::showbase << std::hex << dns_message.id();

    // setup receipt of reply
    Socket.async_receive_from(
            boost::asio::buffer(ReceiveBuffer.get_array()),
            NameServer,
            boost::bind( &DnsResolver::handle_dns_result, this,
                         boost::asio::placeholders::error,
                         boost::asio::placeholders::bytes_transferred)
    );

    // schedule timeout
    (void) ResolveTimeoutTimer.expires_from_now(
                                        seconds(Config::ResolveTimeoutSeconds));
    ResolveTimeoutTimer.async_wait( boost::bind(
                                      &DnsResolver::handle_resolve_timeout,
                                      this, boost::asio::placeholders::error) );

    // send dns request
    dns_message.encode(RequestBuffer);
    size_t bytes_sent;
    try
    {
        bytes_sent = Socket.send_to(
                                boost::asio::buffer(RequestBuffer.get_array()),
                                NameServer );
    }
    catch (boost::system::system_error &err)
    {
        GlobalLogger.warning() << LogPrefix
                               << "Sending of DNS request message failed: "
                               << err.what();
        handle_unavailable();
        return;
    }

    if ( bytes_sent == 0 )
    {
        GlobalLogger.warning() << LogPrefix << "Empty DNS request sent!";
        handle_unavailable();
        return;
    }

    GlobalLogger.info() << LogPrefix << "resolving under way";
}


void DnsResolver::handle_dns_result(const boost::system::error_code &error,
                                    const std::size_t bytes_transferred)
{
    if ( error ==  boost::asio::error::operation_aborted )   // cancelled
    {
        GlobalLogger.info() << LogPrefix
                            << "DNS resolve operation was cancelled";
        bool was_success = false;
        finalize_resolve(was_success);
    }
    else if (error)
    {
        GlobalLogger.info() << LogPrefix << "DNS resolve resulted in error "
                            << error << " --> treat like unavailable";
        handle_unavailable();
        return;
    }

    GlobalLogger.debug() << LogPrefix << "Handling DNS result ("
                         << bytes_transferred << " bytes transferred)";

    // next 3(+1) lines copied from boost/net/dns/resolver.hpp:
    // clamp the recvBuffer with the number of bytes transferred or decode buffr
    ReceiveBuffer.length(bytes_transferred);
    boost::net::dns::message result_message;
    result_message.decode( ReceiveBuffer );

    // check ID
    if (RequestId != result_message.id())
        GlobalLogger.warning() << "Received answer for request ID "
           << std::showbase << std::hex << result_message.id()
           << " but expected ID " << RequestId;
    else
        GlobalLogger.debug() << LogPrefix << "Result has correct ID "
                                      << std::showbase << std::hex << RequestId;

    // loop over answers, remembering ips and cnames
    // work with a regular pointer to list of answers since result_message is
    //   owner of data and that exists until end of function
    // Items in answers list are shared_ptr to resource_base_t
    HostAddressVec ip_list;
    std::vector<std::string> hosts_for_ips;
    std::vector<string_pair> result_cnames;
    std::vector<string_pair> result_nameservers;

    gather_results(result_message.answers(), &ip_list, &hosts_for_ips,
                   &result_cnames, &result_nameservers);

    // remember cname tree (if there were any)
    // assume each cname points to next ( source --> destination )
    std::string source = ResolverBase::Hostname;
    BOOST_FOREACH( const std::string &cname, result_cnames )
    {
        update_cache( source, cname );
        source = cname;
    }

    // IPs point to last CNAME (or Hostname if no cnames given)
    if ( !ip_list.empty() )
    {
        update_cache( source, ip_list );

        // clean up
        bool was_success = true;
        finalize_resolve(was_success);
    }
    else if ( !result_cnames.empty() )
    {   // no IPs but a cname --> re-start resolving with that
        handle_cname(source);
    }
    else
    {   // no answers --> check for nameservers in authorities section
        // and corresponding IPs in additional section
        if ( !result_nameservers.empty() )
            GlobalLogger.warning() << "Received NS records in answers! "
                                   << "That is quite unexpected..."
        gather_results(result_message.authorites(), &ip_list, &hosts_for_ips,
                       &result_cnames, &result_nameservers);
        gather_results(result_message.additionals(), &ip_list, &hosts_for_ips,
                       &result_cnames, &result_nameservers);

        int index, index_found=-1;
        // go through name servers
        BOOST_FOREACH( const string_pair &nameserver, result_nameservers )
        {
            index = 0;
            // go through ips and look for match
            BOOST_FOREACH( const std::string &ip_host, hosts_for_ips )
            {
                if (nameserver.second == ip_host)
                {
                    index_found = index;
                    break;
                }
                ++index;
            }

            if (index_found > -1)
                break;
        }
        if (index_found > -1)
        {   // have a name server with ip
            handle_recurse(ip_list[index_found]);


    GlobalLogger.info() << LogPrefix << "Have " << result_ips.size()
                        << " IPs and " << result_cnames.size() << " CNAMEs";

    // We expect either one single CNAME and no IPs or a list of IPs.
    // But deal with other cases as well
    if (result_ips.empty() && result_cnames.empty())
        handle_unavailable();   // we just got crap, this is a dead end

    bool do_resolve_cnames = !Config::DnsRequestsAreRecursive;

    if (Config::DnsRequestsAreRecursive && !result_cnames.empty()
                                        && result_ips.empty() )
    {
        GlobalLogger.warning() << LogPrefix << "CNAMES appear to be unresolved"
            << " although DNS requests are recursive! --> try on our own";
        do_resolve_cnames = true;
    }
    else
        GlobalLogger.info() << LogPrefix << "Ignore CNAMES, assume they were "
                                         << "resolved";

    if (do_resolve_cnames)
    {
        BOOST_FOREACH( const std::string &cname, result_cnames )
            handle_cname(cname);  // will schedule another DNS call
    }

    if ( !result_ips.empty() )
        handle_ips(result_ips);
}

void DnsResolver::gather_results(const boost::net::dns::rr_list_t *answers,
                                 HostAddressVec *result_ips,
                                 std::vector<std::string> *hosts_for_ips,
                                 std::vector<string_pair> *result_cnames,
                                 std::vector<string_pair> *result_nameservers)
                                                                           const
{
    using boost::net::dns::resource_base_t;
    BOOST_FOREACH( boost::shared_ptr<resource_base_t> rr_item, *answers )
    {
        boost::net::dns::type_t rr_type = rr_item->rtype();
        uint32_t ttl = rr_item->ttl();
        std::string domain = rr_item->domain();

        if (rr_type == boost::net::dns::type_a)
        {    // 'A' resource records carry IPv4 addresses
            if (Protocol == DNS_IPv6)
            {
                GlobalLogger.info() << LogPrefix << "Ignoring IPv4 address "
                        << "because resolver was configured to only use IPv6.";
                continue;
            }
            boost::asio::ip::address_v4 ip =
                ( dynamic_cast<boost::net::dns::a_resource *> (rr_item.get()) )
                ->address();
            hosts_for_ips->push_back( domain );
            result_ips->push_back( HostAddress(ip, ttl) );
            GlobalLogger.debug() << LogPrefix << "IPv4 " << ip << " with TTL "
                                 << ttl << "s for " << domain;
        }
        else if (rr_type == boost::net::dns::type_a6)
        {   // 'AAAA' resource records carry IPv6 addresses
            if (Protocol == DNS_IPv4)
            {
                GlobalLogger.info() << LogPrefix << "Ignoring IPv6 address "
                        << "because resolver was configured to only use IPv4.";
                continue;
            }
            boost::asio::ip::address_v6 ip =
                ( dynamic_cast<boost::net::dns::a6_resource *> (rr_item.get()) )
                ->address();
            hosts_for_ips->push_back( domain );
            result_ips->push_back( HostAddress(ip, ttl) );
            GlobalLogger.debug() << LogPrefix << "IPv6 " << ip << " with TTL "
                                 << ttl << "s for " << domain;
        }
        else if (rr_type == boost::net::dns::type_cname)
        {   // 'CNAME' resource records that carry aliases
            std::string cname =
                (dynamic_cast<boost::net::dns::cname_resource *>(rr_item.get()))
                ->canonicalname();
            result_cnames->push_back( string_pair(domain, cname) );
            GlobalLogger.debug() << LogPrefix << "CNAME " << cname
                                 << " with TTL " << ttl << "s for " << domain;
        }
        else if (rr_type == boost::net::dns::type_ns)
        {   // NS (nameserver) resource records
            std::string nameserver =
                (dynamic_cast<boost::net::dns::ns_resource *>(rr_item.get()))
                ->nameserver();
            result_nameservers->push_back( string_pair(domain, nameserver) );
            GlobalLogger.debug() << LogPrefix << "NameServer " << nameserver
                                 << " with TTL " << ttl << "s for " << domain;
        }
        else if (rr_type == boost::net::dns::type_soa)
            GlobalLogger.debug() << LogPrefix << "SOA resource";
        else if (rr_type == boost::net::dns::type_ptr)
            GlobalLogger.debug() << LogPrefix << "ptr resource";
        else if (rr_type == boost::net::dns::type_hinfo)
            GlobalLogger.debug() << LogPrefix << "hinfo resource";
        else if (rr_type == boost::net::dns::type_mx)
            GlobalLogger.debug() << LogPrefix << "mx resource";
        else if (rr_type == boost::net::dns::type_txt)
            GlobalLogger.debug() << LogPrefix << "txt resource";
        else if (rr_type == boost::net::dns::type_srv)
            GlobalLogger.debug() << LogPrefix << "srv resource";
        else if (rr_type == boost::net::dns::type_axfr)
            GlobalLogger.debug() << LogPrefix << "axfr resource";
        else
            GlobalLogger.debug() << LogPrefix << "unknown resource type: "
                                 << std::showbase << std::hex
                                 << static_cast<unsigned>(rr_item->rtype());
    }
}


void DnsResolver::handle_ips(const HostAddressVec &ips)
{
    // save in cache
    ResolverBase::update_cache( ips );

    // clean up
    bool was_success = true;
    finalize_resolve(was_success);
}


void DnsResolver::handle_unavailable()
{
    // schedule new attempt in quite a while
    StaleDataLongtermTimer.expires_from_now(
                                     minutes(Config::StaleDataLongtermMinutes));
    StaleDataLongtermTimer.async_wait(
            boost::bind( &DnsResolver::wait_timer_timeout_handler,
                         this, boost::asio::placeholders::error
            )
    );

    // for now, admit failure
    bool was_success = false;
    finalize_resolve(was_success);
}

void DnsResolver::handle_cname(const std::string &canonical_name)
{
    // get resolver for canonical name
    ResolverItem resolver = DnsMaster::get_instance()
                            ->get_resolver_for(canonical_name, Protocol);
    callback_type callback = boost::bind( &DnsResolver::cname_resolve_callback,
                                          this, canonical_name, _1, _2 );
    resolver->async_resolve( callback );

    stop_trying();
}


void DnsResolver::cname_resolve_callback(const std::string &canonical_name,
                                         const bool was_success,
                                         const int recursion_count)
{
    if (was_success)
        // tell cache to return cname's ips if queried for our hostname
        ResolverBase::update_cache(
                             ResolverBase::get_cached_results(canonical_name) );
    else
        GlobalLogger.info() << LogPrefix << "Cname resolution failed";

    // cname counts like one recursion step more...
    finalize_resolve(was_success, recursion_count+1);
}

void DnsResolver::handle_recurse(const HostAddress &name_server)
{
    // get resolver for same hostname but using a different name server
    if (Recursor)
    {
        GlobalLogger.warning() << "Recursor has not been reset!";
        Recursor.reset();
    }

    Recursor = DnsMaster::get_instance()->get_recursor_for(
                                      Hostname, Protocol, name_server.get_ip());
    callback_type callback = boost::bind(
                                       &DnsResolver::recursive_resolve_callback,
                                       this, name_server.get_ttl().get_value(),
                                       _1, _2 );
    Recursor->async_resolve( callback );

    stop_trying();
}


void DnsResolver::recursive_resolve_callback(const uint32_t min_ttl,
                                             const bool was_success,
                                             const int recursion_count)
{
    if (was_success)
        // make sure the saved TTL is not larger than the one we found here
        ResolverBase::update_cache_ttl(min_ttl);
    else
        GlobalLogger.info() << LogPrefix << "Recursive resolution failed";

    // do not need recursor any more; next time re-create from different random
    //    name server
    if ( !Recursor )
        GlobalLogger.warning() << "Recursor was reset before callback!";
    else
        Recursor.reset();

    finalize_resolve(was_success, recursion_count+1);

}


void DnsResolver::finalize_resolve(const bool was_success,
                                   const int recursion_count)
{
    // stop timers
    if (recursion_count > 0)
        stop_trying();
    // else was called already from handle_cname

    // schedule callbacks, clearing callback list
    ResolverBase::schedule_callbacks(was_success, recursion_count);

    // finalize
    GlobalLogger.notice() << LogPrefix << "Done resolving"
                          << " with success = " << was_success
                          << " and recursion_count = " << recursion_count;
    IsResolving = false;
}

void DnsResolver::stop_trying()
{
    // cancel timers
    GlobalLogger.debug() << LogPrefix << "Cancelling timers";
    ResolveTimeoutTimer.cancel();
    PauseBeforeRetryTimer.cancel();
    StaleDataLongtermTimer.cancel();

    // clean up
    RetryCount = 0;
}

void DnsResolver::handle_resolve_timeout(const boost::system::error_code &error)
{
    if ( error ==  boost::asio::error::operation_aborted )   // cancelled
    {
        GlobalLogger.warning() << LogPrefix
                               << "Resolve timeout timer was cancelled!";
        return;
    }
    else if (error)
    {
        GlobalLogger.warning() << LogPrefix
                               << "resolve timeout handler received error "
                               << error;
        return;
    }

    GlobalLogger.notice() << LogPrefix << "DNS resolving timed out";

    // increment timer
    ++RetryCount;

    if ( RetryCount > DnsMaster::get_instance()
                      ->get_max_address_resolution_attempts() )
    {
        handle_unavailable();
        RetryCount = 0;
    }
    else
    {   // schedule retry
        PauseBeforeRetryTimer.expires_from_now(
                seconds(Config::PauseBeforeRetrySeconds));
        PauseBeforeRetryTimer.async_wait(
                boost::bind( &DnsResolver::wait_timer_timeout_handler,
                             this, boost::asio::placeholders::error) );
    }
}

void DnsResolver::wait_timer_timeout_handler(
                                         const boost::system::error_code &error)
{
    if ( error ==  boost::asio::error::operation_aborted )   // cancelled
        GlobalLogger.warning() << LogPrefix
                               << "Resolve timeout timer was cancelled!";
    else if (error)
        GlobalLogger.warning() << LogPrefix
                               << "resolve timeout handler received error "
                               << error;
    else
    {
        GlobalLogger.info() << LogPrefix << "Done waiting --> re-try resolve";
        do_resolve();
    }
}


//==============================================================================
// RETRIEVAL
//==============================================================================

HostAddress DnsResolver::get_next_ip()
{
    // get cached data
    HostAddressVec cached_data = ResolverBase::get_cached_results();

    // if no results cached, return default-constructed HostAddress (0.0.0.0)
    if ( cached_data.empty() )
    {
        HostAddress return_value;
        return return_value;
    }

    // check validity of index (cache may have changed since last call)
    if (NextIpIndex >= cached_data.size())
        NextIpIndex = 0;

    // return next IP
    return cached_data[NextIpIndex++];
}

bool DnsResolver::have_up_to_date_ip()
{
    // get cached data
    HostAddressVec cached_data = ResolverBase::get_cached_results();

    // get threshold
    uint32_t resolved_ip_ttl_threshold = static_cast<uint32_t>(
                   DnsMaster::get_instance()->get_resolved_ip_ttl_threshold() );

    // loop over addresses
    BOOST_FOREACH( const HostAddress &addr, cached_data )
    {
        uint32_t ttl = addr.get_ttl().get_updated_value();
        if ( ttl > resolved_ip_ttl_threshold )
            return true;
    }

    // if not returned true by now, we have tried all IPs without success
    return false;
}

int DnsResolver::get_resolved_ip_count()
{
    return ResolverBase::get_cached_results().size();
}

// (created using vim -- the world's best text editor)