2 * rr.h - resource record definitions
4 * a Net::DNS like library for C
6 * (c) NLnet Labs, 2005-2006
8 * See the file LICENSE for the license
14 * Contains the definition of ldns_rr and functions to manipulate those.
21 #include <ldns/common.h>
22 #include <ldns/rdata.h>
23 #include <ldns/buffer.h>
24 #include <ldns/error.h>
30 /** Maximum length of a dname label */
31 #define LDNS_MAX_LABELLEN 63
32 /** Maximum length of a complete dname */
33 #define LDNS_MAX_DOMAINLEN 255
34 /** Maximum number of pointers in 1 dname */
35 #define LDNS_MAX_POINTERS 65535
36 /** The bytes TTL, CLASS and length use up in an rr */
37 #define LDNS_RR_OVERHEAD 10
39 /* The first fields are contiguous and can be referenced instantly */
40 #define LDNS_RDATA_FIELD_DESCRIPTORS_COMMON 258
45 * The different RR classes.
47 enum ldns_enum_rr_class
53 /** Hesiod (Dyer 87) */
55 /** None class, dynamic update */
56 LDNS_RR_CLASS_NONE = 254,
58 LDNS_RR_CLASS_ANY = 255,
60 LDNS_RR_CLASS_FIRST = 0,
61 LDNS_RR_CLASS_LAST = 65535,
62 LDNS_RR_CLASS_COUNT = LDNS_RR_CLASS_LAST - LDNS_RR_CLASS_FIRST + 1
64 typedef enum ldns_enum_rr_class ldns_rr_class;
67 * Used to specify whether compression is allowed.
69 enum ldns_enum_rr_compress
71 /** compression is allowed */
75 typedef enum ldns_enum_rr_compress ldns_rr_compress;
78 * The different RR types.
80 enum ldns_enum_rr_type
84 /** an authoritative name server */
86 /** a mail destination (Obsolete - use MX) */
88 /** a mail forwarder (Obsolete - use MX) */
90 /** the canonical name for an alias */
91 LDNS_RR_TYPE_CNAME = 5,
92 /** marks the start of a zone of authority */
94 /** a mailbox domain name (EXPERIMENTAL) */
96 /** a mail group member (EXPERIMENTAL) */
98 /** a mail rename domain name (EXPERIMENTAL) */
100 /** a null RR (EXPERIMENTAL) */
101 LDNS_RR_TYPE_NULL = 10,
102 /** a well known service description */
103 LDNS_RR_TYPE_WKS = 11,
104 /** a domain name pointer */
105 LDNS_RR_TYPE_PTR = 12,
106 /** host information */
107 LDNS_RR_TYPE_HINFO = 13,
108 /** mailbox or mail list information */
109 LDNS_RR_TYPE_MINFO = 14,
111 LDNS_RR_TYPE_MX = 15,
113 LDNS_RR_TYPE_TXT = 16,
115 LDNS_RR_TYPE_RP = 17,
117 LDNS_RR_TYPE_AFSDB = 18,
119 LDNS_RR_TYPE_X25 = 19,
121 LDNS_RR_TYPE_ISDN = 20,
123 LDNS_RR_TYPE_RT = 21,
125 LDNS_RR_TYPE_NSAP = 22,
127 LDNS_RR_TYPE_NSAP_PTR = 23,
129 LDNS_RR_TYPE_SIG = 24,
131 LDNS_RR_TYPE_KEY = 25,
133 LDNS_RR_TYPE_PX = 26,
135 LDNS_RR_TYPE_GPOS = 27,
137 LDNS_RR_TYPE_AAAA = 28,
138 /** LOC record RFC1876 */
139 LDNS_RR_TYPE_LOC = 29,
141 LDNS_RR_TYPE_NXT = 30,
142 /** draft-ietf-nimrod-dns-01.txt */
143 LDNS_RR_TYPE_EID = 31,
144 /** draft-ietf-nimrod-dns-01.txt */
145 LDNS_RR_TYPE_NIMLOC = 32,
146 /** SRV record RFC2782 */
147 LDNS_RR_TYPE_SRV = 33,
148 /** http://www.jhsoft.com/rfc/af-saa-0069.000.rtf */
149 LDNS_RR_TYPE_ATMA = 34,
151 LDNS_RR_TYPE_NAPTR = 35,
153 LDNS_RR_TYPE_KX = 36,
155 LDNS_RR_TYPE_CERT = 37,
157 LDNS_RR_TYPE_A6 = 38,
159 LDNS_RR_TYPE_DNAME = 39,
160 /** dnsind-kitchen-sink-02.txt */
161 LDNS_RR_TYPE_SINK = 40,
162 /** Pseudo OPT record... */
163 LDNS_RR_TYPE_OPT = 41,
165 LDNS_RR_TYPE_APL = 42,
166 /** RFC4034, RFC3658 */
167 LDNS_RR_TYPE_DS = 43,
168 /** SSH Key Fingerprint */
169 LDNS_RR_TYPE_SSHFP = 44, /* RFC 4255 */
171 LDNS_RR_TYPE_IPSECKEY = 45, /* RFC 4025 */
173 LDNS_RR_TYPE_RRSIG = 46, /* RFC 4034 */
174 LDNS_RR_TYPE_NSEC = 47, /* RFC 4034 */
175 LDNS_RR_TYPE_DNSKEY = 48, /* RFC 4034 */
177 LDNS_RR_TYPE_DHCID = 49, /* RFC 4701 */
179 LDNS_RR_TYPE_NSEC3 = 50, /* RFC 5155 */
180 LDNS_RR_TYPE_NSEC3PARAM = 51, /* RFC 5155 */
181 LDNS_RR_TYPE_NSEC3PARAMS = 51,
182 LDNS_RR_TYPE_TLSA = 52, /* RFC 6698 */
184 LDNS_RR_TYPE_HIP = 55, /* RFC 5205 */
186 /** draft-reid-dnsext-zs */
187 LDNS_RR_TYPE_NINFO = 56,
188 /** draft-reid-dnsext-rkey */
189 LDNS_RR_TYPE_RKEY = 57,
190 /** draft-ietf-dnsop-trust-history */
191 LDNS_RR_TYPE_TALINK = 58,
192 /** draft-barwood-dnsop-ds-publis */
193 LDNS_RR_TYPE_CDS = 59,
195 LDNS_RR_TYPE_SPF = 99, /* RFC 4408 */
197 LDNS_RR_TYPE_UINFO = 100,
198 LDNS_RR_TYPE_UID = 101,
199 LDNS_RR_TYPE_GID = 102,
200 LDNS_RR_TYPE_UNSPEC = 103,
202 LDNS_RR_TYPE_NID = 104, /* RFC 6742 */
203 LDNS_RR_TYPE_L32 = 105, /* RFC 6742 */
204 LDNS_RR_TYPE_L64 = 106, /* RFC 6742 */
205 LDNS_RR_TYPE_LP = 107, /* RFC 6742 */
207 LDNS_RR_TYPE_EUI48 = 108, /* RFC 7043 */
208 LDNS_RR_TYPE_EUI64 = 109, /* RFC 7043 */
210 LDNS_RR_TYPE_TKEY = 249, /* RFC 2930 */
211 LDNS_RR_TYPE_TSIG = 250,
212 LDNS_RR_TYPE_IXFR = 251,
213 LDNS_RR_TYPE_AXFR = 252,
214 /** A request for mailbox-related records (MB, MG or MR) */
215 LDNS_RR_TYPE_MAILB = 253,
216 /** A request for mail agent RRs (Obsolete - see MX) */
217 LDNS_RR_TYPE_MAILA = 254,
218 /** any type (wildcard) */
219 LDNS_RR_TYPE_ANY = 255,
220 /** draft-faltstrom-uri-06 */
221 LDNS_RR_TYPE_URI = 256,
222 LDNS_RR_TYPE_CAA = 257, /* RFC 6844 */
224 /** DNSSEC Trust Authorities */
225 LDNS_RR_TYPE_TA = 32768,
226 /* RFC 4431, 5074, DNSSEC Lookaside Validation */
227 LDNS_RR_TYPE_DLV = 32769,
229 /* type codes from nsec3 experimental phase
230 LDNS_RR_TYPE_NSEC3 = 65324,
231 LDNS_RR_TYPE_NSEC3PARAMS = 65325, */
232 LDNS_RR_TYPE_FIRST = 0,
233 LDNS_RR_TYPE_LAST = 65535,
234 LDNS_RR_TYPE_COUNT = LDNS_RR_TYPE_LAST - LDNS_RR_TYPE_FIRST + 1
236 typedef enum ldns_enum_rr_type ldns_rr_type;
241 * This is the basic DNS element that contains actual data
247 All RRs have the same top level format shown below:
250 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
251 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
256 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
258 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
260 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
263 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
265 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--|
268 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
272 NAME an owner name, i.e., the name of the node to which this
273 resource record pertains.
275 TYPE two octets containing one of the RR TYPE codes.
277 CLASS two octets containing one of the RR CLASS codes.
279 TTL a 32 bit signed integer that specifies the time interval
280 that the resource record may be cached before the source
281 of the information should again be consulted. Zero
282 values are interpreted to mean that the RR can only be
283 used for the transaction in progress, and should not be
284 cached. For example, SOA records are always distributed
285 with a zero TTL to prohibit caching. Zero values can
286 also be used for extremely volatile data.
288 RDLENGTH an unsigned 16 bit integer that specifies the length in
289 octets of the RDATA field.
291 RDATA a variable length string of octets that describes the
292 resource. The format of this information varies
293 according to the TYPE and CLASS of the resource record.
296 * The actual amount and type of rdata fields depend on the RR type of the
297 * RR, and can be found by using \ref ldns_rr_descriptor functions.
299 struct ldns_struct_rr
301 /** Owner name, uncompressed */
305 /** Number of data fields */
307 /** the type of the RR. A, MX etc. */
308 ldns_rr_type _rr_type;
309 /** Class of the resource record. */
310 ldns_rr_class _rr_class;
311 /* everything in the rdata is in network order */
312 /** The array of rdata's */
313 ldns_rdf **_rdata_fields;
314 /** question rr [it would be nicer if thous is after _rd_count]
315 ABI change: Fix this in next major release
319 typedef struct ldns_struct_rr ldns_rr;
322 * List or Set of Resource Records
324 * Contains a list of rr's <br>
325 * No official RFC-like checks are made
327 struct ldns_struct_rr_list
333 typedef struct ldns_struct_rr_list ldns_rr_list;
336 * Contains all information about resource record types.
338 * This structure contains, for all rr types, the rdata fields that are defined.
340 struct ldns_struct_rr_descriptor
342 /** Type of the RR that is described here */
344 /** Textual name of the RR type. */
346 /** Minimum number of rdata fields in the RRs of this type. */
348 /** Maximum number of rdata fields in the RRs of this type. */
350 /** Wireformat specification for the rr, i.e. the types of rdata fields in their respective order. */
351 const ldns_rdf_type *_wireformat;
352 /** Special rdf types */
353 ldns_rdf_type _variable;
354 /** Specifies whether compression can be used for dnames in this RR type. */
355 ldns_rr_compress _compress;
356 /** The number of DNAMEs in the _wireformat string, for parsing. */
357 uint8_t _dname_count;
359 typedef struct ldns_struct_rr_descriptor ldns_rr_descriptor;
363 * Create a rr type bitmap rdf providing enough space to set all
364 * known (to ldns) rr types.
365 * \param[out] rdf the constructed rdf
366 * \return LDNS_STATUS_OK if all went well.
368 ldns_status ldns_rdf_bitmap_known_rr_types_space(ldns_rdf** rdf);
371 * Create a rr type bitmap rdf with at least all known (to ldns) rr types set.
372 * \param[out] rdf the constructed rdf
373 * \return LDNS_STATUS_OK if all went well.
375 ldns_status ldns_rdf_bitmap_known_rr_types(ldns_rdf** rdf);
379 * creates a new rr structure.
382 ldns_rr* ldns_rr_new(void);
385 * creates a new rr structure, based on the given type.
386 * alloc enough space to hold all the rdf's
388 ldns_rr* ldns_rr_new_frm_type(ldns_rr_type t);
391 * frees an RR structure
392 * \param[in] *rr the RR to be freed
395 void ldns_rr_free(ldns_rr *rr);
398 * creates an rr from a string.
399 * The string should be a fully filled-in rr, like
400 * ownername <space> TTL <space> CLASS <space>
401 * TYPE <space> RDATA.
402 * \param[out] n the rr to return
403 * \param[in] str the string to convert
404 * \param[in] default_ttl default ttl value for the rr.
405 * If 0 DEF_TTL will be used
406 * \param[in] origin when the owner is relative add this.
407 * The caller must ldns_rdf_deep_free it.
408 * \param[out] prev the previous ownername. if this value is not NULL,
409 * the function overwrites this with the ownername found in this
410 * string. The caller must then ldns_rdf_deep_free it.
411 * \return a status msg describing an error or LDNS_STATUS_OK
413 ldns_status ldns_rr_new_frm_str(ldns_rr **n, const char *str,
414 uint32_t default_ttl, ldns_rdf *origin,
418 * creates an rr for the question section from a string, i.e.
419 * without RDATA fields
420 * Origin and previous RR functionality are the same as in
421 * ldns_rr_new_frm_str()
422 * \param[out] n the rr to return
423 * \param[in] str the string to convert
424 * \param[in] origin when the owner is relative add this.
425 * The caller must ldns_rdf_deep_free it.
426 * \param prev the previous ownername. the function overwrite this with
427 * the current found ownername. The caller must ldns_rdf_deep_free it.
428 * \return a status msg describing an error or LDNS_STATUS_OK
430 ldns_status ldns_rr_new_question_frm_str(ldns_rr **n, const char *str,
431 ldns_rdf *origin, ldns_rdf **prev);
434 * creates a new rr from a file containing a string.
435 * \param[out] rr the new rr
436 * \param[in] fp the file pointer to use
437 * \param[in] default_ttl pointer to a default ttl for the rr. If NULL DEF_TTL will be used
438 * the pointer will be updated if the file contains a $TTL directive
439 * \param[in] origin when the owner is relative add this
440 * the pointer will be updated if the file contains a $ORIGIN directive
441 * The caller must ldns_rdf_deep_free it.
442 * \param[in] prev when the owner is whitespaces use this as the * ownername
443 * the pointer will be updated after the call
444 * The caller must ldns_rdf_deep_free it.
445 * \return a ldns_status with an error or LDNS_STATUS_OK
447 ldns_status ldns_rr_new_frm_fp(ldns_rr **rr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev);
450 * creates a new rr from a file containing a string.
451 * \param[out] rr the new rr
452 * \param[in] fp the file pointer to use
453 * \param[in] default_ttl a default ttl for the rr. If NULL DEF_TTL will be used
454 * the pointer will be updated if the file contains a $TTL directive
455 * \param[in] origin when the owner is relative add this
456 * the pointer will be updated if the file contains a $ORIGIN directive
457 * The caller must ldns_rdf_deep_free it.
458 * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes)
459 * \param[in] prev when the owner is whitespaces use this as the * ownername
460 * the pointer will be updated after the call
461 * The caller must ldns_rdf_deep_free it.
462 * \return a ldns_status with an error or LDNS_STATUS_OK
464 ldns_status ldns_rr_new_frm_fp_l(ldns_rr **rr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev, int *line_nr);
467 * sets the owner in the rr structure.
468 * \param[in] *rr rr to operate on
469 * \param[in] *owner set to this owner
472 void ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner);
475 * sets the question flag in the rr structure.
476 * \param[in] *rr rr to operate on
477 * \param[in] question question flag
480 void ldns_rr_set_question(ldns_rr *rr, bool question);
483 * sets the ttl in the rr structure.
484 * \param[in] *rr rr to operate on
485 * \param[in] ttl set to this ttl
488 void ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl);
491 * sets the rd_count in the rr.
492 * \param[in] *rr rr to operate on
493 * \param[in] count set to this count
496 void ldns_rr_set_rd_count(ldns_rr *rr, size_t count);
499 * sets the type in the rr.
500 * \param[in] *rr rr to operate on
501 * \param[in] rr_type set to this type
504 void ldns_rr_set_type(ldns_rr *rr, ldns_rr_type rr_type);
507 * sets the class in the rr.
508 * \param[in] *rr rr to operate on
509 * \param[in] rr_class set to this class
512 void ldns_rr_set_class(ldns_rr *rr, ldns_rr_class rr_class);
515 * sets a rdf member, it will be set on the
516 * position given. The old value is returned, like pop.
517 * \param[in] *rr the rr to operate on
518 * \param[in] *f the rdf to set
519 * \param[in] position the position the set the rdf
520 * \return the old value in the rr, NULL on failyre
522 ldns_rdf* ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position);
525 * sets rd_field member, it will be
526 * placed in the next available spot.
527 * \param[in] *rr rr to operate on
528 * \param[in] *f the data field member to set
531 bool ldns_rr_push_rdf(ldns_rr *rr, const ldns_rdf *f);
534 * removes a rd_field member, it will be
535 * popped from the last position.
536 * \param[in] *rr rr to operate on
537 * \return rdf which was popped (null if nothing)
539 ldns_rdf* ldns_rr_pop_rdf(ldns_rr *rr);
542 * returns the rdata field member counter.
543 * \param[in] *rr rr to operate on
544 * \param[in] nr the number of the rdf to return
547 ldns_rdf* ldns_rr_rdf(const ldns_rr *rr, size_t nr);
550 * returns the owner name of an rr structure.
551 * \param[in] *rr rr to operate on
554 ldns_rdf* ldns_rr_owner(const ldns_rr *rr);
557 * returns the question flag of an rr structure.
558 * \param[in] *rr rr to operate on
559 * \return bool true if question
561 bool ldns_rr_is_question(const ldns_rr *rr);
564 * returns the ttl of an rr structure.
565 * \param[in] *rr the rr to read from
566 * \return the ttl of the rr
568 uint32_t ldns_rr_ttl(const ldns_rr *rr);
571 * returns the rd_count of an rr structure.
572 * \param[in] *rr the rr to read from
573 * \return the rd count of the rr
575 size_t ldns_rr_rd_count(const ldns_rr *rr);
578 * returns the type of the rr.
579 * \param[in] *rr the rr to read from
580 * \return the type of the rr
582 ldns_rr_type ldns_rr_get_type(const ldns_rr *rr);
585 * returns the class of the rr.
586 * \param[in] *rr the rr to read from
587 * \return the class of the rr
589 ldns_rr_class ldns_rr_get_class(const ldns_rr *rr);
594 * returns the number of rr's in an rr_list.
595 * \param[in] rr_list the rr_list to read from
596 * \return the number of rr's
598 size_t ldns_rr_list_rr_count(const ldns_rr_list *rr_list);
601 * sets the number of rr's in an rr_list.
602 * \param[in] rr_list the rr_list to set the count on
603 * \param[in] count the number of rr in this list
606 void ldns_rr_list_set_rr_count(ldns_rr_list *rr_list, size_t count);
609 * set a rr on a specific index in a ldns_rr_list
610 * \param[in] rr_list the rr_list to use
611 * \param[in] r the rr to set
612 * \param[in] count index into the rr_list
613 * \return the old rr which was stored in the rr_list, or
614 * NULL is the index was too large
615 * set a specific rr */
616 ldns_rr * ldns_rr_list_set_rr(ldns_rr_list *rr_list, const ldns_rr *r, size_t count);
619 * returns a specific rr of an rrlist.
620 * \param[in] rr_list the rr_list to read from
621 * \param[in] nr return this rr
622 * \return the rr at position nr
624 ldns_rr* ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr);
627 * creates a new rr_list structure.
628 * \return a new rr_list structure
630 ldns_rr_list* ldns_rr_list_new(void);
633 * frees an rr_list structure.
634 * \param[in] rr_list the list to free
636 void ldns_rr_list_free(ldns_rr_list *rr_list);
639 * frees an rr_list structure and all rrs contained therein.
640 * \param[in] rr_list the list to free
642 void ldns_rr_list_deep_free(ldns_rr_list *rr_list);
645 * concatenates two ldns_rr_lists together. This modifies
646 * *left (to extend it and add the pointers from *right).
647 * \param[in] left the leftside
648 * \param[in] right the rightside
649 * \return a left with right concatenated to it
651 bool ldns_rr_list_cat(ldns_rr_list *left, ldns_rr_list *right);
654 * concatenates two ldns_rr_lists together, but makes clones of the rr's
655 * (instead of pointer copying).
656 * \param[in] left the leftside
657 * \param[in] right the rightside
658 * \return a new rr_list with leftside/rightside concatenated
660 ldns_rr_list* ldns_rr_list_cat_clone(ldns_rr_list *left, ldns_rr_list *right);
663 * pushes an rr to an rrlist.
664 * \param[in] rr_list the rr_list to push to
665 * \param[in] rr the rr to push
666 * \return false on error, otherwise true
668 bool ldns_rr_list_push_rr(ldns_rr_list *rr_list, const ldns_rr *rr);
671 * pushes an rr_list to an rrlist.
672 * \param[in] rr_list the rr_list to push to
673 * \param[in] push_list the rr_list to push
674 * \return false on error, otherwise true
676 bool ldns_rr_list_push_rr_list(ldns_rr_list *rr_list, const ldns_rr_list *push_list);
679 * pops the last rr from an rrlist.
680 * \param[in] rr_list the rr_list to pop from
681 * \return NULL if nothing to pop. Otherwise the popped RR
683 ldns_rr* ldns_rr_list_pop_rr(ldns_rr_list *rr_list);
686 * pops an rr_list of size s from an rrlist.
687 * \param[in] rr_list the rr_list to pop from
688 * \param[in] size the number of rr's to pop
689 * \return NULL if nothing to pop. Otherwise the popped rr_list
691 ldns_rr_list* ldns_rr_list_pop_rr_list(ldns_rr_list *rr_list, size_t size);
694 * returns true if the given rr is one of the rrs in the
695 * list, or if it is equal to one
696 * \param[in] rr_list the rr_list to check
697 * \param[in] rr the rr to check
698 * \return true if rr_list contains rr, false otherwise
700 bool ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, ldns_rr *rr);
703 * checks if an rr_list is a rrset.
704 * \param[in] rr_list the rr_list to check
705 * \return true if it is an rrset otherwise false
707 bool ldns_is_rrset(ldns_rr_list *rr_list);
710 * pushes an rr to an rrset (which really are rr_list's).
711 * \param[in] *rr_list the rrset to push the rr to
712 * \param[in] *rr the rr to push
713 * \return true if the push succeeded otherwise false
715 bool ldns_rr_set_push_rr(ldns_rr_list *rr_list, ldns_rr *rr);
718 * pops the last rr from an rrset. This function is there only
720 * \param[in] rr_list the rr_list to pop from
721 * \return NULL if nothing to pop. Otherwise the popped RR
724 ldns_rr* ldns_rr_set_pop_rr(ldns_rr_list *rr_list);
727 * pops the first rrset from the list,
728 * the list must be sorted, so that all rr's from each rrset
729 * are next to each other
731 ldns_rr_list *ldns_rr_list_pop_rrset(ldns_rr_list *rr_list);
735 * retrieves a rrtype by looking up its name.
736 * \param[in] name a string with the name
737 * \return the type which corresponds with the name
739 ldns_rr_type ldns_get_rr_type_by_name(const char *name);
742 * retrieves a class by looking up its name.
743 * \param[in] name string with the name
744 * \return the cass which corresponds with the name
746 ldns_rr_class ldns_get_rr_class_by_name(const char *name);
749 * clones a rr and all its data
750 * \param[in] rr the rr to clone
751 * \return the new rr or NULL on failure
753 ldns_rr* ldns_rr_clone(const ldns_rr *rr);
757 * \param[in] rrlist the rrlist to clone
758 * \return the cloned rr list
760 ldns_rr_list* ldns_rr_list_clone(const ldns_rr_list *rrlist);
763 * sorts an rr_list (canonical wire format). the sorting is done inband.
764 * \param[in] unsorted the rr_list to be sorted
767 void ldns_rr_list_sort(ldns_rr_list *unsorted);
770 * compares two rrs. The TTL is not looked at.
771 * \param[in] rr1 the first one
772 * \param[in] rr2 the second one
774 * -1 if rr1 comes before rr2
775 * +1 if rr2 comes before rr1
777 int ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2);
780 * compares two rrs, up to the rdata.
781 * \param[in] rr1 the first one
782 * \param[in] rr2 the second one
784 * -1 if rr1 comes before rr2
785 * +1 if rr2 comes before rr1
787 int ldns_rr_compare_no_rdata(const ldns_rr *rr1, const ldns_rr *rr2);
790 * compares the wireformat of two rrs, contained in the given buffers.
791 * \param[in] rr1_buf the first one
792 * \param[in] rr2_buf the second one
794 * -1 if rr1_buf comes before rr2_buf
795 * +1 if rr2_buf comes before rr1_buf
797 int ldns_rr_compare_wire(ldns_buffer *rr1_buf, ldns_buffer *rr2_buf);
800 * returns true of the given rr's are equal.
801 * Also returns true if one record is a DS that represents the
802 * same DNSKEY record as the other record
803 * \param[in] rr1 the first rr
804 * \param[in] rr2 the second rr
805 * \return true if equal otherwise false
807 bool ldns_rr_compare_ds(const ldns_rr *rr1, const ldns_rr *rr2);
810 * compares two rr listss.
811 * \param[in] rrl1 the first one
812 * \param[in] rrl2 the second one
814 * -1 if rrl1 comes before rrl2
815 * +1 if rrl2 comes before rrl1
817 int ldns_rr_list_compare(const ldns_rr_list *rrl1, const ldns_rr_list *rrl2);
820 * calculates the uncompressed size of an RR.
821 * \param[in] r the rr to operate on
822 * \return size of the rr
824 size_t ldns_rr_uncompressed_size(const ldns_rr *r);
827 * converts each dname in a rr to its canonical form.
828 * \param[in] rr the rr to work on
831 void ldns_rr2canonical(ldns_rr *rr);
834 * converts each dname in each rr in a rr_list to its canonical form.
835 * \param[in] rr_list the rr_list to work on
838 void ldns_rr_list2canonical(ldns_rr_list *rr_list);
841 * counts the number of labels of the ownername.
842 * \param[in] rr count the labels of this rr
843 * \return the number of labels
845 uint8_t ldns_rr_label_count(ldns_rr *rr);
848 * returns the resource record descriptor for the given rr type.
850 * \param[in] type the type value of the rr type
851 *\return the ldns_rr_descriptor for this type
853 const ldns_rr_descriptor *ldns_rr_descript(uint16_t type);
856 * returns the minimum number of rdata fields of the rr type this descriptor describes.
858 * \param[in] descriptor for an rr type
859 * \return the minimum number of rdata fields
861 size_t ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor);
864 * returns the maximum number of rdata fields of the rr type this descriptor describes.
866 * \param[in] descriptor for an rr type
867 * \return the maximum number of rdata fields
869 size_t ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor);
872 * returns the rdf type for the given rdata field number of the rr type for the given descriptor.
874 * \param[in] descriptor for an rr type
875 * \param[in] field the field number
876 * \return the rdf type for the field
878 ldns_rdf_type ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor, size_t field);
881 * Return the rr_list which matches the rdf at position field. Think
882 * type-covered stuff for RRSIG
884 * \param[in] l the rr_list to look in
885 * \param[in] r the rdf to use for the comparison
886 * \param[in] pos at which position can we find the rdf
888 * \return a new rr list with only the RRs that match
891 ldns_rr_list *ldns_rr_list_subtype_by_rdf(ldns_rr_list *l, ldns_rdf *r, size_t pos);
894 * convert an rdf of type LDNS_RDF_TYPE_TYPE to an actual
895 * LDNS_RR_TYPE. This is usefull in the case when inspecting
896 * the rrtype covered field of an RRSIG.
897 * \param[in] rd the rdf to look at
898 * \return a ldns_rr_type with equivalent LDNS_RR_TYPE
901 ldns_rr_type ldns_rdf2rr_type(const ldns_rdf *rd);
904 * Returns the type of the first element of the RR
905 * If there are no elements present, 0 is returned
907 * \param[in] rr_list The rr list
908 * \return rr_type of the first element, or 0 if the list is empty
911 ldns_rr_list_type(const ldns_rr_list *rr_list);
914 * Returns the owner domain name rdf of the first element of the RR
915 * If there are no elements present, NULL is returned
917 * \param[in] rr_list The rr list
918 * \return dname of the first element, or NULL if the list is empty
921 ldns_rr_list_owner(const ldns_rr_list *rr_list);
927 #endif /* LDNS_RR_H */