Kea  2.3.5-git
rdataclass.h
Go to the documentation of this file.
1 
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 
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 
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 
118  TSIG& operator=(const TSIG& source);
119 
121  ~TSIG();
122 
126  const Name& getAlgorithm() const;
127 
133  uint64_t getTimeSigned() const;
134 
138  uint16_t getFudge() const;
139 
143  uint16_t getMACSize() const;
144 
157  const void* getMAC() const;
158 
162  uint16_t getOriginalID() const;
163 
167  uint16_t getError() const;
168 
172  uint16_t getOtherLen() const;
173 
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 
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 
307  AFSDB& operator=(const AFSDB& source);
311 
318  const Name& getServer() const;
319 
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 
399 
401  uint8_t getFlags() const;
402 
404  const std::string& getTag() const;
405 
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 
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 
559  DLV& operator=(const DLV& source);
560 
562  ~DLV();
563 
567  uint16_t getTag() const;
568 private:
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 
702 
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 
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 
796  DS& operator=(const DS& source);
797 
799  ~DS();
800 
804  uint16_t getTag() const;
805 private:
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 
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:
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 
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 
962  MINFO& operator=(const MINFO& source);
963 
981  Name getRmailbox() const { return (rmailbox_); }
982 
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 
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 
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 
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:
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
1213  explicit NS(const Name& nsname) : nsname_(nsname) {}
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 
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 
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 
1521  class PseudoRR {
1522  public:
1527  PseudoRR(uint16_t code,
1528  boost::shared_ptr<std::vector<uint8_t> >& data);
1529 
1531  uint16_t getCode() const;
1532 
1534  const uint8_t* getData() const;
1535 
1538  uint16_t getLength() const;
1539 
1540  private:
1541  uint16_t code_;
1542  boost::shared_ptr<std::vector<uint8_t> > data_;
1543  };
1544 
1553  void appendPseudoRR(uint16_t code, const uint8_t* data, uint16_t length);
1554 
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 
1625  explicit PTR(const Name& ptr_name) : ptr_name_(ptr_name) {}
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 
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 
1696 
1701  RP(const Name& mailbox, const Name& text) :
1702  mailbox_(mailbox), text_(text)
1703  {}
1704 
1722  Name getMailbox() const { return (mailbox_); }
1723 
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 
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 
1873  Serial getSerial() const;
1874 
1876  uint32_t getMinimum() const;
1877 private:
1880  Name mname_;
1881  Name rname_;
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 
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 
1962  SPF& operator=(const SPF& source);
1963 
1965  ~SPF();
1966 
1970 
1974  const std::vector<std::vector<uint8_t> >& getString() const;
1975 
1976 private:
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 
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 
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 
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 
2158  TKEY& operator=(const TKEY& source);
2159 
2161  ~TKEY();
2162 
2166  const Name& getAlgorithm() const;
2167 
2171  uint32_t getInception() const;
2172 
2174  std::string getInceptionDate() const;
2175 
2179  uint32_t getExpire() const;
2180 
2182  std::string getExpireDate() const;
2183 
2187  uint16_t getMode() const;
2188 
2192  uint16_t getError() const;
2193 
2197  uint16_t getKeyLen() const;
2198 
2202  const void* getKey() const;
2203 
2207  uint16_t getOtherLen() const;
2208 
2214  const void* getOtherData() const;
2215 
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 
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:
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 
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 
2615  const std::vector<uint8_t>& getDigest() const;
2616 
2617 private:
2618  // helper for string and lexer constructors
2619  void constructFromLexer(MasterLexer& lexer);
2620 
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 
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 
2699  SRV& operator=(const SRV& source);
2700 
2702  ~SRV();
2703 
2707 
2711  uint16_t getPriority() const;
2712 
2716  uint16_t getWeight() const;
2717 
2721  uint16_t getPort() const;
2722 
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:
rdata::TSIG class represents the TSIG RDATA as defined in RFC2845.
Definition: rdataclass.h:63
The Name class encapsulates DNS names.
Definition: name.h:223
rdata::RRSIG class represents the RRSIG RDATA as defined in RFC4034.
Definition: rdataclass.h:1784
rdata::generic::DS class represents the DS RDATA as defined in RFC3658.
Definition: rdataclass.h:770
NS(const Name &nsname)
Specialized constructor.
Definition: rdataclass.h:1213
This class defines DNS serial numbers and serial arithmetic.
Definition: serial.h:41
The Rdata class is an abstract base class that provides a set of common interfaces to manipulate conc...
Definition: rdata.h:123
rdata::TKEY class represents the TKEY RDATA as defined in RFC2930.
Definition: rdataclass.h:2108
Name getText() const
Return the value of the text field.
Definition: rdataclass.h:1728
static const uint16_t GSS_API_MODE
The GSS_API constant for the Mode field.
Definition: rdataclass.h:2217
A class representing a pseudo RR (or option) within an OPT RR (see RFC 6891).
Definition: rdataclass.h:1521
rdata::SRV class represents the SRV RDATA as defined in RFC2782.
Definition: rdataclass.h:2673
rdata::generic::RP class represents the RP RDATA as defined in RFC1183.
Definition: rdataclass.h:1678
Options
Options how the parsing should work.
Definition: master_loader.h:39
The AbstractMessageRenderer class is an abstract base class that provides common interfaces for rende...
rdata::DHCID class represents the DHCID RDATA as defined in RFC4701.
Definition: rdataclass.h:2595
Name getEmailbox() const
Return the value of the emailbox field.
Definition: rdataclass.h:987
The OutputBuffer class is a buffer abstraction for manipulating mutable data.
Definition: buffer.h:294
PTR(const Name &ptr_name)
Specialized constructor.
Definition: rdataclass.h:1625
rdata::generic::MINFO class represents the MINFO RDATA as defined in RFC1035.
Definition: rdataclass.h:941
Defines the logger used by the top-level component of kea-lfc.
uint16_t code_
HINFO class represents the HINFO rdata defined in RFC1034, RFC1035
Definition: rdataclass.h:861
rdata::SPF class represents the SPF RDATA as defined in RFC4408.
Definition: rdataclass.h:1936
The RRType class encapsulates DNS resource record types.
Definition: rrtype.h:106
Name getMailbox() const
Return the value of the mailbox field.
Definition: rdataclass.h:1722
The InputBuffer class is a buffer abstraction for manipulating read-only data.
Definition: buffer.h:81
rdata::AFSDB class represents the AFSDB RDATA as defined in RFC1183.
Definition: rdataclass.h:287
NAPTR class represents the NAPTR rdata defined in RFC2915, RFC2168 and RFC3403
Definition: rdataclass.h:1118
RP(const Name &mailbox, const Name &text)
We use the default copy constructor and assignment operator.
Definition: rdataclass.h:1701
rdata::generic::DLV class represents the DLV RDATA as defined in RFC4431.
Definition: rdataclass.h:533
Name getRmailbox() const
Return the value of the rmailbox field.
Definition: rdataclass.h:981
Tokenizer for parsing DNS master files.
Definition: master_lexer.h:301
Set of issue callbacks for a loader.