contrib/ldns/ldns/rr.h

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