pdns/dnsrecords.hh

   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 #ifndef PDNS_DNSRECORDS_HH
  23 #define PDNS_DNSRECORDS_HH
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28
  29 #include "dnsparser.hh"
  30 #include "dnswriter.hh"
  31 #include "rcpgenerator.hh"
  32 #include <set>
  33 #include <bitset>
  34 #include "namespaces.hh"
  35 #include "iputils.hh"
  36
  37 #define includeboilerplate(RNAME)   RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr); \
  38   RNAME##RecordContent(const string& zoneData);                                                  \
  39   static void report(void);                                                                      \
  40   static void unreport(void);                                                                    \
  41   static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);          \
  42   static std::shared_ptr<DNSRecordContent> make(const string& zonedata);                         \
  43   string getZoneRepresentation(bool noDot=false) const override;                                 \
  44   void toPacket(DNSPacketWriter& pw) override;                                                   \
  45   uint16_t getType() const override { return QType::RNAME; }                                   \
  46   template<class Convertor> void xfrPacket(Convertor& conv, bool noDot=false);
  47
  48 class NAPTRRecordContent : public DNSRecordContent
  49 {
  50 public:
  51   NAPTRRecordContent(uint16_t order, uint16_t preference, string flags, string services, string regexp, DNSName replacement);
  52
  53   includeboilerplate(NAPTR)
  54   template<class Convertor> void xfrRecordContent(Convertor& conv);
  55 private:
  56   uint16_t d_order, d_preference;
  57   string d_flags, d_services, d_regexp;
  58   DNSName d_replacement;
  59 };
  60
  61
  62 class ARecordContent : public DNSRecordContent
  63 {
  64 public:
  65   explicit ARecordContent(const ComboAddress& ca);
  66   explicit ARecordContent(uint32_t ip);
  67   includeboilerplate(A)
  68   void doRecordCheck(const DNSRecord& dr);
  69   ComboAddress getCA(int port=0) const;
  70   bool operator==(const DNSRecordContent& rhs) const override
  71   {
  72     if(typeid(*this) != typeid(rhs))
  73       return false;
  74     return d_ip == dynamic_cast<const ARecordContent&>(rhs).d_ip;
  75   }
  76 private:
  77   uint32_t d_ip;
  78 };
  79
  80 class AAAARecordContent : public DNSRecordContent
  81 {
  82 public:
  83   AAAARecordContent(std::string &val);
  84   explicit AAAARecordContent(const ComboAddress& ca);
  85   includeboilerplate(AAAA)
  86   ComboAddress getCA(int port=0) const;
  87   bool operator==(const DNSRecordContent& rhs) const override
  88   {
  89     if(typeid(*this) != typeid(rhs))
  90       return false;
  91     return d_ip6 == dynamic_cast<const decltype(this)>(&rhs)->d_ip6;
  92   }
  93 private:
  94   string d_ip6; // why??
  95 };
  96
  97 class MXRecordContent : public DNSRecordContent
  98 {
  99 public:
 100   MXRecordContent(uint16_t preference, const DNSName& mxname);
 101
 102   includeboilerplate(MX)
 103
 104   uint16_t d_preference;
 105   DNSName d_mxname;
 106
 107   bool operator==(const DNSRecordContent& rhs) const override
 108   {
 109     if(typeid(*this) != typeid(rhs))
 110       return false;
 111     auto rrhs =dynamic_cast<const decltype(this)>(&rhs);
 112     return std::tie(d_preference, d_mxname) == std::tie(rrhs->d_preference, rrhs->d_mxname);
 113   }
 114
 115 };
 116
 117 class KXRecordContent : public DNSRecordContent
 118 {
 119 public:
 120   KXRecordContent(uint16_t preference, const DNSName& exchanger);
 121
 122   includeboilerplate(KX)
 123
 124 private:
 125   uint16_t d_preference;
 126   DNSName d_exchanger;
 127 };
 128
 129 class IPSECKEYRecordContent : public DNSRecordContent
 130 {
 131 public:
 132   IPSECKEYRecordContent(uint16_t preference, uint8_t gatewaytype, uint8_t algo, const DNSName& gateway, const string& publickey);
 133
 134   includeboilerplate(IPSECKEY)
 135
 136 private:
 137   uint32_t d_ip4;
 138   DNSName d_gateway;
 139   string d_publickey;
 140   string d_ip6;
 141   uint8_t d_preference, d_gatewaytype, d_algorithm;
 142 };
 143
 144 class DHCIDRecordContent : public DNSRecordContent
 145 {
 146 public:
 147   includeboilerplate(DHCID)
 148
 149 private:
 150   string d_content;
 151 };
 152
 153
 154 class SRVRecordContent : public DNSRecordContent
 155 {
 156 public:
 157   SRVRecordContent(uint16_t preference, uint16_t weight, uint16_t port, const DNSName& target);
 158
 159   includeboilerplate(SRV)
 160
 161   uint16_t d_weight, d_port;
 162   DNSName d_target;
 163   uint16_t d_preference;
 164 };
 165
 166 class TSIGRecordContent : public DNSRecordContent
 167 {
 168 public:
 169   includeboilerplate(TSIG)
 170   TSIGRecordContent() {}
 171
 172   uint16_t d_origID{0};
 173   uint16_t d_fudge{0};
 174
 175   DNSName d_algoName;
 176   string d_mac;
 177   string d_otherData;
 178   uint64_t d_time{0};
 179   //  uint16_t d_macSize;
 180   uint16_t d_eRcode{0};
 181   // uint16_t d_otherLen
 182 };
 183
 184
 185 class TXTRecordContent : public DNSRecordContent
 186 {
 187 public:
 188   includeboilerplate(TXT)
 189
 190   string d_text;
 191 };
 192
 193 #ifdef HAVE_LUA_RECORDS
 194 class LUARecordContent : public DNSRecordContent
 195 {
 196 public:
 197   includeboilerplate(LUA)
 198   string getCode() const;
 199   uint16_t d_type;
 200   string d_code;
 201 };
 202 #endif
 203
 204 class ENTRecordContent : public DNSRecordContent
 205 {
 206 public:
 207   includeboilerplate(ENT)
 208 };
 209
 210 class SPFRecordContent : public DNSRecordContent
 211 {
 212 public:
 213   includeboilerplate(SPF)
 214   const std::string& getText() const
 215   {
 216     return d_text;
 217   }
 218
 219 private:
 220   string d_text;
 221 };
 222
 223
 224 class NSRecordContent : public DNSRecordContent
 225 {
 226 public:
 227   includeboilerplate(NS)
 228   explicit NSRecordContent(const DNSName& content) : d_content(content){}
 229   const DNSName& getNS() const { return d_content; }
 230   bool operator==(const DNSRecordContent& rhs) const override
 231   {
 232     if(typeid(*this) != typeid(rhs))
 233       return false;
 234     auto rrhs =dynamic_cast<const decltype(this)>(&rhs);
 235     return d_content == rrhs->d_content;
 236   }
 237
 238 private:
 239   DNSName d_content;
 240 };
 241
 242 class PTRRecordContent : public DNSRecordContent
 243 {
 244 public:
 245   includeboilerplate(PTR)
 246   explicit PTRRecordContent(const DNSName& content) : d_content(content){}
 247   const DNSName& getContent() const { return d_content; }
 248 private:
 249   DNSName d_content;
 250 };
 251
 252 class CNAMERecordContent : public DNSRecordContent
 253 {
 254 public:
 255   includeboilerplate(CNAME)
 256   CNAMERecordContent(const DNSName& content) : d_content(content){}
 257   DNSName getTarget() const { return d_content; }
 258 private:
 259   DNSName d_content;
 260 };
 261
 262 class ALIASRecordContent : public DNSRecordContent
 263 {
 264 public:
 265   includeboilerplate(ALIAS)
 266
 267   DNSName d_content;
 268 };
 269
 270
 271 class DNAMERecordContent : public DNSRecordContent
 272 {
 273 public:
 274   includeboilerplate(DNAME)
 275   DNAMERecordContent(const DNSName& content) : d_content(content){}
 276   const DNSName& getTarget() const { return d_content; }
 277 private:
 278   DNSName d_content;
 279 };
 280
 281
 282 class MBRecordContent : public DNSRecordContent
 283 {
 284 public:
 285   includeboilerplate(MB)
 286
 287 private:
 288   DNSName d_madname;
 289 };
 290
 291 class MGRecordContent : public DNSRecordContent
 292 {
 293 public:
 294   includeboilerplate(MG)
 295
 296 private:
 297   DNSName d_mgmname;
 298 };
 299
 300 class MRRecordContent : public DNSRecordContent
 301 {
 302 public:
 303   includeboilerplate(MR)
 304
 305 private:
 306   DNSName d_alias;
 307 };
 308
 309 class MINFORecordContent : public DNSRecordContent
 310 {
 311 public:
 312   includeboilerplate(MINFO)
 313
 314 private:
 315   DNSName d_rmailbx;
 316   DNSName d_emailbx;
 317 };
 318
 319 class OPTRecordContent : public DNSRecordContent
 320 {
 321 public:
 322   OPTRecordContent(){}
 323   includeboilerplate(OPT)
 324   void getData(vector<pair<uint16_t, string> > &opts);
 325 private:
 326   string d_data;
 327 };
 328
 329
 330 class HINFORecordContent : public DNSRecordContent
 331 {
 332 public:
 333   includeboilerplate(HINFO)
 334
 335 private:
 336   string d_cpu, d_host;
 337 };
 338
 339 class RPRecordContent : public DNSRecordContent
 340 {
 341 public:
 342   includeboilerplate(RP)
 343
 344 private:
 345   DNSName d_mbox, d_info;
 346 };
 347
 348
 349 class DNSKEYRecordContent : public DNSRecordContent
 350 {
 351 public:
 352   DNSKEYRecordContent();
 353   includeboilerplate(DNSKEY)
 354   uint16_t getTag() const;
 355   uint16_t getTag();
 356
 357   uint16_t d_flags{0};
 358   uint8_t d_protocol{0};
 359   uint8_t d_algorithm{0};
 360   string d_key;
 361   bool operator<(const DNSKEYRecordContent& rhs) const
 362   {
 363     return tie(d_flags, d_protocol, d_algorithm, d_key) <
 364       tie(rhs.d_flags, rhs.d_protocol, rhs.d_algorithm, rhs.d_key);
 365   }
 366 };
 367
 368 class CDNSKEYRecordContent : public DNSRecordContent
 369 {
 370 public:
 371   CDNSKEYRecordContent();
 372   includeboilerplate(CDNSKEY)
 373   uint16_t getTag();
 374
 375   uint16_t d_flags{0};
 376   uint8_t d_protocol{0};
 377   uint8_t d_algorithm{0};
 378   string d_key;
 379 };
 380
 381 class DSRecordContent : public DNSRecordContent
 382 {
 383 public:
 384   DSRecordContent();
 385   bool operator==(const DNSRecordContent& rhs) const override
 386   {
 387     if(typeid(*this) != typeid(rhs))
 388       return false;
 389     auto rrhs =dynamic_cast<const decltype(this)>(&rhs);
 390     return tie(d_tag, d_algorithm, d_digesttype, d_digest) ==
 391       tie(rrhs->d_tag, rrhs->d_algorithm, rrhs->d_digesttype, rrhs->d_digest);
 392   }
 393   bool operator<(const DSRecordContent& rhs) const
 394   {
 395     return tie(d_tag, d_algorithm, d_digesttype, d_digest) <
 396       tie(rhs.d_tag, rhs.d_algorithm, rhs.d_digesttype, rhs.d_digest);
 397   }
 398
 399   includeboilerplate(DS)
 400
 401   uint16_t d_tag{0};
 402   uint8_t d_algorithm{0}, d_digesttype{0};
 403   string d_digest;
 404 };
 405
 406 class CDSRecordContent : public DNSRecordContent
 407 {
 408 public:
 409   CDSRecordContent();
 410   includeboilerplate(CDS)
 411
 412   uint16_t d_tag{0};
 413   uint8_t d_algorithm{0}, d_digesttype{0};
 414   string d_digest;
 415 };
 416
 417 class DLVRecordContent : public DNSRecordContent
 418 {
 419 public:
 420   DLVRecordContent();
 421   includeboilerplate(DLV)
 422
 423   uint16_t d_tag{0};
 424   uint8_t d_algorithm{0}, d_digesttype{0};
 425   string d_digest;
 426 };
 427
 428
 429 class SSHFPRecordContent : public DNSRecordContent
 430 {
 431 public:
 432   includeboilerplate(SSHFP)
 433
 434 private:
 435   uint8_t d_algorithm, d_fptype;
 436   string d_fingerprint;
 437 };
 438
 439 class KEYRecordContent : public DNSRecordContent
 440 {
 441 public:
 442   includeboilerplate(KEY)
 443
 444 private:
 445   uint16_t d_flags;
 446   uint8_t d_protocol, d_algorithm;
 447   string d_certificate;
 448 };
 449
 450 class AFSDBRecordContent : public DNSRecordContent
 451 {
 452 public:
 453   includeboilerplate(AFSDB)
 454
 455 private:
 456   uint16_t d_subtype;
 457   DNSName d_hostname;
 458 };
 459
 460
 461 class CERTRecordContent : public DNSRecordContent
 462 {
 463 public:
 464   includeboilerplate(CERT)
 465
 466 private:
 467   uint16_t d_type, d_tag;
 468   string d_certificate;
 469   uint8_t d_algorithm;
 470 };
 471
 472 class TLSARecordContent : public DNSRecordContent
 473 {
 474 public:
 475   includeboilerplate(TLSA)
 476
 477 private:
 478   uint8_t d_certusage, d_selector, d_matchtype;
 479   string d_cert;
 480 };
 481
 482 class SMIMEARecordContent : public DNSRecordContent
 483 {
 484 public:
 485   includeboilerplate(SMIMEA)
 486
 487 private:
 488   uint8_t d_certusage, d_selector, d_matchtype;
 489   string d_cert;
 490 };
 491
 492 class OPENPGPKEYRecordContent : public DNSRecordContent
 493 {
 494 public:
 495   includeboilerplate(OPENPGPKEY)
 496
 497 private:
 498   string d_keyring;
 499 };
 500
 501
 502 class RRSIGRecordContent : public DNSRecordContent
 503 {
 504 public:
 505   RRSIGRecordContent();
 506   includeboilerplate(RRSIG)
 507
 508   uint16_t d_type{0};
 509   uint16_t d_tag{0};
 510   DNSName d_signer;
 511   string d_signature;
 512   uint32_t d_originalttl{0}, d_sigexpire{0}, d_siginception{0};
 513   uint8_t d_algorithm{0}, d_labels{0};
 514 };
 515
 516 //namespace {
 517   struct soatimes
 518   {
 519     uint32_t serial;
 520     uint32_t refresh;
 521     uint32_t retry;
 522     uint32_t expire;
 523     uint32_t minimum;
 524   };
 525 //}
 526
 527 class RKEYRecordContent : public DNSRecordContent
 528 {
 529 public:
 530   RKEYRecordContent();
 531   includeboilerplate(RKEY)
 532   uint16_t d_flags{0};
 533   uint8_t d_protocol{0}, d_algorithm{0};
 534   string d_key;
 535 };
 536
 537 class SOARecordContent : public DNSRecordContent
 538 {
 539 public:
 540   includeboilerplate(SOA)
 541   SOARecordContent(const DNSName& mname, const DNSName& rname, const struct soatimes& st);
 542
 543   DNSName d_mname;
 544   DNSName d_rname;
 545   struct soatimes d_st;
 546 };
 547
 548 class NSECBitmap
 549 {
 550 public:
 551   NSECBitmap(): d_bitset(nullptr)
 552   {
 553   }
 554   NSECBitmap(const NSECBitmap& rhs): d_set(rhs.d_set)
 555   {
 556     if (rhs.d_bitset) {
 557       d_bitset = std::unique_ptr<std::bitset<nbTypes>>(new std::bitset<nbTypes>(*(rhs.d_bitset)));
 558     }
 559   }
 560   NSECBitmap& operator=(const NSECBitmap& rhs)
 561   {
 562     d_set = rhs.d_set;
 563
 564     if (rhs.d_bitset) {
 565       d_bitset = std::unique_ptr<std::bitset<nbTypes>>(new std::bitset<nbTypes>(*(rhs.d_bitset)));
 566     }
 567
 568     return *this;
 569   }
 570   NSECBitmap(NSECBitmap&& rhs): d_bitset(std::move(rhs.d_bitset)), d_set(std::move(rhs.d_set))
 571   {
 572   }
 573   bool isSet(uint16_t type) const
 574   {
 575     if (d_bitset) {
 576       return d_bitset->test(type);
 577     }
 578     return d_set.count(type);
 579   }
 580   void set(uint16_t type)
 581   {
 582     if (!d_bitset) {
 583       if (d_set.size() >= 200) {
 584         migrateToBitSet();
 585       }
 586     }
 587     if (d_bitset) {
 588       d_bitset->set(type);
 589     }
 590     else {
 591       d_set.insert(type);
 592     }
 593   }
 594   size_t count() const
 595   {
 596     if (d_bitset) {
 597       return d_bitset->count();
 598     }
 599     else {
 600       return d_set.size();
 601     }
 602   }
 603
 604   void fromPacket(PacketReader& pr);
 605   void toPacket(DNSPacketWriter& pw);
 606   std::string getZoneRepresentation() const;
 607
 608   static constexpr size_t const nbTypes = 65536;
 609
 610 private:
 611
 612   void migrateToBitSet()
 613   {
 614     d_bitset = std::unique_ptr<std::bitset<nbTypes>>(new std::bitset<nbTypes>());
 615     for (const auto& type : d_set) {
 616       d_bitset->set(type);
 617     }
 618     d_set.clear();
 619   }
 620   /* using a dynamic set is very efficient for a small number of
 621      types covered (~200), but uses a lot of memory (up to 3MB)
 622      when there are a lot of them.
 623      So we start with the set, but allocate and switch to a bitset
 624      if the number of covered types increases a lot */
 625   std::unique_ptr<std::bitset<nbTypes>> d_bitset;
 626   std::set<uint16_t> d_set;
 627 };
 628
 629 class NSECRecordContent : public DNSRecordContent
 630 {
 631 public:
 632   static void report(void);
 633   NSECRecordContent()
 634   {}
 635   NSECRecordContent(const string& content, const string& zone=""); //FIXME400: DNSName& zone?
 636
 637   static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
 638   static std::shared_ptr<DNSRecordContent> make(const string& content);
 639   string getZoneRepresentation(bool noDot=false) const override;
 640   void toPacket(DNSPacketWriter& pw) override;
 641   uint16_t getType() const override
 642   {
 643     return QType::NSEC;
 644   }
 645   bool isSet(uint16_t type) const
 646   {
 647     return d_bitmap.isSet(type);
 648   }
 649   void set(uint16_t type)
 650   {
 651     d_bitmap.set(type);
 652   }
 653   void set(const NSECBitmap& bitmap)
 654   {
 655     d_bitmap = bitmap;
 656   }
 657   size_t numberOfTypesSet() const
 658   {
 659     return d_bitmap.count();
 660   }
 661
 662   DNSName d_next;
 663 private:
 664   NSECBitmap d_bitmap;
 665 };
 666
 667 class NSEC3RecordContent : public DNSRecordContent
 668 {
 669 public:
 670   static void report(void);
 671   NSEC3RecordContent()
 672   {}
 673   NSEC3RecordContent(const string& content, const string& zone=""); //FIXME400: DNSName& zone?
 674
 675   static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
 676   static std::shared_ptr<DNSRecordContent> make(const string& content);
 677   string getZoneRepresentation(bool noDot=false) const override;
 678   void toPacket(DNSPacketWriter& pw) override;
 679
 680   uint8_t d_algorithm{0}, d_flags{0};
 681   uint16_t d_iterations{0};
 682   string d_salt;
 683   string d_nexthash;
 684
 685   uint16_t getType() const override
 686   {
 687     return QType::NSEC3;
 688   }
 689   bool isSet(uint16_t type) const
 690   {
 691     return d_bitmap.isSet(type);
 692   }
 693   void set(uint16_t type)
 694   {
 695     d_bitmap.set(type);
 696   }
 697   void set(const NSECBitmap& bitmap)
 698   {
 699     d_bitmap = bitmap;
 700   }
 701   size_t numberOfTypesSet() const
 702   {
 703     return d_bitmap.count();
 704   }
 705
 706 private:
 707   NSECBitmap d_bitmap;
 708 };
 709
 710
 711 class NSEC3PARAMRecordContent : public DNSRecordContent
 712 {
 713 public:
 714   static void report(void);
 715   NSEC3PARAMRecordContent()
 716   {}
 717   NSEC3PARAMRecordContent(const string& content, const string& zone=""); // FIXME400: DNSName& zone?
 718
 719   static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
 720   static std::shared_ptr<DNSRecordContent> make(const string& content);
 721   string getZoneRepresentation(bool noDot=false) const override;
 722   void toPacket(DNSPacketWriter& pw) override;
 723
 724   uint16_t getType() const override
 725   {
 726     return QType::NSEC3PARAM;
 727   }
 728
 729
 730   uint8_t d_algorithm{0}, d_flags{0};
 731   uint16_t d_iterations{0};
 732   string d_salt;
 733 };
 734
 735
 736 class LOCRecordContent : public DNSRecordContent
 737 {
 738 public:
 739   static void report(void);
 740   LOCRecordContent()
 741   {}
 742   LOCRecordContent(const string& content, const string& zone="");
 743
 744   static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
 745   static std::shared_ptr<DNSRecordContent> make(const string& content);
 746   string getZoneRepresentation(bool noDot=false) const override;
 747   void toPacket(DNSPacketWriter& pw) override;
 748
 749   uint8_t d_version{0}, d_size{0}, d_horizpre{0}, d_vertpre{0};
 750   uint32_t d_latitude{0}, d_longitude{0}, d_altitude{0};
 751   uint16_t getType() const override
 752   {
 753     return QType::LOC;
 754   }
 755
 756 private:
 757 };
 758
 759 class EUI48RecordContent : public DNSRecordContent
 760 {
 761 public:
 762   EUI48RecordContent() {};
 763   static void report(void);
 764   static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
 765   static std::shared_ptr<DNSRecordContent> make(const string& zone); // FIXME400: DNSName& zone?
 766   string getZoneRepresentation(bool noDot=false) const override;
 767   void toPacket(DNSPacketWriter& pw) override;
 768   uint16_t getType() const override { return QType::EUI48; }
 769 private:
 770  // storage for the bytes
 771  uint8_t d_eui48[6];
 772 };
 773
 774 class EUI64RecordContent : public DNSRecordContent
 775 {
 776 public:
 777   EUI64RecordContent() {};
 778   static void report(void);
 779   static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
 780   static std::shared_ptr<DNSRecordContent> make(const string& zone); // FIXME400: DNSName& zone?
 781   string getZoneRepresentation(bool noDot=false) const override;
 782   void toPacket(DNSPacketWriter& pw) override;
 783   uint16_t getType() const override { return QType::EUI64; }
 784 private:
 785  // storage for the bytes
 786  uint8_t d_eui64[8];
 787 };
 788
 789 class TKEYRecordContent : public DNSRecordContent
 790 {
 791 public:
 792   TKEYRecordContent();
 793   includeboilerplate(TKEY)
 794
 795   // storage for the bytes
 796   uint16_t d_othersize{0};
 797   uint16_t d_mode{0};
 798   uint32_t d_inception{0};
 799   uint32_t d_expiration{0};
 800
 801   DNSName d_algo;
 802   string d_key;
 803   string d_other;
 804
 805   uint16_t d_error{0};
 806   uint16_t d_keysize{0};
 807 private:
 808 };
 809
 810 class URIRecordContent : public DNSRecordContent {
 811   public:
 812     includeboilerplate(URI)
 813   private:
 814     uint16_t d_priority, d_weight;
 815     string d_target;
 816 };
 817
 818 class CAARecordContent : public DNSRecordContent {
 819   public:
 820     includeboilerplate(CAA)
 821   private:
 822     uint8_t d_flags;
 823     string d_tag, d_value;
 824 };
 825
 826 #define boilerplate(RNAME, RTYPE)                                                                         \
 827 std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 828 {                                                                                                  \
 829   return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 830 }                                                                                                  \
 831                                                                                                    \
 832 RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 833 {                                                                                                  \
 834   doRecordCheck(dr);                                                                               \
 835   xfrPacket(pr);                                                                                   \
 836 }                                                                                                  \
 837                                                                                                    \
 838 std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const string& zonedata)         \
 839 {                                                                                                  \
 840   return std::make_shared<RNAME##RecordContent>(zonedata);                                         \
 841 }                                                                                                  \
 842                                                                                                    \
 843 void RNAME##RecordContent::toPacket(DNSPacketWriter& pw)                                           \
 844 {                                                                                                  \
 845   this->xfrPacket(pw);                                                                             \
 846 }                                                                                                  \
 847                                                                                                    \
 848 void RNAME##RecordContent::report(void)                                                            \
 849 {                                                                                                  \
 850   regist(1, RTYPE, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);              \
 851   regist(254, RTYPE, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);            \
 852 }                                                                                                  \
 853 void RNAME##RecordContent::unreport(void)                                                          \
 854 {                                                                                                  \
 855   unregist(1, RTYPE);                                                                              \
 856   unregist(254, RTYPE);                                                                            \
 857 }                                                                                                  \
 858                                                                                                    \
 859 RNAME##RecordContent::RNAME##RecordContent(const string& zoneData)                                 \
 860 {                                                                                                  \
 861   try {                                                                                            \
 862     RecordTextReader rtr(zoneData);                                                                \
 863     xfrPacket(rtr);                                                                                \
 864   }                                                                                                \
 865   catch(RecordTextException& rte) {                                                                \
 866     throw MOADNSException("Parsing record content (try 'pdnsutil check-zone'): "+string(rte.what()));  \
 867   }                                                                                                \
 868 }                                                                                                  \
 869                                                                                                    \
 870 string RNAME##RecordContent::getZoneRepresentation(bool noDot) const                               \
 871 {                                                                                                  \
 872   string ret;                                                                                      \
 873   RecordTextWriter rtw(ret, noDot);                                                                       \
 874   const_cast<RNAME##RecordContent*>(this)->xfrPacket(rtw);                                         \
 875   return ret;                                                                                      \
 876 }
 877
 878
 879 #define boilerplate_conv(RNAME, TYPE, CONV)                       \
 880 boilerplate(RNAME, TYPE)                                          \
 881 template<class Convertor>                                         \
 882 void RNAME##RecordContent::xfrPacket(Convertor& conv, bool noDot) \
 883 {                                                                 \
 884   CONV;                                                           \
 885   if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
 886 }                                                                 \
 887
 888 struct EDNSOpts
 889 {
 890   enum zFlags { DNSSECOK=32768 };
 891   vector<pair<uint16_t, string> > d_options;
 892   uint16_t d_packetsize{0};
 893   uint16_t d_extFlags{0};
 894   uint8_t d_extRCode, d_version;
 895 };
 896 //! Convenience function that fills out EDNS0 options, and returns true if there are any
 897
 898 class MOADNSParser;
 899 bool getEDNSOpts(const MOADNSParser& mdp, EDNSOpts* eo);
 900 DNSRecord makeOpt(const uint16_t udpsize, const uint16_t extRCode, const uint16_t extFlags);
 901 void reportBasicTypes();
 902 void reportOtherTypes();
 903 void reportAllTypes();
 904 ComboAddress getAddr(const DNSRecord& dr, uint16_t defport=0);
 905 void checkHostnameCorrectness(const DNSResourceRecord& rr);
 906 #endif