pdns/dnsrecords.cc

   1 /*
   2  * This file is part of PowerDNS or dnsdist.
   3  * Copyright -- PowerDNS.COM B.V. and its contributors
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * In addition, for the avoidance of any doubt, permission is granted to
  10  * link this program with OpenSSL and to (re)distribute the binaries
  11  * produced as the result of such linking.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25 #include "utility.hh"
  26 #include "dnsrecords.hh"
  27 #include "iputils.hh"
  28
  29
  30 void DNSResourceRecord::setContent(const string &cont) {
  31   content = cont;
  32   switch(qtype.getCode()) {
  33     case QType::SRV:
  34     case QType::MX:
  35       if (content.size() >= 2 && *(content.rbegin()+1) == ' ')
  36         return;
  37     case QType::CNAME:
  38     case QType::DNAME:
  39     case QType::NS:
  40     case QType::PTR:
  41       if(!content.empty())
  42         boost::erase_tail(content, 1);
  43   }
  44 }
  45
  46 string DNSResourceRecord::getZoneRepresentation(bool noDot) const {
  47   ostringstream ret;
  48   vector<string> parts;
  49   string last;
  50
  51   switch(qtype.getCode()) {
  52     case QType::SRV:
  53     case QType::MX:
  54       stringtok(parts, content);
  55       if (!parts.size())
  56         return "";
  57       last = *parts.rbegin();
  58       ret << content;
  59       if (last == ".")
  60         break;
  61       if (*(last.rbegin()) != '.' && !noDot)
  62         ret << ".";
  63       break;
  64     case QType::CNAME:
  65     case QType::DNAME:
  66     case QType::NS:
  67     case QType::PTR:
  68       ret<<content;
  69       if (*(content.rbegin()) != '.' && !noDot)
  70         ret<<".";
  71       break;
  72     default:
  73       ret<<content;
  74     break;
  75   }
  76   return ret.str();
  77 }
  78
  79 bool DNSResourceRecord::operator==(const DNSResourceRecord& rhs)
  80 {
  81   string lcontent=toLower(content);
  82   string rcontent=toLower(rhs.content);
  83
  84   return
  85     tie(qname, qtype, lcontent, ttl) ==
  86     tie(rhs.qname, rhs.qtype, rcontent, rhs.ttl);
  87 }
  88
  89 boilerplate_conv(A, QType::A, conv.xfrIP(d_ip));
  90
  91 ARecordContent::ARecordContent(uint32_t ip)
  92 {
  93   d_ip = ip;
  94 }
  95
  96 ARecordContent::ARecordContent(const ComboAddress& ca)
  97 {
  98   d_ip = ca.sin4.sin_addr.s_addr;
  99 }
 100
 101 AAAARecordContent::AAAARecordContent(const ComboAddress& ca)
 102 {
 103   d_ip6.assign((const char*)ca.sin6.sin6_addr.s6_addr, 16);
 104 }
 105
 106
 107
 108 ComboAddress ARecordContent::getCA(int port) const
 109 {
 110   ComboAddress ret;
 111   ret.sin4.sin_family=AF_INET;
 112   ret.sin4.sin_port=htons(port);
 113   memcpy(&ret.sin4.sin_addr.s_addr, &d_ip, sizeof(ret.sin4.sin_addr.s_addr));
 114   return ret;
 115 }
 116
 117 ComboAddress AAAARecordContent::getCA(int port) const
 118 {
 119   ComboAddress ret;
 120   ret.reset();
 121
 122   ret.sin4.sin_family=AF_INET6;
 123   ret.sin6.sin6_port = htons(port);
 124   memcpy(&ret.sin6.sin6_addr.s6_addr, d_ip6.c_str(), sizeof(ret.sin6.sin6_addr.s6_addr));
 125   return ret;
 126 }
 127
 128
 129 void ARecordContent::doRecordCheck(const DNSRecord& dr)
 130 {
 131   if(dr.d_clen!=4)
 132     throw MOADNSException("Wrong size for A record ("+std::to_string(dr.d_clen)+")");
 133 }
 134
 135 boilerplate_conv(AAAA, QType::AAAA, conv.xfrIP6(d_ip6); );
 136
 137 boilerplate_conv(NS, QType::NS, conv.xfrName(d_content, true));
 138 boilerplate_conv(PTR, QType::PTR, conv.xfrName(d_content, true));
 139 boilerplate_conv(CNAME, QType::CNAME, conv.xfrName(d_content, true));
 140 boilerplate_conv(ALIAS, QType::ALIAS, conv.xfrName(d_content, false));
 141 boilerplate_conv(DNAME, QType::DNAME, conv.xfrName(d_content));
 142 boilerplate_conv(MB, QType::MB, conv.xfrName(d_madname, true));
 143 boilerplate_conv(MG, QType::MG, conv.xfrName(d_mgmname, true));
 144 boilerplate_conv(MR, QType::MR, conv.xfrName(d_alias, true));
 145 boilerplate_conv(MINFO, QType::MINFO, conv.xfrName(d_rmailbx, true); conv.xfrName(d_emailbx, true));
 146 boilerplate_conv(TXT, QType::TXT, conv.xfrText(d_text, true));
 147 #ifdef HAVE_LUA_RECORDS
 148 boilerplate_conv(LUA, QType::LUA, conv.xfrType(d_type); conv.xfrText(d_code, true));
 149 #endif
 150 boilerplate_conv(ENT, 0, );
 151 boilerplate_conv(SPF, 99, conv.xfrText(d_text, true));
 152 boilerplate_conv(HINFO, QType::HINFO,  conv.xfrText(d_cpu);   conv.xfrText(d_host));
 153
 154 boilerplate_conv(RP, QType::RP,
 155                  conv.xfrName(d_mbox);
 156                  conv.xfrName(d_info)
 157                  );
 158
 159
 160 boilerplate_conv(OPT, QType::OPT,
 161                    conv.xfrBlob(d_data)
 162                  );
 163
 164 #ifdef HAVE_LUA_RECORDS
 165 string LUARecordContent::getCode()
 166 {
 167   // in d_code, series of "part1" "part2"
 168   vector<string> parts;
 169   stringtok(parts, d_code, "\"");
 170   string ret;
 171   for(const auto& p : parts) {
 172     ret += p;
 173     ret.append(1, ' ');
 174   }
 175   return ret;
 176 }
 177 #endif
 178
 179 void OPTRecordContent::getData(vector<pair<uint16_t, string> >& options)
 180 {
 181   string::size_type pos=0;
 182   uint16_t code, len;
 183   while(d_data.size() >= 4 + pos) {
 184     code = 256 * (unsigned char)d_data[pos] + (unsigned char)d_data[pos+1];
 185     len = 256 * (unsigned char)d_data[pos+2] + (unsigned char)d_data[pos+3];
 186     pos+=4;
 187
 188     if(pos + len > d_data.size())
 189       break;
 190
 191     string field(d_data.c_str() + pos, len);
 192     pos+=len;
 193     options.push_back(make_pair(code, field));
 194   }
 195 }
 196
 197 boilerplate_conv(TSIG, QType::TSIG,
 198                  conv.xfrName(d_algoName);
 199                  conv.xfr48BitInt(d_time);
 200                  conv.xfr16BitInt(d_fudge);
 201                  uint16_t size=d_mac.size();
 202                  conv.xfr16BitInt(size);
 203                  if (size>0) conv.xfrBlobNoSpaces(d_mac, size);
 204                  conv.xfr16BitInt(d_origID);
 205                  conv.xfr16BitInt(d_eRcode);
 206                  size=d_otherData.size();
 207                  conv.xfr16BitInt(size);
 208                  if (size>0) conv.xfrBlobNoSpaces(d_otherData, size);
 209                  );
 210
 211 MXRecordContent::MXRecordContent(uint16_t preference, const DNSName& mxname):  d_preference(preference), d_mxname(mxname)
 212 {
 213 }
 214
 215 boilerplate_conv(MX, QType::MX,
 216                  conv.xfr16BitInt(d_preference);
 217                  conv.xfrName(d_mxname, true);
 218                  )
 219
 220 boilerplate_conv(KX, QType::KX,
 221                  conv.xfr16BitInt(d_preference);
 222                  conv.xfrName(d_exchanger, false);
 223                  )
 224
 225 boilerplate_conv(IPSECKEY, QType::IPSECKEY,
 226    conv.xfr8BitInt(d_preference);
 227    conv.xfr8BitInt(d_gatewaytype);
 228    conv.xfr8BitInt(d_algorithm);
 229
 230    // now we need to determine values
 231    switch(d_gatewaytype) {
 232    case 0: // NO KEY
 233      break;
 234    case 1: // IPv4 GW
 235      conv.xfrIP(d_ip4);
 236      break;
 237    case 2: // IPv6 GW
 238      conv.xfrIP6(d_ip6);
 239      break;
 240    case 3: // DNS label
 241      conv.xfrName(d_gateway, false);
 242      break;
 243    default:
 244      throw MOADNSException("Parsing record content: invalid gateway type");
 245    };
 246
 247    switch(d_algorithm) {
 248    case 0:
 249      break;
 250    case 1:
 251    case 2:
 252      conv.xfrBlob(d_publickey);
 253      break;
 254    default:
 255      throw MOADNSException("Parsing record content: invalid algorithm type");
 256    }
 257 )
 258
 259 boilerplate_conv(DHCID, 49,
 260                  conv.xfrBlob(d_content);
 261                  )
 262
 263
 264 boilerplate_conv(AFSDB, QType::AFSDB,
 265                  conv.xfr16BitInt(d_subtype);
 266                  conv.xfrName(d_hostname);
 267                  )
 268
 269
 270 boilerplate_conv(NAPTR, QType::NAPTR,
 271                  conv.xfr16BitInt(d_order);    conv.xfr16BitInt(d_preference);
 272                  conv.xfrText(d_flags);        conv.xfrText(d_services);         conv.xfrText(d_regexp);
 273                  conv.xfrName(d_replacement);
 274                  )
 275
 276
 277 SRVRecordContent::SRVRecordContent(uint16_t preference, uint16_t weight, uint16_t port, const DNSName& target)
 278 : d_weight(weight), d_port(port), d_target(target), d_preference(preference)
 279 {}
 280
 281 boilerplate_conv(SRV, QType::SRV,
 282                  conv.xfr16BitInt(d_preference);   conv.xfr16BitInt(d_weight);   conv.xfr16BitInt(d_port);
 283                  conv.xfrName(d_target);
 284                  )
 285
 286 SOARecordContent::SOARecordContent(const DNSName& mname, const DNSName& rname, const struct soatimes& st)
 287 : d_mname(mname), d_rname(rname), d_st(st)
 288 {
 289 }
 290
 291 boilerplate_conv(SOA, QType::SOA,
 292                  conv.xfrName(d_mname, true);
 293                  conv.xfrName(d_rname, true);
 294                  conv.xfr32BitInt(d_st.serial);
 295                  conv.xfr32BitInt(d_st.refresh);
 296                  conv.xfr32BitInt(d_st.retry);
 297                  conv.xfr32BitInt(d_st.expire);
 298                  conv.xfr32BitInt(d_st.minimum);
 299                  );
 300 #undef KEY
 301 boilerplate_conv(KEY, QType::KEY,
 302                  conv.xfr16BitInt(d_flags);
 303                  conv.xfr8BitInt(d_protocol);
 304                  conv.xfr8BitInt(d_algorithm);
 305                  conv.xfrBlob(d_certificate);
 306                  );
 307
 308 boilerplate_conv(CERT, 37,
 309                  conv.xfr16BitInt(d_type);
 310                  if (d_type == 0) throw MOADNSException("CERT type 0 is reserved");
 311
 312                  conv.xfr16BitInt(d_tag);
 313                  conv.xfr8BitInt(d_algorithm);
 314                  conv.xfrBlob(d_certificate);
 315                  )
 316
 317 boilerplate_conv(TLSA, 52,
 318                  conv.xfr8BitInt(d_certusage);
 319                  conv.xfr8BitInt(d_selector);
 320                  conv.xfr8BitInt(d_matchtype);
 321                  conv.xfrHexBlob(d_cert, true);
 322                  )
 323
 324 boilerplate_conv(OPENPGPKEY, 61,
 325                  conv.xfrBlob(d_keyring);
 326                  )
 327
 328 boilerplate_conv(SMIMEA, 53,
 329                  conv.xfr8BitInt(d_certusage);
 330                  conv.xfr8BitInt(d_selector);
 331                  conv.xfr8BitInt(d_matchtype);
 332                  conv.xfrHexBlob(d_cert, true);
 333                  )
 334
 335 DSRecordContent::DSRecordContent() {}
 336 boilerplate_conv(DS, 43,
 337                  conv.xfr16BitInt(d_tag);
 338                  conv.xfr8BitInt(d_algorithm);
 339                  conv.xfr8BitInt(d_digesttype);
 340                  conv.xfrHexBlob(d_digest, true); // keep reading across spaces
 341                  )
 342
 343 CDSRecordContent::CDSRecordContent() {}
 344 boilerplate_conv(CDS, 59,
 345                  conv.xfr16BitInt(d_tag);
 346                  conv.xfr8BitInt(d_algorithm);
 347                  conv.xfr8BitInt(d_digesttype);
 348                  conv.xfrHexBlob(d_digest, true); // keep reading across spaces
 349                  )
 350
 351 DLVRecordContent::DLVRecordContent() {}
 352 boilerplate_conv(DLV,32769 ,
 353                  conv.xfr16BitInt(d_tag);
 354                  conv.xfr8BitInt(d_algorithm);
 355                  conv.xfr8BitInt(d_digesttype);
 356                  conv.xfrHexBlob(d_digest, true); // keep reading across spaces
 357                  )
 358
 359
 360 boilerplate_conv(SSHFP, 44,
 361                  conv.xfr8BitInt(d_algorithm);
 362                  conv.xfr8BitInt(d_fptype);
 363                  conv.xfrHexBlob(d_fingerprint, true);
 364                  )
 365
 366 boilerplate_conv(RRSIG, 46,
 367                  conv.xfrType(d_type);
 368                    conv.xfr8BitInt(d_algorithm);
 369                    conv.xfr8BitInt(d_labels);
 370                    conv.xfr32BitInt(d_originalttl);
 371                    conv.xfrTime(d_sigexpire);
 372                    conv.xfrTime(d_siginception);
 373                  conv.xfr16BitInt(d_tag);
 374                  conv.xfrName(d_signer);
 375                  conv.xfrBlob(d_signature);
 376                  )
 377
 378 RRSIGRecordContent::RRSIGRecordContent() {}
 379
 380 boilerplate_conv(DNSKEY, 48,
 381                  conv.xfr16BitInt(d_flags);
 382                  conv.xfr8BitInt(d_protocol);
 383                  conv.xfr8BitInt(d_algorithm);
 384                  conv.xfrBlob(d_key);
 385                  )
 386 DNSKEYRecordContent::DNSKEYRecordContent() {}
 387
 388 boilerplate_conv(CDNSKEY, 60,
 389                  conv.xfr16BitInt(d_flags);
 390                  conv.xfr8BitInt(d_protocol);
 391                  conv.xfr8BitInt(d_algorithm);
 392                  conv.xfrBlob(d_key);
 393                  )
 394 CDNSKEYRecordContent::CDNSKEYRecordContent() {}
 395
 396 boilerplate_conv(RKEY, 57,
 397                  conv.xfr16BitInt(d_flags);
 398                  conv.xfr8BitInt(d_protocol);
 399                  conv.xfrBlob(d_key);
 400                  )
 401 RKEYRecordContent::RKEYRecordContent() {}
 402
 403 /* EUI48 start */
 404 void EUI48RecordContent::report(void)
 405 {
 406   regist(1, QType::EUI48, &make, &make, "EUI48");
 407 }
 408 std::shared_ptr<DNSRecordContent> EUI48RecordContent::make(const DNSRecord &dr, PacketReader& pr)
 409 {
 410     if(dr.d_clen!=6)
 411       throw MOADNSException("Wrong size for EUI48 record");
 412
 413     auto ret=std::make_shared<EUI48RecordContent>();
 414     pr.copyRecord((uint8_t*) &ret->d_eui48, 6);
 415     return ret;
 416 }
 417 std::shared_ptr<DNSRecordContent> EUI48RecordContent::make(const string& zone)
 418 {
 419     // try to parse
 420     auto ret=std::make_shared<EUI48RecordContent>();
 421     // format is 6 hex bytes and dashes
 422     if (sscanf(zone.c_str(), "%2hhx-%2hhx-%2hhx-%2hhx-%2hhx-%2hhx",
 423            ret->d_eui48, ret->d_eui48+1, ret->d_eui48+2,
 424            ret->d_eui48+3, ret->d_eui48+4, ret->d_eui48+5) != 6) {
 425        throw MOADNSException("Asked to encode '"+zone+"' as an EUI48 address, but does not parse");
 426     }
 427     return ret;
 428 }
 429 void EUI48RecordContent::toPacket(DNSPacketWriter& pw)
 430 {
 431     string blob(d_eui48, d_eui48+6);
 432     pw.xfrBlob(blob);
 433 }
 434 string EUI48RecordContent::getZoneRepresentation(bool noDot) const
 435 {
 436     char tmp[18];
 437     snprintf(tmp,sizeof(tmp),"%02x-%02x-%02x-%02x-%02x-%02x",
 438            d_eui48[0], d_eui48[1], d_eui48[2],
 439            d_eui48[3], d_eui48[4], d_eui48[5]);
 440     return tmp;
 441 }
 442
 443 /* EUI48 end */
 444
 445 /* EUI64 start */
 446
 447 void EUI64RecordContent::report(void)
 448 {
 449   regist(1, QType::EUI64, &make, &make, "EUI64");
 450 }
 451 std::shared_ptr<DNSRecordContent> EUI64RecordContent::make(const DNSRecord &dr, PacketReader& pr)
 452 {
 453     if(dr.d_clen!=8)
 454       throw MOADNSException("Wrong size for EUI64 record");
 455
 456     auto ret=std::make_shared<EUI64RecordContent>();
 457     pr.copyRecord((uint8_t*) &ret->d_eui64, 8);
 458     return ret;
 459 }
 460 std::shared_ptr<DNSRecordContent> EUI64RecordContent::make(const string& zone)
 461 {
 462     // try to parse
 463     auto ret=std::make_shared<EUI64RecordContent>();
 464     // format is 8 hex bytes and dashes
 465     if (sscanf(zone.c_str(), "%2hhx-%2hhx-%2hhx-%2hhx-%2hhx-%2hhx-%2hhx-%2hhx",
 466            ret->d_eui64, ret->d_eui64+1, ret->d_eui64+2,
 467            ret->d_eui64+3, ret->d_eui64+4, ret->d_eui64+5,
 468            ret->d_eui64+6, ret->d_eui64+7) != 8) {
 469        throw MOADNSException("Asked to encode '"+zone+"' as an EUI64 address, but does not parse");
 470     }
 471     return ret;
 472 }
 473 void EUI64RecordContent::toPacket(DNSPacketWriter& pw)
 474 {
 475     string blob(d_eui64, d_eui64+8);
 476     pw.xfrBlob(blob);
 477 }
 478 string EUI64RecordContent::getZoneRepresentation(bool noDot) const
 479 {
 480     char tmp[24];
 481     snprintf(tmp,sizeof(tmp),"%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x",
 482            d_eui64[0], d_eui64[1], d_eui64[2],
 483            d_eui64[3], d_eui64[4], d_eui64[5],
 484            d_eui64[6], d_eui64[7]);
 485     return tmp;
 486 }
 487
 488 /* EUI64 end */
 489
 490 boilerplate_conv(TKEY, QType::TKEY,
 491                  conv.xfrName(d_algo);
 492                  conv.xfr32BitInt(d_inception);
 493                  conv.xfr32BitInt(d_expiration);
 494                  conv.xfr16BitInt(d_mode);
 495                  conv.xfr16BitInt(d_error);
 496                  conv.xfr16BitInt(d_keysize);
 497                  if (d_keysize>0) conv.xfrBlobNoSpaces(d_key, d_keysize);
 498                  conv.xfr16BitInt(d_othersize);
 499                  if (d_othersize>0) conv.xfrBlobNoSpaces(d_other, d_othersize);
 500                  )
 501 TKEYRecordContent::TKEYRecordContent() { d_othersize = 0; } // fix CID#1288932
 502
 503 boilerplate_conv(URI, QType::URI,
 504                  conv.xfr16BitInt(d_priority);
 505                  conv.xfr16BitInt(d_weight);
 506                  conv.xfrText(d_target, true, false);
 507                  )
 508
 509 boilerplate_conv(CAA, QType::CAA,
 510                  conv.xfr8BitInt(d_flags);
 511                  conv.xfrUnquotedText(d_tag, true);
 512                  conv.xfrText(d_value, true, false); /* no lenField */
 513                 )
 514
 515 static uint16_t makeTag(const std::string& data)
 516 {
 517   const unsigned char* key=(const unsigned char*)data.c_str();
 518   unsigned int keysize=data.length();
 519
 520   unsigned long ac;     /* assumed to be 32 bits or larger */
 521   unsigned int i;                /* loop index */
 522
 523   for ( ac = 0, i = 0; i < keysize; ++i )
 524     ac += (i & 1) ? key[i] : key[i] << 8;
 525   ac += (ac >> 16) & 0xFFFF;
 526   return ac & 0xFFFF;
 527 }
 528
 529 uint16_t DNSKEYRecordContent::getTag() const
 530 {
 531   DNSKEYRecordContent tmp(*this);
 532   return makeTag(tmp.serialize(DNSName()));  // this can't be const for some reason
 533 }
 534
 535 uint16_t DNSKEYRecordContent::getTag()
 536 {
 537   return makeTag(this->serialize(DNSName()));
 538 }
 539
 540
 541 /*
 542  * Fills `eo` by parsing the EDNS(0) OPT RR (RFC 6891)
 543  */
 544 bool getEDNSOpts(const MOADNSParser& mdp, EDNSOpts* eo)
 545 {
 546   eo->d_extFlags=0;
 547   if(mdp.d_header.arcount && !mdp.d_answers.empty()) {
 548     for(const MOADNSParser::answers_t::value_type& val :  mdp.d_answers) {
 549       if(val.first.d_place == DNSResourceRecord::ADDITIONAL && val.first.d_type == QType::OPT) {
 550         eo->d_packetsize=val.first.d_class;
 551
 552         EDNS0Record stuff;
 553         uint32_t ttl=ntohl(val.first.d_ttl);
 554         static_assert(sizeof(EDNS0Record) == sizeof(uint32_t), "sizeof(EDNS0Record) must match sizeof(uint32_t)");
 555         memcpy(&stuff, &ttl, sizeof(stuff));
 556
 557         eo->d_extRCode=stuff.extRCode;
 558         eo->d_version=stuff.version;
 559         eo->d_extFlags = ntohs(stuff.extFlags);
 560         auto orc = getRR<OPTRecordContent>(val.first);
 561         if(orc == nullptr)
 562           return false;
 563         orc->getData(eo->d_options);
 564         return true;
 565       }
 566     }
 567   }
 568   return false;
 569 }
 570
 571 DNSRecord makeOpt(const uint16_t udpsize, const uint16_t extRCode, const uint16_t extFlags)
 572 {
 573   EDNS0Record stuff;
 574   stuff.extRCode=0;
 575   stuff.version=0;
 576   stuff.extFlags=htons(extFlags);
 577   DNSRecord dr;
 578   static_assert(sizeof(EDNS0Record) == sizeof(dr.d_ttl), "sizeof(EDNS0Record) must match sizeof(DNSRecord.d_ttl)");
 579   memcpy(&dr.d_ttl, &stuff, sizeof(stuff));
 580   dr.d_ttl=ntohl(dr.d_ttl);
 581   dr.d_name=g_rootdnsname;
 582   dr.d_type = QType::OPT;
 583   dr.d_class=udpsize;
 584   dr.d_place=DNSResourceRecord::ADDITIONAL;
 585   dr.d_content = std::make_shared<OPTRecordContent>();
 586   // if we ever do options, I think we stuff them into OPTRecordContent::data
 587   return dr;
 588 }
 589
 590
 591 void reportBasicTypes()
 592 {
 593   ARecordContent::report();
 594   AAAARecordContent::report();
 595   NSRecordContent::report();
 596   CNAMERecordContent::report();
 597   MXRecordContent::report();
 598   SOARecordContent::report();
 599   SRVRecordContent::report();
 600   PTRRecordContent::report();
 601   DNSRecordContent::regist(QClass::CHAOS, QType::TXT, &TXTRecordContent::make, &TXTRecordContent::make, "TXT");
 602   TXTRecordContent::report();
 603 #ifdef HAVE_LUA_RECORDS
 604   LUARecordContent::report();
 605 #endif
 606   DNSRecordContent::regist(QClass::IN, QType::ANY, 0, 0, "ANY");
 607   DNSRecordContent::regist(QClass::IN, QType::AXFR, 0, 0, "AXFR");
 608   DNSRecordContent::regist(QClass::IN, QType::IXFR, 0, 0, "IXFR");
 609 }
 610
 611 void reportOtherTypes()
 612 {
 613    MBRecordContent::report();
 614    MGRecordContent::report();
 615    MRRecordContent::report();
 616    AFSDBRecordContent::report();
 617    DNAMERecordContent::report();
 618    ALIASRecordContent::report();
 619    SPFRecordContent::report();
 620    NAPTRRecordContent::report();
 621    LOCRecordContent::report();
 622    ENTRecordContent::report();
 623    HINFORecordContent::report();
 624    RPRecordContent::report();
 625    KEYRecordContent::report();
 626    DNSKEYRecordContent::report();
 627    DHCIDRecordContent::report();
 628    CDNSKEYRecordContent::report();
 629    RKEYRecordContent::report();
 630    RRSIGRecordContent::report();
 631    DSRecordContent::report();
 632    CDSRecordContent::report();
 633    SSHFPRecordContent::report();
 634    CERTRecordContent::report();
 635    NSECRecordContent::report();
 636    NSEC3RecordContent::report();
 637    NSEC3PARAMRecordContent::report();
 638    TLSARecordContent::report();
 639    SMIMEARecordContent::report();
 640    OPENPGPKEYRecordContent::report();
 641    DLVRecordContent::report();
 642    DNSRecordContent::regist(QClass::ANY, QType::TSIG, &TSIGRecordContent::make, &TSIGRecordContent::make, "TSIG");
 643    DNSRecordContent::regist(QClass::ANY, QType::TKEY, &TKEYRecordContent::make, &TKEYRecordContent::make, "TKEY");
 644    //TSIGRecordContent::report();
 645    OPTRecordContent::report();
 646    EUI48RecordContent::report();
 647    EUI64RecordContent::report();
 648    MINFORecordContent::report();
 649    URIRecordContent::report();
 650    CAARecordContent::report();
 651 }
 652
 653 void reportAllTypes()
 654 {
 655   reportBasicTypes();
 656   reportOtherTypes();
 657 }
 658
 659 ComboAddress getAddr(const DNSRecord& dr, uint16_t defport)
 660 {
 661   if(auto addr=getRR<ARecordContent>(dr)) {
 662     return addr->getCA(defport);
 663   }
 664   else
 665     return getRR<AAAARecordContent>(dr)->getCA(defport);
 666 }
 667
 668
 669 #if 0
 670 static struct Reporter
 671 {
 672   Reporter()
 673   {
 674     reportAllTypes();
 675   }
 676 } reporter __attribute__((init_priority(65535)));
 677 #endif