1 /* 2 * rr.h - resource record definitions 3 * 4 * a Net::DNS like library for C 5 * 6 * (c) NLnet Labs, 2005-2006 7 * 8 * See the file LICENSE for the license 9 */ 10 11 /** 12 * \file 13 * 14 * Contains the definition of ldns_rr and functions to manipulate those. 15 */ 16 17 18 #ifndef LDNS_RR_H 19 #define LDNS_RR_H 20 21 #include <ldns/common.h> 22 #include <ldns/rdata.h> 23 #include <ldns/buffer.h> 24 #include <ldns/error.h> 25 26 #ifdef __cplusplus 27 extern "C" { 28 #endif 29 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 38 39 /* The first fields are 'common' and can be referenced instantly */ 40 #define LDNS_RDATA_FIELD_DESCRIPTORS_COMMON 53 41 42 43 44 /** 45 * The different RR classes. 46 */ 47 enum ldns_enum_rr_class 48 { 49 /** the Internet */ 50 LDNS_RR_CLASS_IN = 1, 51 /** Chaos class */ 52 LDNS_RR_CLASS_CH = 3, 53 /** Hesiod (Dyer 87) */ 54 LDNS_RR_CLASS_HS = 4, 55 /** None class, dynamic update */ 56 LDNS_RR_CLASS_NONE = 254, 57 /** Any class */ 58 LDNS_RR_CLASS_ANY = 255, 59 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 63 }; 64 typedef enum ldns_enum_rr_class ldns_rr_class; 65 66 /** 67 * Used to specify whether compression is allowed. 68 */ 69 enum ldns_enum_rr_compress 70 { 71 /** compression is allowed */ 72 LDNS_RR_COMPRESS, 73 LDNS_RR_NO_COMPRESS 74 }; 75 typedef enum ldns_enum_rr_compress ldns_rr_compress; 76 77 /** 78 * The different RR types. 79 */ 80 enum ldns_enum_rr_type 81 { 82 /** a host address */ 83 LDNS_RR_TYPE_A = 1, 84 /** an authoritative name server */ 85 LDNS_RR_TYPE_NS = 2, 86 /** a mail destination (Obsolete - use MX) */ 87 LDNS_RR_TYPE_MD = 3, 88 /** a mail forwarder (Obsolete - use MX) */ 89 LDNS_RR_TYPE_MF = 4, 90 /** the canonical name for an alias */ 91 LDNS_RR_TYPE_CNAME = 5, 92 /** marks the start of a zone of authority */ 93 LDNS_RR_TYPE_SOA = 6, 94 /** a mailbox domain name (EXPERIMENTAL) */ 95 LDNS_RR_TYPE_MB = 7, 96 /** a mail group member (EXPERIMENTAL) */ 97 LDNS_RR_TYPE_MG = 8, 98 /** a mail rename domain name (EXPERIMENTAL) */ 99 LDNS_RR_TYPE_MR = 9, 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, 110 /** mail exchange */ 111 LDNS_RR_TYPE_MX = 15, 112 /** text strings */ 113 LDNS_RR_TYPE_TXT = 16, 114 /** RFC1183 */ 115 LDNS_RR_TYPE_RP = 17, 116 /** RFC1183 */ 117 LDNS_RR_TYPE_AFSDB = 18, 118 /** RFC1183 */ 119 LDNS_RR_TYPE_X25 = 19, 120 /** RFC1183 */ 121 LDNS_RR_TYPE_ISDN = 20, 122 /** RFC1183 */ 123 LDNS_RR_TYPE_RT = 21, 124 /** RFC1706 */ 125 LDNS_RR_TYPE_NSAP = 22, 126 /** RFC1348 */ 127 LDNS_RR_TYPE_NSAP_PTR = 23, 128 /** 2535typecode */ 129 LDNS_RR_TYPE_SIG = 24, 130 /** 2535typecode */ 131 LDNS_RR_TYPE_KEY = 25, 132 /** RFC2163 */ 133 LDNS_RR_TYPE_PX = 26, 134 /** RFC1712 */ 135 LDNS_RR_TYPE_GPOS = 27, 136 /** ipv6 address */ 137 LDNS_RR_TYPE_AAAA = 28, 138 /** LOC record RFC1876 */ 139 LDNS_RR_TYPE_LOC = 29, 140 /** 2535typecode */ 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, 150 /** RFC2915 */ 151 LDNS_RR_TYPE_NAPTR = 35, 152 /** RFC2230 */ 153 LDNS_RR_TYPE_KX = 36, 154 /** RFC2538 */ 155 LDNS_RR_TYPE_CERT = 37, 156 /** RFC2874 */ 157 LDNS_RR_TYPE_A6 = 38, 158 /** RFC2672 */ 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, 164 /** RFC3123 */ 165 LDNS_RR_TYPE_APL = 42, 166 /** draft-ietf-dnsext-delegation */ 167 LDNS_RR_TYPE_DS = 43, 168 /** SSH Key Fingerprint */ 169 LDNS_RR_TYPE_SSHFP = 44, /* RFC 4255 */ 170 /** IPsec Key */ 171 LDNS_RR_TYPE_IPSECKEY = 45, /* RFC 4025 */ 172 /** DNSSEC */ 173 LDNS_RR_TYPE_RRSIG = 46, /* RFC 4034 */ 174 LDNS_RR_TYPE_NSEC = 47, /* RFC 4034 */ 175 LDNS_RR_TYPE_DNSKEY = 48, /* RFC 4034 */ 176 177 LDNS_RR_TYPE_DHCID = 49, /* RFC 4701 */ 178 /* NSEC3 */ 179 LDNS_RR_TYPE_NSEC3 = 50, /* RFC 5155 */ 180 LDNS_RR_TYPE_NSEC3PARAM = 51, /* RFC 5155 */ 181 LDNS_RR_TYPE_NSEC3PARAMS = 51, 182 /** draft-ietf-dane-protocol */ 183 LDNS_RR_TYPE_TLSA = 52, 184 185 /** draft-ietf-dnsop-trust-history */ 186 LDNS_RR_TYPE_TALINK = 58, 187 188 LDNS_RR_TYPE_SPF = 99, 189 190 LDNS_RR_TYPE_UINFO = 100, 191 LDNS_RR_TYPE_UID = 101, 192 LDNS_RR_TYPE_GID = 102, 193 LDNS_RR_TYPE_UNSPEC = 103, 194 195 LDNS_RR_TYPE_TSIG = 250, 196 LDNS_RR_TYPE_IXFR = 251, 197 LDNS_RR_TYPE_AXFR = 252, 198 /** A request for mailbox-related records (MB, MG or MR) */ 199 LDNS_RR_TYPE_MAILB = 253, 200 /** A request for mail agent RRs (Obsolete - see MX) */ 201 LDNS_RR_TYPE_MAILA = 254, 202 /** any type (wildcard) */ 203 LDNS_RR_TYPE_ANY = 255, 204 205 /* RFC 4431, 5074, DNSSEC Lookaside Validation */ 206 LDNS_RR_TYPE_DLV = 32769, 207 208 /* type codes from nsec3 experimental phase 209 LDNS_RR_TYPE_NSEC3 = 65324, 210 LDNS_RR_TYPE_NSEC3PARAMS = 65325, */ 211 LDNS_RR_TYPE_FIRST = 0, 212 LDNS_RR_TYPE_LAST = 65535, 213 LDNS_RR_TYPE_COUNT = LDNS_RR_TYPE_LAST - LDNS_RR_TYPE_FIRST + 1 214 }; 215 typedef enum ldns_enum_rr_type ldns_rr_type; 216 217 /** 218 * Resource Record 219 * 220 * This is the basic DNS element that contains actual data 221 * 222 * From RFC1035: 223 * <pre> 224 3.2.1. Format 225 226 All RRs have the same top level format shown below: 227 228 1 1 1 1 1 1 229 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 230 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 231 | | 232 / / 233 / NAME / 234 | | 235 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 236 | TYPE | 237 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 238 | CLASS | 239 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 240 | TTL | 241 | | 242 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 243 | RDLENGTH | 244 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--| 245 / RDATA / 246 / / 247 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 248 249 where: 250 251 NAME an owner name, i.e., the name of the node to which this 252 resource record pertains. 253 254 TYPE two octets containing one of the RR TYPE codes. 255 256 CLASS two octets containing one of the RR CLASS codes. 257 258 TTL a 32 bit signed integer that specifies the time interval 259 that the resource record may be cached before the source 260 of the information should again be consulted. Zero 261 values are interpreted to mean that the RR can only be 262 used for the transaction in progress, and should not be 263 cached. For example, SOA records are always distributed 264 with a zero TTL to prohibit caching. Zero values can 265 also be used for extremely volatile data. 266 267 RDLENGTH an unsigned 16 bit integer that specifies the length in 268 octets of the RDATA field. 269 270 RDATA a variable length string of octets that describes the 271 resource. The format of this information varies 272 according to the TYPE and CLASS of the resource record. 273 * </pre> 274 * 275 * The actual amount and type of rdata fields depend on the RR type of the 276 * RR, and can be found by using \ref ldns_rr_descriptor functions. 277 */ 278 struct ldns_struct_rr 279 { 280 /** Owner name, uncompressed */ 281 ldns_rdf *_owner; 282 /** Time to live */ 283 uint32_t _ttl; 284 /** Number of data fields */ 285 size_t _rd_count; 286 /** the type of the RR. A, MX etc. */ 287 ldns_rr_type _rr_type; 288 /** Class of the resource record. */ 289 ldns_rr_class _rr_class; 290 /* everything in the rdata is in network order */ 291 /** The array of rdata's */ 292 ldns_rdf **_rdata_fields; 293 /** question rr [it would be nicer if thous is after _rd_count] 294 ABI change: Fix this in next major release 295 */ 296 bool _rr_question; 297 }; 298 typedef struct ldns_struct_rr ldns_rr; 299 300 /** 301 * List or Set of Resource Records 302 * 303 * Contains a list of rr's <br> 304 * No official RFC-like checks are made 305 */ 306 struct ldns_struct_rr_list 307 { 308 size_t _rr_count; 309 size_t _rr_capacity; 310 ldns_rr **_rrs; 311 }; 312 typedef struct ldns_struct_rr_list ldns_rr_list; 313 314 /** 315 * Contains all information about resource record types. 316 * 317 * This structure contains, for all rr types, the rdata fields that are defined. 318 */ 319 struct ldns_struct_rr_descriptor 320 { 321 /** Type of the RR that is described here */ 322 ldns_rr_type _type; 323 /** Textual name of the RR type. */ 324 const char *_name; 325 /** Minimum number of rdata fields in the RRs of this type. */ 326 uint8_t _minimum; 327 /** Maximum number of rdata fields in the RRs of this type. */ 328 uint8_t _maximum; 329 /** Wireformat specification for the rr, i.e. the types of rdata fields in their respective order. */ 330 const ldns_rdf_type *_wireformat; 331 /** Special rdf types */ 332 ldns_rdf_type _variable; 333 /** Specifies whether compression can be used for dnames in this RR type. */ 334 ldns_rr_compress _compress; 335 /** The number of DNAMEs in the _wireformat string, for parsing. */ 336 uint8_t _dname_count; 337 }; 338 typedef struct ldns_struct_rr_descriptor ldns_rr_descriptor; 339 340 /** 341 * creates a new rr structure. 342 * \return ldns_rr * 343 */ 344 ldns_rr* ldns_rr_new(void); 345 346 /** 347 * creates a new rr structure, based on the given type. 348 * alloc enough space to hold all the rdf's 349 */ 350 ldns_rr* ldns_rr_new_frm_type(ldns_rr_type t); 351 352 /** 353 * frees an RR structure 354 * \param[in] *rr the RR to be freed 355 * \return void 356 */ 357 void ldns_rr_free(ldns_rr *rr); 358 359 /** 360 * creates an rr from a string. 361 * The string should be a fully filled-in rr, like 362 * ownername <space> TTL <space> CLASS <space> 363 * TYPE <space> RDATA. 364 * \param[out] n the rr to return 365 * \param[in] str the string to convert 366 * \param[in] default_ttl default ttl value for the rr. 367 * If 0 DEF_TTL will be used 368 * \param[in] origin when the owner is relative add this. 369 * The caller must ldns_rdf_deep_free it. 370 * \param[out] prev the previous ownername. if this value is not NULL, 371 * the function overwrites this with the ownername found in this 372 * string. The caller must then ldns_rdf_deep_free it. 373 * \return a status msg describing an error or LDNS_STATUS_OK 374 */ 375 ldns_status ldns_rr_new_frm_str(ldns_rr **n, const char *str, 376 uint32_t default_ttl, ldns_rdf *origin, 377 ldns_rdf **prev); 378 379 /** 380 * creates an rr for the question section from a string, i.e. 381 * without RDATA fields 382 * Origin and previous RR functionality are the same as in 383 * ldns_rr_new_frm_str() 384 * \param[out] n the rr to return 385 * \param[in] str the string to convert 386 * \param[in] origin when the owner is relative add this. 387 * The caller must ldns_rdf_deep_free it. 388 * \param prev the previous ownername. the function overwrite this with 389 * the current found ownername. The caller must ldns_rdf_deep_free it. 390 * \return a status msg describing an error or LDNS_STATUS_OK 391 */ 392 ldns_status ldns_rr_new_question_frm_str(ldns_rr **n, const char *str, 393 ldns_rdf *origin, ldns_rdf **prev); 394 395 /** 396 * creates a new rr from a file containing a string. 397 * \param[out] rr the new rr 398 * \param[in] fp the file pointer to use 399 * \param[in] default_ttl pointer to a default ttl for the rr. If NULL DEF_TTL will be used 400 * the pointer will be updated if the file contains a $TTL directive 401 * \param[in] origin when the owner is relative add this 402 * the pointer will be updated if the file contains a $ORIGIN directive 403 * The caller must ldns_rdf_deep_free it. 404 * \param[in] prev when the owner is whitespaces use this as the * ownername 405 * the pointer will be updated after the call 406 * The caller must ldns_rdf_deep_free it. 407 * \return a ldns_status with an error or LDNS_STATUS_OK 408 */ 409 ldns_status ldns_rr_new_frm_fp(ldns_rr **rr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev); 410 411 /** 412 * creates a new rr from a file containing a string. 413 * \param[out] rr the new rr 414 * \param[in] fp the file pointer to use 415 * \param[in] default_ttl a default ttl for the rr. If NULL DEF_TTL will be used 416 * the pointer will be updated if the file contains a $TTL directive 417 * \param[in] origin when the owner is relative add this 418 * the pointer will be updated if the file contains a $ORIGIN directive 419 * The caller must ldns_rdf_deep_free it. 420 * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) 421 * \param[in] prev when the owner is whitespaces use this as the * ownername 422 * the pointer will be updated after the call 423 * The caller must ldns_rdf_deep_free it. 424 * \return a ldns_status with an error or LDNS_STATUS_OK 425 */ 426 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); 427 428 /** 429 * sets the owner in the rr structure. 430 * \param[in] *rr rr to operate on 431 * \param[in] *owner set to this owner 432 * \return void 433 */ 434 void ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner); 435 436 /** 437 * sets the question flag in the rr structure. 438 * \param[in] *rr rr to operate on 439 * \param[in] question question flag 440 * \return void 441 */ 442 void ldns_rr_set_question(ldns_rr *rr, bool question); 443 444 /** 445 * sets the ttl in the rr structure. 446 * \param[in] *rr rr to operate on 447 * \param[in] ttl set to this ttl 448 * \return void 449 */ 450 void ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl); 451 452 /** 453 * sets the rd_count in the rr. 454 * \param[in] *rr rr to operate on 455 * \param[in] count set to this count 456 * \return void 457 */ 458 void ldns_rr_set_rd_count(ldns_rr *rr, size_t count); 459 460 /** 461 * sets the type in the rr. 462 * \param[in] *rr rr to operate on 463 * \param[in] rr_type set to this type 464 * \return void 465 */ 466 void ldns_rr_set_type(ldns_rr *rr, ldns_rr_type rr_type); 467 468 /** 469 * sets the class in the rr. 470 * \param[in] *rr rr to operate on 471 * \param[in] rr_class set to this class 472 * \return void 473 */ 474 void ldns_rr_set_class(ldns_rr *rr, ldns_rr_class rr_class); 475 476 /** 477 * sets a rdf member, it will be set on the 478 * position given. The old value is returned, like pop. 479 * \param[in] *rr the rr to operate on 480 * \param[in] *f the rdf to set 481 * \param[in] position the position the set the rdf 482 * \return the old value in the rr, NULL on failyre 483 */ 484 ldns_rdf* ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position); 485 486 /** 487 * sets rd_field member, it will be 488 * placed in the next available spot. 489 * \param[in] *rr rr to operate on 490 * \param[in] *f the data field member to set 491 * \return bool 492 */ 493 bool ldns_rr_push_rdf(ldns_rr *rr, const ldns_rdf *f); 494 495 /** 496 * removes a rd_field member, it will be 497 * popped from the last position. 498 * \param[in] *rr rr to operate on 499 * \return rdf which was popped (null if nothing) 500 */ 501 ldns_rdf* ldns_rr_pop_rdf(ldns_rr *rr); 502 503 /** 504 * returns the rdata field member counter. 505 * \param[in] *rr rr to operate on 506 * \param[in] nr the number of the rdf to return 507 * \return ldns_rdf * 508 */ 509 ldns_rdf* ldns_rr_rdf(const ldns_rr *rr, size_t nr); 510 511 /** 512 * returns the owner name of an rr structure. 513 * \param[in] *rr rr to operate on 514 * \return ldns_rdf * 515 */ 516 ldns_rdf* ldns_rr_owner(const ldns_rr *rr); 517 518 /** 519 * returns the question flag of an rr structure. 520 * \param[in] *rr rr to operate on 521 * \return bool true if question 522 */ 523 bool ldns_rr_is_question(const ldns_rr *rr); 524 525 /** 526 * returns the ttl of an rr structure. 527 * \param[in] *rr the rr to read from 528 * \return the ttl of the rr 529 */ 530 uint32_t ldns_rr_ttl(const ldns_rr *rr); 531 532 /** 533 * returns the rd_count of an rr structure. 534 * \param[in] *rr the rr to read from 535 * \return the rd count of the rr 536 */ 537 size_t ldns_rr_rd_count(const ldns_rr *rr); 538 539 /** 540 * returns the type of the rr. 541 * \param[in] *rr the rr to read from 542 * \return the type of the rr 543 */ 544 ldns_rr_type ldns_rr_get_type(const ldns_rr *rr); 545 546 /** 547 * returns the class of the rr. 548 * \param[in] *rr the rr to read from 549 * \return the class of the rr 550 */ 551 ldns_rr_class ldns_rr_get_class(const ldns_rr *rr); 552 553 /* rr_lists */ 554 555 /** 556 * returns the number of rr's in an rr_list. 557 * \param[in] rr_list the rr_list to read from 558 * \return the number of rr's 559 */ 560 size_t ldns_rr_list_rr_count(const ldns_rr_list *rr_list); 561 562 /** 563 * sets the number of rr's in an rr_list. 564 * \param[in] rr_list the rr_list to set the count on 565 * \param[in] count the number of rr in this list 566 * \return void 567 */ 568 void ldns_rr_list_set_rr_count(ldns_rr_list *rr_list, size_t count); 569 570 /** 571 * set a rr on a specific index in a ldns_rr_list 572 * \param[in] rr_list the rr_list to use 573 * \param[in] r the rr to set 574 * \param[in] count index into the rr_list 575 * \return the old rr which was stored in the rr_list, or 576 * NULL is the index was too large 577 * set a specific rr */ 578 ldns_rr * ldns_rr_list_set_rr(ldns_rr_list *rr_list, const ldns_rr *r, size_t count); 579 580 /** 581 * returns a specific rr of an rrlist. 582 * \param[in] rr_list the rr_list to read from 583 * \param[in] nr return this rr 584 * \return the rr at position nr 585 */ 586 ldns_rr* ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr); 587 588 /** 589 * creates a new rr_list structure. 590 * \return a new rr_list structure 591 */ 592 ldns_rr_list* ldns_rr_list_new(); 593 594 /** 595 * frees an rr_list structure. 596 * \param[in] rr_list the list to free 597 */ 598 void ldns_rr_list_free(ldns_rr_list *rr_list); 599 600 /** 601 * frees an rr_list structure and all rrs contained therein. 602 * \param[in] rr_list the list to free 603 */ 604 void ldns_rr_list_deep_free(ldns_rr_list *rr_list); 605 606 /** 607 * concatenates two ldns_rr_lists together. This modifies 608 * *left (to extend it and add the pointers from *right). 609 * \param[in] left the leftside 610 * \param[in] right the rightside 611 * \return a left with right concatenated to it 612 */ 613 bool ldns_rr_list_cat(ldns_rr_list *left, ldns_rr_list *right); 614 615 /** 616 * concatenates two ldns_rr_lists together, but makes clones of the rr's 617 * (instead of pointer copying). 618 * \param[in] left the leftside 619 * \param[in] right the rightside 620 * \return a new rr_list with leftside/rightside concatenated 621 */ 622 ldns_rr_list* ldns_rr_list_cat_clone(ldns_rr_list *left, ldns_rr_list *right); 623 624 /** 625 * pushes an rr to an rrlist. 626 * \param[in] rr_list the rr_list to push to 627 * \param[in] rr the rr to push 628 * \return false on error, otherwise true 629 */ 630 bool ldns_rr_list_push_rr(ldns_rr_list *rr_list, const ldns_rr *rr); 631 632 /** 633 * pushes an rr_list to an rrlist. 634 * \param[in] rr_list the rr_list to push to 635 * \param[in] push_list the rr_list to push 636 * \return false on error, otherwise true 637 */ 638 bool ldns_rr_list_push_rr_list(ldns_rr_list *rr_list, const ldns_rr_list *push_list); 639 640 /** 641 * pops the last rr from an rrlist. 642 * \param[in] rr_list the rr_list to pop from 643 * \return NULL if nothing to pop. Otherwise the popped RR 644 */ 645 ldns_rr* ldns_rr_list_pop_rr(ldns_rr_list *rr_list); 646 647 /** 648 * pops an rr_list of size s from an rrlist. 649 * \param[in] rr_list the rr_list to pop from 650 * \param[in] size the number of rr's to pop 651 * \return NULL if nothing to pop. Otherwise the popped rr_list 652 */ 653 ldns_rr_list* ldns_rr_list_pop_rr_list(ldns_rr_list *rr_list, size_t size); 654 655 /** 656 * returns true if the given rr is one of the rrs in the 657 * list, or if it is equal to one 658 * \param[in] rr_list the rr_list to check 659 * \param[in] rr the rr to check 660 * \return true if rr_list contains rr, false otherwise 661 */ 662 bool ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, ldns_rr *rr); 663 664 /** 665 * checks if an rr_list is a rrset. 666 * \param[in] rr_list the rr_list to check 667 * \return true if it is an rrset otherwise false 668 */ 669 bool ldns_is_rrset(ldns_rr_list *rr_list); 670 671 /** 672 * pushes an rr to an rrset (which really are rr_list's). 673 * \param[in] *rr_list the rrset to push the rr to 674 * \param[in] *rr the rr to push 675 * \return true if the push succeeded otherwise false 676 */ 677 bool ldns_rr_set_push_rr(ldns_rr_list *rr_list, ldns_rr *rr); 678 679 /** 680 * pops the last rr from an rrset. This function is there only 681 * for the symmetry. 682 * \param[in] rr_list the rr_list to pop from 683 * \return NULL if nothing to pop. Otherwise the popped RR 684 * 685 */ 686 ldns_rr* ldns_rr_set_pop_rr(ldns_rr_list *rr_list); 687 688 /** 689 * pops the first rrset from the list, 690 * the list must be sorted, so that all rr's from each rrset 691 * are next to each other 692 */ 693 ldns_rr_list *ldns_rr_list_pop_rrset(ldns_rr_list *rr_list); 694 695 696 /** 697 * retrieves a rrtype by looking up its name. 698 * \param[in] name a string with the name 699 * \return the type which corresponds with the name 700 */ 701 ldns_rr_type ldns_get_rr_type_by_name(const char *name); 702 703 /** 704 * retrieves a class by looking up its name. 705 * \param[in] name string with the name 706 * \return the cass which corresponds with the name 707 */ 708 ldns_rr_class ldns_get_rr_class_by_name(const char *name); 709 710 /** 711 * clones a rr and all its data 712 * \param[in] rr the rr to clone 713 * \return the new rr or NULL on failure 714 */ 715 ldns_rr* ldns_rr_clone(const ldns_rr *rr); 716 717 /** 718 * clones an rrlist. 719 * \param[in] rrlist the rrlist to clone 720 * \return the cloned rr list 721 */ 722 ldns_rr_list* ldns_rr_list_clone(const ldns_rr_list *rrlist); 723 724 /** 725 * sorts an rr_list (canonical wire format). the sorting is done inband. 726 * \param[in] unsorted the rr_list to be sorted 727 * \return void 728 */ 729 void ldns_rr_list_sort(ldns_rr_list *unsorted); 730 731 /** 732 * compares two rrs. The TTL is not looked at. 733 * \param[in] rr1 the first one 734 * \param[in] rr2 the second one 735 * \return 0 if equal 736 * -1 if rr1 comes before rr2 737 * +1 if rr2 comes before rr1 738 */ 739 int ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2); 740 741 /** 742 * compares two rrs, up to the rdata. 743 * \param[in] rr1 the first one 744 * \param[in] rr2 the second one 745 * \return 0 if equal 746 * -1 if rr1 comes before rr2 747 * +1 if rr2 comes before rr1 748 */ 749 int ldns_rr_compare_no_rdata(const ldns_rr *rr1, const ldns_rr *rr2); 750 751 /** 752 * compares the wireformat of two rrs, contained in the given buffers. 753 * \param[in] rr1_buf the first one 754 * \param[in] rr2_buf the second one 755 * \return 0 if equal 756 * -1 if rr1_buf comes before rr2_buf 757 * +1 if rr2_buf comes before rr1_buf 758 */ 759 int ldns_rr_compare_wire(ldns_buffer *rr1_buf, ldns_buffer *rr2_buf); 760 761 /** 762 * returns true of the given rr's are equal. 763 * Also returns true if one record is a DS that represents the 764 * same DNSKEY record as the other record 765 * \param[in] rr1 the first rr 766 * \param[in] rr2 the second rr 767 * \return true if equal otherwise false 768 */ 769 bool ldns_rr_compare_ds(const ldns_rr *rr1, const ldns_rr *rr2); 770 771 /** 772 * compares two rr listss. 773 * \param[in] rrl1 the first one 774 * \param[in] rrl2 the second one 775 * \return 0 if equal 776 * -1 if rrl1 comes before rrl2 777 * +1 if rrl2 comes before rrl1 778 */ 779 int ldns_rr_list_compare(const ldns_rr_list *rrl1, const ldns_rr_list *rrl2); 780 781 /** 782 * calculates the uncompressed size of an RR. 783 * \param[in] r the rr to operate on 784 * \return size of the rr 785 */ 786 size_t ldns_rr_uncompressed_size(const ldns_rr *r); 787 788 /** 789 * converts each dname in a rr to its canonical form. 790 * \param[in] rr the rr to work on 791 * \return void 792 */ 793 void ldns_rr2canonical(ldns_rr *rr); 794 795 /** 796 * converts each dname in each rr in a rr_list to its canonical form. 797 * \param[in] rr_list the rr_list to work on 798 * \return void 799 */ 800 void ldns_rr_list2canonical(ldns_rr_list *rr_list); 801 802 /** 803 * counts the number of labels of the ownername. 804 * \param[in] rr count the labels of this rr 805 * \return the number of labels 806 */ 807 uint8_t ldns_rr_label_count(ldns_rr *rr); 808 809 /** 810 * returns the resource record descriptor for the given rr type. 811 * 812 * \param[in] type the type value of the rr type 813 *\return the ldns_rr_descriptor for this type 814 */ 815 const ldns_rr_descriptor *ldns_rr_descript(uint16_t type); 816 817 /** 818 * returns the minimum number of rdata fields of the rr type this descriptor describes. 819 * 820 * \param[in] descriptor for an rr type 821 * \return the minimum number of rdata fields 822 */ 823 size_t ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor); 824 825 /** 826 * returns the maximum number of rdata fields of the rr type this descriptor describes. 827 * 828 * \param[in] descriptor for an rr type 829 * \return the maximum number of rdata fields 830 */ 831 size_t ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor); 832 833 /** 834 * returns the rdf type for the given rdata field number of the rr type for the given descriptor. 835 * 836 * \param[in] descriptor for an rr type 837 * \param[in] field the field number 838 * \return the rdf type for the field 839 */ 840 ldns_rdf_type ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor, size_t field); 841 842 /** 843 * Return the rr_list which matches the rdf at position field. Think 844 * type-covered stuff for RRSIG 845 * 846 * \param[in] l the rr_list to look in 847 * \param[in] r the rdf to use for the comparison 848 * \param[in] pos at which position can we find the rdf 849 * 850 * \return a new rr list with only the RRs that match 851 * 852 */ 853 ldns_rr_list *ldns_rr_list_subtype_by_rdf(ldns_rr_list *l, ldns_rdf *r, size_t pos); 854 855 /** 856 * convert an rdf of type LDNS_RDF_TYPE_TYPE to an actual 857 * LDNS_RR_TYPE. This is usefull in the case when inspecting 858 * the rrtype covered field of an RRSIG. 859 * \param[in] rd the rdf to look at 860 * \return a ldns_rr_type with equivalent LDNS_RR_TYPE 861 * 862 */ 863 ldns_rr_type ldns_rdf2rr_type(const ldns_rdf *rd); 864 865 /** 866 * Returns the type of the first element of the RR 867 * If there are no elements present, 0 is returned 868 * 869 * \param[in] rr_list The rr list 870 * \return rr_type of the first element, or 0 if the list is empty 871 */ 872 ldns_rr_type 873 ldns_rr_list_type(const ldns_rr_list *rr_list); 874 875 /** 876 * Returns the owner domain name rdf of the first element of the RR 877 * If there are no elements present, NULL is returned 878 * 879 * \param[in] rr_list The rr list 880 * \return dname of the first element, or NULL if the list is empty 881 */ 882 ldns_rdf * 883 ldns_rr_list_owner(const ldns_rr_list *rr_list); 884 885 #ifdef __cplusplus 886 } 887 #endif 888 889 #endif /* LDNS_RR_H */ 890