developer.intra2net.com Git - pingcheck/blob - src/dns/dnsmaster.cpp

   1 /*
   2  The software in this package is distributed under the GNU General
   3  Public License version 2 (with a special exception described below).
   4
   5  A copy of GNU General Public License (GPL) is included in this distribution,
   6  in the file COPYING.GPL.
   7
   8  As a special exception, if other files instantiate templates or use macros
   9  or inline functions from this file, or you compile this file and link it
  10  with other works to produce a work based on this file, this file
  11  does not by itself cause the resulting work to be covered
  12  by the GNU General Public License.
  13
  14  However the source code for this file must still be made available
  15  in accordance with section (3) of the GNU General Public License.
  16
  17  This exception does not invalidate any other reasons why a work based
  18  on this file might be covered by the GNU General Public License.
  19
  20  Christian Herdtweck, Intra2net AG 2015
  21  */
  22
  23 #include "dns/dnsmaster.h"
  24
  25 #include <logfunc.hpp>
  26 #include <boost/bind.hpp>
  27 #include <boost/asio/placeholders.hpp>
  28
  29 #include "dns/ippseudoresolver.h"
  30 #include "dns/dnsresolver.h"
  31
  32 using boost::bind;
  33 using I2n::Logger::GlobalLogger;
  34
  35
  36 DnsMasterItem DnsMaster::TheOnlyInstance;
  37
  38 // just delegates work to other create_master function
  39 void DnsMaster::create_master(const IoServiceItem &io_serv,
  40                             const boost::asio::ip::address &default_name_server,
  41                             const int resolved_ip_ttl_threshold,
  42                             const int min_time_between_resolves,
  43                             const int max_address_resolution_attempts,
  44                             const int max_recursion_count,
  45                             const std::string &cache_file)
  46 {
  47     GlobalLogger.info() << "DnsMaster: Creating cache";
  48     DnsCacheItem cache(
  49             new DnsCache(io_serv,
  50                          cache_file,
  51                          static_cast<uint32_t>(min_time_between_resolves)
  52             )
  53         );
  54     create_master(io_serv,
  55                   default_name_server,
  56                   resolved_ip_ttl_threshold,
  57                   max_address_resolution_attempts,
  58                   max_recursion_count,
  59                   cache);
  60 }
  61
  62 void DnsMaster::create_master(const IoServiceItem &io_serv,
  63                             const boost::asio::ip::address &default_name_server,
  64                             const int resolved_ip_ttl_threshold,
  65                             const int max_address_resolution_attempts,
  66                             const int max_recursion_count,
  67                             const DnsCacheItem &cache)
  68 {
  69     if (TheOnlyInstance)
  70     {
  71         GlobalLogger.warning() << "DnsMaster: "
  72                               << "Blocking attempt to create another instance!";
  73         return;
  74     }
  75
  76     GlobalLogger.info() << "DNS Master: creating instance";
  77     TheOnlyInstance.reset( new DnsMaster(io_serv,
  78                                          default_name_server,
  79                                          resolved_ip_ttl_threshold,
  80                                          max_address_resolution_attempts,
  81                                          max_recursion_count,
  82                                          cache)
  83                          );
  84 }
  85
  86 DnsMaster::DnsMaster(const IoServiceItem &io_serv,
  87                      const boost::asio::ip::address &default_name_server,
  88                      const int resolved_ip_ttl_threshold,
  89                      const int max_address_resolution_attempts,
  90                      const int max_recursion_count,
  91                      const DnsCacheItem &cache)
  92     : IoService( io_serv )
  93     , DefaultNameServer( default_name_server )
  94     , ResolvedIpTtlThreshold( resolved_ip_ttl_threshold )
  95     , MaxAddressResolutionAttempts( max_address_resolution_attempts )
  96     , MaxRecursionCount( max_recursion_count )
  97     , Cache(cache)
  98     , ResolverMap()
  99 {
 100 }
 101
 102
 103 DnsMasterItem& DnsMaster::get_instance()
 104 {
 105     if ( !TheOnlyInstance )
 106         GlobalLogger.error() << "DnsMaster: "
 107                             << "Request to return instance before creating it!";
 108     return TheOnlyInstance;
 109 }
 110
 111 DnsMaster::~DnsMaster()
 112 {
 113     GlobalLogger.info() << "DnsMaster: being destructed";
 114
 115     if (DnsMaster::TheOnlyInstance)
 116     {   // apparently, this static variable still exists while itself is
 117         // destructed...
 118         //GlobalLogger.warning() << "DnsMaster: being destructed but not "
 119         //                       << "singleton instance TheOnlyInstance!";
 120         DnsMaster::TheOnlyInstance.reset();
 121     }
 122
 123     // Items in ResolverMap and the DnsCache might still be referenced by
 124     // Resolvers and are smart pointers, anyway --> nothing to do here
 125 }
 126
 127
 128
 129 ResolverItem& DnsMaster::get_resolver_for( const std::string &hostname,
 130                                            const PingProtocol &ping_protocol )
 131 {
 132     // find suitable DnsIpProtocol for ping protocol
 133     DnsIpProtocol protocol = ping2dns_protocol(ping_protocol);
 134     return get_resolver_for(hostname, protocol);
 135 }
 136
 137
 138 ResolverItem& DnsMaster::get_resolver_for(const std::string &hostname,
 139                                           const DnsIpProtocol &protocol)
 140 {
 141     // create key to ResolverMap
 142     resolver_key_type key(hostname, protocol);
 143     if ( ResolverMap.count(key) == 0 )
 144     {   // need to create a resolver
 145
 146         // check if it is an ip address, so can create a simple pseudo resolver
 147         if ( is_ip(hostname) )
 148         {
 149             boost::asio::ip::address ip
 150                               = boost::asio::ip::address::from_string(hostname);
 151             if ( (protocol == DNS_IPv4 && !ip.is_v4()) ||
 152                  (protocol == DNS_IPv6 && !ip.is_v6()) )
 153                 GlobalLogger.warning() << "DnsMaster:"
 154                                        << "Asked to create a DNS resolver "
 155                                        << "for wrong IP protocol: v4 != v6! "
 156                                        << "We will comply.";
 157             GlobalLogger.info() << "DnsMaster: Creating PseudoResolver for IP "
 158                                 << ip;
 159             ResolverItem new_resolver( new IpPseudoResolver(IoService,
 160                                                             hostname,
 161                                                             protocol,
 162                                                             Cache) );
 163             ResolverMap[key] = new_resolver;
 164         }
 165         else
 166         {
 167             GlobalLogger.info() << "DnsMaster: Creating Resolver for host "
 168                 << hostname << " and protocol " << to_string(protocol);
 169             ResolverItem new_resolver( new DnsResolver(IoService,
 170                                                        hostname,
 171                                                        protocol,
 172                                                        Cache,
 173                                                        DefaultNameServer) );
 174             ResolverMap[key] = new_resolver;
 175         }
 176     }
 177     return ResolverMap[key];
 178 }
 179
 180 /**
 181  * return true if given hostname string actually is an IP
 182  *
 183  * delegates decision to boost::asio::ip::address::from_string
 184  */
 185 bool DnsMaster::is_ip(const std::string &hostname) const
 186 {
 187     try
 188     {
 189         boost::asio::ip::address ip = boost::asio::ip::address::from_string(
 190                                                                       hostname);
 191         return ip.is_v4() || ip.is_v6();
 192     }
 193     catch ( const std::exception &ex )
 194     {
 195         return false;
 196     }
 197 }
 198
 199
 200 /*boost::asio::ip::address &DnsMaster::get_name_server() const
 201 {
 202     return NameServer;
 203 }*/
 204
 205 int DnsMaster::get_resolved_ip_ttl_threshold() const
 206 {
 207     return ResolvedIpTtlThreshold;
 208 }
 209
 210 int DnsMaster::get_max_address_resolution_attempts() const
 211 {
 212     return MaxAddressResolutionAttempts;
 213 }
 214
 215 int DnsMaster::get_max_recursion_count() const
 216 {
 217     return MaxRecursionCount;
 218 }
 219