1 /////////////// 2 /////////////// 3 /////////////// THIS FILE IS AUTOMATICALLY GENERATED BY gen-rdatacode.py. 4 /////////////// DO NOT EDIT! 5 /////////////// 6 /////////////// 7 8 9 #ifndef DNS_RDATACLASS_H 10 #define DNS_RDATACLASS_H 1 11 12 #include <dns/master_loader.h> 13 14 namespace isc { 15 namespace dns { 16 class Name; 17 class MasterLexer; 18 class MasterLoaderCallbacks; 19 } 20 } 21 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 22 // 23 // This Source Code Form is subject to the terms of the Mozilla Public 24 // License, v. 2.0. If a copy of the MPL was not distributed with this 25 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 26 27 #ifndef ANY_TSIG_250_H 28 #define ANY_TSIG_250_H 1 29 30 #include <stdint.h> 31 32 #include <string> 33 34 #include <dns/name.h> 35 #include <dns/rdata.h> 36 37 namespace isc { 38 namespace util { 39 40 class InputBuffer; 41 class OutputBuffer; 42 } 43 44 namespace dns { 45 46 // BEGIN_COMMON_DECLARATIONS 47 48 class AbstractMessageRenderer; 49 50 // END_COMMON_DECLARATIONS 51 52 namespace rdata { 53 namespace any { 54 55 struct TSIGImpl; 56 57 /// \brief \c rdata::TSIG class represents the TSIG RDATA as defined %in 58 /// RFC2845. 59 /// 60 /// This class implements the basic interfaces inherited from the abstract 61 /// \c rdata::Rdata class, and provides trivial accessors specific to the 62 /// TSIG RDATA. 63 class TSIG : public Rdata { 64 public: 65 // BEGIN_COMMON_MEMBERS 66 67 explicit TSIG(const std::string& type_str); 68 TSIG(isc::util::InputBuffer& buffer, size_t rdata_len); 69 TSIG(const TSIG& other); 70 TSIG( 71 MasterLexer& lexer, const Name* name, 72 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 73 virtual std::string toText() const; 74 virtual void toWire(isc::util::OutputBuffer& buffer) const; 75 virtual void toWire(AbstractMessageRenderer& renderer) const; 76 virtual int compare(const Rdata& other) const; 77 78 // END_COMMON_MEMBERS 79 80 /// \brief Constructor from RDATA field parameters. 81 /// 82 /// The parameters are a straightforward mapping of %TSIG RDATA 83 /// fields as defined %in RFC2845, but there are some implementation 84 /// specific notes as follows. 85 /// 86 /// \c algorithm is a \c Name object that specifies the algorithm. 87 /// For example, if the algorithm is HMAC-SHA256, \c algorithm would be 88 /// \c Name("hmac-sha256"). 89 /// 90 /// \c time_signed corresponds to the Time Signed field, which is of 91 /// 48-bit unsigned integer type, and therefore cannot exceed 2^48-1; 92 /// otherwise, an exception of type \c OutOfRange will be thrown. 93 /// 94 /// \c mac_size and \c mac correspond to the MAC Size and MAC fields, 95 /// respectively. When the MAC field is empty, \c mac must be NULL. 96 /// \c mac_size and \c mac must be consistent %in that \c mac_size is 0 if 97 /// and only if \c mac is NULL; otherwise an exception of type 98 /// InvalidParameter will be thrown. 99 /// 100 /// The same restriction applies to \c other_len and \c other_data, 101 /// which correspond to the Other Len and Other Data fields, respectively. 102 /// 103 /// This constructor internally involves resource allocation, and if 104 /// it fails, a corresponding standard exception will be thrown. 105 TSIG(const Name& algorithm, uint64_t time_signed, uint16_t fudge, 106 uint16_t mac_size, const void* mac, uint16_t original_id, 107 uint16_t error, uint16_t other_len, const void* other_data); 108 109 /// \brief Assignment operator. 110 /// 111 /// It internally allocates a resource, and if it fails a corresponding 112 /// standard exception will be thrown. 113 /// This operator never throws an exception otherwise. 114 /// 115 /// This operator provides the strong exception guarantee: When an 116 /// exception is thrown the content of the assignment target will be 117 /// intact. 118 TSIG& operator=(const TSIG& source); 119 120 /// \brief The destructor. 121 ~TSIG(); 122 123 /// \brief Return the algorithm name. 124 /// 125 /// This method never throws an exception. 126 const Name& getAlgorithm() const; 127 128 /// \brief Return the value of the Time Signed field. 129 /// 130 /// The returned value does not exceed 2^48-1. 131 /// 132 /// This method never throws an exception. 133 uint64_t getTimeSigned() const; 134 135 /// \brief Return the value of the Fudge field. 136 /// 137 /// This method never throws an exception. 138 uint16_t getFudge() const; 139 140 /// \brief Return the value of the MAC Size field. 141 /// 142 /// This method never throws an exception. 143 uint16_t getMACSize() const; 144 145 /// \brief Return the value of the MAC field. 146 /// 147 /// If the MAC field is empty, it returns NULL. 148 /// Otherwise, the memory region beginning at the address returned by 149 /// this method is valid up to the bytes specified by the return value 150 /// of \c getMACSize(). 151 /// The memory region is only valid while the corresponding \c TSIG 152 /// object is valid. The caller must hold the \c TSIG object while 153 /// it needs to refer to the region or it must make a local copy of the 154 /// region. 155 /// 156 /// This method never throws an exception. 157 const void* getMAC() const; 158 159 /// \brief Return the value of the Original ID field. 160 /// 161 /// This method never throws an exception. 162 uint16_t getOriginalID() const; 163 164 /// \brief Return the value of the Error field. 165 /// 166 /// This method never throws an exception. 167 uint16_t getError() const; 168 169 /// \brief Return the value of the Other Len field. 170 /// 171 /// This method never throws an exception. 172 uint16_t getOtherLen() const; 173 174 /// \brief Return the value of the Other Data field. 175 /// 176 /// The same note as \c getMAC() applies. 177 /// 178 /// This method never throws an exception. 179 const void* getOtherData() const; 180 private: 181 TSIGImpl* constructFromLexer(MasterLexer& lexer, const Name* origin); 182 183 TSIGImpl* impl_; 184 }; 185 186 } // end of namespace "any" 187 } // end of namespace "rdata" 188 } // end of namespace "dns" 189 } // end of namespace "isc" 190 #endif // ANY_TSIG_250_H 191 192 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 193 // 194 // This Source Code Form is subject to the terms of the Mozilla Public 195 // License, v. 2.0. If a copy of the MPL was not distributed with this 196 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 197 198 #ifndef CH_A_1_H 199 #define CH_A_1_H 1 200 201 #include <string> 202 203 #include <dns/rdata.h> 204 205 namespace isc { 206 namespace util { 207 208 class InputBuffer; 209 class OutputBuffer; 210 } 211 212 namespace dns { 213 214 // BEGIN_COMMON_DECLARATIONS 215 216 class AbstractMessageRenderer; 217 218 // END_COMMON_DECLARATIONS 219 220 namespace rdata { 221 namespace ch { 222 223 class A : public Rdata { 224 public: 225 // BEGIN_COMMON_MEMBERS 226 227 explicit A(const std::string& type_str); 228 A(isc::util::InputBuffer& buffer, size_t rdata_len); 229 A(const A& other); 230 A( 231 MasterLexer& lexer, const Name* name, 232 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 233 virtual std::string toText() const; 234 virtual void toWire(isc::util::OutputBuffer& buffer) const; 235 virtual void toWire(AbstractMessageRenderer& renderer) const; 236 virtual int compare(const Rdata& other) const; 237 238 // END_COMMON_MEMBERS 239 }; 240 241 } // end of namespace "ch" 242 } // end of namespace "rdata" 243 } // end of namespace "dns" 244 } // end of namespace "isc" 245 #endif // CH_A_1_H 246 247 // Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC") 248 // 249 // This Source Code Form is subject to the terms of the Mozilla Public 250 // License, v. 2.0. If a copy of the MPL was not distributed with this 251 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 252 253 #ifndef GENERIC_AFSDB_18_H 254 #define GENERIC_AFSDB_18_H 1 255 256 #include <stdint.h> 257 258 #include <string> 259 260 #include <dns/name.h> 261 #include <dns/rdata.h> 262 263 namespace isc { 264 namespace util { 265 266 class InputBuffer; 267 class OutputBuffer; 268 } 269 270 namespace dns { 271 272 // BEGIN_COMMON_DECLARATIONS 273 274 class AbstractMessageRenderer; 275 276 // END_COMMON_DECLARATIONS 277 278 namespace rdata { 279 namespace generic { 280 281 /// \brief \c rdata::AFSDB class represents the AFSDB RDATA as defined %in 282 /// RFC1183. 283 /// 284 /// This class implements the basic interfaces inherited from the abstract 285 /// \c rdata::Rdata class, and provides trivial accessors specific to the 286 /// AFSDB RDATA. 287 class AFSDB : public Rdata { 288 public: 289 // BEGIN_COMMON_MEMBERS 290 291 explicit AFSDB(const std::string& type_str); 292 AFSDB(isc::util::InputBuffer& buffer, size_t rdata_len); 293 AFSDB(const AFSDB& other); 294 AFSDB( 295 MasterLexer& lexer, const Name* name, 296 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 297 virtual std::string toText() const; 298 virtual void toWire(isc::util::OutputBuffer& buffer) const; 299 virtual void toWire(AbstractMessageRenderer& renderer) const; 300 virtual int compare(const Rdata& other) const; 301 302 // END_COMMON_MEMBERS 303 304 /// \brief Assignment operator. 305 /// 306 /// This method never throws an exception. 307 AFSDB& operator=(const AFSDB& source); 308 /// 309 /// Specialized methods 310 /// 311 312 /// \brief Return the value of the server field. 313 /// 314 /// \return A reference to a \c Name class object corresponding to the 315 /// internal server name. 316 /// 317 /// This method never throws an exception. 318 const Name& getServer() const; 319 320 /// \brief Return the value of the subtype field. 321 /// 322 /// This method never throws an exception. 323 uint16_t getSubtype() const; 324 325 private: 326 void createFromLexer(MasterLexer& lexer, const Name* origin); 327 328 uint16_t subtype_; 329 Name server_; 330 }; 331 332 } // end of namespace "generic" 333 } // end of namespace "rdata" 334 } // end of namespace "dns" 335 } // end of namespace "isc" 336 #endif // GENERIC_AFSDB_18_H 337 338 // Copyright (C) 2014-2021 Internet Systems Consortium, Inc. ("ISC") 339 // 340 // This Source Code Form is subject to the terms of the Mozilla Public 341 // License, v. 2.0. If a copy of the MPL was not distributed with this 342 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 343 344 #ifndef GENERIC_CAA_257_H 345 #define GENERIC_CAA_257_H 1 346 347 #include <stdint.h> 348 349 #include <dns/name.h> 350 #include <dns/rdata.h> 351 352 #include <string> 353 #include <vector> 354 355 namespace isc { 356 namespace util { 357 358 class InputBuffer; 359 class OutputBuffer; 360 } 361 362 namespace dns { 363 364 // BEGIN_COMMON_DECLARATIONS 365 366 class AbstractMessageRenderer; 367 368 // END_COMMON_DECLARATIONS 369 370 namespace rdata { 371 namespace generic { 372 373 struct CAAImpl; 374 375 class CAA : public Rdata { 376 public: 377 // BEGIN_COMMON_MEMBERS 378 379 explicit CAA(const std::string& type_str); 380 CAA(isc::util::InputBuffer& buffer, size_t rdata_len); 381 CAA(const CAA& other); 382 CAA( 383 MasterLexer& lexer, const Name* name, 384 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 385 virtual std::string toText() const; 386 virtual void toWire(isc::util::OutputBuffer& buffer) const; 387 virtual void toWire(AbstractMessageRenderer& renderer) const; 388 virtual int compare(const Rdata& other) const; 389 390 // END_COMMON_MEMBERS 391 392 CAA(uint8_t flags, const std::string& tag, const std::string& value); 393 CAA& operator=(const CAA& source); 394 ~CAA(); 395 396 /// 397 /// Specialized methods 398 /// 399 400 /// \brief Return the Flags field of the CAA RDATA. 401 uint8_t getFlags() const; 402 403 /// \brief Return the Tag field of the CAA RDATA. 404 const std::string& getTag() const; 405 406 /// \brief Return the Value field of the CAA RDATA. 407 /// 408 /// Note: The const reference which is returned is valid only during 409 /// the lifetime of this \c generic::CAA object. It should not be 410 /// used afterwards. 411 const std::vector<uint8_t>& getValue() const; 412 413 private: 414 CAAImpl* constructFromLexer(MasterLexer& lexer); 415 416 CAAImpl* impl_; 417 }; 418 419 } // end of namespace "generic" 420 } // end of namespace "rdata" 421 } // end of namespace "dns" 422 } // end of namespace "isc" 423 #endif // GENERIC_CAA_257_H 424 425 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 426 // 427 // This Source Code Form is subject to the terms of the Mozilla Public 428 // License, v. 2.0. If a copy of the MPL was not distributed with this 429 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 430 431 #ifndef GENERIC_CNAME_5_H 432 #define GENERIC_CNAME_5_H 1 433 434 #include <string> 435 436 #include <dns/name.h> 437 #include <dns/rdata.h> 438 439 namespace isc { 440 namespace util { 441 442 class InputBuffer; 443 class OutputBuffer; 444 } 445 446 namespace dns { 447 448 // BEGIN_COMMON_DECLARATIONS 449 450 class AbstractMessageRenderer; 451 452 // END_COMMON_DECLARATIONS 453 454 namespace rdata { 455 namespace generic { 456 457 class CNAME : public Rdata { 458 public: 459 // BEGIN_COMMON_MEMBERS 460 461 explicit CNAME(const std::string& type_str); 462 CNAME(isc::util::InputBuffer& buffer, size_t rdata_len); 463 CNAME(const CNAME& other); 464 CNAME( 465 MasterLexer& lexer, const Name* name, 466 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 467 virtual std::string toText() const; 468 virtual void toWire(isc::util::OutputBuffer& buffer) const; 469 virtual void toWire(AbstractMessageRenderer& renderer) const; 470 virtual int compare(const Rdata& other) const; 471 472 // END_COMMON_MEMBERS 473 474 // CNAME specific methods 475 CNAME(const Name& cname); 476 const Name& getCname() const; 477 private: 478 Name cname_; 479 }; 480 481 } // end of namespace "generic" 482 } // end of namespace "rdata" 483 } // end of namespace "dns" 484 } // end of namespace "isc" 485 #endif // GENERIC_CNAME_5_H 486 487 // Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC") 488 // 489 // This Source Code Form is subject to the terms of the Mozilla Public 490 // License, v. 2.0. If a copy of the MPL was not distributed with this 491 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 492 493 #ifndef GENERIC_DLV_32769_H 494 #define GENERIC_DLV_32769_H 1 495 496 #include <stdint.h> 497 498 #include <string> 499 500 #include <dns/name.h> 501 #include <dns/rrtype.h> 502 #include <dns/rrttl.h> 503 #include <dns/rdata.h> 504 505 namespace isc { 506 namespace util { 507 508 class InputBuffer; 509 class OutputBuffer; 510 } 511 512 namespace dns { 513 514 // BEGIN_COMMON_DECLARATIONS 515 516 class AbstractMessageRenderer; 517 518 // END_COMMON_DECLARATIONS 519 520 namespace rdata { 521 namespace generic { 522 523 namespace detail { 524 template <class Type, uint16_t typeCode> class DSLikeImpl; 525 } 526 527 /// \brief \c rdata::generic::DLV class represents the DLV RDATA as defined in 528 /// RFC4431. 529 /// 530 /// This class implements the basic interfaces inherited from the abstract 531 /// \c rdata::Rdata class, and provides trivial accessors specific to the 532 /// DLV RDATA. 533 class DLV : public Rdata { 534 public: 535 // BEGIN_COMMON_MEMBERS 536 537 explicit DLV(const std::string& type_str); 538 DLV(isc::util::InputBuffer& buffer, size_t rdata_len); 539 DLV(const DLV& other); 540 DLV( 541 MasterLexer& lexer, const Name* name, 542 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 543 virtual std::string toText() const; 544 virtual void toWire(isc::util::OutputBuffer& buffer) const; 545 virtual void toWire(AbstractMessageRenderer& renderer) const; 546 virtual int compare(const Rdata& other) const; 547 548 // END_COMMON_MEMBERS 549 550 /// \brief Assignment operator. 551 /// 552 /// It internally allocates a resource, and if it fails a corresponding 553 /// standard exception will be thrown. 554 /// This operator never throws an exception otherwise. 555 /// 556 /// This operator provides the strong exception guarantee: When an 557 /// exception is thrown the content of the assignment target will be 558 /// intact. 559 DLV& operator=(const DLV& source); 560 561 /// \brief The destructor. 562 ~DLV(); 563 564 /// \brief Return the value of the Tag field. 565 /// 566 /// This method never throws an exception. 567 uint16_t getTag() const; 568 private: 569 typedef detail::DSLikeImpl<DLV, 32769> DLVImpl; 570 DLVImpl* impl_; 571 }; 572 573 } // end of namespace "generic" 574 } // end of namespace "rdata" 575 } // end of namespace "dns" 576 } // end of namespace "isc" 577 #endif // GENERIC_DLV_32769_H 578 579 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 580 // 581 // This Source Code Form is subject to the terms of the Mozilla Public 582 // License, v. 2.0. If a copy of the MPL was not distributed with this 583 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 584 585 #ifndef GENERIC_DNAME_39_H 586 #define GENERIC_DNAME_39_H 1 587 588 #include <string> 589 590 #include <dns/name.h> 591 #include <dns/rdata.h> 592 593 namespace isc { 594 namespace util { 595 596 class InputBuffer; 597 class OutputBuffer; 598 } 599 600 namespace dns { 601 602 // BEGIN_COMMON_DECLARATIONS 603 604 class AbstractMessageRenderer; 605 606 // END_COMMON_DECLARATIONS 607 608 namespace rdata { 609 namespace generic { 610 611 class DNAME : public Rdata { 612 public: 613 // BEGIN_COMMON_MEMBERS 614 615 explicit DNAME(const std::string& type_str); 616 DNAME(isc::util::InputBuffer& buffer, size_t rdata_len); 617 DNAME(const DNAME& other); 618 DNAME( 619 MasterLexer& lexer, const Name* name, 620 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 621 virtual std::string toText() const; 622 virtual void toWire(isc::util::OutputBuffer& buffer) const; 623 virtual void toWire(AbstractMessageRenderer& renderer) const; 624 virtual int compare(const Rdata& other) const; 625 626 // END_COMMON_MEMBERS 627 628 // DNAME specific methods 629 DNAME(const Name& dname); 630 const Name& getDname() const; 631 private: 632 Name dname_; 633 }; 634 635 } // end of namespace "generic" 636 } // end of namespace "rdata" 637 } // end of namespace "dns" 638 } // end of namespace "isc" 639 #endif // GENERIC_DNAME_39_H 640 641 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 642 // 643 // This Source Code Form is subject to the terms of the Mozilla Public 644 // License, v. 2.0. If a copy of the MPL was not distributed with this 645 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 646 647 #include <stdint.h> 648 649 #include <string> 650 651 #include <dns/name.h> 652 #include <dns/rrtype.h> 653 #include <dns/rrttl.h> 654 #include <dns/rdata.h> 655 #include <dns/master_lexer.h> 656 657 #ifndef GENERIC_DNSKEY_48_H 658 #define GENERIC_DNSKEY_48_H 1 659 660 namespace isc { 661 namespace util { 662 663 class InputBuffer; 664 class OutputBuffer; 665 } 666 667 namespace dns { 668 669 // BEGIN_COMMON_DECLARATIONS 670 671 class AbstractMessageRenderer; 672 673 // END_COMMON_DECLARATIONS 674 675 namespace rdata { 676 namespace generic { 677 678 struct DNSKEYImpl; 679 680 class DNSKEY : public Rdata { 681 public: 682 // BEGIN_COMMON_MEMBERS 683 684 explicit DNSKEY(const std::string& type_str); 685 DNSKEY(isc::util::InputBuffer& buffer, size_t rdata_len); 686 DNSKEY(const DNSKEY& other); 687 DNSKEY( 688 MasterLexer& lexer, const Name* name, 689 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 690 virtual std::string toText() const; 691 virtual void toWire(isc::util::OutputBuffer& buffer) const; 692 virtual void toWire(AbstractMessageRenderer& renderer) const; 693 virtual int compare(const Rdata& other) const; 694 695 // END_COMMON_MEMBERS 696 DNSKEY& operator=(const DNSKEY& source); 697 ~DNSKEY(); 698 699 /// 700 /// Specialized methods 701 /// 702 703 /// \brief Returns the key tag 704 /// 705 /// \throw isc::OutOfRange if the key data for RSA/MD5 is too short 706 /// to support tag extraction. 707 uint16_t getTag() const; 708 709 uint16_t getFlags() const; 710 uint8_t getAlgorithm() const; 711 712 private: 713 DNSKEYImpl* constructFromLexer(isc::dns::MasterLexer& lexer); 714 715 DNSKEYImpl* impl_; 716 }; 717 718 } // end of namespace "generic" 719 } // end of namespace "rdata" 720 } // end of namespace "dns" 721 } // end of namespace "isc" 722 #endif // GENERIC_DNSKEY_48_H 723 724 // Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC") 725 // 726 // This Source Code Form is subject to the terms of the Mozilla Public 727 // License, v. 2.0. If a copy of the MPL was not distributed with this 728 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 729 730 #ifndef GENERIC_DS_43_H 731 #define GENERIC_DS_43_H 1 732 733 #include <stdint.h> 734 735 #include <string> 736 737 #include <dns/name.h> 738 #include <dns/rrtype.h> 739 #include <dns/rrttl.h> 740 #include <dns/rdata.h> 741 742 namespace isc { 743 namespace util { 744 745 class InputBuffer; 746 class OutputBuffer; 747 } 748 749 namespace dns { 750 751 // BEGIN_COMMON_DECLARATIONS 752 753 class AbstractMessageRenderer; 754 755 // END_COMMON_DECLARATIONS 756 757 namespace rdata { 758 namespace generic { 759 760 namespace detail { 761 template <class Type, uint16_t typeCode> class DSLikeImpl; 762 } 763 764 /// \brief \c rdata::generic::DS class represents the DS RDATA as defined in 765 /// RFC3658. 766 /// 767 /// This class implements the basic interfaces inherited from the abstract 768 /// \c rdata::Rdata class, and provides trivial accessors specific to the 769 /// DS RDATA. 770 class DS : public Rdata { 771 public: 772 // BEGIN_COMMON_MEMBERS 773 774 explicit DS(const std::string& type_str); 775 DS(isc::util::InputBuffer& buffer, size_t rdata_len); 776 DS(const DS& other); 777 DS( 778 MasterLexer& lexer, const Name* name, 779 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 780 virtual std::string toText() const; 781 virtual void toWire(isc::util::OutputBuffer& buffer) const; 782 virtual void toWire(AbstractMessageRenderer& renderer) const; 783 virtual int compare(const Rdata& other) const; 784 785 // END_COMMON_MEMBERS 786 787 /// \brief Assignment operator. 788 /// 789 /// It internally allocates a resource, and if it fails a corresponding 790 /// standard exception will be thrown. 791 /// This operator never throws an exception otherwise. 792 /// 793 /// This operator provides the strong exception guarantee: When an 794 /// exception is thrown the content of the assignment target will be 795 /// intact. 796 DS& operator=(const DS& source); 797 798 /// \brief The destructor. 799 ~DS(); 800 801 /// \brief Return the value of the Tag field. 802 /// 803 /// This method never throws an exception. 804 uint16_t getTag() const; 805 private: 806 typedef detail::DSLikeImpl<DS, 43> DSImpl; 807 DSImpl* impl_; 808 }; 809 810 } // end of namespace "generic" 811 } // end of namespace "rdata" 812 } // end of namespace "dns" 813 } // end of namespace "isc" 814 #endif // GENERIC_DS_43_H 815 816 // Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC") 817 // 818 // This Source Code Form is subject to the terms of the Mozilla Public 819 // License, v. 2.0. If a copy of the MPL was not distributed with this 820 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 821 822 #ifndef GENERIC_HINFO_13_H 823 #define GENERIC_HINFO_13_H 1 824 #include <stdint.h> 825 826 #include <string> 827 828 #include <boost/scoped_ptr.hpp> 829 #include <boost/noncopyable.hpp> 830 831 #include <dns/name.h> 832 #include <dns/rdata.h> 833 #include <util/buffer.h> 834 835 namespace isc { 836 namespace util { 837 838 class InputBuffer; 839 class OutputBuffer; 840 } 841 842 namespace dns { 843 844 // BEGIN_COMMON_DECLARATIONS 845 846 class AbstractMessageRenderer; 847 848 // END_COMMON_DECLARATIONS 849 850 namespace rdata { 851 namespace generic { 852 853 class HINFOImpl; 854 855 /// \brief \c HINFO class represents the HINFO rdata defined in 856 /// RFC1034, RFC1035 857 /// 858 /// This class implements the basic interfaces inherited from the 859 /// \c rdata::Rdata class, and provides accessors specific to the 860 /// HINFO rdata. 861 class HINFO : public Rdata { 862 public: 863 // BEGIN_COMMON_MEMBERS 864 865 explicit HINFO(const std::string& type_str); 866 HINFO(isc::util::InputBuffer& buffer, size_t rdata_len); 867 HINFO(const HINFO& other); 868 HINFO( 869 MasterLexer& lexer, const Name* name, 870 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 871 virtual std::string toText() const; 872 virtual void toWire(isc::util::OutputBuffer& buffer) const; 873 virtual void toWire(AbstractMessageRenderer& renderer) const; 874 virtual int compare(const Rdata& other) const; 875 876 // END_COMMON_MEMBERS 877 878 // HINFO specific methods 879 ~HINFO(); 880 881 HINFO& operator=(const HINFO&); 882 883 const std::string getCPU() const; 884 const std::string getOS() const; 885 886 private: 887 /// Helper template function for toWire() 888 /// 889 /// \param outputer Where to write data in 890 template <typename T> 891 void toWireHelper(T& outputer) const; 892 893 boost::scoped_ptr<HINFOImpl> impl_; 894 }; 895 896 897 } // end of namespace "generic" 898 } // end of namespace "rdata" 899 } // end of namespace "dns" 900 } // end of namespace "isc" 901 #endif // GENERIC_HINFO_13_H 902 903 // Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC") 904 // 905 // This Source Code Form is subject to the terms of the Mozilla Public 906 // License, v. 2.0. If a copy of the MPL was not distributed with this 907 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 908 909 #ifndef GENERIC_MINFO_14_H 910 #define GENERIC_MINFO_14_H 1 911 912 #include <string> 913 914 #include <dns/name.h> 915 #include <dns/rdata.h> 916 917 namespace isc { 918 namespace util { 919 920 class InputBuffer; 921 class OutputBuffer; 922 } 923 924 namespace dns { 925 926 // BEGIN_COMMON_DECLARATIONS 927 928 class AbstractMessageRenderer; 929 930 // END_COMMON_DECLARATIONS 931 932 namespace rdata { 933 namespace generic { 934 935 /// \brief \c rdata::generic::MINFO class represents the MINFO RDATA as 936 /// defined in RFC1035. 937 /// 938 /// This class implements the basic interfaces inherited from the abstract 939 /// \c rdata::Rdata class, and provides trivial accessors specific to the 940 /// MINFO RDATA. 941 class MINFO : public Rdata { 942 public: 943 // BEGIN_COMMON_MEMBERS 944 945 explicit MINFO(const std::string& type_str); 946 MINFO(isc::util::InputBuffer& buffer, size_t rdata_len); 947 MINFO(const MINFO& other); 948 MINFO( 949 MasterLexer& lexer, const Name* name, 950 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 951 virtual std::string toText() const; 952 virtual void toWire(isc::util::OutputBuffer& buffer) const; 953 virtual void toWire(AbstractMessageRenderer& renderer) const; 954 virtual int compare(const Rdata& other) const; 955 956 // END_COMMON_MEMBERS 957 958 /// \brief Define the assignment operator. 959 /// 960 /// \exception std::bad_alloc Memory allocation fails in copying 961 /// internal member variables (this should be very rare). 962 MINFO& operator=(const MINFO& source); 963 964 /// \brief Return the value of the rmailbox field. 965 /// 966 /// \throw std::bad_alloc If resource allocation for the returned 967 /// \c Name fails. 968 /// 969 /// \note 970 /// Unlike the case of some other RDATA classes (such as 971 /// \c NS::getNSName()), this method constructs a new \c Name object 972 /// and returns it, instead of returning a reference to a \c Name object 973 /// internally maintained in the class (which is a private member). 974 /// This is based on the observation that this method will be rarely 975 /// used and even when it's used it will not be in a performance context 976 /// (for example, a recursive resolver won't need this field in its 977 /// resolution process). By returning a new object we have flexibility 978 /// of changing the internal representation without the risk of changing 979 /// the interface or method property. 980 /// The same note applies to the \c getEmailbox() method. getRmailbox()981 Name getRmailbox() const { return (rmailbox_); } 982 983 /// \brief Return the value of the emailbox field. 984 /// 985 /// \throw std::bad_alloc If resource allocation for the returned 986 /// \c Name fails. getEmailbox()987 Name getEmailbox() const { return (emailbox_); } 988 989 private: 990 Name rmailbox_; 991 Name emailbox_; 992 }; 993 994 } // end of namespace "generic" 995 } // end of namespace "rdata" 996 } // end of namespace "dns" 997 } // end of namespace "isc" 998 #endif // GENERIC_MINFO_14_H 999 1000 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 1001 // 1002 // This Source Code Form is subject to the terms of the Mozilla Public 1003 // License, v. 2.0. If a copy of the MPL was not distributed with this 1004 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1005 1006 #ifndef GENERIC_MX_15_H 1007 #define GENERIC_MX_15_H 1 1008 1009 #include <stdint.h> 1010 1011 #include <string> 1012 1013 #include <dns/name.h> 1014 #include <dns/rdata.h> 1015 1016 namespace isc { 1017 namespace util { 1018 1019 class InputBuffer; 1020 class OutputBuffer; 1021 } 1022 1023 namespace dns { 1024 1025 // BEGIN_COMMON_DECLARATIONS 1026 1027 class AbstractMessageRenderer; 1028 1029 // END_COMMON_DECLARATIONS 1030 1031 namespace rdata { 1032 namespace generic { 1033 1034 class MX : public Rdata { 1035 public: 1036 // BEGIN_COMMON_MEMBERS 1037 1038 explicit MX(const std::string& type_str); 1039 MX(isc::util::InputBuffer& buffer, size_t rdata_len); 1040 MX(const MX& other); 1041 MX( 1042 MasterLexer& lexer, const Name* name, 1043 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1044 virtual std::string toText() const; 1045 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1046 virtual void toWire(AbstractMessageRenderer& renderer) const; 1047 virtual int compare(const Rdata& other) const; 1048 1049 // END_COMMON_MEMBERS 1050 1051 MX(uint16_t preference, const Name& mxname); 1052 1053 /// 1054 /// Specialized methods 1055 /// 1056 const Name& getMXName() const; 1057 uint16_t getMXPref() const; 1058 1059 private: 1060 void constructFromLexer(isc::dns::MasterLexer& lexer, 1061 const isc::dns::Name* origin); 1062 1063 /// Note: this is a prototype version; we may reconsider 1064 /// this representation later. 1065 uint16_t preference_; 1066 Name mxname_; 1067 }; 1068 1069 } // end of namespace "generic" 1070 } // end of namespace "rdata" 1071 } // end of namespace "dns" 1072 } // end of namespace "isc" 1073 #endif // GENERIC_MX_15_H 1074 1075 // Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC") 1076 // 1077 // This Source Code Form is subject to the terms of the Mozilla Public 1078 // License, v. 2.0. If a copy of the MPL was not distributed with this 1079 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1080 1081 #ifndef GENERIC_NAPTR_35_H 1082 #define GENERIC_NAPTR_35_H 1 1083 1084 #include <string> 1085 1086 #include <boost/scoped_ptr.hpp> 1087 1088 #include <dns/name.h> 1089 #include <dns/rdata.h> 1090 #include <util/buffer.h> 1091 1092 namespace isc { 1093 namespace util { 1094 1095 class InputBuffer; 1096 class OutputBuffer; 1097 } 1098 1099 namespace dns { 1100 1101 // BEGIN_COMMON_DECLARATIONS 1102 1103 class AbstractMessageRenderer; 1104 1105 // END_COMMON_DECLARATIONS 1106 1107 namespace rdata { 1108 namespace generic { 1109 1110 class NAPTRImpl; 1111 1112 /// \brief \c NAPTR class represents the NAPTR rdata defined in 1113 /// RFC2915, RFC2168 and RFC3403 1114 /// 1115 /// This class implements the basic interfaces inherited from the 1116 /// \c rdata::Rdata class, and provides accessors specific to the 1117 /// NAPTR rdata. 1118 class NAPTR : public Rdata { 1119 public: 1120 // BEGIN_COMMON_MEMBERS 1121 1122 explicit NAPTR(const std::string& type_str); 1123 NAPTR(isc::util::InputBuffer& buffer, size_t rdata_len); 1124 NAPTR(const NAPTR& other); 1125 NAPTR( 1126 MasterLexer& lexer, const Name* name, 1127 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1128 virtual std::string toText() const; 1129 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1130 virtual void toWire(AbstractMessageRenderer& renderer) const; 1131 virtual int compare(const Rdata& other) const; 1132 1133 // END_COMMON_MEMBERS 1134 1135 // NAPTR specific methods 1136 ~NAPTR(); 1137 1138 NAPTR& operator=(const NAPTR& source); 1139 1140 uint16_t getOrder() const; 1141 uint16_t getPreference() const; 1142 const std::string getFlags() const; 1143 const std::string getServices() const; 1144 const std::string getRegexp() const; 1145 const Name& getReplacement() const; 1146 private: 1147 /// Helper template function for toWire() 1148 /// 1149 /// \param outputer Where to write data in 1150 template <typename T> 1151 void toWireHelper(T& outputer) const; 1152 1153 boost::scoped_ptr<NAPTRImpl> impl_; 1154 }; 1155 1156 } // end of namespace "generic" 1157 } // end of namespace "rdata" 1158 } // end of namespace "dns" 1159 } // end of namespace "isc" 1160 #endif // GENERIC_NAPTR_35_H 1161 1162 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 1163 // 1164 // This Source Code Form is subject to the terms of the Mozilla Public 1165 // License, v. 2.0. If a copy of the MPL was not distributed with this 1166 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1167 1168 #ifndef GENERIC_NS_2_H 1169 #define GENERIC_NS_2_H 1 1170 1171 #include <string> 1172 1173 #include <dns/name.h> 1174 #include <dns/rdata.h> 1175 1176 namespace isc { 1177 namespace util { 1178 1179 class InputBuffer; 1180 class OutputBuffer; 1181 } 1182 1183 namespace dns { 1184 1185 // BEGIN_COMMON_DECLARATIONS 1186 1187 class AbstractMessageRenderer; 1188 1189 // END_COMMON_DECLARATIONS 1190 1191 namespace rdata { 1192 namespace generic { 1193 1194 class NS : public Rdata { 1195 public: 1196 // BEGIN_COMMON_MEMBERS 1197 1198 explicit NS(const std::string& type_str); 1199 NS(isc::util::InputBuffer& buffer, size_t rdata_len); 1200 NS(const NS& other); 1201 NS( 1202 MasterLexer& lexer, const Name* name, 1203 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1204 virtual std::string toText() const; 1205 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1206 virtual void toWire(AbstractMessageRenderer& renderer) const; 1207 virtual int compare(const Rdata& other) const; 1208 1209 // END_COMMON_MEMBERS 1210 /// 1211 /// Specialized constructor 1212 /// NS(const Name & nsname)1213 explicit NS(const Name& nsname) : nsname_(nsname) {} 1214 /// 1215 /// Specialized methods 1216 /// 1217 const Name& getNSName() const; 1218 private: 1219 Name nsname_; 1220 }; 1221 1222 } // end of namespace "generic" 1223 } // end of namespace "rdata" 1224 } // end of namespace "dns" 1225 } // end of namespace "isc" 1226 #endif // GENERIC_NS_2_H 1227 1228 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 1229 // 1230 // This Source Code Form is subject to the terms of the Mozilla Public 1231 // License, v. 2.0. If a copy of the MPL was not distributed with this 1232 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1233 1234 #include <stdint.h> 1235 1236 #include <string> 1237 #include <vector> 1238 1239 #include <dns/name.h> 1240 #include <dns/rrtype.h> 1241 #include <dns/rrttl.h> 1242 #include <dns/rdata.h> 1243 #include <dns/master_lexer.h> 1244 1245 #ifndef GENERIC_NSEC3_50_H 1246 #define GENERIC_NSEC3_50_H 1 1247 1248 namespace isc { 1249 namespace util { 1250 1251 class InputBuffer; 1252 class OutputBuffer; 1253 } 1254 1255 namespace dns { 1256 1257 // BEGIN_COMMON_DECLARATIONS 1258 1259 class AbstractMessageRenderer; 1260 1261 // END_COMMON_DECLARATIONS 1262 1263 namespace rdata { 1264 namespace generic { 1265 1266 struct NSEC3Impl; 1267 1268 class NSEC3 : public Rdata { 1269 public: 1270 // BEGIN_COMMON_MEMBERS 1271 1272 explicit NSEC3(const std::string& type_str); 1273 NSEC3(isc::util::InputBuffer& buffer, size_t rdata_len); 1274 NSEC3(const NSEC3& other); 1275 NSEC3( 1276 MasterLexer& lexer, const Name* name, 1277 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1278 virtual std::string toText() const; 1279 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1280 virtual void toWire(AbstractMessageRenderer& renderer) const; 1281 virtual int compare(const Rdata& other) const; 1282 1283 // END_COMMON_MEMBERS 1284 NSEC3& operator=(const NSEC3& source); 1285 ~NSEC3(); 1286 1287 uint8_t getHashalg() const; 1288 uint8_t getFlags() const; 1289 uint16_t getIterations() const; 1290 const std::vector<uint8_t>& getSalt() const; 1291 const std::vector<uint8_t>& getNext() const; 1292 1293 private: 1294 NSEC3Impl* constructFromLexer(isc::dns::MasterLexer& lexer); 1295 1296 NSEC3Impl* impl_; 1297 }; 1298 1299 } // end of namespace "generic" 1300 } // end of namespace "rdata" 1301 } // end of namespace "dns" 1302 } // end of namespace "isc" 1303 #endif // GENERIC_NSEC3_50_H 1304 1305 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 1306 // 1307 // This Source Code Form is subject to the terms of the Mozilla Public 1308 // License, v. 2.0. If a copy of the MPL was not distributed with this 1309 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1310 1311 #include <stdint.h> 1312 1313 #include <string> 1314 #include <vector> 1315 1316 #include <dns/name.h> 1317 #include <dns/rrtype.h> 1318 #include <dns/rrttl.h> 1319 #include <dns/rdata.h> 1320 #include <dns/master_lexer.h> 1321 1322 #ifndef GENERIC_NSEC3PARAM_51_H 1323 #define GENERIC_NSEC3PARAM_51_H 1 1324 1325 namespace isc { 1326 namespace util { 1327 1328 class InputBuffer; 1329 class OutputBuffer; 1330 } 1331 1332 namespace dns { 1333 1334 // BEGIN_COMMON_DECLARATIONS 1335 1336 class AbstractMessageRenderer; 1337 1338 // END_COMMON_DECLARATIONS 1339 1340 namespace rdata { 1341 namespace generic { 1342 1343 struct NSEC3PARAMImpl; 1344 1345 class NSEC3PARAM : public Rdata { 1346 public: 1347 // BEGIN_COMMON_MEMBERS 1348 1349 explicit NSEC3PARAM(const std::string& type_str); 1350 NSEC3PARAM(isc::util::InputBuffer& buffer, size_t rdata_len); 1351 NSEC3PARAM(const NSEC3PARAM& other); 1352 NSEC3PARAM( 1353 MasterLexer& lexer, const Name* name, 1354 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1355 virtual std::string toText() const; 1356 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1357 virtual void toWire(AbstractMessageRenderer& renderer) const; 1358 virtual int compare(const Rdata& other) const; 1359 1360 // END_COMMON_MEMBERS 1361 NSEC3PARAM& operator=(const NSEC3PARAM& source); 1362 ~NSEC3PARAM(); 1363 1364 /// 1365 /// Specialized methods 1366 /// 1367 uint8_t getHashalg() const; 1368 uint8_t getFlags() const; 1369 uint16_t getIterations() const; 1370 const std::vector<uint8_t>& getSalt() const; 1371 1372 private: 1373 NSEC3PARAMImpl* constructFromLexer(isc::dns::MasterLexer& lexer); 1374 1375 NSEC3PARAMImpl* impl_; 1376 }; 1377 1378 } // end of namespace "generic" 1379 } // end of namespace "rdata" 1380 } // end of namespace "dns" 1381 } // end of namespace "isc" 1382 #endif // GENERIC_NSEC3PARAM_51_H 1383 1384 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 1385 // 1386 // This Source Code Form is subject to the terms of the Mozilla Public 1387 // License, v. 2.0. If a copy of the MPL was not distributed with this 1388 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1389 1390 #include <stdint.h> 1391 1392 #include <string> 1393 1394 #include <dns/name.h> 1395 #include <dns/rrtype.h> 1396 #include <dns/rrttl.h> 1397 #include <dns/rdata.h> 1398 1399 #ifndef GENERIC_NSEC_47_H 1400 #define GENERIC_NSEC_47_H 1 1401 1402 namespace isc { 1403 namespace util { 1404 1405 class InputBuffer; 1406 class OutputBuffer; 1407 } 1408 1409 namespace dns { 1410 1411 // BEGIN_COMMON_DECLARATIONS 1412 1413 class AbstractMessageRenderer; 1414 1415 // END_COMMON_DECLARATIONS 1416 1417 namespace rdata { 1418 namespace generic { 1419 1420 struct NSECImpl; 1421 1422 class NSEC : public Rdata { 1423 public: 1424 // BEGIN_COMMON_MEMBERS 1425 1426 explicit NSEC(const std::string& type_str); 1427 NSEC(isc::util::InputBuffer& buffer, size_t rdata_len); 1428 NSEC(const NSEC& other); 1429 NSEC( 1430 MasterLexer& lexer, const Name* name, 1431 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1432 virtual std::string toText() const; 1433 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1434 virtual void toWire(AbstractMessageRenderer& renderer) const; 1435 virtual int compare(const Rdata& other) const; 1436 1437 // END_COMMON_MEMBERS 1438 NSEC& operator=(const NSEC& source); 1439 ~NSEC(); 1440 1441 // specialized methods 1442 1443 /// Return the next domain name. 1444 /// 1445 /// \exception std::bad_alloc Resource allocation failure in name copy. 1446 /// 1447 /// \return The next domain name field in the form of \c Name object. 1448 const Name& getNextName() const; 1449 1450 private: 1451 NSECImpl* impl_; 1452 }; 1453 1454 } // end of namespace "generic" 1455 } // end of namespace "rdata" 1456 } // end of namespace "dns" 1457 } // end of namespace "isc" 1458 #endif // GENERIC_NSEC_47_H 1459 1460 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 1461 // 1462 // This Source Code Form is subject to the terms of the Mozilla Public 1463 // License, v. 2.0. If a copy of the MPL was not distributed with this 1464 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1465 1466 #ifndef GENERIC_OPT_41_H 1467 #define GENERIC_OPT_41_H 1 1468 1469 #include <string> 1470 1471 #include <dns/rdata.h> 1472 1473 #include <boost/shared_ptr.hpp> 1474 1475 #include <vector> 1476 1477 namespace isc { 1478 namespace util { 1479 1480 class InputBuffer; 1481 class OutputBuffer; 1482 } 1483 1484 namespace dns { 1485 1486 // BEGIN_COMMON_DECLARATIONS 1487 1488 class AbstractMessageRenderer; 1489 1490 // END_COMMON_DECLARATIONS 1491 1492 namespace rdata { 1493 namespace generic { 1494 1495 struct OPTImpl; 1496 1497 class OPT : public Rdata { 1498 public: 1499 // BEGIN_COMMON_MEMBERS 1500 1501 explicit OPT(const std::string& type_str); 1502 OPT(isc::util::InputBuffer& buffer, size_t rdata_len); 1503 OPT(const OPT& other); 1504 OPT( 1505 MasterLexer& lexer, const Name* name, 1506 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1507 virtual std::string toText() const; 1508 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1509 virtual void toWire(AbstractMessageRenderer& renderer) const; 1510 virtual int compare(const Rdata& other) const; 1511 1512 // END_COMMON_MEMBERS 1513 1514 // The default constructor makes sense for OPT as it can be empty. 1515 OPT(); 1516 OPT& operator=(const OPT& source); 1517 ~OPT(); 1518 1519 /// \brief A class representing a pseudo RR (or option) within an 1520 /// OPT RR (see RFC 6891). 1521 class PseudoRR { 1522 public: 1523 /// \brief Constructor. 1524 /// \param code The OPTION-CODE field of the pseudo RR. 1525 /// \param data The OPTION-DATA field of the pseudo 1526 /// RR. OPTION-LENGTH is set to the length of this vector. 1527 PseudoRR(uint16_t code, 1528 boost::shared_ptr<std::vector<uint8_t> >& data); 1529 1530 /// \brief Return the option code of this pseudo RR. 1531 uint16_t getCode() const; 1532 1533 /// \brief Return the option data of this pseudo RR. 1534 const uint8_t* getData() const; 1535 1536 /// \brief Return the length of the option data of this 1537 /// pseudo RR. 1538 uint16_t getLength() const; 1539 1540 private: 1541 uint16_t code_; 1542 boost::shared_ptr<std::vector<uint8_t> > data_; 1543 }; 1544 1545 /// \brief Append a pseudo RR (option) in this OPT RR. 1546 /// 1547 /// \param code The OPTION-CODE field of the pseudo RR. 1548 /// \param data The OPTION-DATA field of the pseudo RR. 1549 /// \param length The size of the \c data argument. OPTION-LENGTH is 1550 /// set to this size. 1551 /// \throw isc::InvalidParameter if this pseudo RR would cause 1552 /// the OPT RDATA to overflow its RDLENGTH. 1553 void appendPseudoRR(uint16_t code, const uint8_t* data, uint16_t length); 1554 1555 /// \brief Return a vector of the pseudo RRs (options) in this 1556 /// OPT RR. 1557 /// 1558 /// Note: The returned reference is only valid during the lifetime 1559 /// of this \c generic::OPT object. It should not be used 1560 /// afterwards. 1561 const std::vector<PseudoRR>& getPseudoRRs() const; 1562 1563 private: 1564 OPTImpl* impl_; 1565 }; 1566 1567 } // end of namespace "generic" 1568 } // end of namespace "rdata" 1569 } // end of namespace "dns" 1570 } // end of namespace "isc" 1571 #endif // GENERIC_OPT_41_H 1572 1573 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 1574 // 1575 // This Source Code Form is subject to the terms of the Mozilla Public 1576 // License, v. 2.0. If a copy of the MPL was not distributed with this 1577 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1578 1579 #ifndef GENERIC_PTR_12_H 1580 #define GENERIC_PTR_12_H 1 1581 1582 #include <string> 1583 1584 #include <dns/name.h> 1585 #include <dns/rdata.h> 1586 1587 namespace isc { 1588 namespace util { 1589 1590 class InputBuffer; 1591 class OutputBuffer; 1592 } 1593 1594 namespace dns { 1595 1596 // BEGIN_COMMON_DECLARATIONS 1597 1598 class AbstractMessageRenderer; 1599 1600 // END_COMMON_DECLARATIONS 1601 1602 namespace rdata { 1603 namespace generic { 1604 1605 class PTR : public Rdata { 1606 public: 1607 // BEGIN_COMMON_MEMBERS 1608 1609 explicit PTR(const std::string& type_str); 1610 PTR(isc::util::InputBuffer& buffer, size_t rdata_len); 1611 PTR(const PTR& other); 1612 PTR( 1613 MasterLexer& lexer, const Name* name, 1614 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1615 virtual std::string toText() const; 1616 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1617 virtual void toWire(AbstractMessageRenderer& renderer) const; 1618 virtual int compare(const Rdata& other) const; 1619 1620 // END_COMMON_MEMBERS 1621 1622 /// 1623 /// Specialized constructor 1624 /// PTR(const Name & ptr_name)1625 explicit PTR(const Name& ptr_name) : ptr_name_(ptr_name) {} 1626 /// 1627 /// Specialized methods 1628 /// 1629 const Name& getPTRName() const; 1630 private: 1631 Name ptr_name_; 1632 }; 1633 1634 } // end of namespace "generic" 1635 } // end of namespace "rdata" 1636 } // end of namespace "dns" 1637 } // end of namespace "isc" 1638 #endif // GENERIC_PTR_12_H 1639 1640 // Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC") 1641 // 1642 // This Source Code Form is subject to the terms of the Mozilla Public 1643 // License, v. 2.0. If a copy of the MPL was not distributed with this 1644 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1645 1646 #ifndef GENERIC_RP_17_H 1647 #define GENERIC_RP_17_H 1 1648 1649 #include <string> 1650 1651 #include <dns/name.h> 1652 #include <dns/rdata.h> 1653 1654 namespace isc { 1655 namespace util { 1656 1657 class InputBuffer; 1658 class OutputBuffer; 1659 } 1660 1661 namespace dns { 1662 1663 // BEGIN_COMMON_DECLARATIONS 1664 1665 class AbstractMessageRenderer; 1666 1667 // END_COMMON_DECLARATIONS 1668 1669 namespace rdata { 1670 namespace generic { 1671 1672 /// \brief \c rdata::generic::RP class represents the RP RDATA as defined in 1673 /// RFC1183. 1674 /// 1675 /// This class implements the basic interfaces inherited from the abstract 1676 /// \c rdata::Rdata class, and provides trivial accessors specific to the 1677 /// RP RDATA. 1678 class RP : public Rdata { 1679 public: 1680 // BEGIN_COMMON_MEMBERS 1681 1682 explicit RP(const std::string& type_str); 1683 RP(isc::util::InputBuffer& buffer, size_t rdata_len); 1684 RP(const RP& other); 1685 RP( 1686 MasterLexer& lexer, const Name* name, 1687 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1688 virtual std::string toText() const; 1689 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1690 virtual void toWire(AbstractMessageRenderer& renderer) const; 1691 virtual int compare(const Rdata& other) const; 1692 1693 // END_COMMON_MEMBERS 1694 1695 /// We use the default copy constructor and assignment operator. 1696 1697 /// \brief Constructor from RDATA field parameters. 1698 /// 1699 /// The parameters are a straightforward mapping of %RP RDATA 1700 /// fields as defined in RFC1183. RP(const Name & mailbox,const Name & text)1701 RP(const Name& mailbox, const Name& text) : 1702 mailbox_(mailbox), text_(text) 1703 {} 1704 1705 /// \brief Return the value of the mailbox field. 1706 /// 1707 /// \throw std::bad_alloc If resource allocation for the returned 1708 /// \c Name fails. 1709 /// 1710 /// \note 1711 /// Unlike the case of some other RDATA classes (such as 1712 /// \c NS::getNSName()), this method constructs a new \c Name object 1713 /// and returns it, instead of returning a reference to a \c Name object 1714 /// internally maintained in the class (which is a private member). 1715 /// This is based on the observation that this method will be rarely used 1716 /// and even when it's used it will not be in a performance context 1717 /// (for example, a recursive resolver won't need this field in its 1718 /// resolution process). By returning a new object we have flexibility of 1719 /// changing the internal representation without the risk of changing 1720 /// the interface or method property. 1721 /// The same note applies to the \c getText() method. getMailbox()1722 Name getMailbox() const { return (mailbox_); } 1723 1724 /// \brief Return the value of the text field. 1725 /// 1726 /// \throw std::bad_alloc If resource allocation for the returned 1727 /// \c Name fails. getText()1728 Name getText() const { return (text_); } 1729 1730 private: 1731 Name mailbox_; 1732 Name text_; 1733 }; 1734 1735 } // end of namespace "generic" 1736 } // end of namespace "rdata" 1737 } // end of namespace "dns" 1738 } // end of namespace "isc" 1739 #endif // GENERIC_RP_17_H 1740 1741 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 1742 // 1743 // This Source Code Form is subject to the terms of the Mozilla Public 1744 // License, v. 2.0. If a copy of the MPL was not distributed with this 1745 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1746 1747 #include <stdint.h> 1748 1749 #include <string> 1750 1751 #include <dns/name.h> 1752 #include <dns/rrtype.h> 1753 #include <dns/rdata.h> 1754 1755 #ifndef GENERIC_RRSIG_46_H 1756 #define GENERIC_RRSIG_46_H 1 1757 1758 namespace isc { 1759 namespace util { 1760 1761 class InputBuffer; 1762 class OutputBuffer; 1763 } 1764 1765 namespace dns { 1766 1767 // BEGIN_COMMON_DECLARATIONS 1768 1769 class AbstractMessageRenderer; 1770 1771 // END_COMMON_DECLARATIONS 1772 1773 namespace rdata { 1774 namespace generic { 1775 1776 struct RRSIGImpl; 1777 1778 /// \brief \c rdata::RRSIG class represents the RRSIG RDATA as defined %in 1779 /// RFC4034. 1780 /// 1781 /// This class implements the basic interfaces inherited from the abstract 1782 /// \c rdata::Rdata class, and provides trivial accessors specific to the 1783 /// RRSIG RDATA. 1784 class RRSIG : public Rdata { 1785 public: 1786 // BEGIN_COMMON_MEMBERS 1787 1788 explicit RRSIG(const std::string& type_str); 1789 RRSIG(isc::util::InputBuffer& buffer, size_t rdata_len); 1790 RRSIG(const RRSIG& other); 1791 RRSIG( 1792 MasterLexer& lexer, const Name* name, 1793 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1794 virtual std::string toText() const; 1795 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1796 virtual void toWire(AbstractMessageRenderer& renderer) const; 1797 virtual int compare(const Rdata& other) const; 1798 1799 // END_COMMON_MEMBERS 1800 RRSIG& operator=(const RRSIG& source); 1801 ~RRSIG(); 1802 1803 // specialized methods 1804 const RRType& typeCovered() const; 1805 private: 1806 // helper function for string and lexer constructors 1807 RRSIGImpl* constructFromLexer(MasterLexer& lexer, const Name* origin); 1808 1809 RRSIGImpl* impl_; 1810 }; 1811 1812 } // end of namespace "generic" 1813 } // end of namespace "rdata" 1814 } // end of namespace "dns" 1815 } // end of namespace "isc" 1816 #endif // GENERIC_RRSIG_46_H 1817 1818 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 1819 // 1820 // This Source Code Form is subject to the terms of the Mozilla Public 1821 // License, v. 2.0. If a copy of the MPL was not distributed with this 1822 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1823 1824 #ifndef GENERIC_SOA_6_H 1825 #define GENERIC_SOA_6_H 1 1826 1827 #include <string> 1828 1829 #include <dns/name.h> 1830 #include <dns/rdata.h> 1831 #include <dns/serial.h> 1832 1833 namespace isc { 1834 namespace util { 1835 1836 class InputBuffer; 1837 class OutputBuffer; 1838 } 1839 1840 namespace dns { 1841 1842 // BEGIN_COMMON_DECLARATIONS 1843 1844 class AbstractMessageRenderer; 1845 1846 // END_COMMON_DECLARATIONS 1847 1848 namespace rdata { 1849 namespace generic { 1850 1851 class SOA : public Rdata { 1852 public: 1853 // BEGIN_COMMON_MEMBERS 1854 1855 explicit SOA(const std::string& type_str); 1856 SOA(isc::util::InputBuffer& buffer, size_t rdata_len); 1857 SOA(const SOA& other); 1858 SOA( 1859 MasterLexer& lexer, const Name* name, 1860 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1861 virtual std::string toText() const; 1862 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1863 virtual void toWire(AbstractMessageRenderer& renderer) const; 1864 virtual int compare(const Rdata& other) const; 1865 1866 // END_COMMON_MEMBERS 1867 1868 SOA(const Name& mname, const Name& rname, uint32_t serial, 1869 uint32_t refresh, uint32_t retry, uint32_t expire, 1870 uint32_t minimum); 1871 1872 /// \brief Returns the serial stored in the SOA. 1873 Serial getSerial() const; 1874 1875 /// brief Returns the minimum TTL field value of the SOA. 1876 uint32_t getMinimum() const; 1877 private: 1878 /// Note: this is a prototype version; we may reconsider 1879 /// this representation later. 1880 Name mname_; 1881 Name rname_; 1882 /// serial, refresh, retry, expire, minimum, stored in network byte order 1883 uint8_t numdata_[20]; 1884 }; 1885 1886 } // end of namespace "generic" 1887 } // end of namespace "rdata" 1888 } // end of namespace "dns" 1889 } // end of namespace "isc" 1890 #endif // GENERIC_SOA_6_H 1891 1892 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 1893 // 1894 // This Source Code Form is subject to the terms of the Mozilla Public 1895 // License, v. 2.0. If a copy of the MPL was not distributed with this 1896 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1897 1898 #ifndef GENERIC_SPF_99_H 1899 #define GENERIC_SPF_99_H 1 1900 1901 #include <stdint.h> 1902 1903 #include <string> 1904 #include <vector> 1905 1906 #include <dns/rdata.h> 1907 1908 namespace isc { 1909 namespace util { 1910 1911 class InputBuffer; 1912 class OutputBuffer; 1913 } 1914 1915 namespace dns { 1916 1917 // BEGIN_COMMON_DECLARATIONS 1918 1919 class AbstractMessageRenderer; 1920 1921 // END_COMMON_DECLARATIONS 1922 1923 namespace rdata { 1924 namespace generic { 1925 1926 namespace detail { 1927 template<class Type, uint16_t typeCode> class TXTLikeImpl; 1928 } 1929 1930 /// \brief \c rdata::SPF class represents the SPF RDATA as defined %in 1931 /// RFC4408. 1932 /// 1933 /// This class implements the basic interfaces inherited from the abstract 1934 /// \c rdata::Rdata class. The semantics of the class is provided by 1935 /// a copy of instantiated TXTLikeImpl class common to both TXT and SPF. 1936 class SPF : public Rdata { 1937 public: 1938 // BEGIN_COMMON_MEMBERS 1939 1940 explicit SPF(const std::string& type_str); 1941 SPF(isc::util::InputBuffer& buffer, size_t rdata_len); 1942 SPF(const SPF& other); 1943 SPF( 1944 MasterLexer& lexer, const Name* name, 1945 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 1946 virtual std::string toText() const; 1947 virtual void toWire(isc::util::OutputBuffer& buffer) const; 1948 virtual void toWire(AbstractMessageRenderer& renderer) const; 1949 virtual int compare(const Rdata& other) const; 1950 1951 // END_COMMON_MEMBERS 1952 1953 /// \brief Assignment operator. 1954 /// 1955 /// It internally allocates a resource, and if it fails a corresponding 1956 /// standard exception will be thrown. 1957 /// This operator never throws an exception otherwise. 1958 /// 1959 /// This operator provides the strong exception guarantee: When an 1960 /// exception is thrown the content of the assignment target will be 1961 /// intact. 1962 SPF& operator=(const SPF& source); 1963 1964 /// \brief The destructor. 1965 ~SPF(); 1966 1967 /// 1968 /// Specialized methods 1969 /// 1970 1971 /// \brief Return a reference to the data strings 1972 /// 1973 /// This method never throws an exception. 1974 const std::vector<std::vector<uint8_t> >& getString() const; 1975 1976 private: 1977 typedef isc::dns::rdata::generic::detail::TXTLikeImpl<SPF, 99> SPFImpl; 1978 SPFImpl* impl_; 1979 }; 1980 1981 } // end of namespace "generic" 1982 } // end of namespace "rdata" 1983 } // end of namespace "dns" 1984 } // end of namespace "isc" 1985 #endif // GENERIC_SPF_99_H 1986 1987 // Copyright (C) 2012-2021 Internet Systems Consortium, Inc. ("ISC") 1988 // 1989 // This Source Code Form is subject to the terms of the Mozilla Public 1990 // License, v. 2.0. If a copy of the MPL was not distributed with this 1991 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 1992 1993 #ifndef GENERIC_SSHFP_44_H 1994 #define GENERIC_SSHFP_44_H 1 1995 1996 #include <stdint.h> 1997 1998 #include <string> 1999 #include <vector> 2000 2001 #include <dns/name.h> 2002 #include <dns/rdata.h> 2003 2004 namespace isc { 2005 namespace util { 2006 2007 class InputBuffer; 2008 class OutputBuffer; 2009 } 2010 2011 namespace dns { 2012 2013 // BEGIN_COMMON_DECLARATIONS 2014 2015 class AbstractMessageRenderer; 2016 2017 // END_COMMON_DECLARATIONS 2018 2019 namespace rdata { 2020 namespace generic { 2021 2022 struct SSHFPImpl; 2023 2024 class SSHFP : public Rdata { 2025 public: 2026 // BEGIN_COMMON_MEMBERS 2027 2028 explicit SSHFP(const std::string& type_str); 2029 SSHFP(isc::util::InputBuffer& buffer, size_t rdata_len); 2030 SSHFP(const SSHFP& other); 2031 SSHFP( 2032 MasterLexer& lexer, const Name* name, 2033 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 2034 virtual std::string toText() const; 2035 virtual void toWire(isc::util::OutputBuffer& buffer) const; 2036 virtual void toWire(AbstractMessageRenderer& renderer) const; 2037 virtual int compare(const Rdata& other) const; 2038 2039 // END_COMMON_MEMBERS 2040 2041 SSHFP(uint8_t algorithm, uint8_t fingerprint_type, 2042 const std::string& fingerprint); 2043 SSHFP& operator=(const SSHFP& source); 2044 ~SSHFP(); 2045 2046 /// 2047 /// Specialized methods 2048 /// 2049 uint8_t getAlgorithmNumber() const; 2050 uint8_t getFingerprintType() const; 2051 const std::vector<uint8_t>& getFingerprint() const; 2052 size_t getFingerprintLength() const; 2053 2054 private: 2055 SSHFPImpl* constructFromLexer(MasterLexer& lexer); 2056 2057 SSHFPImpl* impl_; 2058 }; 2059 2060 } // end of namespace "generic" 2061 } // end of namespace "rdata" 2062 } // end of namespace "dns" 2063 } // end of namespace "isc" 2064 #endif // GENERIC_SSHFP_44_H 2065 2066 // Copyright (C) 2021 Internet Systems Consortium, Inc. ("ISC") 2067 // 2068 // This Source Code Form is subject to the terms of the Mozilla Public 2069 // License, v. 2.0. If a copy of the MPL was not distributed with this 2070 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 2071 2072 #ifndef GENERIC_TKEY_249_H 2073 #define GENERIC_TKEY_249_H 1 2074 2075 #include <stdint.h> 2076 2077 #include <string> 2078 2079 #include <dns/name.h> 2080 #include <dns/rdata.h> 2081 2082 namespace isc { 2083 namespace util { 2084 2085 class InputBuffer; 2086 class OutputBuffer; 2087 } 2088 2089 namespace dns { 2090 2091 // BEGIN_COMMON_DECLARATIONS 2092 2093 class AbstractMessageRenderer; 2094 2095 // END_COMMON_DECLARATIONS 2096 2097 namespace rdata { 2098 namespace generic { 2099 2100 struct TKEYImpl; 2101 2102 /// \brief \c rdata::TKEY class represents the TKEY RDATA as defined %in 2103 /// RFC2930. 2104 /// 2105 /// This class implements the basic interfaces inherited from the abstract 2106 /// \c rdata::Rdata class, and provides trivial accessors specific to the 2107 /// TKEY RDATA. 2108 class TKEY : public Rdata { 2109 public: 2110 // BEGIN_COMMON_MEMBERS 2111 2112 explicit TKEY(const std::string& type_str); 2113 TKEY(isc::util::InputBuffer& buffer, size_t rdata_len); 2114 TKEY(const TKEY& other); 2115 TKEY( 2116 MasterLexer& lexer, const Name* name, 2117 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 2118 virtual std::string toText() const; 2119 virtual void toWire(isc::util::OutputBuffer& buffer) const; 2120 virtual void toWire(AbstractMessageRenderer& renderer) const; 2121 virtual int compare(const Rdata& other) const; 2122 2123 // END_COMMON_MEMBERS 2124 2125 /// \brief Constructor from RDATA field parameters. 2126 /// 2127 /// The parameters are a straightforward mapping of %TKEY RDATA 2128 /// fields as defined %in RFC2930. 2129 /// 2130 /// This RR is pretty close to the TSIG RR with 32 bit timestamps, 2131 /// or the RRSIG RR with a second "other" data field. 2132 /// 2133 /// This constructor internally involves resource allocation, and if 2134 /// it fails, a corresponding standard exception will be thrown. 2135 /// 2136 /// \param algorithm The DNS name of the algorithm e.g. gss-tsig. 2137 /// \param inception The inception time (in seconds since 1970). 2138 /// \param expire The expire time (in seconds since 1970). 2139 /// \param mode The mode e.g. Diffie-Hellman (2) or GSS-API (3). 2140 /// \param error The error code (extended error space shared with TSIG). 2141 /// \param key_len The key length (0 means no key). 2142 /// \param key The key (can be 0). 2143 /// \param other_len The other data length (0 means no other data). 2144 /// \param other_data The other data (can be and usually is 0). 2145 TKEY(const Name& algorithm, uint32_t inception, uint32_t expire, 2146 uint16_t mode, uint16_t error, uint16_t key_len, 2147 const void* key, uint16_t other_len, const void* other_data); 2148 2149 /// \brief Assignment operator. 2150 /// 2151 /// It internally allocates a resource, and if it fails a corresponding 2152 /// standard exception will be thrown. 2153 /// This operator never throws an exception otherwise. 2154 /// 2155 /// This operator provides the strong exception guarantee: When an 2156 /// exception is thrown the content of the assignment target will be 2157 /// intact. 2158 TKEY& operator=(const TKEY& source); 2159 2160 /// \brief The destructor. 2161 ~TKEY(); 2162 2163 /// \brief Return the algorithm name. 2164 /// 2165 /// This method never throws an exception. 2166 const Name& getAlgorithm() const; 2167 2168 /// \brief Return the value of the Inception field as a number. 2169 /// 2170 /// This method never throws an exception. 2171 uint32_t getInception() const; 2172 2173 /// \brief Return the value of the Inception field as a string. 2174 std::string getInceptionDate() const; 2175 2176 /// \brief Return the value of the Expire field as a number. 2177 /// 2178 /// This method never throws an exception. 2179 uint32_t getExpire() const; 2180 2181 /// \brief Return the value of the Expire field as a string. 2182 std::string getExpireDate() const; 2183 2184 /// \brief Return the value of the Mode field. 2185 /// 2186 /// This method never throws an exception. 2187 uint16_t getMode() const; 2188 2189 /// \brief Return the value of the Error field. 2190 /// 2191 /// This method never throws an exception. 2192 uint16_t getError() const; 2193 2194 /// \brief Return the value of the Key Len field. 2195 /// 2196 /// This method never throws an exception. 2197 uint16_t getKeyLen() const; 2198 2199 /// \brief Return the value of the Key field. 2200 /// 2201 /// This method never throws an exception. 2202 const void* getKey() const; 2203 2204 /// \brief Return the value of the Other Len field. 2205 /// 2206 /// This method never throws an exception. 2207 uint16_t getOtherLen() const; 2208 2209 /// \brief Return the value of the Other Data field. 2210 /// 2211 /// The same note as \c getMAC() applies. 2212 /// 2213 /// This method never throws an exception. 2214 const void* getOtherData() const; 2215 2216 /// \brief The GSS_API constant for the Mode field. 2217 static const uint16_t GSS_API_MODE; 2218 2219 private: 2220 TKEYImpl* constructFromLexer(MasterLexer& lexer, const Name* origin); 2221 2222 TKEYImpl* impl_; 2223 }; 2224 2225 } // end of namespace "generic" 2226 } // end of namespace "rdata" 2227 } // end of namespace "dns" 2228 } // end of namespace "isc" 2229 #endif // GENERIC_TKEY_249_H 2230 2231 // Copyright (C) 2014-2021 Internet Systems Consortium, Inc. ("ISC") 2232 // 2233 // This Source Code Form is subject to the terms of the Mozilla Public 2234 // License, v. 2.0. If a copy of the MPL was not distributed with this 2235 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 2236 2237 #ifndef GENERIC_TLSA_52_H 2238 #define GENERIC_TLSA_52_H 1 2239 2240 #include <stdint.h> 2241 2242 #include <dns/name.h> 2243 #include <dns/rdata.h> 2244 2245 #include <string> 2246 #include <vector> 2247 2248 namespace isc { 2249 namespace util { 2250 2251 class InputBuffer; 2252 class OutputBuffer; 2253 } 2254 2255 namespace dns { 2256 2257 // BEGIN_COMMON_DECLARATIONS 2258 2259 class AbstractMessageRenderer; 2260 2261 // END_COMMON_DECLARATIONS 2262 2263 namespace rdata { 2264 namespace generic { 2265 2266 struct TLSAImpl; 2267 2268 class TLSA : public Rdata { 2269 public: 2270 // BEGIN_COMMON_MEMBERS 2271 2272 explicit TLSA(const std::string& type_str); 2273 TLSA(isc::util::InputBuffer& buffer, size_t rdata_len); 2274 TLSA(const TLSA& other); 2275 TLSA( 2276 MasterLexer& lexer, const Name* name, 2277 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 2278 virtual std::string toText() const; 2279 virtual void toWire(isc::util::OutputBuffer& buffer) const; 2280 virtual void toWire(AbstractMessageRenderer& renderer) const; 2281 virtual int compare(const Rdata& other) const; 2282 2283 // END_COMMON_MEMBERS 2284 2285 TLSA(uint8_t certificate_usage, uint8_t selector, 2286 uint8_t matching_type, const std::string& certificate_assoc_data); 2287 TLSA& operator=(const TLSA& source); 2288 ~TLSA(); 2289 2290 /// 2291 /// Specialized methods 2292 /// 2293 uint8_t getCertificateUsage() const; 2294 uint8_t getSelector() const; 2295 uint8_t getMatchingType() const; 2296 const std::vector<uint8_t>& getData() const; 2297 size_t getDataLength() const; 2298 2299 private: 2300 TLSAImpl* constructFromLexer(MasterLexer& lexer); 2301 2302 TLSAImpl* impl_; 2303 }; 2304 2305 } // end of namespace "generic" 2306 } // end of namespace "rdata" 2307 } // end of namespace "dns" 2308 } // end of namespace "isc" 2309 #endif // GENERIC_TLSA_52_H 2310 2311 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 2312 // 2313 // This Source Code Form is subject to the terms of the Mozilla Public 2314 // License, v. 2.0. If a copy of the MPL was not distributed with this 2315 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 2316 2317 #ifndef GENERIC_TXT_16_H 2318 #define GENERIC_TXT_16_H 1 2319 2320 #include <stdint.h> 2321 2322 #include <string> 2323 #include <vector> 2324 2325 #include <dns/rdata.h> 2326 2327 namespace isc { 2328 namespace util { 2329 2330 class InputBuffer; 2331 class OutputBuffer; 2332 } 2333 2334 namespace dns { 2335 2336 // BEGIN_COMMON_DECLARATIONS 2337 2338 class AbstractMessageRenderer; 2339 2340 // END_COMMON_DECLARATIONS 2341 2342 namespace rdata { 2343 namespace generic { 2344 2345 namespace detail { 2346 template<class Type, uint16_t typeCode> class TXTLikeImpl; 2347 } 2348 2349 class TXT : public Rdata { 2350 public: 2351 // BEGIN_COMMON_MEMBERS 2352 2353 explicit TXT(const std::string& type_str); 2354 TXT(isc::util::InputBuffer& buffer, size_t rdata_len); 2355 TXT(const TXT& other); 2356 TXT( 2357 MasterLexer& lexer, const Name* name, 2358 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 2359 virtual std::string toText() const; 2360 virtual void toWire(isc::util::OutputBuffer& buffer) const; 2361 virtual void toWire(AbstractMessageRenderer& renderer) const; 2362 virtual int compare(const Rdata& other) const; 2363 2364 // END_COMMON_MEMBERS 2365 2366 TXT& operator=(const TXT& source); 2367 ~TXT(); 2368 2369 private: 2370 typedef isc::dns::rdata::generic::detail::TXTLikeImpl<TXT, 16> TXTImpl; 2371 TXTImpl* impl_; 2372 }; 2373 2374 } // end of namespace "generic" 2375 } // end of namespace "rdata" 2376 } // end of namespace "dns" 2377 } // end of namespace "isc" 2378 #endif // GENERIC_TXT_16_H 2379 2380 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 2381 // 2382 // This Source Code Form is subject to the terms of the Mozilla Public 2383 // License, v. 2.0. If a copy of the MPL was not distributed with this 2384 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 2385 2386 #ifndef HS_A_1_H 2387 #define HS_A_1_H 1 2388 2389 #include <string> 2390 2391 #include <dns/rdata.h> 2392 2393 namespace isc { 2394 namespace util { 2395 2396 class InputBuffer; 2397 class OutputBuffer; 2398 } 2399 2400 namespace dns { 2401 2402 // BEGIN_COMMON_DECLARATIONS 2403 2404 class AbstractMessageRenderer; 2405 2406 // END_COMMON_DECLARATIONS 2407 2408 namespace rdata { 2409 namespace hs { 2410 2411 class A : public Rdata { 2412 public: 2413 // BEGIN_COMMON_MEMBERS 2414 2415 explicit A(const std::string& type_str); 2416 A(isc::util::InputBuffer& buffer, size_t rdata_len); 2417 A(const A& other); 2418 A( 2419 MasterLexer& lexer, const Name* name, 2420 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 2421 virtual std::string toText() const; 2422 virtual void toWire(isc::util::OutputBuffer& buffer) const; 2423 virtual void toWire(AbstractMessageRenderer& renderer) const; 2424 virtual int compare(const Rdata& other) const; 2425 2426 // END_COMMON_MEMBERS 2427 }; 2428 2429 } // end of namespace "hs" 2430 } // end of namespace "rdata" 2431 } // end of namespace "dns" 2432 } // end of namespace "isc" 2433 #endif // HS_A_1_H 2434 2435 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 2436 // 2437 // This Source Code Form is subject to the terms of the Mozilla Public 2438 // License, v. 2.0. If a copy of the MPL was not distributed with this 2439 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 2440 2441 #ifndef IN_A_1_H 2442 #define IN_A_1_H 1 2443 2444 #include <string> 2445 2446 #include <dns/rdata.h> 2447 2448 namespace isc { 2449 namespace util { 2450 2451 class InputBuffer; 2452 class OutputBuffer; 2453 } 2454 2455 namespace dns { 2456 2457 // BEGIN_COMMON_DECLARATIONS 2458 2459 class AbstractMessageRenderer; 2460 2461 // END_COMMON_DECLARATIONS 2462 2463 namespace rdata { 2464 namespace in { 2465 2466 class A : public Rdata { 2467 public: 2468 // BEGIN_COMMON_MEMBERS 2469 2470 explicit A(const std::string& type_str); 2471 A(isc::util::InputBuffer& buffer, size_t rdata_len); 2472 A(const A& other); 2473 A( 2474 MasterLexer& lexer, const Name* name, 2475 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 2476 virtual std::string toText() const; 2477 virtual void toWire(isc::util::OutputBuffer& buffer) const; 2478 virtual void toWire(AbstractMessageRenderer& renderer) const; 2479 virtual int compare(const Rdata& other) const; 2480 2481 // END_COMMON_MEMBERS 2482 2483 //We can use the default destructor. 2484 //virtual ~A() {} 2485 // notyet: 2486 //const struct in_addr& getAddress() const { return (addr_); } 2487 private: 2488 uint32_t addr_; // raw IPv4 address (network byte order) 2489 }; 2490 } // end of namespace "in" 2491 } // end of namespace "rdata" 2492 } // end of namespace "dns" 2493 } // end of namespace "isc" 2494 #endif // IN_A_1_H 2495 2496 // Copyright (C) 2010-2021 Internet Systems Consortium, Inc. ("ISC") 2497 // 2498 // This Source Code Form is subject to the terms of the Mozilla Public 2499 // License, v. 2.0. If a copy of the MPL was not distributed with this 2500 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 2501 2502 #ifndef IN_AAAA_28_H 2503 #define IN_AAAA_28_H 1 2504 2505 #include <stdint.h> 2506 2507 #include <string> 2508 2509 #include <dns/rdata.h> 2510 2511 namespace isc { 2512 namespace util { 2513 2514 class InputBuffer; 2515 class OutputBuffer; 2516 } 2517 2518 namespace dns { 2519 2520 // BEGIN_COMMON_DECLARATIONS 2521 2522 class AbstractMessageRenderer; 2523 2524 // END_COMMON_DECLARATIONS 2525 2526 namespace rdata { 2527 namespace in { 2528 2529 class AAAA : public Rdata { 2530 public: 2531 // BEGIN_COMMON_MEMBERS 2532 2533 explicit AAAA(const std::string& type_str); 2534 AAAA(isc::util::InputBuffer& buffer, size_t rdata_len); 2535 AAAA(const AAAA& other); 2536 AAAA( 2537 MasterLexer& lexer, const Name* name, 2538 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 2539 virtual std::string toText() const; 2540 virtual void toWire(isc::util::OutputBuffer& buffer) const; 2541 virtual void toWire(AbstractMessageRenderer& renderer) const; 2542 virtual int compare(const Rdata& other) const; 2543 2544 // END_COMMON_MEMBERS 2545 // notyet: 2546 //const struct in6_addr& getAddress() const { return (addr_); } 2547 private: 2548 uint8_t addr_[16]; // raw IPv6 address (network byte order) 2549 }; 2550 2551 } // end of namespace "in" 2552 } // end of namespace "rdata" 2553 } // end of namespace "dns" 2554 } // end of namespace "isc" 2555 #endif // IN_AAAA_28_H 2556 2557 // Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC") 2558 // 2559 // This Source Code Form is subject to the terms of the Mozilla Public 2560 // License, v. 2.0. If a copy of the MPL was not distributed with this 2561 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 2562 2563 #ifndef IN_DHCID_49_H 2564 #define IN_DHCID_49_H 1 2565 2566 #include <string> 2567 #include <vector> 2568 2569 #include <dns/rdata.h> 2570 2571 namespace isc { 2572 namespace util { 2573 2574 class InputBuffer; 2575 class OutputBuffer; 2576 } 2577 2578 namespace dns { 2579 2580 // BEGIN_COMMON_DECLARATIONS 2581 2582 class AbstractMessageRenderer; 2583 2584 // END_COMMON_DECLARATIONS 2585 2586 namespace rdata { 2587 namespace in { 2588 2589 /// \brief \c rdata::DHCID class represents the DHCID RDATA as defined %in 2590 /// RFC4701. 2591 /// 2592 /// This class implements the basic interfaces inherited from the abstract 2593 /// \c rdata::Rdata class, and provides trivial accessors specific to the 2594 /// DHCID RDATA. 2595 class DHCID : public Rdata { 2596 public: 2597 // BEGIN_COMMON_MEMBERS 2598 2599 explicit DHCID(const std::string& type_str); 2600 DHCID(isc::util::InputBuffer& buffer, size_t rdata_len); 2601 DHCID(const DHCID& other); 2602 DHCID( 2603 MasterLexer& lexer, const Name* name, 2604 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 2605 virtual std::string toText() const; 2606 virtual void toWire(isc::util::OutputBuffer& buffer) const; 2607 virtual void toWire(AbstractMessageRenderer& renderer) const; 2608 virtual int compare(const Rdata& other) const; 2609 2610 // END_COMMON_MEMBERS 2611 2612 /// \brief Return the digest. 2613 /// 2614 /// This method never throws an exception. 2615 const std::vector<uint8_t>& getDigest() const; 2616 2617 private: 2618 // helper for string and lexer constructors 2619 void constructFromLexer(MasterLexer& lexer); 2620 2621 /// \brief Private data representation 2622 /// 2623 /// Opaque data at least 3 octets long as per RFC4701. 2624 /// 2625 std::vector<uint8_t> digest_; 2626 }; 2627 } // end of namespace "in" 2628 } // end of namespace "rdata" 2629 } // end of namespace "dns" 2630 } // end of namespace "isc" 2631 #endif // IN_DHCID_49_H 2632 2633 // Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC") 2634 // 2635 // This Source Code Form is subject to the terms of the Mozilla Public 2636 // License, v. 2.0. If a copy of the MPL was not distributed with this 2637 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 2638 2639 #ifndef IN_SRV_33_H 2640 #define IN_SRV_33_H 1 2641 2642 #include <stdint.h> 2643 2644 #include <dns/name.h> 2645 #include <dns/rdata.h> 2646 2647 namespace isc { 2648 namespace util { 2649 2650 class InputBuffer; 2651 class OutputBuffer; 2652 } 2653 2654 namespace dns { 2655 2656 // BEGIN_COMMON_DECLARATIONS 2657 2658 class AbstractMessageRenderer; 2659 2660 // END_COMMON_DECLARATIONS 2661 2662 namespace rdata { 2663 namespace in { 2664 2665 struct SRVImpl; 2666 2667 /// \brief \c rdata::SRV class represents the SRV RDATA as defined %in 2668 /// RFC2782. 2669 /// 2670 /// This class implements the basic interfaces inherited from the abstract 2671 /// \c rdata::Rdata class, and provides trivial accessors specific to the 2672 /// SRV RDATA. 2673 class SRV : public Rdata { 2674 public: 2675 // BEGIN_COMMON_MEMBERS 2676 2677 explicit SRV(const std::string& type_str); 2678 SRV(isc::util::InputBuffer& buffer, size_t rdata_len); 2679 SRV(const SRV& other); 2680 SRV( 2681 MasterLexer& lexer, const Name* name, 2682 MasterLoader::Options options, MasterLoaderCallbacks& callbacks); 2683 virtual std::string toText() const; 2684 virtual void toWire(isc::util::OutputBuffer& buffer) const; 2685 virtual void toWire(AbstractMessageRenderer& renderer) const; 2686 virtual int compare(const Rdata& other) const; 2687 2688 // END_COMMON_MEMBERS 2689 2690 /// \brief Assignment operator. 2691 /// 2692 /// It internally allocates a resource, and if it fails a corresponding 2693 /// standard exception will be thrown. 2694 /// This operator never throws an exception otherwise. 2695 /// 2696 /// This operator provides the strong exception guarantee: When an 2697 /// exception is thrown the content of the assignment target will be 2698 /// intact. 2699 SRV& operator=(const SRV& source); 2700 2701 /// \brief The destructor. 2702 ~SRV(); 2703 2704 /// 2705 /// Specialized methods 2706 /// 2707 2708 /// \brief Return the value of the priority field. 2709 /// 2710 /// This method never throws an exception. 2711 uint16_t getPriority() const; 2712 2713 /// \brief Return the value of the weight field. 2714 /// 2715 /// This method never throws an exception. 2716 uint16_t getWeight() const; 2717 2718 /// \brief Return the value of the port field. 2719 /// 2720 /// This method never throws an exception. 2721 uint16_t getPort() const; 2722 2723 /// \brief Return the value of the target field. 2724 /// 2725 /// \return A reference to a \c Name class object corresponding to the 2726 /// internal target name. 2727 /// 2728 /// This method never throws an exception. 2729 const Name& getTarget() const; 2730 2731 private: 2732 SRVImpl* impl_; 2733 }; 2734 2735 } // end of namespace "in" 2736 } // end of namespace "rdata" 2737 } // end of namespace "dns" 2738 } // end of namespace "isc" 2739 #endif // IN_SRV_33_H 2740 2741 2742 #endif // DNS_RDATACLASS_H 2743 2744 // Local Variables: 2745 // mode: c++ 2746 // End: 2747