DNS-ldns.cpp

   1 #include "DNS-ldns.hpp"
   2
   3 #include "DNS-iostream.hpp"
   4
   5 #include <algorithm>
   6 #include <iomanip>
   7
   8 #include <cstdbool> // needs to be above ldns includes
   9 #include <ldns/ldns.h>
  10 #include <ldns/packet.h>
  11 #include <ldns/rr.h>
  12
  13 #include <arpa/inet.h>
  14
  15 #include <glog/logging.h>
  16
  17 #include <fmt/format.h>
  18
  19 namespace DNS_ldns {
  20
  21 std::string rr_name_str(ldns_rdf const* rdf)
  22 {
  23   auto const sz = ldns_rdf_size(rdf);
  24
  25   if (sz > LDNS_MAX_DOMAINLEN) {
  26     LOG(WARNING) << "rdf size too large";
  27     return "<too long>";
  28   }
  29   if (sz == 1) {
  30     return ""; // root label
  31   }
  32
  33   auto const data = ldns_rdf_data(rdf);
  34
  35   unsigned char src_pos = 0;
  36   unsigned char len     = data[src_pos];
  37
  38   std::string str;
  39   str.reserve(64);
  40   while ((len > 0) && (src_pos < sz)) {
  41     src_pos++;
  42     for (unsigned char i = 0; i < len; ++i) {
  43       unsigned char c = data[src_pos];
  44       // if (c == '.' || c == ';' || c == '(' || c == ')' || c == '\\') {
  45       if (c == '.' || c == '\\') {
  46         str += '\\';
  47         // str += c;
  48       }
  49       // else if (!(isascii(c) && isgraph(c))) {
  50       //   str += fmt::format("0x{:02x}", c);
  51       // }
  52       // else {
  53       str += c;
  54       // }
  55       src_pos++;
  56     }
  57     if (src_pos < sz) {
  58       str += '.';
  59     }
  60     len = data[src_pos];
  61   }
  62
  63   if (str.length() && ('.' == str.back())) {
  64     str.erase(str.length() - 1);
  65   }
  66
  67   return str;
  68 }
  69
  70 std::string rr_str(ldns_rdf const* rdf)
  71 {
  72   CHECK_NOTNULL(rdf);
  73
  74   auto const data  = static_cast<char const*>(rdf->_data);
  75   auto const udata = static_cast<unsigned char const*>(rdf->_data);
  76
  77   return std::string(data + 1, static_cast<std::string::size_type>(*udata));
  78 }
  79
  80 Resolver::Resolver()
  81 {
  82   auto const status = ldns_resolver_new_frm_file(&res_, nullptr);
  83   CHECK_EQ(status, LDNS_STATUS_OK) << "failed to initialize DNS resolver: "
  84                                    << ldns_get_errorstr_by_id(status);
  85 }
  86
  87 Resolver::~Resolver() { ldns_resolver_deep_free(res_); }
  88
  89 Domain::Domain(char const* domain)
  90   : str_(domain)
  91   , rdfp_(CHECK_NOTNULL(ldns_dname_new_frm_str(domain)))
  92 {
  93 }
  94
  95 Domain::Domain(std::string const& domain)
  96   : str_(domain)
  97   , rdfp_(CHECK_NOTNULL(ldns_dname_new_frm_str(domain.c_str())))
  98 {
  99 }
 100
 101 Domain::~Domain() { ldns_rdf_deep_free(rdfp_); }
 102
 103 Query::Query(Resolver const& res, DNS::RR_type type, std::string const& dom)
 104   : Query(res, type, dom.c_str())
 105 {
 106 }
 107
 108 Query::Query(Resolver const& res, DNS::RR_type type, char const* domain)
 109 {
 110   Domain const dom{domain};
 111
 112   ldns_status const status = ldns_resolver_query_status(
 113       &p_, res.get(), dom.get(), static_cast<ldns_enum_rr_type>(type),
 114       LDNS_RR_CLASS_IN, LDNS_RD | LDNS_AD);
 115
 116   if (status != LDNS_STATUS_OK) {
 117     bogus_or_indeterminate_ = true;
 118
 119     // LOG(WARNING) << "Query (" << dom.str() << "/" << type << ") "
 120     //              << "ldns_resolver_query_status failed: "
 121     //              << ldns_get_errorstr_by_id(status);
 122
 123     // If we have only one nameserver, reset the RTT otherwise all
 124     // future use of this resolver object will fail.
 125
 126     ldns_resolver_set_nameserver_rtt(res.get(), 0,
 127                                      LDNS_RESOLV_RTT_MIN); // "reachable"
 128   }
 129
 130   if (p_) {
 131     authentic_data_ = ldns_pkt_ad(p_);
 132
 133     auto const rcode = ldns_pkt_get_rcode(p_);
 134
 135     switch (rcode) {
 136     case LDNS_RCODE_NOERROR: break;
 137
 138     case LDNS_RCODE_NXDOMAIN:
 139       nx_domain_ = true;
 140       // LOG(WARNING) << "NX domain (" << dom.str() << "/" << type << ")";
 141       break;
 142
 143     case LDNS_RCODE_SERVFAIL:
 144       bogus_or_indeterminate_ = true;
 145       // LOG(WARNING) << "DNS server fail (" << dom.str() << "/" << type << ")";
 146       break;
 147
 148     default:
 149       bogus_or_indeterminate_ = true;
 150       LOG(WARNING) << "DNS unknown error (" << dom.str() << "/" << type
 151                    << "), rcode = " << DNS::rcode_c_str(rcode) << " (" << rcode
 152                    << ")";
 153       break;
 154     }
 155   }
 156 }
 157
 158 Query::~Query()
 159 {
 160   if (p_)
 161     ldns_pkt_free(p_);
 162 }
 163
 164 DNS::RR_collection Query::get_records() const
 165 {
 166   RR_list const rrlst{*this};
 167   return rrlst.get_records();
 168 }
 169
 170 std::vector<std::string> Query::get_strings() const
 171 {
 172   RR_list const rrlst{*this};
 173   return rrlst.get_strings();
 174 }
 175
 176 RR_list::RR_list(Query const& q)
 177 {
 178   if (q.get()) {
 179     // no clones, so no frees required
 180     rrlst_answer_     = ldns_pkt_answer(q.get());
 181     rrlst_additional_ = ldns_pkt_additional(q.get());
 182   }
 183 }
 184
 185 RR_list::~RR_list() {}
 186
 187 DNS::RR_collection RR_list::get_records() const
 188 {
 189   DNS::RR_collection ret;
 190
 191   if (rrlst_answer_) {
 192
 193     ret.reserve(ldns_rr_list_rr_count(rrlst_answer_));
 194
 195     for (unsigned i = 0; i < ldns_rr_list_rr_count(rrlst_answer_); ++i) {
 196       auto const rr = ldns_rr_list_rr(rrlst_answer_, i);
 197
 198       if (rr) {
 199         // LOG(INFO) << "ldns_rr_rd_count(rr) == " << ldns_rr_rd_count(rr);
 200
 201         switch (ldns_rr_get_type(rr)) {
 202         case LDNS_RR_TYPE_A: {
 203           CHECK_EQ(ldns_rr_rd_count(rr), 1);
 204           auto const rdf = ldns_rr_rdf(rr, 0);
 205           CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_A);
 206           ret.emplace_back(DNS::RR_A{ldns_rdf_data(rdf), ldns_rdf_size(rdf)});
 207           break;
 208         }
 209         case LDNS_RR_TYPE_CNAME: {
 210           CHECK_EQ(ldns_rr_rd_count(rr), 1);
 211           auto const rdf = ldns_rr_rdf(rr, 0);
 212           CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_DNAME);
 213           ret.emplace_back(DNS::RR_CNAME{rr_name_str(rdf)});
 214           break;
 215         }
 216         case LDNS_RR_TYPE_PTR: {
 217           CHECK_EQ(ldns_rr_rd_count(rr), 1);
 218           auto const rdf = ldns_rr_rdf(rr, 0);
 219           CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_DNAME);
 220           ret.emplace_back(DNS::RR_PTR{rr_name_str(rdf)});
 221           break;
 222         }
 223         case LDNS_RR_TYPE_MX: {
 224           CHECK_EQ(ldns_rr_rd_count(rr), 2);
 225           auto const rdf_0 = ldns_rr_rdf(rr, 0);
 226           CHECK_EQ(ldns_rdf_get_type(rdf_0), LDNS_RDF_TYPE_INT16);
 227           auto const rdf_1 = ldns_rr_rdf(rr, 1);
 228           CHECK_EQ(ldns_rdf_get_type(rdf_1), LDNS_RDF_TYPE_DNAME);
 229           ret.emplace_back(
 230               DNS::RR_MX{rr_name_str(rdf_1), ldns_rdf2native_int16(rdf_0)});
 231           break;
 232         }
 233         case LDNS_RR_TYPE_TXT: {
 234           CHECK_EQ(ldns_rr_rd_count(rr), 1);
 235           auto const rdf = ldns_rr_rdf(rr, 0);
 236           CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_STR);
 237           ret.emplace_back(DNS::RR_TXT{rr_str(rdf)});
 238           break;
 239         }
 240         case LDNS_RR_TYPE_AAAA: {
 241           CHECK_EQ(ldns_rr_rd_count(rr), 1);
 242           auto const rdf = ldns_rr_rdf(rr, 0);
 243           CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_AAAA);
 244           ret.emplace_back(
 245               DNS::RR_AAAA{ldns_rdf_data(rdf), ldns_rdf_size(rdf)});
 246           break;
 247         }
 248         case LDNS_RR_TYPE_TLSA: {
 249           CHECK_EQ(ldns_rr_rd_count(rr), 4);
 250
 251           auto const usage{[&] {
 252             auto const rdf = ldns_rr_rdf(rr, 0);
 253             CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_CERTIFICATE_USAGE);
 254             return ldns_rdf2native_int8(rdf);
 255           }()};
 256
 257           auto const selector{[&] {
 258             auto const rdf = ldns_rr_rdf(rr, 1);
 259             CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_SELECTOR);
 260             return ldns_rdf2native_int8(rdf);
 261           }()};
 262
 263           auto const matching_type{[&] {
 264             auto const rdf = ldns_rr_rdf(rr, 2);
 265             CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_MATCHING_TYPE);
 266             return ldns_rdf2native_int8(rdf);
 267           }()};
 268
 269           auto const rdf = ldns_rr_rdf(rr, 3);
 270           CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_HEX);
 271
 272           ret.emplace_back(DNS::RR_TLSA{usage, selector, matching_type,
 273                                         ldns_rdf_data(rdf),
 274                                         ldns_rdf_size(rdf)});
 275           break;
 276         }
 277
 278         default:
 279           LOG(WARNING) << "unknown RR type == " << ldns_rr_get_type(rr);
 280           break;
 281         }
 282       }
 283     }
 284   }
 285
 286   if (rrlst_additional_) {
 287     auto const rr_count = ldns_rr_list_rr_count(rrlst_additional_);
 288     if (rr_count) {
 289       LOG(WARNING) << rr_count << " additional RR records";
 290       for (unsigned i = 0; i < rr_count; ++i) {
 291         auto const rr = ldns_rr_list_rr(rrlst_additional_, i);
 292         if (rr) {
 293           auto type = ldns_rr_get_type(rr);
 294           LOG(WARNING) << "additional record " << i << " type "
 295                        << DNS::RR_type_c_str(type);
 296         }
 297       }
 298     }
 299   }
 300
 301   return ret;
 302 }
 303
 304 std::vector<std::string> RR_list::get_strings() const
 305 {
 306   std::vector<std::string> ret;
 307
 308   if (rrlst_answer_) {
 309
 310     ret.reserve(ldns_rr_list_rr_count(rrlst_answer_));
 311
 312     for (unsigned i = 0; i < ldns_rr_list_rr_count(rrlst_answer_); ++i) {
 313       auto const rr = ldns_rr_list_rr(rrlst_answer_, i);
 314
 315       if (rr) {
 316         // LOG(INFO) << "ldns_rr_rd_count(rr) == " << ldns_rr_rd_count(rr);
 317
 318         switch (ldns_rr_get_type(rr)) {
 319         case LDNS_RR_TYPE_A: {
 320           CHECK_EQ(ldns_rr_rd_count(rr), 1);
 321           auto const rdf = ldns_rr_rdf(rr, 0);
 322           CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_A);
 323           auto const a{DNS::RR_A{ldns_rdf_data(rdf), ldns_rdf_size(rdf)}};
 324           ret.emplace_back(a.c_str());
 325           break;
 326         }
 327         case LDNS_RR_TYPE_CNAME: {
 328           CHECK_EQ(ldns_rr_rd_count(rr), 1);
 329           auto const rdf = ldns_rr_rdf(rr, 0);
 330           CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_DNAME);
 331           ret.emplace_back(rr_name_str(rdf));
 332           break;
 333         }
 334         case LDNS_RR_TYPE_PTR: {
 335           CHECK_EQ(ldns_rr_rd_count(rr), 1);
 336           auto const rdf = ldns_rr_rdf(rr, 0);
 337           CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_DNAME);
 338           ret.emplace_back(rr_name_str(rdf));
 339           break;
 340         }
 341         case LDNS_RR_TYPE_MX: {
 342           CHECK_EQ(ldns_rr_rd_count(rr), 2);
 343           auto const rdf_0 = ldns_rr_rdf(rr, 0);
 344           CHECK_EQ(ldns_rdf_get_type(rdf_0), LDNS_RDF_TYPE_INT16);
 345           auto const rdf_1 = ldns_rr_rdf(rr, 1);
 346           CHECK_EQ(ldns_rdf_get_type(rdf_1), LDNS_RDF_TYPE_DNAME);
 347           ret.emplace_back(rr_name_str(rdf_1));
 348           break;
 349         }
 350         case LDNS_RR_TYPE_TXT: {
 351           CHECK_EQ(ldns_rr_rd_count(rr), 1);
 352           auto const rdf = ldns_rr_rdf(rr, 0);
 353           CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_STR);
 354           ret.emplace_back(rr_str(rdf));
 355           break;
 356         }
 357         case LDNS_RR_TYPE_AAAA: {
 358           CHECK_EQ(ldns_rr_rd_count(rr), 1);
 359           auto const rdf = ldns_rr_rdf(rr, 0);
 360           CHECK_EQ(ldns_rdf_get_type(rdf), LDNS_RDF_TYPE_AAAA);
 361           auto const a{DNS::RR_AAAA{ldns_rdf_data(rdf), ldns_rdf_size(rdf)}};
 362           ret.emplace_back(a.c_str());
 363           break;
 364         }
 365         default:
 366           LOG(WARNING) << "unknown RR type == " << ldns_rr_get_type(rr);
 367           break;
 368         }
 369       }
 370     }
 371   }
 372
 373   return ret;
 374 }
 375
 376 DNS::RR_collection Resolver::get_records(DNS::RR_type typ,
 377                                          char const*  domain) const
 378 {
 379   Query const   q{*this, typ, domain};
 380   RR_list const rrlst{q};
 381   return rrlst.get_records();
 382 }
 383
 384 std::vector<std::string> Resolver::get_strings(DNS::RR_type typ,
 385                                                char const*  domain) const
 386 {
 387   Query const   q{*this, typ, domain};
 388   RR_list const rrlst{q};
 389   return rrlst.get_strings();
 390 }
 391
 392 } // namespace DNS_ldns