Kea 2.5.7
rdataclass.h
Go to the documentation of this file.
1
7
8
9#ifndef DNS_RDATACLASS_H
10#define DNS_RDATACLASS_H 1
11
12#include <dns/master_loader.h>
13
14namespace isc {
15namespace dns {
16class Name;
17class MasterLexer;
18class 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
37namespace isc {
38namespace util {
39
40class InputBuffer;
41class OutputBuffer;
42}
43
44namespace dns {
45
46// BEGIN_COMMON_DECLARATIONS
47
48class AbstractMessageRenderer;
49
50// END_COMMON_DECLARATIONS
51
52namespace rdata {
53namespace any {
54
55struct TSIGImpl;
56
63class TSIG : public Rdata {
64public:
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);
71 MasterLexer& lexer, const Name* name,
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
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;
180private:
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
205namespace isc {
206namespace util {
207
208class InputBuffer;
209class OutputBuffer;
210}
211
212namespace dns {
213
214// BEGIN_COMMON_DECLARATIONS
215
216class AbstractMessageRenderer;
217
218// END_COMMON_DECLARATIONS
219
220namespace rdata {
221namespace ch {
222
223class A : public Rdata {
224public:
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);
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
263namespace isc {
264namespace util {
265
266class InputBuffer;
267class OutputBuffer;
268}
269
270namespace dns {
271
272// BEGIN_COMMON_DECLARATIONS
273
274class AbstractMessageRenderer;
275
276// END_COMMON_DECLARATIONS
277
278namespace rdata {
279namespace generic {
280
287class AFSDB : public Rdata {
288public:
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);
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
325private:
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
355namespace isc {
356namespace util {
357
358class InputBuffer;
359class OutputBuffer;
360}
361
362namespace dns {
363
364// BEGIN_COMMON_DECLARATIONS
365
366class AbstractMessageRenderer;
367
368// END_COMMON_DECLARATIONS
369
370namespace rdata {
371namespace generic {
372
373struct CAAImpl;
374
375class CAA : public Rdata {
376public:
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);
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);
395
399
401 uint8_t getFlags() const;
402
404 const std::string& getTag() const;
405
411 const std::vector<uint8_t>& getValue() const;
412
413private:
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
439namespace isc {
440namespace util {
441
442class InputBuffer;
443class OutputBuffer;
444}
445
446namespace dns {
447
448// BEGIN_COMMON_DECLARATIONS
449
450class AbstractMessageRenderer;
451
452// END_COMMON_DECLARATIONS
453
454namespace rdata {
455namespace generic {
456
457class CNAME : public Rdata {
458public:
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);
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;
477private:
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
505namespace isc {
506namespace util {
507
508class InputBuffer;
509class OutputBuffer;
510}
511
512namespace dns {
513
514// BEGIN_COMMON_DECLARATIONS
515
516class AbstractMessageRenderer;
517
518// END_COMMON_DECLARATIONS
519
520namespace rdata {
521namespace generic {
522
523namespace detail {
524template <class Type, uint16_t typeCode> class DSLikeImpl;
525}
526
533class DLV : public Rdata {
534public:
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);
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
563
567 uint16_t getTag() const;
568private:
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
593namespace isc {
594namespace util {
595
596class InputBuffer;
597class OutputBuffer;
598}
599
600namespace dns {
601
602// BEGIN_COMMON_DECLARATIONS
603
604class AbstractMessageRenderer;
605
606// END_COMMON_DECLARATIONS
607
608namespace rdata {
609namespace generic {
610
611class DNAME : public Rdata {
612public:
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);
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;
631private:
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
660namespace isc {
661namespace util {
662
663class InputBuffer;
664class OutputBuffer;
665}
666
667namespace dns {
668
669// BEGIN_COMMON_DECLARATIONS
670
671class AbstractMessageRenderer;
672
673// END_COMMON_DECLARATIONS
674
675namespace rdata {
676namespace generic {
677
678struct DNSKEYImpl;
679
680class DNSKEY : public Rdata {
681public:
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);
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);
698
702
707 uint16_t getTag() const;
708
709 uint16_t getFlags() const;
710 uint8_t getAlgorithm() const;
711
712private:
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
742namespace isc {
743namespace util {
744
745class InputBuffer;
746class OutputBuffer;
747}
748
749namespace dns {
750
751// BEGIN_COMMON_DECLARATIONS
752
753class AbstractMessageRenderer;
754
755// END_COMMON_DECLARATIONS
756
757namespace rdata {
758namespace generic {
759
760namespace detail {
761template <class Type, uint16_t typeCode> class DSLikeImpl;
762}
763
770class DS : public Rdata {
771public:
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);
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
800
804 uint16_t getTag() const;
805private:
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
835namespace isc {
836namespace util {
837
838class InputBuffer;
839class OutputBuffer;
840}
841
842namespace dns {
843
844// BEGIN_COMMON_DECLARATIONS
845
846class AbstractMessageRenderer;
847
848// END_COMMON_DECLARATIONS
849
850namespace rdata {
851namespace generic {
852
853class HINFOImpl;
854
861class HINFO : public Rdata {
862public:
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);
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
880
882
883 const std::string getCPU() const;
884 const std::string getOS() const;
885
886private:
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
917namespace isc {
918namespace util {
919
920class InputBuffer;
921class OutputBuffer;
922}
923
924namespace dns {
925
926// BEGIN_COMMON_DECLARATIONS
927
928class AbstractMessageRenderer;
929
930// END_COMMON_DECLARATIONS
931
932namespace rdata {
933namespace generic {
934
941class MINFO : public Rdata {
942public:
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);
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
989private:
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
1016namespace isc {
1017namespace util {
1018
1019class InputBuffer;
1020class OutputBuffer;
1021}
1022
1023namespace dns {
1024
1025// BEGIN_COMMON_DECLARATIONS
1026
1027class AbstractMessageRenderer;
1028
1029// END_COMMON_DECLARATIONS
1030
1031namespace rdata {
1032namespace generic {
1033
1034class MX : public Rdata {
1035public:
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);
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
1059private:
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
1092namespace isc {
1093namespace util {
1094
1095class InputBuffer;
1096class OutputBuffer;
1097}
1098
1099namespace dns {
1100
1101// BEGIN_COMMON_DECLARATIONS
1102
1103class AbstractMessageRenderer;
1104
1105// END_COMMON_DECLARATIONS
1106
1107namespace rdata {
1108namespace generic {
1109
1110class NAPTRImpl;
1111
1118class NAPTR : public Rdata {
1119public:
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);
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
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;
1146private:
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
1176namespace isc {
1177namespace util {
1178
1179class InputBuffer;
1180class OutputBuffer;
1181}
1182
1183namespace dns {
1184
1185// BEGIN_COMMON_DECLARATIONS
1186
1187class AbstractMessageRenderer;
1188
1189// END_COMMON_DECLARATIONS
1190
1191namespace rdata {
1192namespace generic {
1193
1194class NS : public Rdata {
1195public:
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);
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;
1218private:
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
1248namespace isc {
1249namespace util {
1250
1251class InputBuffer;
1252class OutputBuffer;
1253}
1254
1255namespace dns {
1256
1257// BEGIN_COMMON_DECLARATIONS
1258
1259class AbstractMessageRenderer;
1260
1261// END_COMMON_DECLARATIONS
1262
1263namespace rdata {
1264namespace generic {
1265
1266struct NSEC3Impl;
1267
1268class NSEC3 : public Rdata {
1269public:
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);
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);
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
1293private:
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
1325namespace isc {
1326namespace util {
1327
1328class InputBuffer;
1329class OutputBuffer;
1330}
1331
1332namespace dns {
1333
1334// BEGIN_COMMON_DECLARATIONS
1335
1336class AbstractMessageRenderer;
1337
1338// END_COMMON_DECLARATIONS
1339
1340namespace rdata {
1341namespace generic {
1342
1343struct NSEC3PARAMImpl;
1344
1345class NSEC3PARAM : public Rdata {
1346public:
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);
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
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
1372private:
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
1402namespace isc {
1403namespace util {
1404
1405class InputBuffer;
1406class OutputBuffer;
1407}
1408
1409namespace dns {
1410
1411// BEGIN_COMMON_DECLARATIONS
1412
1413class AbstractMessageRenderer;
1414
1415// END_COMMON_DECLARATIONS
1416
1417namespace rdata {
1418namespace generic {
1419
1420struct NSECImpl;
1421
1422class NSEC : public Rdata {
1423public:
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);
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);
1440
1441 // specialized methods
1442
1448 const Name& getNextName() const;
1449
1450private:
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
1477namespace isc {
1478namespace util {
1479
1480class InputBuffer;
1481class OutputBuffer;
1482}
1483
1484namespace dns {
1485
1486// BEGIN_COMMON_DECLARATIONS
1487
1488class AbstractMessageRenderer;
1489
1490// END_COMMON_DECLARATIONS
1491
1492namespace rdata {
1493namespace generic {
1494
1495struct OPTImpl;
1496
1497class OPT : public Rdata {
1498public:
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);
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.
1516 OPT& operator=(const OPT& source);
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
1563private:
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
1587namespace isc {
1588namespace util {
1589
1590class InputBuffer;
1591class OutputBuffer;
1592}
1593
1594namespace dns {
1595
1596// BEGIN_COMMON_DECLARATIONS
1597
1598class AbstractMessageRenderer;
1599
1600// END_COMMON_DECLARATIONS
1601
1602namespace rdata {
1603namespace generic {
1604
1605class PTR : public Rdata {
1606public:
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);
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;
1630private:
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
1654namespace isc {
1655namespace util {
1656
1657class InputBuffer;
1658class OutputBuffer;
1659}
1660
1661namespace dns {
1662
1663// BEGIN_COMMON_DECLARATIONS
1664
1665class AbstractMessageRenderer;
1666
1667// END_COMMON_DECLARATIONS
1668
1669namespace rdata {
1670namespace generic {
1671
1678class RP : public Rdata {
1679public:
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);
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
1730private:
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
1758namespace isc {
1759namespace util {
1760
1761class InputBuffer;
1762class OutputBuffer;
1763}
1764
1765namespace dns {
1766
1767// BEGIN_COMMON_DECLARATIONS
1768
1769class AbstractMessageRenderer;
1770
1771// END_COMMON_DECLARATIONS
1772
1773namespace rdata {
1774namespace generic {
1775
1776struct RRSIGImpl;
1777
1784class RRSIG : public Rdata {
1785public:
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);
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);
1802
1803 // specialized methods
1804 const RRType& typeCovered() const;
1805private:
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
1833namespace isc {
1834namespace util {
1835
1836class InputBuffer;
1837class OutputBuffer;
1838}
1839
1840namespace dns {
1841
1842// BEGIN_COMMON_DECLARATIONS
1843
1844class AbstractMessageRenderer;
1845
1846// END_COMMON_DECLARATIONS
1847
1848namespace rdata {
1849namespace generic {
1850
1851class SOA : public Rdata {
1852public:
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);
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
1874
1876 uint32_t getMinimum() const;
1877private:
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
1908namespace isc {
1909namespace util {
1910
1911class InputBuffer;
1912class OutputBuffer;
1913}
1914
1915namespace dns {
1916
1917// BEGIN_COMMON_DECLARATIONS
1918
1919class AbstractMessageRenderer;
1920
1921// END_COMMON_DECLARATIONS
1922
1923namespace rdata {
1924namespace generic {
1925
1926namespace detail {
1927template<class Type, uint16_t typeCode> class TXTLikeImpl;
1928}
1929
1936class SPF : public Rdata {
1937public:
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);
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
1966
1970
1974 const std::vector<std::vector<uint8_t> >& getString() const;
1975
1976private:
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
2004namespace isc {
2005namespace util {
2006
2007class InputBuffer;
2008class OutputBuffer;
2009}
2010
2011namespace dns {
2012
2013// BEGIN_COMMON_DECLARATIONS
2014
2015class AbstractMessageRenderer;
2016
2017// END_COMMON_DECLARATIONS
2018
2019namespace rdata {
2020namespace generic {
2021
2022struct SSHFPImpl;
2023
2024class SSHFP : public Rdata {
2025public:
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);
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);
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
2054private:
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
2082namespace isc {
2083namespace util {
2084
2085class InputBuffer;
2086class OutputBuffer;
2087}
2088
2089namespace dns {
2090
2091// BEGIN_COMMON_DECLARATIONS
2092
2093class AbstractMessageRenderer;
2094
2095// END_COMMON_DECLARATIONS
2096
2097namespace rdata {
2098namespace generic {
2099
2100struct TKEYImpl;
2101
2108class TKEY : public Rdata {
2109public:
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);
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
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
2219private:
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
2248namespace isc {
2249namespace util {
2250
2251class InputBuffer;
2252class OutputBuffer;
2253}
2254
2255namespace dns {
2256
2257// BEGIN_COMMON_DECLARATIONS
2258
2259class AbstractMessageRenderer;
2260
2261// END_COMMON_DECLARATIONS
2262
2263namespace rdata {
2264namespace generic {
2265
2266struct TLSAImpl;
2267
2268class TLSA : public Rdata {
2269public:
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);
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);
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
2299private:
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
2327namespace isc {
2328namespace util {
2329
2330class InputBuffer;
2331class OutputBuffer;
2332}
2333
2334namespace dns {
2335
2336// BEGIN_COMMON_DECLARATIONS
2337
2338class AbstractMessageRenderer;
2339
2340// END_COMMON_DECLARATIONS
2341
2342namespace rdata {
2343namespace generic {
2344
2345namespace detail {
2346template<class Type, uint16_t typeCode> class TXTLikeImpl;
2347}
2348
2349class TXT : public Rdata {
2350public:
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);
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);
2368
2369private:
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
2393namespace isc {
2394namespace util {
2395
2396class InputBuffer;
2397class OutputBuffer;
2398}
2399
2400namespace dns {
2401
2402// BEGIN_COMMON_DECLARATIONS
2403
2404class AbstractMessageRenderer;
2405
2406// END_COMMON_DECLARATIONS
2407
2408namespace rdata {
2409namespace hs {
2410
2411class A : public Rdata {
2412public:
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);
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
2448namespace isc {
2449namespace util {
2450
2451class InputBuffer;
2452class OutputBuffer;
2453}
2454
2455namespace dns {
2456
2457// BEGIN_COMMON_DECLARATIONS
2458
2459class AbstractMessageRenderer;
2460
2461// END_COMMON_DECLARATIONS
2462
2463namespace rdata {
2464namespace in {
2465
2466class A : public Rdata {
2467public:
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);
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_); }
2487private:
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
2511namespace isc {
2512namespace util {
2513
2514class InputBuffer;
2515class OutputBuffer;
2516}
2517
2518namespace dns {
2519
2520// BEGIN_COMMON_DECLARATIONS
2521
2522class AbstractMessageRenderer;
2523
2524// END_COMMON_DECLARATIONS
2525
2526namespace rdata {
2527namespace in {
2528
2529class AAAA : public Rdata {
2530public:
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);
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_); }
2547private:
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
2571namespace isc {
2572namespace util {
2573
2574class InputBuffer;
2575class OutputBuffer;
2576}
2577
2578namespace dns {
2579
2580// BEGIN_COMMON_DECLARATIONS
2581
2582class AbstractMessageRenderer;
2583
2584// END_COMMON_DECLARATIONS
2585
2586namespace rdata {
2587namespace in {
2588
2595class DHCID : public Rdata {
2596public:
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);
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
2617private:
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
2647namespace isc {
2648namespace util {
2649
2650class InputBuffer;
2651class OutputBuffer;
2652}
2653
2654namespace dns {
2655
2656// BEGIN_COMMON_DECLARATIONS
2657
2658class AbstractMessageRenderer;
2659
2660// END_COMMON_DECLARATIONS
2661
2662namespace rdata {
2663namespace in {
2664
2665struct SRVImpl;
2666
2673class SRV : public Rdata {
2674public:
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);
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
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
2731private:
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:
The AbstractMessageRenderer class is an abstract base class that provides common interfaces for rende...
Tokenizer for parsing DNS master files.
Definition: master_lexer.h:301
Set of issue callbacks for a loader.
Options
Options how the parsing should work.
Definition: master_loader.h:39
The Name class encapsulates DNS names.
Definition: name.h:223
The RRType class encapsulates DNS resource record types.
Definition: rrtype.h:106
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::TSIG class represents the TSIG RDATA as defined in RFC2845.
Definition: rdataclass.h:63
TSIG(isc::util::InputBuffer &buffer, size_t rdata_len)
TSIG(const Name &algorithm, uint64_t time_signed, uint16_t fudge, uint16_t mac_size, const void *mac, uint16_t original_id, uint16_t error, uint16_t other_len, const void *other_data)
Constructor from RDATA field parameters.
uint16_t getOriginalID() const
Return the value of the Original ID field.
uint16_t getError() const
Return the value of the Error field.
virtual std::string toText() const
Convert an Rdata to a string.
TSIG & operator=(const TSIG &source)
Assignment operator.
~TSIG()
The destructor.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
TSIG(const TSIG &other)
TSIG(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
const Name & getAlgorithm() const
Return the algorithm name.
uint16_t getOtherLen() const
Return the value of the Other Len field.
TSIG(const std::string &type_str)
const void * getOtherData() const
Return the value of the Other Data field.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
const void * getMAC() const
Return the value of the MAC field.
uint16_t getFudge() const
Return the value of the Fudge field.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
uint16_t getMACSize() const
Return the value of the MAC Size field.
uint64_t getTimeSigned() const
Return the value of the Time Signed field.
A(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
A(const A &other)
A(const std::string &type_str)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
A(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual std::string toText() const
Convert an Rdata to a string.
rdata::AFSDB class represents the AFSDB RDATA as defined in RFC1183.
Definition: rdataclass.h:287
uint16_t getSubtype() const
Return the value of the subtype field.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
AFSDB(const std::string &type_str)
AFSDB(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual std::string toText() const
Convert an Rdata to a string.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
const Name & getServer() const
Specialized methods.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
AFSDB & operator=(const AFSDB &source)
Assignment operator.
AFSDB(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
virtual std::string toText() const
Convert an Rdata to a string.
CAA(const std::string &type_str)
CAA(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
uint8_t getFlags() const
Specialized methods.
CAA(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
const std::vector< uint8_t > & getValue() const
Return the Value field of the CAA RDATA.
CAA(uint8_t flags, const std::string &tag, const std::string &value)
CAA & operator=(const CAA &source)
const std::string & getTag() const
Return the Tag field of the CAA RDATA.
const Name & getCname() const
virtual std::string toText() const
Convert an Rdata to a string.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
CNAME(const std::string &type_str)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
CNAME(isc::util::InputBuffer &buffer, size_t rdata_len)
CNAME(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
rdata::generic::DLV class represents the DLV RDATA as defined in RFC4431.
Definition: rdataclass.h:533
DLV(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
DLV & operator=(const DLV &source)
Assignment operator.
uint16_t getTag() const
Return the value of the Tag field.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
virtual std::string toText() const
Convert an Rdata to a string.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
DLV(isc::util::InputBuffer &buffer, size_t rdata_len)
DLV(const std::string &type_str)
const Name & getDname() const
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
DNAME(const std::string &type_str)
virtual std::string toText() const
Convert an Rdata to a string.
DNAME(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
DNAME(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
DNSKEY(const std::string &type_str)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
DNSKEY(const DNSKEY &other)
DNSKEY(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual std::string toText() const
Convert an Rdata to a string.
DNSKEY(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
uint16_t getTag() const
Specialized methods.
DNSKEY & operator=(const DNSKEY &source)
rdata::generic::DS class represents the DS RDATA as defined in RFC3658.
Definition: rdataclass.h:770
DS(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
DS(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
DS & operator=(const DS &source)
Assignment operator.
DS(const std::string &type_str)
uint16_t getTag() const
Return the value of the Tag field.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
virtual std::string toText() const
Convert an Rdata to a string.
HINFO class represents the HINFO rdata defined in RFC1034, RFC1035
Definition: rdataclass.h:861
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
HINFO & operator=(const HINFO &)
HINFO(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual std::string toText() const
Convert an Rdata to a string.
HINFO(const std::string &type_str)
const std::string getOS() const
const std::string getCPU() const
HINFO(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
rdata::generic::MINFO class represents the MINFO RDATA as defined in RFC1035.
Definition: rdataclass.h:941
Name getRmailbox() const
Return the value of the rmailbox field.
Definition: rdataclass.h:981
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
MINFO(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
MINFO(isc::util::InputBuffer &buffer, size_t rdata_len)
MINFO & operator=(const MINFO &source)
Define the assignment operator.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
Name getEmailbox() const
Return the value of the emailbox field.
Definition: rdataclass.h:987
MINFO(const std::string &type_str)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
virtual std::string toText() const
Convert an Rdata to a string.
const Name & getMXName() const
Specialized methods.
uint16_t getMXPref() const
MX(uint16_t preference, const Name &mxname)
MX(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
MX(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual std::string toText() const
Convert an Rdata to a string.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
MX(const std::string &type_str)
NAPTR class represents the NAPTR rdata defined in RFC2915, RFC2168 and RFC3403
Definition: rdataclass.h:1118
NAPTR & operator=(const NAPTR &source)
const Name & getReplacement() const
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
NAPTR(const std::string &type_str)
const std::string getFlags() const
virtual std::string toText() const
Convert an Rdata to a string.
NAPTR(isc::util::InputBuffer &buffer, size_t rdata_len)
const std::string getServices() const
const std::string getRegexp() const
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
NAPTR(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
const std::vector< uint8_t > & getSalt() const
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
NSEC3PARAM(const NSEC3PARAM &other)
virtual std::string toText() const
Convert an Rdata to a string.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
NSEC3PARAM(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
uint8_t getHashalg() const
Specialized methods.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
NSEC3PARAM(const std::string &type_str)
NSEC3PARAM(isc::util::InputBuffer &buffer, size_t rdata_len)
NSEC3PARAM & operator=(const NSEC3PARAM &source)
NSEC3(const std::string &type_str)
const std::vector< uint8_t > & getNext() const
NSEC3(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
NSEC3(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
NSEC3 & operator=(const NSEC3 &source)
virtual std::string toText() const
Convert an Rdata to a string.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
const std::vector< uint8_t > & getSalt() const
NSEC(const std::string &type_str)
const Name & getNextName() const
Return the next domain name.
NSEC & operator=(const NSEC &source)
NSEC(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
virtual std::string toText() const
Convert an Rdata to a string.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
NSEC(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual std::string toText() const
Convert an Rdata to a string.
NS(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
NS(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
NS(const std::string &type_str)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
const Name & getNSName() const
Specialized methods.
NS(const Name &nsname)
Specialized constructor.
Definition: rdataclass.h:1213
A class representing a pseudo RR (or option) within an OPT RR (see RFC 6891).
Definition: rdataclass.h:1521
const uint8_t * getData() const
Return the option data of this pseudo RR.
uint16_t getLength() const
Return the length of the option data of this pseudo RR.
uint16_t getCode() const
Return the option code of this pseudo RR.
PseudoRR(uint16_t code, boost::shared_ptr< std::vector< uint8_t > > &data)
Constructor.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
virtual std::string toText() const
Convert an Rdata to a string.
void appendPseudoRR(uint16_t code, const uint8_t *data, uint16_t length)
Append a pseudo RR (option) in this OPT RR.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
OPT & operator=(const OPT &source)
const std::vector< PseudoRR > & getPseudoRRs() const
Return a vector of the pseudo RRs (options) in this OPT RR.
OPT(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
OPT(isc::util::InputBuffer &buffer, size_t rdata_len)
OPT(const std::string &type_str)
virtual std::string toText() const
Convert an Rdata to a string.
PTR(const std::string &type_str)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
PTR(isc::util::InputBuffer &buffer, size_t rdata_len)
PTR(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
const Name & getPTRName() const
Specialized methods.
PTR(const Name &ptr_name)
Specialized constructor.
Definition: rdataclass.h:1625
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
rdata::generic::RP class represents the RP RDATA as defined in RFC1183.
Definition: rdataclass.h:1678
RP(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
RP(const std::string &type_str)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
virtual std::string toText() const
Convert an Rdata to a string.
RP(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
RP(const Name &mailbox, const Name &text)
We use the default copy constructor and assignment operator.
Definition: rdataclass.h:1701
Name getText() const
Return the value of the text field.
Definition: rdataclass.h:1728
Name getMailbox() const
Return the value of the mailbox field.
Definition: rdataclass.h:1722
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
rdata::RRSIG class represents the RRSIG RDATA as defined in RFC4034.
Definition: rdataclass.h:1784
const RRType & typeCovered() const
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
virtual std::string toText() const
Convert an Rdata to a string.
RRSIG(const std::string &type_str)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
RRSIG(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
RRSIG & operator=(const RRSIG &source)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
RRSIG(isc::util::InputBuffer &buffer, size_t rdata_len)
SOA(const std::string &type_str)
Serial getSerial() const
Returns the serial stored in the SOA.
SOA(const Name &mname, const Name &rname, uint32_t serial, uint32_t refresh, uint32_t retry, uint32_t expire, uint32_t minimum)
SOA(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual std::string toText() const
Convert an Rdata to a string.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
uint32_t getMinimum() const
brief Returns the minimum TTL field value of the SOA.
SOA(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
rdata::SPF class represents the SPF RDATA as defined in RFC4408.
Definition: rdataclass.h:1936
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
SPF & operator=(const SPF &source)
Assignment operator.
SPF(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
SPF(const std::string &type_str)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
SPF(isc::util::InputBuffer &buffer, size_t rdata_len)
const std::vector< std::vector< uint8_t > > & getString() const
Specialized methods.
virtual std::string toText() const
Convert an Rdata to a string.
SSHFP & operator=(const SSHFP &source)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
SSHFP(isc::util::InputBuffer &buffer, size_t rdata_len)
uint8_t getFingerprintType() const
virtual std::string toText() const
Convert an Rdata to a string.
const std::vector< uint8_t > & getFingerprint() const
SSHFP(const std::string &type_str)
SSHFP(uint8_t algorithm, uint8_t fingerprint_type, const std::string &fingerprint)
SSHFP(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
uint8_t getAlgorithmNumber() const
Specialized methods.
rdata::TKEY class represents the TKEY RDATA as defined in RFC2930.
Definition: rdataclass.h:2108
const Name & getAlgorithm() const
Return the algorithm name.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
TKEY & operator=(const TKEY &source)
Assignment operator.
uint32_t getInception() const
Return the value of the Inception field as a number.
uint16_t getMode() const
Return the value of the Mode field.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
std::string getInceptionDate() const
Return the value of the Inception field as a string.
virtual std::string toText() const
Convert an Rdata to a string.
TKEY(isc::util::InputBuffer &buffer, size_t rdata_len)
uint32_t getExpire() const
Return the value of the Expire field as a number.
static const uint16_t GSS_API_MODE
The GSS_API constant for the Mode field.
Definition: rdataclass.h:2217
const void * getKey() const
Return the value of the Key field.
std::string getExpireDate() const
Return the value of the Expire field as a string.
TKEY(const std::string &type_str)
uint16_t getOtherLen() const
Return the value of the Other Len field.
TKEY(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
uint16_t getError() const
Return the value of the Error field.
TKEY(const Name &algorithm, uint32_t inception, uint32_t expire, uint16_t mode, uint16_t error, uint16_t key_len, const void *key, uint16_t other_len, const void *other_data)
Constructor from RDATA field parameters.
uint16_t getKeyLen() const
Return the value of the Key Len field.
const void * getOtherData() const
Return the value of the Other Data field.
TLSA(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
virtual std::string toText() const
Convert an Rdata to a string.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
TLSA & operator=(const TLSA &source)
TLSA(const std::string &type_str)
TLSA(isc::util::InputBuffer &buffer, size_t rdata_len)
uint8_t getCertificateUsage() const
Specialized methods.
TLSA(uint8_t certificate_usage, uint8_t selector, uint8_t matching_type, const std::string &certificate_assoc_data)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
const std::vector< uint8_t > & getData() const
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
TXT(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual std::string toText() const
Convert an Rdata to a string.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
TXT & operator=(const TXT &source)
TXT(const std::string &type_str)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
TXT(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual std::string toText() const
Convert an Rdata to a string.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
A(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
A(isc::util::InputBuffer &buffer, size_t rdata_len)
A(const A &other)
A(const std::string &type_str)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
AAAA(isc::util::InputBuffer &buffer, size_t rdata_len)
AAAA(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
AAAA(const AAAA &other)
virtual std::string toText() const
Convert an Rdata to a string.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
AAAA(const std::string &type_str)
A(const std::string &type_str)
A(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
A(const A &other)
A(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
virtual std::string toText() const
Convert an Rdata to a string.
rdata::DHCID class represents the DHCID RDATA as defined in RFC4701.
Definition: rdataclass.h:2595
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
DHCID(isc::util::InputBuffer &buffer, size_t rdata_len)
virtual std::string toText() const
Convert an Rdata to a string.
DHCID(const DHCID &other)
DHCID(const std::string &type_str)
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
const std::vector< uint8_t > & getDigest() const
Return the digest.
DHCID(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
rdata::SRV class represents the SRV RDATA as defined in RFC2782.
Definition: rdataclass.h:2673
SRV(const std::string &type_str)
~SRV()
The destructor.
SRV & operator=(const SRV &source)
Assignment operator.
virtual int compare(const Rdata &other) const
Compare two instances of Rdata.
SRV(isc::util::InputBuffer &buffer, size_t rdata_len)
uint16_t getPort() const
Return the value of the port field.
uint16_t getPriority() const
Specialized methods.
const Name & getTarget() const
Return the value of the target field.
SRV(MasterLexer &lexer, const Name *name, MasterLoader::Options options, MasterLoaderCallbacks &callbacks)
virtual std::string toText() const
Convert an Rdata to a string.
uint16_t getWeight() const
Return the value of the weight field.
virtual void toWire(AbstractMessageRenderer &renderer) const
Render the Rdata in the wire format into a MessageRenderer object.
SRV(const SRV &other)
virtual void toWire(isc::util::OutputBuffer &buffer) const
Render the Rdata in the wire format into a buffer.
The InputBuffer class is a buffer abstraction for manipulating read-only data.
Definition: buffer.h:81
The OutputBuffer class is a buffer abstraction for manipulating mutable data.
Definition: buffer.h:294
Defines the logger used by the top-level component of kea-lfc.