ldns  1.7.0
rr.c
Go to the documentation of this file.
1 /* rr.c
2  *
3  * access functions for ldns_rr -
4  * a Net::DNS like library for C
5  * LibDNS Team @ NLnet Labs
6  *
7  * (c) NLnet Labs, 2004-2006
8  * See the file LICENSE for the license
9  */
10 #include <ldns/config.h>
11 
12 #include <ldns/ldns.h>
13 
14 #include <strings.h>
15 #include <limits.h>
16 
17 #include <errno.h>
18 
19 #define LDNS_SYNTAX_DATALEN 16
20 #define LDNS_TTL_DATALEN 21
21 #define LDNS_RRLIST_INIT 8
22 
23 ldns_rr *
25 {
26  ldns_rr *rr;
27  rr = LDNS_MALLOC(ldns_rr);
28  if (!rr) {
29  return NULL;
30  }
31 
32  ldns_rr_set_owner(rr, NULL);
33  ldns_rr_set_question(rr, false);
34  ldns_rr_set_rd_count(rr, 0);
35  rr->_rdata_fields = NULL;
38  return rr;
39 }
40 
41 ldns_rr *
43 {
44  ldns_rr *rr;
45  const ldns_rr_descriptor *desc;
46  size_t i;
47 
48  rr = LDNS_MALLOC(ldns_rr);
49  if (!rr) {
50  return NULL;
51  }
52 
53  desc = ldns_rr_descript(t);
54 
56  if(!rr->_rdata_fields) {
57  LDNS_FREE(rr);
58  return NULL;
59  }
60  for (i = 0; i < ldns_rr_descriptor_minimum(desc); i++) {
61  rr->_rdata_fields[i] = NULL;
62  }
63 
64  ldns_rr_set_owner(rr, NULL);
65  ldns_rr_set_question(rr, false);
66  /* set the count to minimum */
70  ldns_rr_set_type(rr, t);
71  return rr;
72 }
73 
74 void
76 {
77  size_t i;
78  if (rr) {
79  if (ldns_rr_owner(rr)) {
81  }
82  for (i = 0; i < ldns_rr_rd_count(rr); i++) {
84  }
86  LDNS_FREE(rr);
87  }
88 }
89 
90 /* Syntactic sugar for ldns_rr_new_frm_str_internal */
91 INLINE bool
92 ldns_rdf_type_maybe_quoted(ldns_rdf_type rdf_type)
93 {
94  return rdf_type == LDNS_RDF_TYPE_STR ||
95  rdf_type == LDNS_RDF_TYPE_LONG_STR;
96 }
97 
98 /*
99  * trailing spaces are allowed
100  * leading spaces are not allowed
101  * allow ttl to be optional
102  * class is optional too
103  * if ttl is missing, and default_ttl is 0, use DEF_TTL
104  * allow ttl to be written as 1d3h
105  * So the RR should look like. e.g.
106  * miek.nl. 3600 IN MX 10 elektron.atoom.net
107  * or
108  * miek.nl. 1h IN MX 10 elektron.atoom.net
109  * or
110  * miek.nl. IN MX 10 elektron.atoom.net
111  */
112 static ldns_status
113 ldns_rr_new_frm_str_internal(ldns_rr **newrr, const char *str,
114  uint32_t default_ttl, const ldns_rdf *origin,
115  ldns_rdf **prev, bool question)
116 {
117  ldns_rr *new;
118  const ldns_rr_descriptor *desc;
119  ldns_rr_type rr_type;
120  ldns_buffer *rr_buf = NULL;
121  ldns_buffer *rd_buf = NULL;
122  uint32_t ttl_val;
123  char *owner = NULL;
124  char *ttl = NULL;
125  ldns_rr_class clas_val;
126  char *clas = NULL;
127  char *type = NULL;
128  char *rdata = NULL;
129  char *rd = NULL;
130  char *xtok = NULL; /* For RDF types with spaces (i.e. extra tokens) */
131  size_t rd_strlen;
132  const char *delimiters;
133  ssize_t c;
134  ldns_rdf *owner_dname;
135  const char* endptr;
136  int was_unknown_rr_format = 0;
137  ldns_status status = LDNS_STATUS_OK;
138 
139  /* used for types with unknown number of rdatas */
140  bool done;
141  bool quoted;
142 
143  ldns_rdf *r = NULL;
144  uint16_t r_cnt;
145  uint16_t r_min;
146  uint16_t r_max;
147  size_t pre_data_pos;
148 
149  uint16_t hex_data_size;
150  char *hex_data_str = NULL;
151  uint16_t cur_hex_data_size;
152  size_t hex_pos = 0;
153  uint8_t *hex_data = NULL;
154 
155  new = ldns_rr_new();
156 
157  owner = LDNS_XMALLOC(char, LDNS_MAX_DOMAINLEN + 1);
158  ttl = LDNS_XMALLOC(char, LDNS_TTL_DATALEN);
159  clas = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN);
160  rdata = LDNS_XMALLOC(char, LDNS_MAX_PACKETLEN + 1);
161  rr_buf = LDNS_MALLOC(ldns_buffer);
162  rd_buf = LDNS_MALLOC(ldns_buffer);
163  rd = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
164  xtok = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
165  if (rr_buf) {
166  rr_buf->_data = NULL;
167  }
168  if (rd_buf) {
169  rd_buf->_data = NULL;
170  }
171  if (!new || !owner || !ttl || !clas || !rdata ||
172  !rr_buf || !rd_buf || !rd || !xtok) {
173 
174  goto memerror;
175  }
176 
177  ldns_buffer_new_frm_data(rr_buf, (char*)str, strlen(str));
178 
179  /* split the rr in its parts -1 signals trouble */
180  if (ldns_bget_token(rr_buf, owner, "\t\n ", LDNS_MAX_DOMAINLEN) == -1){
181 
182  status = LDNS_STATUS_SYNTAX_ERR;
183  goto error;
184  }
185 
186  if (ldns_bget_token(rr_buf, ttl, "\t\n ", LDNS_TTL_DATALEN) == -1) {
187 
189  goto error;
190  }
191  ttl_val = (uint32_t) ldns_str2period(ttl, &endptr);
192 
193  if (strlen(ttl) > 0 && !isdigit((int) ttl[0])) {
194  /* ah, it's not there or something */
195  if (default_ttl == 0) {
196  ttl_val = LDNS_DEFAULT_TTL;
197  } else {
198  ttl_val = default_ttl;
199  }
200  /* we not ASSUMING the TTL is missing and that
201  * the rest of the RR is still there. That is
202  * CLASS TYPE RDATA
203  * so ttl value we read is actually the class
204  */
205  clas_val = ldns_get_rr_class_by_name(ttl);
206  /* class can be left out too, assume IN, current
207  * token must be type
208  */
209  if (clas_val == 0) {
210  clas_val = LDNS_RR_CLASS_IN;
211  type = LDNS_XMALLOC(char, strlen(ttl) + 1);
212  if (!type) {
213  goto memerror;
214  }
215  strncpy(type, ttl, strlen(ttl) + 1);
216  }
217  } else {
218  if (-1 == ldns_bget_token(
219  rr_buf, clas, "\t\n ", LDNS_SYNTAX_DATALEN)) {
220 
222  goto error;
223  }
224  clas_val = ldns_get_rr_class_by_name(clas);
225  /* class can be left out too, assume IN, current
226  * token must be type
227  */
228  if (clas_val == 0) {
229  clas_val = LDNS_RR_CLASS_IN;
230  type = LDNS_XMALLOC(char, strlen(clas) + 1);
231  if (!type) {
232  goto memerror;
233  }
234  strncpy(type, clas, strlen(clas) + 1);
235  }
236  }
237  /* the rest should still be waiting for us */
238 
239  if (!type) {
240  type = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN);
241  if (!type) {
242  goto memerror;
243  }
244  if (-1 == ldns_bget_token(
245  rr_buf, type, "\t\n ", LDNS_SYNTAX_DATALEN)) {
246 
248  goto error;
249  }
250  }
251 
252  if (ldns_bget_token(rr_buf, rdata, "\0", LDNS_MAX_PACKETLEN) == -1) {
253  /* apparently we are done, and it's only a question RR
254  * so do not set status and go to ldnserror here
255  */
256  }
257  ldns_buffer_new_frm_data(rd_buf, rdata, strlen(rdata));
258 
259  if (strlen(owner) <= 1 && strncmp(owner, "@", 1) == 0) {
260  if (origin) {
261  ldns_rr_set_owner(new, ldns_rdf_clone(origin));
262  } else if (prev && *prev) {
263  ldns_rr_set_owner(new, ldns_rdf_clone(*prev));
264  } else {
265  /* default to root */
267  }
268 
269  /* @ also overrides prev */
270  if (prev) {
271  ldns_rdf_deep_free(*prev);
272  *prev = ldns_rdf_clone(ldns_rr_owner(new));
273  if (!*prev) {
274  goto memerror;
275  }
276  }
277  } else {
278  if (strlen(owner) == 0) {
279  /* no ownername was given, try prev, if that fails
280  * origin, else default to root */
281  if (prev && *prev) {
282  ldns_rr_set_owner(new, ldns_rdf_clone(*prev));
283  } else if (origin) {
284  ldns_rr_set_owner(new, ldns_rdf_clone(origin));
285  } else {
286  ldns_rr_set_owner(new,
288  }
289  if(!ldns_rr_owner(new)) {
290  goto memerror;
291  }
292  } else {
293  owner_dname = ldns_dname_new_frm_str(owner);
294  if (!owner_dname) {
295  status = LDNS_STATUS_SYNTAX_ERR;
296  goto error;
297  }
298 
299  ldns_rr_set_owner(new, owner_dname);
300  if (!ldns_dname_str_absolute(owner) && origin) {
301  if(ldns_dname_cat(ldns_rr_owner(new), origin)
302  != LDNS_STATUS_OK) {
303 
304  status = LDNS_STATUS_SYNTAX_ERR;
305  goto error;
306  }
307  }
308  if (prev) {
309  ldns_rdf_deep_free(*prev);
310  *prev = ldns_rdf_clone(ldns_rr_owner(new));
311  if (!*prev) {
312  goto error;
313  }
314  }
315  }
316  }
317  LDNS_FREE(owner);
318 
319  ldns_rr_set_question(new, question);
320 
321  ldns_rr_set_ttl(new, ttl_val);
322  LDNS_FREE(ttl);
323 
324  ldns_rr_set_class(new, clas_val);
325  LDNS_FREE(clas);
326 
327  rr_type = ldns_get_rr_type_by_name(type);
328  LDNS_FREE(type);
329 
330  desc = ldns_rr_descript((uint16_t)rr_type);
331  ldns_rr_set_type(new, rr_type);
332  if (desc) {
333  /* only the rdata remains */
334  r_max = ldns_rr_descriptor_maximum(desc);
335  r_min = ldns_rr_descriptor_minimum(desc);
336  } else {
337  r_min = 0;
338  r_max = 1;
339  }
340 
341  for (done = false, r_cnt = 0; !done && r_cnt < r_max; r_cnt++) {
342  quoted = false;
343 
344  switch (ldns_rr_descriptor_field_type(desc, r_cnt)) {
345  case LDNS_RDF_TYPE_B64 :
346  case LDNS_RDF_TYPE_HEX : /* These rdf types may con- */
347  case LDNS_RDF_TYPE_LOC : /* tain whitespace, only if */
348  case LDNS_RDF_TYPE_WKS : /* it is the last rd field. */
350  case LDNS_RDF_TYPE_NSEC : if (r_cnt == r_max - 1) {
351  delimiters = "\n";
352  break;
353  }
354  default : delimiters = "\n\t ";
355  }
356 
357  if (ldns_rdf_type_maybe_quoted(
359  desc, r_cnt)) &&
360  ldns_buffer_remaining(rd_buf) > 0){
361 
362  /* skip spaces */
363  while (ldns_buffer_remaining(rd_buf) > 0 &&
364  *(ldns_buffer_current(rd_buf)) == ' ') {
365  ldns_buffer_skip(rd_buf, 1);
366  }
367 
368  if (ldns_buffer_remaining(rd_buf) > 0 &&
369  *(ldns_buffer_current(rd_buf)) == '\"') {
370  delimiters = "\"\0";
371  ldns_buffer_skip(rd_buf, 1);
372  quoted = true;
373  }
374  if (!quoted && ldns_rr_descriptor_field_type(desc, r_cnt)
376 
378  goto error;
379  }
380  }
381 
382  /* because number of fields can be variable, we can't rely on
383  * _maximum() only
384  */
385 
386  /* skip spaces */
387  while (ldns_buffer_position(rd_buf) < ldns_buffer_limit(rd_buf)
388  && *(ldns_buffer_current(rd_buf)) == ' '
389  && !quoted) {
390 
391  ldns_buffer_skip(rd_buf, 1);
392  }
393 
394  pre_data_pos = ldns_buffer_position(rd_buf);
395  if (-1 == (c = ldns_bget_token(
396  rd_buf, rd, delimiters, LDNS_MAX_RDFLEN))) {
397 
398  done = true;
399  break;
400  }
401  /* hmmz, rfc3597 specifies that any type can be represented
402  * with \# method, which can contain spaces...
403  * it does specify size though...
404  */
405  rd_strlen = strlen(rd);
406 
407  /* unknown RR data */
408  if (strncmp(rd, "\\#", 2) == 0 && !quoted &&
409  (rd_strlen == 2 || rd[2]==' ')) {
410 
411  was_unknown_rr_format = 1;
412  /* go back to before \#
413  * and skip it while setting delimiters better
414  */
415  ldns_buffer_set_position(rd_buf, pre_data_pos);
416  delimiters = "\n\t ";
417  (void)ldns_bget_token(rd_buf, rd,
418  delimiters, LDNS_MAX_RDFLEN);
419  /* read rdata octet length */
420  c = ldns_bget_token(rd_buf, rd,
421  delimiters, LDNS_MAX_RDFLEN);
422  if (c == -1) {
423  /* something goes very wrong here */
425  goto error;
426  }
427  hex_data_size = (uint16_t) atoi(rd);
428  /* copy hex chars into hex str (2 chars per byte) */
429  hex_data_str = LDNS_XMALLOC(char, 2*hex_data_size + 1);
430  if (!hex_data_str) {
431  /* malloc error */
432  goto memerror;
433  }
434  cur_hex_data_size = 0;
435  while(cur_hex_data_size < 2 * hex_data_size) {
436  c = ldns_bget_token(rd_buf, rd,
437  delimiters, LDNS_MAX_RDFLEN);
438  if (c != -1) {
439  rd_strlen = strlen(rd);
440  }
441  if (c == -1 ||
442  (size_t)cur_hex_data_size + rd_strlen >
443  2 * (size_t)hex_data_size) {
444 
446  goto error;
447  }
448  strncpy(hex_data_str + cur_hex_data_size, rd,
449  rd_strlen);
450 
451  cur_hex_data_size += rd_strlen;
452  }
453  hex_data_str[cur_hex_data_size] = '\0';
454 
455  /* correct the rdf type */
456  /* if *we* know the type, interpret it as wireformat */
457  if (desc) {
458  hex_pos = 0;
459  hex_data =
460  LDNS_XMALLOC(uint8_t, hex_data_size+2);
461 
462  if (!hex_data) {
463  goto memerror;
464  }
465  ldns_write_uint16(hex_data, hex_data_size);
467  hex_data + 2, hex_data_str);
468  status = ldns_wire2rdf(new, hex_data,
469  hex_data_size + 2, &hex_pos);
470  if (status != LDNS_STATUS_OK) {
471  goto error;
472  }
473  LDNS_FREE(hex_data);
474  } else {
476  hex_data_str);
477  if (!r) {
478  goto memerror;
479  }
481  if (!ldns_rr_push_rdf(new, r)) {
482  goto memerror;
483  }
484  }
485  LDNS_FREE(hex_data_str);
486 
487  } else if(rd_strlen > 0 || quoted) {
488  /* Normal RR */
489  switch(ldns_rr_descriptor_field_type(desc, r_cnt)) {
490 
491  case LDNS_RDF_TYPE_HEX:
492  case LDNS_RDF_TYPE_B64:
493  /* When this is the last rdata field, then the
494  * rest should be read in (cause then these
495  * rdf types may contain spaces).
496  */
497  if (r_cnt == r_max - 1) {
498  c = ldns_bget_token(rd_buf, xtok,
499  "\n", LDNS_MAX_RDFLEN);
500  if (c != -1) {
501  (void) strncat(rd, xtok,
503  strlen(rd) - 1);
504  }
505  }
508  desc, r_cnt), rd);
509  break;
510 
511  case LDNS_RDF_TYPE_HIP:
512  /*
513  * In presentation format this RDATA type has
514  * three tokens: An algorithm byte, then a
515  * variable length HIT (in hexbytes) and then
516  * a variable length Public Key (in base64).
517  *
518  * We have just read the algorithm, so we need
519  * two more tokens: HIT and Public Key.
520  */
521  do {
522  /* Read and append HIT */
523  if (ldns_bget_token(rd_buf,
524  xtok, delimiters,
525  LDNS_MAX_RDFLEN) == -1)
526  break;
527 
528  (void) strncat(rd, " ",
530  strlen(rd) - 1);
531  (void) strncat(rd, xtok,
533  strlen(rd) - 1);
534 
535  /* Read and append Public Key*/
536  if (ldns_bget_token(rd_buf,
537  xtok, delimiters,
538  LDNS_MAX_RDFLEN) == -1)
539  break;
540 
541  (void) strncat(rd, " ",
543  strlen(rd) - 1);
544  (void) strncat(rd, xtok,
546  strlen(rd) - 1);
547  } while (false);
548 
551  desc, r_cnt), rd);
552  break;
553 
554  case LDNS_RDF_TYPE_DNAME:
557  desc, r_cnt), rd);
558 
559  /* check if the origin should be used
560  * or concatenated
561  */
562  if (r && ldns_rdf_size(r) > 1 &&
563  ldns_rdf_data(r)[0] == 1 &&
564  ldns_rdf_data(r)[1] == '@') {
565 
567 
568  r = origin ? ldns_rdf_clone(origin)
569 
570  : ( rr_type == LDNS_RR_TYPE_SOA ?
571 
573  ldns_rr_owner(new))
574 
576  LDNS_RDF_TYPE_DNAME, ".")
577  );
578 
579  } else if (r && rd_strlen >= 1 && origin &&
581 
582  status = ldns_dname_cat(r, origin);
583  if (status != LDNS_STATUS_OK) {
584  goto error;
585  }
586  }
587  break;
588  default:
591  desc, r_cnt), rd);
592  break;
593  }
594  if (!r) {
596  goto error;
597  }
598  ldns_rr_push_rdf(new, r);
599  }
600  if (quoted) {
601  if (ldns_buffer_available(rd_buf, 1)) {
602  ldns_buffer_skip(rd_buf, 1);
603  } else {
604  done = true;
605  }
606  }
607 
608  } /* for (done = false, r_cnt = 0; !done && r_cnt < r_max; r_cnt++) */
609  LDNS_FREE(rd);
610  LDNS_FREE(xtok);
611  ldns_buffer_free(rr_buf);
612  LDNS_FREE(rdata);
613  if (ldns_buffer_remaining(rd_buf) > 0) {
614  ldns_buffer_free(rd_buf);
615  ldns_rr_free(new);
617  }
618  ldns_buffer_free(rd_buf);
619 
620  if (!question && desc && !was_unknown_rr_format &&
621  ldns_rr_rd_count(new) < r_min) {
622 
623  ldns_rr_free(new);
625  }
626 
627  if (newrr) {
628  *newrr = new;
629  } else {
630  /* Maybe the caller just wanted to see if it would parse? */
631  ldns_rr_free(new);
632  }
633  return LDNS_STATUS_OK;
634 
635 memerror:
636  status = LDNS_STATUS_MEM_ERR;
637 error:
638  if (rd_buf && rd_buf->_data) {
639  ldns_buffer_free(rd_buf);
640  } else {
641  LDNS_FREE(rd_buf);
642  }
643  if (rr_buf && rr_buf->_data) {
644  ldns_buffer_free(rr_buf);
645  } else {
646  LDNS_FREE(rr_buf);
647  }
648  LDNS_FREE(type);
649  LDNS_FREE(owner);
650  LDNS_FREE(ttl);
651  LDNS_FREE(clas);
652  LDNS_FREE(hex_data);
653  LDNS_FREE(hex_data_str);
654  LDNS_FREE(xtok);
655  LDNS_FREE(rd);
656  LDNS_FREE(rdata);
657  ldns_rr_free(new);
658  return status;
659 }
660 
662 ldns_rr_new_frm_str(ldns_rr **newrr, const char *str,
663  uint32_t default_ttl, const ldns_rdf *origin,
664  ldns_rdf **prev)
665 {
666  return ldns_rr_new_frm_str_internal(newrr,
667  str,
668  default_ttl,
669  origin,
670  prev,
671  false);
672 }
673 
675 ldns_rr_new_question_frm_str(ldns_rr **newrr, const char *str,
676  const ldns_rdf *origin, ldns_rdf **prev)
677 {
678  return ldns_rr_new_frm_str_internal(newrr,
679  str,
680  0,
681  origin,
682  prev,
683  true);
684 }
685 
686 /* Strip whitespace from the start and the end of <line>. */
687 static char *
688 ldns_strip_ws(char *line)
689 {
690  char *s = line, *e;
691 
692  for (s = line; *s && isspace((unsigned char)*s); s++)
693  ;
694 
695  for (e = strchr(s, 0); e > s+2 && isspace((unsigned char)e[-1]) && e[-2] != '\\'; e--)
696  ;
697  *e = 0;
698 
699  return s;
700 }
701 
703 ldns_rr_new_frm_fp(ldns_rr **newrr, FILE *fp, uint32_t *ttl, ldns_rdf **origin, ldns_rdf **prev)
704 {
705  return ldns_rr_new_frm_fp_l(newrr, fp, ttl, origin, prev, NULL);
706 }
707 
709 ldns_rr_new_frm_fp_l(ldns_rr **newrr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev, int *line_nr)
710 {
711  char *line;
712  const char *endptr; /* unused */
713  ldns_rr *rr;
714  uint32_t ttl;
715  ldns_rdf *tmp;
716  ldns_status s;
717  ssize_t size;
718 
719  if (default_ttl) {
720  ttl = *default_ttl;
721  } else {
722  ttl = 0;
723  }
724 
725  line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
726  if (!line) {
727  return LDNS_STATUS_MEM_ERR;
728  }
729 
730  /* read an entire line in from the file */
731  if ((size = ldns_fget_token_l(fp, line, LDNS_PARSE_SKIP_SPACE, LDNS_MAX_LINELEN, line_nr)) == -1) {
732  LDNS_FREE(line);
733  /* if last line was empty, we are now at feof, which is not
734  * always a parse error (happens when for instance last line
735  * was a comment)
736  */
737  return LDNS_STATUS_SYNTAX_ERR;
738  }
739 
740  /* we can have the situation, where we've read ok, but still got
741  * no bytes to play with, in this case size is 0
742  */
743  if (size == 0) {
744  LDNS_FREE(line);
746  }
747 
748  if (strncmp(line, "$ORIGIN", 7) == 0 && isspace((unsigned char)line[7])) {
749  if (*origin) {
750  ldns_rdf_deep_free(*origin);
751  *origin = NULL;
752  }
754  ldns_strip_ws(line + 8));
755  if (!tmp) {
756  /* could not parse what next to $ORIGIN */
757  LDNS_FREE(line);
759  }
760  *origin = tmp;
762  } else if (strncmp(line, "$TTL", 4) == 0 && isspace((unsigned char)line[4])) {
763  if (default_ttl) {
764  *default_ttl = ldns_str2period(
765  ldns_strip_ws(line + 5), &endptr);
766  }
768  } else if (strncmp(line, "$INCLUDE", 8) == 0) {
770  } else if (!*ldns_strip_ws(line)) {
771  LDNS_FREE(line);
773  } else {
774  if (origin && *origin) {
775  s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, *origin, prev);
776  } else {
777  s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, NULL, prev);
778  }
779  }
780  LDNS_FREE(line);
781  if (s == LDNS_STATUS_OK) {
782  if (newrr) {
783  *newrr = rr;
784  } else {
785  /* Just testing if it would parse? */
786  ldns_rr_free(rr);
787  }
788  }
789  return s;
790 }
791 
792 void
794 {
795  rr->_owner = owner;
796 }
797 
798 void
799 ldns_rr_set_question(ldns_rr *rr, bool question)
800 {
801  rr->_rr_question = question;
802 }
803 
804 void
805 ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl)
806 {
807  rr->_ttl = ttl;
808 }
809 
810 void
811 ldns_rr_set_rd_count(ldns_rr *rr, size_t count)
812 {
813  rr->_rd_count = count;
814 }
815 
816 void
818 {
819  rr->_rr_type = rr_type;
820 }
821 
822 void
824 {
825  rr->_rr_class = rr_class;
826 }
827 
828 ldns_rdf *
829 ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position)
830 {
831  size_t rd_count;
832  ldns_rdf *pop;
833 
834  rd_count = ldns_rr_rd_count(rr);
835  if (position < rd_count) {
836  /* dicard the old one */
837  pop = rr->_rdata_fields[position];
838  rr->_rdata_fields[position] = (ldns_rdf*)f;
839  return pop;
840  } else {
841  return NULL;
842  }
843 }
844 
845 bool
847 {
848  size_t rd_count;
849  ldns_rdf **rdata_fields;
850 
851  rd_count = ldns_rr_rd_count(rr);
852 
853  /* grow the array */
854  rdata_fields = LDNS_XREALLOC(
855  rr->_rdata_fields, ldns_rdf *, rd_count + 1);
856  if (!rdata_fields) {
857  return false;
858  }
859 
860  /* add the new member */
861  rr->_rdata_fields = rdata_fields;
862  rr->_rdata_fields[rd_count] = (ldns_rdf*)f;
863 
864  ldns_rr_set_rd_count(rr, rd_count + 1);
865  return true;
866 }
867 
868 ldns_rdf *
870 {
871  size_t rd_count;
872  ldns_rdf *pop;
873  ldns_rdf** newrd;
874 
875  rd_count = ldns_rr_rd_count(rr);
876 
877  if (rd_count == 0) {
878  return NULL;
879  }
880 
881  pop = rr->_rdata_fields[rd_count - 1];
882 
883  /* try to shrink the array */
884  if(rd_count > 1) {
885  newrd = LDNS_XREALLOC(
886  rr->_rdata_fields, ldns_rdf *, rd_count - 1);
887  if(newrd)
888  rr->_rdata_fields = newrd;
889  } else {
891  }
892 
893  ldns_rr_set_rd_count(rr, rd_count - 1);
894  return pop;
895 }
896 
897 ldns_rdf *
898 ldns_rr_rdf(const ldns_rr *rr, size_t nr)
899 {
900  if (rr && nr < ldns_rr_rd_count(rr)) {
901  return rr->_rdata_fields[nr];
902  } else {
903  return NULL;
904  }
905 }
906 
907 ldns_rdf *
909 {
910  return rr->_owner;
911 }
912 
913 bool
915 {
916  return rr->_rr_question;
917 }
918 
919 uint32_t
921 {
922  return rr->_ttl;
923 }
924 
925 size_t
927 {
928  return rr->_rd_count;
929 }
930 
933 {
934  return rr->_rr_type;
935 }
936 
939 {
940  return rr->_rr_class;
941 }
942 
943 /* rr_lists */
944 
945 size_t
947 {
948  if (rr_list) {
949  return rr_list->_rr_count;
950  } else {
951  return 0;
952  }
953 }
954 
955 ldns_rr *
956 ldns_rr_list_set_rr(ldns_rr_list *rr_list, const ldns_rr *r, size_t count)
957 {
958  ldns_rr *old;
959 
960  if (count > ldns_rr_list_rr_count(rr_list)) {
961  return NULL;
962  }
963 
964  old = ldns_rr_list_rr(rr_list, count);
965 
966  /* overwrite old's pointer */
967  rr_list->_rrs[count] = (ldns_rr*)r;
968  return old;
969 }
970 
971 void
973 {
974  assert(count <= rr_list->_rr_capacity);
975  rr_list->_rr_count = count;
976 }
977 
978 ldns_rr *
979 ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr)
980 {
981  if (nr < ldns_rr_list_rr_count(rr_list)) {
982  return rr_list->_rrs[nr];
983  } else {
984  return NULL;
985  }
986 }
987 
988 ldns_rr_list *
990 {
992  if(!rr_list) return NULL;
993  rr_list->_rr_count = 0;
994  rr_list->_rr_capacity = 0;
995  rr_list->_rrs = NULL;
996  return rr_list;
997 }
998 
999 void
1001 {
1002  if (rr_list) {
1003  LDNS_FREE(rr_list->_rrs);
1004  LDNS_FREE(rr_list);
1005  }
1006 }
1007 
1008 void
1010 {
1011  size_t i;
1012 
1013  if (rr_list) {
1014  for (i=0; i < ldns_rr_list_rr_count(rr_list); i++) {
1015  ldns_rr_free(ldns_rr_list_rr(rr_list, i));
1016  }
1017  LDNS_FREE(rr_list->_rrs);
1018  LDNS_FREE(rr_list);
1019  }
1020 }
1021 
1022 
1023 /* add right to left. So we modify *left! */
1024 bool
1026 {
1027  size_t r_rr_count;
1028  size_t i;
1029 
1030  if (!left) {
1031  return false;
1032  }
1033 
1034  if (right) {
1035  r_rr_count = ldns_rr_list_rr_count(right);
1036  } else {
1037  r_rr_count = 0;
1038  }
1039 
1040  /* push right to left */
1041  for(i = 0; i < r_rr_count; i++) {
1042  ldns_rr_list_push_rr(left, ldns_rr_list_rr(right, i));
1043  }
1044  return true;
1045 }
1046 
1047 ldns_rr_list *
1049 {
1050  size_t l_rr_count;
1051  size_t r_rr_count;
1052  size_t i;
1053  ldns_rr_list *cat;
1054 
1055  if (left) {
1056  l_rr_count = ldns_rr_list_rr_count(left);
1057  } else {
1058  return ldns_rr_list_clone(right);
1059  }
1060 
1061  if (right) {
1062  r_rr_count = ldns_rr_list_rr_count(right);
1063  } else {
1064  r_rr_count = 0;
1065  }
1066 
1067  cat = ldns_rr_list_new();
1068 
1069  if (!cat) {
1070  return NULL;
1071  }
1072 
1073  /* left */
1074  for(i = 0; i < l_rr_count; i++) {
1076  ldns_rr_clone(ldns_rr_list_rr(left, i)));
1077  }
1078  /* right */
1079  for(i = 0; i < r_rr_count; i++) {
1081  ldns_rr_clone(ldns_rr_list_rr(right, i)));
1082  }
1083  return cat;
1084 }
1085 
1086 ldns_rr_list *
1087 ldns_rr_list_subtype_by_rdf(const ldns_rr_list *l, const ldns_rdf *r, size_t pos)
1088 {
1089  size_t i;
1090  ldns_rr_list *subtyped;
1091  ldns_rdf *list_rdf;
1092 
1093  subtyped = ldns_rr_list_new();
1094 
1095  for(i = 0; i < ldns_rr_list_rr_count(l); i++) {
1096  list_rdf = ldns_rr_rdf(
1097  ldns_rr_list_rr(l, i),
1098  pos);
1099  if (!list_rdf) {
1100  /* pos is too large or any other error */
1101  ldns_rr_list_deep_free(subtyped);
1102  return NULL;
1103  }
1104 
1105  if (ldns_rdf_compare(list_rdf, r) == 0) {
1106  /* a match */
1107  ldns_rr_list_push_rr(subtyped,
1109  }
1110  }
1111 
1112  if (ldns_rr_list_rr_count(subtyped) > 0) {
1113  return subtyped;
1114  } else {
1115  ldns_rr_list_free(subtyped);
1116  return NULL;
1117  }
1118 }
1119 
1120 bool
1122 {
1123  size_t rr_count;
1124  size_t cap;
1125 
1126  rr_count = ldns_rr_list_rr_count(rr_list);
1127  cap = rr_list->_rr_capacity;
1128 
1129  /* grow the array */
1130  if(rr_count+1 > cap) {
1131  ldns_rr **rrs;
1132 
1133  if(cap == 0)
1134  cap = LDNS_RRLIST_INIT; /* initial list size */
1135  else cap *= 2;
1136  rrs = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap);
1137  if (!rrs) {
1138  return false;
1139  }
1140  rr_list->_rrs = rrs;
1141  rr_list->_rr_capacity = cap;
1142  }
1143 
1144  /* add the new member */
1145  rr_list->_rrs[rr_count] = (ldns_rr*)rr;
1146 
1147  ldns_rr_list_set_rr_count(rr_list, rr_count + 1);
1148  return true;
1149 }
1150 
1151 bool
1153 {
1154  size_t i;
1155 
1156  for(i = 0; i < ldns_rr_list_rr_count(push_list); i++) {
1157  if (!ldns_rr_list_push_rr(rr_list,
1158  ldns_rr_list_rr(push_list, i))) {
1159  return false;
1160  }
1161  }
1162  return true;
1163 }
1164 
1165 ldns_rr *
1167 {
1168  size_t rr_count;
1169  size_t cap;
1170  ldns_rr *pop;
1171 
1172  rr_count = ldns_rr_list_rr_count(rr_list);
1173 
1174  if (rr_count == 0) {
1175  return NULL;
1176  }
1177 
1178  cap = rr_list->_rr_capacity;
1179  pop = ldns_rr_list_rr(rr_list, rr_count - 1);
1180 
1181  /* shrink the array */
1182  if(cap > LDNS_RRLIST_INIT && rr_count-1 <= cap/2) {
1183  ldns_rr** a;
1184  cap /= 2;
1185  a = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap);
1186  if(a) {
1187  rr_list->_rrs = a;
1188  rr_list->_rr_capacity = cap;
1189  }
1190  }
1191 
1192  ldns_rr_list_set_rr_count(rr_list, rr_count - 1);
1193 
1194  return pop;
1195 }
1196 
1197 ldns_rr_list *
1198 ldns_rr_list_pop_rr_list(ldns_rr_list *rr_list, size_t howmany)
1199 {
1200  /* pop a number of rr's and put them in a rr_list */
1201  ldns_rr_list *popped;
1202  ldns_rr *p;
1203  size_t i = howmany;
1204 
1205  popped = ldns_rr_list_new();
1206 
1207  if (!popped) {
1208  return NULL;
1209  }
1210 
1211 
1212  while(i > 0 &&
1213  (p = ldns_rr_list_pop_rr(rr_list)) != NULL) {
1214  ldns_rr_list_push_rr(popped, p);
1215  i--;
1216  }
1217 
1218  if (i == howmany) { /* so i <= 0 */
1219  ldns_rr_list_free(popped);
1220  return NULL;
1221  } else {
1222  return popped;
1223  }
1224 }
1225 
1226 
1227 bool
1229 {
1230  size_t i;
1231 
1232  if (!rr_list || !rr || ldns_rr_list_rr_count(rr_list) == 0) {
1233  return false;
1234  }
1235 
1236  for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
1237  if (rr == ldns_rr_list_rr(rr_list, i)) {
1238  return true;
1239  } else if (ldns_rr_compare(rr, ldns_rr_list_rr(rr_list, i)) == 0) {
1240  return true;
1241  }
1242  }
1243  return false;
1244 }
1245 
1246 bool
1248 {
1249  ldns_rr_type t;
1250  ldns_rr_class c;
1251  ldns_rdf *o;
1252  ldns_rr *tmp;
1253  size_t i;
1254 
1255  if (!rr_list || ldns_rr_list_rr_count(rr_list) == 0) {
1256  return false;
1257  }
1258 
1259  tmp = ldns_rr_list_rr(rr_list, 0);
1260 
1261  t = ldns_rr_get_type(tmp);
1262  c = ldns_rr_get_class(tmp);
1263  o = ldns_rr_owner(tmp);
1264 
1265  /* compare these with the rest of the rr_list, start with 1 */
1266  for (i = 1; i < ldns_rr_list_rr_count(rr_list); i++) {
1267  tmp = ldns_rr_list_rr(rr_list, i);
1268  if (t != ldns_rr_get_type(tmp)) {
1269  return false;
1270  }
1271  if (c != ldns_rr_get_class(tmp)) {
1272  return false;
1273  }
1274  if (ldns_rdf_compare(o, ldns_rr_owner(tmp)) != 0) {
1275  return false;
1276  }
1277  }
1278  return true;
1279 }
1280 
1281 bool
1283 {
1284  size_t rr_count;
1285  size_t i;
1286  ldns_rr *last;
1287 
1288  assert(rr != NULL);
1289 
1290  rr_count = ldns_rr_list_rr_count(rr_list);
1291 
1292  if (rr_count == 0) {
1293  /* nothing there, so checking it is
1294  * not needed */
1295  return ldns_rr_list_push_rr(rr_list, rr);
1296  } else {
1297  /* check with the final rr in the rr_list */
1298  last = ldns_rr_list_rr(rr_list, rr_count - 1);
1299 
1300  if (ldns_rr_get_class(last) != ldns_rr_get_class(rr)) {
1301  return false;
1302  }
1303  if (ldns_rr_get_type(last) != ldns_rr_get_type(rr)) {
1304  return false;
1305  }
1306  /* only check if not equal to RRSIG */
1307  if (ldns_rr_get_type(rr) != LDNS_RR_TYPE_RRSIG) {
1308  if (ldns_rr_ttl(last) != ldns_rr_ttl(rr)) {
1309  return false;
1310  }
1311  }
1312  if (ldns_rdf_compare(ldns_rr_owner(last),
1313  ldns_rr_owner(rr)) != 0) {
1314  return false;
1315  }
1316  /* ok, still alive - check if the rr already
1317  * exists - if so, dont' add it */
1318  for(i = 0; i < rr_count; i++) {
1319  if(ldns_rr_compare(
1320  ldns_rr_list_rr(rr_list, i), rr) == 0) {
1321  return false;
1322  }
1323  }
1324  /* it's safe, push it */
1325  return ldns_rr_list_push_rr(rr_list, rr);
1326  }
1327 }
1328 
1329 ldns_rr *
1331 {
1332  return ldns_rr_list_pop_rr(rr_list);
1333 }
1334 
1335 ldns_rr_list *
1337 {
1338  ldns_rr_list *rrset;
1339  ldns_rr *last_rr = NULL;
1340  ldns_rr *next_rr;
1341 
1342  if (!rr_list) {
1343  return NULL;
1344  }
1345 
1346  rrset = ldns_rr_list_new();
1347  if (!last_rr) {
1348  last_rr = ldns_rr_list_pop_rr(rr_list);
1349  if (!last_rr) {
1350  ldns_rr_list_free(rrset);
1351  return NULL;
1352  } else {
1353  ldns_rr_list_push_rr(rrset, last_rr);
1354  }
1355  }
1356 
1357  if (ldns_rr_list_rr_count(rr_list) > 0) {
1358  next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1);
1359  } else {
1360  next_rr = NULL;
1361  }
1362 
1363  while (next_rr) {
1364  if (
1366  ldns_rr_owner(last_rr)) == 0
1367  &&
1368  ldns_rr_get_type(next_rr) == ldns_rr_get_type(last_rr)
1369  &&
1370  ldns_rr_get_class(next_rr) == ldns_rr_get_class(last_rr)
1371  ) {
1372  ldns_rr_list_push_rr(rrset, ldns_rr_list_pop_rr(rr_list));
1373  if (ldns_rr_list_rr_count(rr_list) > 0) {
1374  last_rr = next_rr;
1375  next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1);
1376  } else {
1377  next_rr = NULL;
1378  }
1379  } else {
1380  next_rr = NULL;
1381  }
1382  }
1383 
1384  return rrset;
1385 }
1386 
1387 ldns_rr *
1389 {
1390  size_t i;
1391  ldns_rr *new_rr;
1392 
1393  if (!rr) {
1394  return NULL;
1395  }
1396 
1397  new_rr = ldns_rr_new();
1398  if (!new_rr) {
1399  return NULL;
1400  }
1401  if (ldns_rr_owner(rr)) {
1403  }
1404  ldns_rr_set_ttl(new_rr, ldns_rr_ttl(rr));
1405  ldns_rr_set_type(new_rr, ldns_rr_get_type(rr));
1406  ldns_rr_set_class(new_rr, ldns_rr_get_class(rr));
1408 
1409  for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1410  if (ldns_rr_rdf(rr,i)) {
1411  ldns_rr_push_rdf(new_rr, ldns_rdf_clone(ldns_rr_rdf(rr, i)));
1412  }
1413  }
1414 
1415  return new_rr;
1416 }
1417 
1418 ldns_rr_list *
1420 {
1421  size_t i;
1422  ldns_rr_list *new_list;
1423  ldns_rr *r;
1424 
1425  if (!rrlist) {
1426  return NULL;
1427  }
1428 
1429  new_list = ldns_rr_list_new();
1430  if (!new_list) {
1431  return NULL;
1432  }
1433  for (i = 0; i < ldns_rr_list_rr_count(rrlist); i++) {
1434  r = ldns_rr_clone(
1435  ldns_rr_list_rr(rrlist, i)
1436  );
1437  if (!r) {
1438  /* huh, failure in cloning */
1439  ldns_rr_list_deep_free(new_list);
1440  return NULL;
1441  }
1442  ldns_rr_list_push_rr(new_list, r);
1443  }
1444  return new_list;
1445 }
1446 
1447 
1448 static int
1449 qsort_schwartz_rr_compare(const void *a, const void *b)
1450 {
1451  int result = 0;
1452  ldns_rr *rr1, *rr2;
1453  ldns_buffer *rr1_buf, *rr2_buf;
1456  /* if we are doing 2wire, we need to do lowercasing on the dname (and maybe on the rdata)
1457  * this must be done for comparison only, so we need to have a temp var for both buffers,
1458  * which is only used when the transformed object value isn't there yet
1459  */
1460  ldns_rr *canonical_a, *canonical_b;
1461 
1462  rr1 = (ldns_rr *) sa->original_object;
1463  rr2 = (ldns_rr *) sb->original_object;
1464 
1465  result = ldns_rr_compare_no_rdata(rr1, rr2);
1466 
1467  if (result == 0) {
1468  if (!sa->transformed_object) {
1469  canonical_a = ldns_rr_clone(sa->original_object);
1470  ldns_rr2canonical(canonical_a);
1474  sa->transformed_object = NULL;
1475  ldns_rr_free(canonical_a);
1476  return 0;
1477  }
1478  ldns_rr_free(canonical_a);
1479  }
1480  if (!sb->transformed_object) {
1481  canonical_b = ldns_rr_clone(sb->original_object);
1482  ldns_rr2canonical(canonical_b);
1487  sa->transformed_object = NULL;
1488  sb->transformed_object = NULL;
1489  ldns_rr_free(canonical_b);
1490  return 0;
1491  }
1492  ldns_rr_free(canonical_b);
1493  }
1494  rr1_buf = (ldns_buffer *) sa->transformed_object;
1495  rr2_buf = (ldns_buffer *) sb->transformed_object;
1496 
1497  result = ldns_rr_compare_wire(rr1_buf, rr2_buf);
1498  }
1499 
1500  return result;
1501 }
1502 
1503 void
1505 {
1506  struct ldns_schwartzian_compare_struct **sortables;
1507  size_t item_count;
1508  size_t i;
1509 
1510  if (unsorted) {
1511  item_count = ldns_rr_list_rr_count(unsorted);
1512 
1513  sortables = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct *,
1514  item_count);
1515  if(!sortables) return; /* no way to return error */
1516  for (i = 0; i < item_count; i++) {
1517  sortables[i] = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct, 1);
1518  if(!sortables[i]) {
1519  /* free the allocated parts */
1520  while(i>0) {
1521  i--;
1522  LDNS_FREE(sortables[i]);
1523  }
1524  /* no way to return error */
1525  LDNS_FREE(sortables);
1526  return;
1527  }
1528  sortables[i]->original_object = ldns_rr_list_rr(unsorted, i);
1529  sortables[i]->transformed_object = NULL;
1530  }
1531  qsort(sortables,
1532  item_count,
1533  sizeof(struct ldns_schwartzian_compare_struct *),
1534  qsort_schwartz_rr_compare);
1535  for (i = 0; i < item_count; i++) {
1536  unsorted->_rrs[i] = sortables[i]->original_object;
1537  if (sortables[i]->transformed_object) {
1538  ldns_buffer_free(sortables[i]->transformed_object);
1539  }
1540  LDNS_FREE(sortables[i]);
1541  }
1542  LDNS_FREE(sortables);
1543  }
1544 }
1545 
1546 int
1548 {
1549  size_t rr1_len;
1550  size_t rr2_len;
1551  size_t offset;
1552 
1553  assert(rr1 != NULL);
1554  assert(rr2 != NULL);
1555 
1556  rr1_len = ldns_rr_uncompressed_size(rr1);
1557  rr2_len = ldns_rr_uncompressed_size(rr2);
1558 
1559  if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) < 0) {
1560  return -1;
1561  } else if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) > 0) {
1562  return 1;
1563  }
1564 
1565  /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */
1566  if (ldns_rr_get_class(rr1) != ldns_rr_get_class(rr2)) {
1567  return ldns_rr_get_class(rr1) - ldns_rr_get_class(rr2);
1568  }
1569 
1570  /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */
1571  if (ldns_rr_get_type(rr1) != ldns_rr_get_type(rr2)) {
1572  return ldns_rr_get_type(rr1) - ldns_rr_get_type(rr2);
1573  }
1574 
1575  /* offset is the owername length + ttl + type + class + rdlen == start of wire format rdata */
1576  offset = ldns_rdf_size(ldns_rr_owner(rr1)) + 4 + 2 + 2 + 2;
1577  /* if either record doesn't have any RDATA... */
1578  if (offset > rr1_len || offset > rr2_len) {
1579  if (rr1_len == rr2_len) {
1580  return 0;
1581  }
1582  return ((int) rr2_len - (int) rr1_len);
1583  }
1584 
1585  return 0;
1586 }
1587 
1588 int ldns_rr_compare_wire(const ldns_buffer *rr1_buf, const ldns_buffer *rr2_buf)
1589 {
1590  size_t rr1_len, rr2_len, min_len, i, offset;
1591 
1592  rr1_len = ldns_buffer_capacity(rr1_buf);
1593  rr2_len = ldns_buffer_capacity(rr2_buf);
1594 
1595  /* jump past dname (checked in earlier part)
1596  * and especially past TTL */
1597  offset = 0;
1598  while (offset < rr1_len && *ldns_buffer_at(rr1_buf, offset) != 0) {
1599  offset += *ldns_buffer_at(rr1_buf, offset) + 1;
1600  }
1601  /* jump to rdata section (PAST the rdata length field, otherwise
1602  rrs with different lengths might be sorted erroneously */
1603  offset += 11;
1604  min_len = (rr1_len < rr2_len) ? rr1_len : rr2_len;
1605  /* Compare RRs RDATA byte for byte. */
1606  for(i = offset; i < min_len; i++) {
1607  if (*ldns_buffer_at(rr1_buf,i) < *ldns_buffer_at(rr2_buf,i)) {
1608  return -1;
1609  } else if (*ldns_buffer_at(rr1_buf,i) > *ldns_buffer_at(rr2_buf,i)) {
1610  return +1;
1611  }
1612  }
1613 
1614  /* If both RDATAs are the same up to min_len, then the shorter one sorts first. */
1615  if (rr1_len < rr2_len) {
1616  return -1;
1617  } else if (rr1_len > rr2_len) {
1618  return +1;
1619  }
1620  /* The RDATAs are equal. */
1621  return 0;
1622 
1623 }
1624 
1625 int
1626 ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2)
1627 {
1628  int result;
1629  size_t rr1_len, rr2_len;
1630 
1631  ldns_buffer *rr1_buf;
1632  ldns_buffer *rr2_buf;
1633 
1634  result = ldns_rr_compare_no_rdata(rr1, rr2);
1635  if (result == 0) {
1636  rr1_len = ldns_rr_uncompressed_size(rr1);
1637  rr2_len = ldns_rr_uncompressed_size(rr2);
1638 
1639  rr1_buf = ldns_buffer_new(rr1_len);
1640  rr2_buf = ldns_buffer_new(rr2_len);
1641 
1642  if (ldns_rr2buffer_wire_canonical(rr1_buf,
1643  rr1,
1645  != LDNS_STATUS_OK) {
1646  ldns_buffer_free(rr1_buf);
1647  ldns_buffer_free(rr2_buf);
1648  return 0;
1649  }
1650  if (ldns_rr2buffer_wire_canonical(rr2_buf,
1651  rr2,
1653  != LDNS_STATUS_OK) {
1654  ldns_buffer_free(rr1_buf);
1655  ldns_buffer_free(rr2_buf);
1656  return 0;
1657  }
1658 
1659  result = ldns_rr_compare_wire(rr1_buf, rr2_buf);
1660 
1661  ldns_buffer_free(rr1_buf);
1662  ldns_buffer_free(rr2_buf);
1663  }
1664 
1665  return result;
1666 }
1667 
1668 /* convert dnskey to a ds with the given algorithm,
1669  * then compare the result with the given ds */
1670 static int
1671 ldns_rr_compare_ds_dnskey(ldns_rr *ds,
1672  ldns_rr *dnskey)
1673 {
1674  ldns_rr *ds_gen;
1675  bool result = false;
1676  ldns_hash algo;
1677 
1678  if (!dnskey || !ds ||
1681  return false;
1682  }
1683 
1684  if (ldns_rr_rdf(ds, 2) == NULL) {
1685  return false;
1686  }
1687  algo = ldns_rdf2native_int8(ldns_rr_rdf(ds, 2));
1688 
1689  ds_gen = ldns_key_rr2ds(dnskey, algo);
1690  if (ds_gen) {
1691  result = ldns_rr_compare(ds, ds_gen) == 0;
1692  ldns_rr_free(ds_gen);
1693  }
1694  return result;
1695 }
1696 
1697 bool
1698 ldns_rr_compare_ds(const ldns_rr *orr1, const ldns_rr *orr2)
1699 {
1700  bool result;
1701  ldns_rr *rr1 = ldns_rr_clone(orr1);
1702  ldns_rr *rr2 = ldns_rr_clone(orr2);
1703 
1704  /* set ttls to zero */
1705  ldns_rr_set_ttl(rr1, 0);
1706  ldns_rr_set_ttl(rr2, 0);
1707 
1708  if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DS &&
1710  result = ldns_rr_compare_ds_dnskey(rr1, rr2);
1711  } else if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DNSKEY &&
1713  result = ldns_rr_compare_ds_dnskey(rr2, rr1);
1714  } else {
1715  result = (ldns_rr_compare(rr1, rr2) == 0);
1716  }
1717 
1718  ldns_rr_free(rr1);
1719  ldns_rr_free(rr2);
1720 
1721  return result;
1722 }
1723 
1724 int
1726 {
1727  size_t i = 0;
1728  int rr_cmp;
1729 
1730  assert(rrl1 != NULL);
1731  assert(rrl2 != NULL);
1732 
1733  for (i = 0; i < ldns_rr_list_rr_count(rrl1) && i < ldns_rr_list_rr_count(rrl2); i++) {
1734  rr_cmp = ldns_rr_compare(ldns_rr_list_rr(rrl1, i), ldns_rr_list_rr(rrl2, i));
1735  if (rr_cmp != 0) {
1736  return rr_cmp;
1737  }
1738  }
1739 
1740  if (i == ldns_rr_list_rr_count(rrl1) &&
1741  i != ldns_rr_list_rr_count(rrl2)) {
1742  return 1;
1743  } else if (i == ldns_rr_list_rr_count(rrl2) &&
1744  i != ldns_rr_list_rr_count(rrl1)) {
1745  return -1;
1746  } else {
1747  return 0;
1748  }
1749 }
1750 
1751 size_t
1753 {
1754  size_t rrsize;
1755  size_t i;
1756 
1757  rrsize = 0;
1758  /* add all the rdf sizes */
1759  for(i = 0; i < ldns_rr_rd_count(r); i++) {
1760  rrsize += ldns_rdf_size(ldns_rr_rdf(r, i));
1761  }
1762  /* ownername */
1763  rrsize += ldns_rdf_size(ldns_rr_owner(r));
1764  rrsize += LDNS_RR_OVERHEAD;
1765  return rrsize;
1766 }
1767 
1768 void
1770 {
1771  uint16_t i;
1772 
1773  if (!rr) {
1774  return;
1775  }
1776 
1778 
1779  /*
1780  * lowercase the rdata dnames if the rr type is one
1781  * of the list in chapter 7 of RFC3597
1782  * Also added RRSIG, because a "Signer's Name" should be canonicalized
1783  * too. See dnssec-bis-updates-16. We can add it to this list because
1784  * the "Signer's Name" is the only dname type rdata field in a RRSIG.
1785  */
1786  switch(ldns_rr_get_type(rr)) {
1787  case LDNS_RR_TYPE_NS:
1788  case LDNS_RR_TYPE_MD:
1789  case LDNS_RR_TYPE_MF:
1790  case LDNS_RR_TYPE_CNAME:
1791  case LDNS_RR_TYPE_SOA:
1792  case LDNS_RR_TYPE_MB:
1793  case LDNS_RR_TYPE_MG:
1794  case LDNS_RR_TYPE_MR:
1795  case LDNS_RR_TYPE_PTR:
1796  case LDNS_RR_TYPE_MINFO:
1797  case LDNS_RR_TYPE_MX:
1798  case LDNS_RR_TYPE_RP:
1799  case LDNS_RR_TYPE_AFSDB:
1800  case LDNS_RR_TYPE_RT:
1801  case LDNS_RR_TYPE_SIG:
1802  case LDNS_RR_TYPE_PX:
1803  case LDNS_RR_TYPE_NXT:
1804  case LDNS_RR_TYPE_NAPTR:
1805  case LDNS_RR_TYPE_KX:
1806  case LDNS_RR_TYPE_SRV:
1807  case LDNS_RR_TYPE_DNAME:
1808  case LDNS_RR_TYPE_A6:
1809  case LDNS_RR_TYPE_RRSIG:
1810  for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1812  }
1813  return;
1814  default:
1815  /* do nothing */
1816  return;
1817  }
1818 }
1819 
1820 void
1822 {
1823  size_t i;
1824  for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
1825  ldns_rr2canonical(ldns_rr_list_rr(rr_list, i));
1826  }
1827 }
1828 
1829 uint8_t
1831 {
1832  if (!rr) {
1833  return 0;
1834  }
1835  return ldns_dname_label_count(
1836  ldns_rr_owner(rr));
1837 }
1838 
1840 static const ldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
1841 static const ldns_rdf_type type_a_wireformat[] = { LDNS_RDF_TYPE_A };
1842 static const ldns_rdf_type type_ns_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1843 static const ldns_rdf_type type_md_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1844 static const ldns_rdf_type type_mf_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1845 static const ldns_rdf_type type_cname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1846 static const ldns_rdf_type type_soa_wireformat[] = {
1850 };
1851 static const ldns_rdf_type type_mb_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1852 static const ldns_rdf_type type_mg_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1853 static const ldns_rdf_type type_mr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1854 static const ldns_rdf_type type_wks_wireformat[] = {
1856 };
1857 static const ldns_rdf_type type_ptr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1858 static const ldns_rdf_type type_hinfo_wireformat[] = {
1860 };
1861 static const ldns_rdf_type type_minfo_wireformat[] = {
1863 };
1864 static const ldns_rdf_type type_mx_wireformat[] = {
1866 };
1867 static const ldns_rdf_type type_rp_wireformat[] = {
1869 };
1870 static const ldns_rdf_type type_afsdb_wireformat[] = {
1872 };
1873 static const ldns_rdf_type type_x25_wireformat[] = { LDNS_RDF_TYPE_STR };
1874 static const ldns_rdf_type type_isdn_wireformat[] = {
1876 };
1877 static const ldns_rdf_type type_rt_wireformat[] = {
1879 };
1880 static const ldns_rdf_type type_nsap_wireformat[] = {
1882 };
1883 static const ldns_rdf_type type_nsap_ptr_wireformat[] = {
1885 };
1886 static const ldns_rdf_type type_sig_wireformat[] = {
1890 };
1891 static const ldns_rdf_type type_key_wireformat[] = {
1893 };
1894 static const ldns_rdf_type type_px_wireformat[] = {
1896 };
1897 static const ldns_rdf_type type_gpos_wireformat[] = {
1899 };
1900 static const ldns_rdf_type type_aaaa_wireformat[] = { LDNS_RDF_TYPE_AAAA };
1901 static const ldns_rdf_type type_loc_wireformat[] = { LDNS_RDF_TYPE_LOC };
1902 static const ldns_rdf_type type_nxt_wireformat[] = {
1904 };
1905 static const ldns_rdf_type type_eid_wireformat[] = {
1907 };
1908 static const ldns_rdf_type type_nimloc_wireformat[] = {
1910 };
1911 static const ldns_rdf_type type_srv_wireformat[] = {
1913 };
1914 static const ldns_rdf_type type_atma_wireformat[] = {
1916 };
1917 static const ldns_rdf_type type_naptr_wireformat[] = {
1919 };
1920 static const ldns_rdf_type type_kx_wireformat[] = {
1922 };
1923 static const ldns_rdf_type type_cert_wireformat[] = {
1925 };
1926 static const ldns_rdf_type type_a6_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
1927 static const ldns_rdf_type type_dname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1928 static const ldns_rdf_type type_sink_wireformat[] = { LDNS_RDF_TYPE_INT8,
1930 };
1931 static const ldns_rdf_type type_apl_wireformat[] = {
1933 };
1934 static const ldns_rdf_type type_ds_wireformat[] = {
1936 };
1937 static const ldns_rdf_type type_sshfp_wireformat[] = {
1939 };
1940 static const ldns_rdf_type type_ipseckey_wireformat[] = {
1942 };
1943 static const ldns_rdf_type type_rrsig_wireformat[] = {
1946 };
1947 static const ldns_rdf_type type_nsec_wireformat[] = {
1949 };
1950 static const ldns_rdf_type type_dhcid_wireformat[] = {
1952 };
1953 static const ldns_rdf_type type_talink_wireformat[] = {
1955 };
1956 #ifdef RRTYPE_OPENPGPKEY
1957 static const ldns_rdf_type type_openpgpkey_wireformat[] = {
1959 };
1960 #endif
1961 static const ldns_rdf_type type_csync_wireformat[] = {
1963 };
1964 /* nsec3 is some vars, followed by same type of data of nsec */
1965 static const ldns_rdf_type type_nsec3_wireformat[] = {
1966 /* LDNS_RDF_TYPE_NSEC3_VARS, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC*/
1968 };
1969 
1970 static const ldns_rdf_type type_nsec3param_wireformat[] = {
1971 /* LDNS_RDF_TYPE_NSEC3_PARAMS_VARS*/
1976 };
1977 
1978 static const ldns_rdf_type type_dnskey_wireformat[] = {
1983 };
1984 static const ldns_rdf_type type_tkey_wireformat[] = {
1992 };
1993 static const ldns_rdf_type type_tsig_wireformat[] = {
2001 };
2002 static const ldns_rdf_type type_tlsa_wireformat[] = {
2007 };
2008 static const ldns_rdf_type type_hip_wireformat[] = {
2010 };
2011 static const ldns_rdf_type type_nid_wireformat[] = {
2014 };
2015 static const ldns_rdf_type type_l32_wireformat[] = {
2018 };
2019 static const ldns_rdf_type type_l64_wireformat[] = {
2022 };
2023 static const ldns_rdf_type type_lp_wireformat[] = {
2026 };
2027 static const ldns_rdf_type type_eui48_wireformat[] = {
2029 };
2030 static const ldns_rdf_type type_eui64_wireformat[] = {
2032 };
2033 static const ldns_rdf_type type_uri_wireformat[] = {
2037 };
2038 static const ldns_rdf_type type_caa_wireformat[] = {
2042 };
2046 /* All RR's defined in 1035 are well known and can thus
2047  * be compressed. See RFC3597. These RR's are:
2048  * CNAME HINFO MB MD MF MG MINFO MR MX NULL NS PTR SOA TXT
2049  */
2050 static ldns_rr_descriptor rdata_field_descriptors[] = {
2051  /* 0 */
2052  { 0, NULL, 0, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2053  /* 1 */
2054  {LDNS_RR_TYPE_A, "A", 1, 1, type_a_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2055  /* 2 */
2056  {LDNS_RR_TYPE_NS, "NS", 1, 1, type_ns_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2057  /* 3 */
2058  {LDNS_RR_TYPE_MD, "MD", 1, 1, type_md_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2059  /* 4 */
2060  {LDNS_RR_TYPE_MF, "MF", 1, 1, type_mf_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2061  /* 5 */
2062  {LDNS_RR_TYPE_CNAME, "CNAME", 1, 1, type_cname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2063  /* 6 */
2064  {LDNS_RR_TYPE_SOA, "SOA", 7, 7, type_soa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 },
2065  /* 7 */
2066  {LDNS_RR_TYPE_MB, "MB", 1, 1, type_mb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2067  /* 8 */
2068  {LDNS_RR_TYPE_MG, "MG", 1, 1, type_mg_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2069  /* 9 */
2070  {LDNS_RR_TYPE_MR, "MR", 1, 1, type_mr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2071  /* 10 */
2072  {LDNS_RR_TYPE_NULL, "NULL", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2073  /* 11 */
2074  {LDNS_RR_TYPE_WKS, "WKS", 2, 2, type_wks_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2075  /* 12 */
2076  {LDNS_RR_TYPE_PTR, "PTR", 1, 1, type_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2077  /* 13 */
2078  {LDNS_RR_TYPE_HINFO, "HINFO", 2, 2, type_hinfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2079  /* 14 */
2080  {LDNS_RR_TYPE_MINFO, "MINFO", 2, 2, type_minfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 },
2081  /* 15 */
2082  {LDNS_RR_TYPE_MX, "MX", 2, 2, type_mx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2083  /* 16 */
2084  {LDNS_RR_TYPE_TXT, "TXT", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
2085  /* 17 */
2086  {LDNS_RR_TYPE_RP, "RP", 2, 2, type_rp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
2087  /* 18 */
2088  {LDNS_RR_TYPE_AFSDB, "AFSDB", 2, 2, type_afsdb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2089  /* 19 */
2090  {LDNS_RR_TYPE_X25, "X25", 1, 1, type_x25_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2091  /* 20 */
2092  {LDNS_RR_TYPE_ISDN, "ISDN", 1, 2, type_isdn_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2093  /* 21 */
2094  {LDNS_RR_TYPE_RT, "RT", 2, 2, type_rt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2095  /* 22 */
2096  {LDNS_RR_TYPE_NSAP, "NSAP", 1, 1, type_nsap_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2097  /* 23 */
2098  {LDNS_RR_TYPE_NSAP_PTR, "NSAP-PTR", 1, 1, type_nsap_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2099  /* 24 */
2100  {LDNS_RR_TYPE_SIG, "SIG", 9, 9, type_sig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2101  /* 25 */
2102  {LDNS_RR_TYPE_KEY, "KEY", 4, 4, type_key_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2103  /* 26 */
2104  {LDNS_RR_TYPE_PX, "PX", 3, 3, type_px_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
2105  /* 27 */
2106  {LDNS_RR_TYPE_GPOS, "GPOS", 3, 3, type_gpos_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2107  /* 28 */
2108  {LDNS_RR_TYPE_AAAA, "AAAA", 1, 1, type_aaaa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2109  /* 29 */
2110  {LDNS_RR_TYPE_LOC, "LOC", 1, 1, type_loc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2111  /* 30 */
2112  {LDNS_RR_TYPE_NXT, "NXT", 2, 2, type_nxt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2113  /* 31 */
2114  {LDNS_RR_TYPE_EID, "EID", 1, 1, type_eid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2115  /* 32 */
2116  {LDNS_RR_TYPE_NIMLOC, "NIMLOC", 1, 1, type_nimloc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2117  /* 33 */
2118  {LDNS_RR_TYPE_SRV, "SRV", 4, 4, type_srv_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2119  /* 34 */
2120  {LDNS_RR_TYPE_ATMA, "ATMA", 1, 1, type_atma_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2121  /* 35 */
2122  {LDNS_RR_TYPE_NAPTR, "NAPTR", 6, 6, type_naptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2123  /* 36 */
2124  {LDNS_RR_TYPE_KX, "KX", 2, 2, type_kx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2125  /* 37 */
2126  {LDNS_RR_TYPE_CERT, "CERT", 4, 4, type_cert_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2127  /* 38 */
2128  {LDNS_RR_TYPE_A6, "A6", 1, 1, type_a6_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2129  /* 39 */
2130  {LDNS_RR_TYPE_DNAME, "DNAME", 1, 1, type_dname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2131  /* 40 */
2132  {LDNS_RR_TYPE_SINK, "SINK", 1, 1, type_sink_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2133  /* 41 */
2134  {LDNS_RR_TYPE_OPT, "OPT", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2135  /* 42 */
2136  {LDNS_RR_TYPE_APL, "APL", 0, 0, type_apl_wireformat, LDNS_RDF_TYPE_APL, LDNS_RR_NO_COMPRESS, 0 },
2137  /* 43 */
2138  {LDNS_RR_TYPE_DS, "DS", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2139  /* 44 */
2140  {LDNS_RR_TYPE_SSHFP, "SSHFP", 3, 3, type_sshfp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2141  /* 45 */
2142  {LDNS_RR_TYPE_IPSECKEY, "IPSECKEY", 1, 1, type_ipseckey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2143  /* 46 */
2144  {LDNS_RR_TYPE_RRSIG, "RRSIG", 9, 9, type_rrsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2145  /* 47 */
2146  {LDNS_RR_TYPE_NSEC, "NSEC", 1, 2, type_nsec_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2147  /* 48 */
2148  {LDNS_RR_TYPE_DNSKEY, "DNSKEY", 4, 4, type_dnskey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2149  /* 49 */
2150  {LDNS_RR_TYPE_DHCID, "DHCID", 1, 1, type_dhcid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2151  /* 50 */
2152  {LDNS_RR_TYPE_NSEC3, "NSEC3", 5, 6, type_nsec3_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2153  /* 51 */
2154  {LDNS_RR_TYPE_NSEC3PARAM, "NSEC3PARAM", 4, 4, type_nsec3param_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2155  /* 52 */
2156  {LDNS_RR_TYPE_TLSA, "TLSA", 4, 4, type_tlsa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2157 
2158  {LDNS_RR_TYPE_SMIMEA, "SMIMEA", 4, 4, type_tlsa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2159 {LDNS_RR_TYPE_NULL, "TYPE54", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2160 
2161  /* 55
2162  * Hip ends with 0 or more Rendezvous Servers represented as dname's.
2163  * Hence the LDNS_RDF_TYPE_DNAME _variable field and the _maximum field
2164  * set to 0.
2165  */
2166  {LDNS_RR_TYPE_HIP, "HIP", 1, 1, type_hip_wireformat, LDNS_RDF_TYPE_DNAME, LDNS_RR_NO_COMPRESS, 0 },
2167 
2168 #ifdef RRTYPE_NINFO
2169  /* 56 */
2170  {LDNS_RR_TYPE_NINFO, "NINFO", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
2171 #else
2172 {LDNS_RR_TYPE_NULL, "TYPE56", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2173 #endif
2174 #ifdef RRTYPE_RKEY
2175  /* 57 */
2176  {LDNS_RR_TYPE_RKEY, "RKEY", 4, 4, type_key_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2177 #else
2178 {LDNS_RR_TYPE_NULL, "TYPE57", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2179 #endif
2180  /* 58 */
2181  {LDNS_RR_TYPE_TALINK, "TALINK", 2, 2, type_talink_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
2182 
2183  /* 59 */
2184  {LDNS_RR_TYPE_CDS, "CDS", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2185  /* 60 */
2186  {LDNS_RR_TYPE_CDNSKEY, "CDNSKEY", 4, 4, type_dnskey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2187 
2188 #ifdef RRTYPE_OPENPGPKEY
2189  /* 61 */
2190  {LDNS_RR_TYPE_OPENPGPKEY, "OPENPGPKEY", 1, 1, type_openpgpkey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2191 #else
2192 {LDNS_RR_TYPE_NULL, "TYPE61", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2193 #endif
2194 
2195 {LDNS_RR_TYPE_CSYNC, "CSYNC", 3, 3, type_csync_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2196 {LDNS_RR_TYPE_NULL, "TYPE63", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2197 {LDNS_RR_TYPE_NULL, "TYPE64", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2198 {LDNS_RR_TYPE_NULL, "TYPE65", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2199 {LDNS_RR_TYPE_NULL, "TYPE66", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2200 {LDNS_RR_TYPE_NULL, "TYPE67", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2201 {LDNS_RR_TYPE_NULL, "TYPE68", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2202 {LDNS_RR_TYPE_NULL, "TYPE69", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2203 {LDNS_RR_TYPE_NULL, "TYPE70", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2204 {LDNS_RR_TYPE_NULL, "TYPE71", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2205 {LDNS_RR_TYPE_NULL, "TYPE72", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2206 {LDNS_RR_TYPE_NULL, "TYPE73", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2207 {LDNS_RR_TYPE_NULL, "TYPE74", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2208 {LDNS_RR_TYPE_NULL, "TYPE75", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2209 {LDNS_RR_TYPE_NULL, "TYPE76", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2210 {LDNS_RR_TYPE_NULL, "TYPE77", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2211 {LDNS_RR_TYPE_NULL, "TYPE78", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2212 {LDNS_RR_TYPE_NULL, "TYPE79", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2213 {LDNS_RR_TYPE_NULL, "TYPE80", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2214 {LDNS_RR_TYPE_NULL, "TYPE81", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2215 {LDNS_RR_TYPE_NULL, "TYPE82", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2216 {LDNS_RR_TYPE_NULL, "TYPE83", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2217 {LDNS_RR_TYPE_NULL, "TYPE84", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2218 {LDNS_RR_TYPE_NULL, "TYPE85", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2219 {LDNS_RR_TYPE_NULL, "TYPE86", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2220 {LDNS_RR_TYPE_NULL, "TYPE87", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2221 {LDNS_RR_TYPE_NULL, "TYPE88", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2222 {LDNS_RR_TYPE_NULL, "TYPE89", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2223 {LDNS_RR_TYPE_NULL, "TYPE90", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2224 {LDNS_RR_TYPE_NULL, "TYPE91", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2225 {LDNS_RR_TYPE_NULL, "TYPE92", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2226 {LDNS_RR_TYPE_NULL, "TYPE93", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2227 {LDNS_RR_TYPE_NULL, "TYPE94", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2228 {LDNS_RR_TYPE_NULL, "TYPE95", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2229 {LDNS_RR_TYPE_NULL, "TYPE96", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2230 {LDNS_RR_TYPE_NULL, "TYPE97", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2231 {LDNS_RR_TYPE_NULL, "TYPE98", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2232 
2233  /* 99 */
2234  {LDNS_RR_TYPE_SPF, "SPF", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
2235 
2236  /* UINFO [IANA-Reserved] */
2237 {LDNS_RR_TYPE_NULL, "TYPE100", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2238  /* UID [IANA-Reserved] */
2239 {LDNS_RR_TYPE_NULL, "TYPE101", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2240  /* GID [IANA-Reserved] */
2241 {LDNS_RR_TYPE_NULL, "TYPE102", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2242  /* UNSPEC [IANA-Reserved] */
2243 {LDNS_RR_TYPE_NULL, "TYPE103", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2244 
2245  /* 104 */
2246  {LDNS_RR_TYPE_NID, "NID", 2, 2, type_nid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2247  /* 105 */
2248  {LDNS_RR_TYPE_L32, "L32", 2, 2, type_l32_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2249  /* 106 */
2250  {LDNS_RR_TYPE_L64, "L64", 2, 2, type_l64_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2251  /* 107 */
2252  {LDNS_RR_TYPE_LP, "LP", 2, 2, type_lp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2253  /* 108 */
2254  {LDNS_RR_TYPE_EUI48, "EUI48", 1, 1, type_eui48_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2255  /* 109 */
2256  {LDNS_RR_TYPE_EUI64, "EUI64", 1, 1, type_eui64_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2257 
2258 {LDNS_RR_TYPE_NULL, "TYPE110", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2259 {LDNS_RR_TYPE_NULL, "TYPE111", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2260 {LDNS_RR_TYPE_NULL, "TYPE112", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2261 {LDNS_RR_TYPE_NULL, "TYPE113", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2262 {LDNS_RR_TYPE_NULL, "TYPE114", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2263 {LDNS_RR_TYPE_NULL, "TYPE115", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2264 {LDNS_RR_TYPE_NULL, "TYPE116", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2265 {LDNS_RR_TYPE_NULL, "TYPE117", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2266 {LDNS_RR_TYPE_NULL, "TYPE118", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2267 {LDNS_RR_TYPE_NULL, "TYPE119", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2268 {LDNS_RR_TYPE_NULL, "TYPE120", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2269 {LDNS_RR_TYPE_NULL, "TYPE121", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2270 {LDNS_RR_TYPE_NULL, "TYPE122", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2271 {LDNS_RR_TYPE_NULL, "TYPE123", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2272 {LDNS_RR_TYPE_NULL, "TYPE124", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2273 {LDNS_RR_TYPE_NULL, "TYPE125", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2274 {LDNS_RR_TYPE_NULL, "TYPE126", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2275 {LDNS_RR_TYPE_NULL, "TYPE127", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2276 {LDNS_RR_TYPE_NULL, "TYPE128", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2277 {LDNS_RR_TYPE_NULL, "TYPE129", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2278 {LDNS_RR_TYPE_NULL, "TYPE130", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2279 {LDNS_RR_TYPE_NULL, "TYPE131", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2280 {LDNS_RR_TYPE_NULL, "TYPE132", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2281 {LDNS_RR_TYPE_NULL, "TYPE133", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2282 {LDNS_RR_TYPE_NULL, "TYPE134", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2283 {LDNS_RR_TYPE_NULL, "TYPE135", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2284 {LDNS_RR_TYPE_NULL, "TYPE136", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2285 {LDNS_RR_TYPE_NULL, "TYPE137", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2286 {LDNS_RR_TYPE_NULL, "TYPE138", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2287 {LDNS_RR_TYPE_NULL, "TYPE139", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2288 {LDNS_RR_TYPE_NULL, "TYPE140", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2289 {LDNS_RR_TYPE_NULL, "TYPE141", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2290 {LDNS_RR_TYPE_NULL, "TYPE142", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2291 {LDNS_RR_TYPE_NULL, "TYPE143", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2292 {LDNS_RR_TYPE_NULL, "TYPE144", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2293 {LDNS_RR_TYPE_NULL, "TYPE145", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2294 {LDNS_RR_TYPE_NULL, "TYPE146", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2295 {LDNS_RR_TYPE_NULL, "TYPE147", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2296 {LDNS_RR_TYPE_NULL, "TYPE148", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2297 {LDNS_RR_TYPE_NULL, "TYPE149", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2298 {LDNS_RR_TYPE_NULL, "TYPE150", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2299 {LDNS_RR_TYPE_NULL, "TYPE151", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2300 {LDNS_RR_TYPE_NULL, "TYPE152", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2301 {LDNS_RR_TYPE_NULL, "TYPE153", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2302 {LDNS_RR_TYPE_NULL, "TYPE154", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2303 {LDNS_RR_TYPE_NULL, "TYPE155", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2304 {LDNS_RR_TYPE_NULL, "TYPE156", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2305 {LDNS_RR_TYPE_NULL, "TYPE157", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2306 {LDNS_RR_TYPE_NULL, "TYPE158", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2307 {LDNS_RR_TYPE_NULL, "TYPE159", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2308 {LDNS_RR_TYPE_NULL, "TYPE160", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2309 {LDNS_RR_TYPE_NULL, "TYPE161", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2310 {LDNS_RR_TYPE_NULL, "TYPE162", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2311 {LDNS_RR_TYPE_NULL, "TYPE163", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2312 {LDNS_RR_TYPE_NULL, "TYPE164", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2313 {LDNS_RR_TYPE_NULL, "TYPE165", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2314 {LDNS_RR_TYPE_NULL, "TYPE166", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2315 {LDNS_RR_TYPE_NULL, "TYPE167", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2316 {LDNS_RR_TYPE_NULL, "TYPE168", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2317 {LDNS_RR_TYPE_NULL, "TYPE169", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2318 {LDNS_RR_TYPE_NULL, "TYPE170", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2319 {LDNS_RR_TYPE_NULL, "TYPE171", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2320 {LDNS_RR_TYPE_NULL, "TYPE172", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2321 {LDNS_RR_TYPE_NULL, "TYPE173", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2322 {LDNS_RR_TYPE_NULL, "TYPE174", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2323 {LDNS_RR_TYPE_NULL, "TYPE175", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2324 {LDNS_RR_TYPE_NULL, "TYPE176", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2325 {LDNS_RR_TYPE_NULL, "TYPE177", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2326 {LDNS_RR_TYPE_NULL, "TYPE178", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2327 {LDNS_RR_TYPE_NULL, "TYPE179", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2328 {LDNS_RR_TYPE_NULL, "TYPE180", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2329 {LDNS_RR_TYPE_NULL, "TYPE181", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2330 {LDNS_RR_TYPE_NULL, "TYPE182", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2331 {LDNS_RR_TYPE_NULL, "TYPE183", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2332 {LDNS_RR_TYPE_NULL, "TYPE184", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2333 {LDNS_RR_TYPE_NULL, "TYPE185", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2334 {LDNS_RR_TYPE_NULL, "TYPE186", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2335 {LDNS_RR_TYPE_NULL, "TYPE187", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2336 {LDNS_RR_TYPE_NULL, "TYPE188", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2337 {LDNS_RR_TYPE_NULL, "TYPE189", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2338 {LDNS_RR_TYPE_NULL, "TYPE190", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2339 {LDNS_RR_TYPE_NULL, "TYPE191", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2340 {LDNS_RR_TYPE_NULL, "TYPE192", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2341 {LDNS_RR_TYPE_NULL, "TYPE193", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2342 {LDNS_RR_TYPE_NULL, "TYPE194", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2343 {LDNS_RR_TYPE_NULL, "TYPE195", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2344 {LDNS_RR_TYPE_NULL, "TYPE196", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2345 {LDNS_RR_TYPE_NULL, "TYPE197", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2346 {LDNS_RR_TYPE_NULL, "TYPE198", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2347 {LDNS_RR_TYPE_NULL, "TYPE199", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2348 {LDNS_RR_TYPE_NULL, "TYPE200", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2349 {LDNS_RR_TYPE_NULL, "TYPE201", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2350 {LDNS_RR_TYPE_NULL, "TYPE202", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2351 {LDNS_RR_TYPE_NULL, "TYPE203", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2352 {LDNS_RR_TYPE_NULL, "TYPE204", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2353 {LDNS_RR_TYPE_NULL, "TYPE205", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2354 {LDNS_RR_TYPE_NULL, "TYPE206", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2355 {LDNS_RR_TYPE_NULL, "TYPE207", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2356 {LDNS_RR_TYPE_NULL, "TYPE208", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2357 {LDNS_RR_TYPE_NULL, "TYPE209", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2358 {LDNS_RR_TYPE_NULL, "TYPE210", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2359 {LDNS_RR_TYPE_NULL, "TYPE211", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2360 {LDNS_RR_TYPE_NULL, "TYPE212", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2361 {LDNS_RR_TYPE_NULL, "TYPE213", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2362 {LDNS_RR_TYPE_NULL, "TYPE214", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2363 {LDNS_RR_TYPE_NULL, "TYPE215", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2364 {LDNS_RR_TYPE_NULL, "TYPE216", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2365 {LDNS_RR_TYPE_NULL, "TYPE217", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2366 {LDNS_RR_TYPE_NULL, "TYPE218", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2367 {LDNS_RR_TYPE_NULL, "TYPE219", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2368 {LDNS_RR_TYPE_NULL, "TYPE220", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2369 {LDNS_RR_TYPE_NULL, "TYPE221", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2370 {LDNS_RR_TYPE_NULL, "TYPE222", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2371 {LDNS_RR_TYPE_NULL, "TYPE223", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2372 {LDNS_RR_TYPE_NULL, "TYPE224", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2373 {LDNS_RR_TYPE_NULL, "TYPE225", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2374 {LDNS_RR_TYPE_NULL, "TYPE226", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2375 {LDNS_RR_TYPE_NULL, "TYPE227", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2376 {LDNS_RR_TYPE_NULL, "TYPE228", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2377 {LDNS_RR_TYPE_NULL, "TYPE229", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2378 {LDNS_RR_TYPE_NULL, "TYPE230", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2379 {LDNS_RR_TYPE_NULL, "TYPE231", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2380 {LDNS_RR_TYPE_NULL, "TYPE232", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2381 {LDNS_RR_TYPE_NULL, "TYPE233", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2382 {LDNS_RR_TYPE_NULL, "TYPE234", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2383 {LDNS_RR_TYPE_NULL, "TYPE235", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2384 {LDNS_RR_TYPE_NULL, "TYPE236", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2385 {LDNS_RR_TYPE_NULL, "TYPE237", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2386 {LDNS_RR_TYPE_NULL, "TYPE238", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2387 {LDNS_RR_TYPE_NULL, "TYPE239", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2388 {LDNS_RR_TYPE_NULL, "TYPE240", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2389 {LDNS_RR_TYPE_NULL, "TYPE241", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2390 {LDNS_RR_TYPE_NULL, "TYPE242", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2391 {LDNS_RR_TYPE_NULL, "TYPE243", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2392 {LDNS_RR_TYPE_NULL, "TYPE244", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2393 {LDNS_RR_TYPE_NULL, "TYPE245", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2394 {LDNS_RR_TYPE_NULL, "TYPE246", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2395 {LDNS_RR_TYPE_NULL, "TYPE247", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2396 {LDNS_RR_TYPE_NULL, "TYPE248", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2397 
2398  /* LDNS_RDF_TYPE_INT16_DATA takes two fields (length and data) as one.
2399  * So, unlike RFC 2930 spec, we have 7 min/max rdf's i.s.o. 8/9.
2400  */
2401  /* 249 */
2402  {LDNS_RR_TYPE_TKEY, "TKEY", 7, 7, type_tkey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2403  /* LDNS_RDF_TYPE_INT16_DATA takes two fields (length and data) as one.
2404  * So, unlike RFC 2930 spec, we have 7 min/max rdf's i.s.o. 8/9.
2405  */
2406  /* 250 */
2407  {LDNS_RR_TYPE_TSIG, "TSIG", 7, 7, type_tsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2408 
2409  /* IXFR: A request for a transfer of an incremental zone transfer */
2410 {LDNS_RR_TYPE_NULL, "TYPE251", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2411  /* AXFR: A request for a transfer of an entire zone */
2412 {LDNS_RR_TYPE_NULL, "TYPE252", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2413  /* MAILB: A request for mailbox-related records (MB, MG or MR) */
2414 {LDNS_RR_TYPE_NULL, "TYPE253", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2415  /* MAILA: A request for mail agent RRs (Obsolete - see MX) */
2416 {LDNS_RR_TYPE_NULL, "TYPE254", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2417  /* ANY: A request for all (available) records */
2418 {LDNS_RR_TYPE_NULL, "TYPE255", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2419 
2420  /* 256 */
2421  {LDNS_RR_TYPE_URI, "URI", 3, 3, type_uri_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2422  /* 257 */
2423  {LDNS_RR_TYPE_CAA, "CAA", 3, 3, type_caa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2424 
2425 #ifdef RRTYPE_AVC
2426  /* 258 */
2427  {LDNS_RR_TYPE_AVC, "AVC", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
2428 #else
2429 {LDNS_RR_TYPE_NULL, "TYPE258", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2430 #endif
2431 
2432 /* split in array, no longer contiguous */
2433 
2434 #ifdef RRTYPE_TA
2435  /* 32768 */
2436  {LDNS_RR_TYPE_TA, "TA", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2437 #else
2438 {LDNS_RR_TYPE_NULL, "TYPE32768", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2439 #endif
2440  /* 32769 */
2441  {LDNS_RR_TYPE_DLV, "DLV", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }
2442 };
2449 #define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \
2450  (sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0]))
2451 
2452 
2453 /*---------------------------------------------------------------------------*
2454  * The functions below return an bitmap RDF with the space required to set
2455  * or unset all known RR types. Arguably these functions are better situated
2456  * in rdata.c, however for the space calculation it is necesarry to walk
2457  * through rdata_field_descriptors which is not easily possible from anywhere
2458  * other than rr.c where it is declared static.
2459  *
2460  * Alternatively rr.c could have provided an iterator for rr_type or
2461  * rdf_descriptors, but this seemed overkill for internal use only.
2462  */
2463 static ldns_rr_descriptor* rdata_field_descriptors_end =
2464  &rdata_field_descriptors[LDNS_RDATA_FIELD_DESCRIPTORS_COUNT];
2465 
2466 /* From RFC3845:
2467  *
2468  * 2.1.2. The List of Type Bit Map(s) Field
2469  *
2470  * The RR type space is split into 256 window blocks, each representing
2471  * the low-order 8 bits of the 16-bit RR type space. Each block that
2472  * has at least one active RR type is encoded using a single octet
2473  * window number (from 0 to 255), a single octet bitmap length (from 1
2474  * to 32) indicating the number of octets used for the window block's
2475  * bitmap, and up to 32 octets (256 bits) of bitmap.
2476  *
2477  * Window blocks are present in the NSEC RR RDATA in increasing
2478  * numerical order.
2479  *
2480  * "|" denotes concatenation
2481  *
2482  * Type Bit Map(s) Field = ( Window Block # | Bitmap Length | Bitmap ) +
2483  *
2484  * <cut>
2485  *
2486  * Blocks with no types present MUST NOT be included. Trailing zero
2487  * octets in the bitmap MUST be omitted. The length of each block's
2488  * bitmap is determined by the type code with the largest numerical
2489  * value within that block, among the set of RR types present at the
2490  * NSEC RR's owner name. Trailing zero octets not specified MUST be
2491  * interpreted as zero octets.
2492  */
2493 static ldns_status
2494 ldns_rdf_bitmap_known_rr_types_set(ldns_rdf** rdf, int value)
2495 {
2496  uint8_t window; /* most significant octet of type */
2497  uint8_t subtype; /* least significant octet of type */
2498  uint16_t windows[256] /* Max subtype per window */
2499 #ifndef S_SPLINT_S
2500  = { 0 }
2501 #endif
2502  ;
2503  ldns_rr_descriptor* d; /* used to traverse rdata_field_descriptors */
2504  size_t i; /* used to traverse windows array */
2505 
2506  size_t sz; /* size needed for type bitmap rdf */
2507  uint8_t* data = NULL; /* rdf data */
2508  uint8_t* dptr; /* used to itraverse rdf data */
2509 
2510  assert(rdf != NULL);
2511 
2512  /* Which windows need to be in the bitmap rdf?
2513  */
2514  for (d=rdata_field_descriptors; d < rdata_field_descriptors_end; d++) {
2515  window = d->_type >> 8;
2516  subtype = d->_type & 0xff;
2517  if (windows[window] < subtype) {
2518  windows[window] = subtype;
2519  }
2520  }
2521 
2522  /* How much space do we need in the rdf for those windows?
2523  */
2524  sz = 0;
2525  for (i = 0; i < 256; i++) {
2526  if (windows[i]) {
2527  sz += windows[i] / 8 + 3;
2528  }
2529  }
2530  if (sz > 0) {
2531  /* Format rdf data according RFC3845 Section 2.1.2 (see above)
2532  */
2533  dptr = data = LDNS_XMALLOC(uint8_t, sz);
2534  memset(data, value, sz);
2535  if (!data) {
2536  return LDNS_STATUS_MEM_ERR;
2537  }
2538  for (i = 0; i < 256; i++) {
2539  if (windows[i]) {
2540  *dptr++ = (uint8_t)i;
2541  *dptr++ = (uint8_t)(windows[i] / 8 + 1);
2542  dptr += dptr[-1];
2543  }
2544  }
2545  }
2546  /* Allocate and return rdf structure for the data
2547  */
2548  *rdf = ldns_rdf_new(LDNS_RDF_TYPE_BITMAP, sz, data);
2549  if (!*rdf) {
2550  LDNS_FREE(data);
2551  return LDNS_STATUS_MEM_ERR;
2552  }
2553  return LDNS_STATUS_OK;
2554 }
2555 
2558 {
2559  return ldns_rdf_bitmap_known_rr_types_set(rdf, 0);
2560 }
2561 
2564 {
2565  return ldns_rdf_bitmap_known_rr_types_set(rdf, 255);
2566 }
2567 /* End of RDF bitmap functions
2568  *---------------------------------------------------------------------------*/
2569 
2570 
2571 const ldns_rr_descriptor *
2572 ldns_rr_descript(uint16_t type)
2573 {
2574  size_t i;
2576  return &rdata_field_descriptors[type];
2577  } else {
2578  /* because not all array index equals type code */
2581  i++) {
2582  if (rdata_field_descriptors[i]._type == type) {
2583  return &rdata_field_descriptors[i];
2584  }
2585  }
2586  return &rdata_field_descriptors[0];
2587  }
2588 }
2589 
2590 size_t
2592 {
2593  if (descriptor) {
2594  return descriptor->_minimum;
2595  } else {
2596  return 0;
2597  }
2598 }
2599 
2600 size_t
2602 {
2603  if (descriptor) {
2604  if (descriptor->_variable != LDNS_RDF_TYPE_NONE) {
2605  /* Should really be SIZE_MAX... bad FreeBSD. */
2606  return UINT_MAX;
2607  } else {
2608  return descriptor->_maximum;
2609  }
2610  } else {
2611  return 0;
2612  }
2613 }
2614 
2617  size_t index)
2618 {
2619  assert(descriptor != NULL);
2620  assert(index < descriptor->_maximum
2621  || descriptor->_variable != LDNS_RDF_TYPE_NONE);
2622  if (index < descriptor->_maximum) {
2623  return descriptor->_wireformat[index];
2624  } else {
2625  return descriptor->_variable;
2626  }
2627 }
2628 
2630 ldns_get_rr_type_by_name(const char *name)
2631 {
2632  unsigned int i;
2633  const char *desc_name;
2634  const ldns_rr_descriptor *desc;
2635 
2636  /* TYPEXX representation */
2637  if (strlen(name) > 4 && strncasecmp(name, "TYPE", 4) == 0) {
2638  return atoi(name + 4);
2639  }
2640 
2641  /* Normal types */
2642  for (i = 0; i < (unsigned int) LDNS_RDATA_FIELD_DESCRIPTORS_COUNT; i++) {
2643  desc = &rdata_field_descriptors[i];
2644  desc_name = desc->_name;
2645  if(desc_name &&
2646  strlen(name) == strlen(desc_name) &&
2647  strncasecmp(name, desc_name, strlen(desc_name)) == 0) {
2648  /* because not all array index equals type code */
2649  return desc->_type;
2650  }
2651  }
2652 
2653  /* special cases for query types */
2654  if (strlen(name) == 4 && strncasecmp(name, "IXFR", 4) == 0) {
2655  return 251;
2656  } else if (strlen(name) == 4 && strncasecmp(name, "AXFR", 4) == 0) {
2657  return 252;
2658  } else if (strlen(name) == 5 && strncasecmp(name, "MAILB", 5) == 0) {
2659  return 253;
2660  } else if (strlen(name) == 5 && strncasecmp(name, "MAILA", 5) == 0) {
2661  return 254;
2662  } else if (strlen(name) == 3 && strncasecmp(name, "ANY", 3) == 0) {
2663  return 255;
2664  }
2665 
2666  return 0;
2667 }
2668 
2670 ldns_get_rr_class_by_name(const char *name)
2671 {
2672  ldns_lookup_table *lt;
2673 
2674  /* CLASSXX representation */
2675  if (strlen(name) > 5 && strncasecmp(name, "CLASS", 5) == 0) {
2676  return atoi(name + 5);
2677  }
2678 
2679  /* Normal types */
2681 
2682  if (lt) {
2683  return lt->id;
2684  }
2685  return 0;
2686 }
2687 
2688 
2691 {
2692  ldns_rr_type r;
2693 
2694  if (!rd) {
2695  return 0;
2696  }
2697 
2699  return 0;
2700  }
2701 
2703  return r;
2704 }
2705 
2708 {
2709  if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) {
2710  return ldns_rr_get_type(ldns_rr_list_rr(rr_list, 0));
2711  } else {
2712  return 0;
2713  }
2714 }
2715 
2716 ldns_rdf *
2718 {
2719  if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) {
2720  return ldns_rr_owner(ldns_rr_list_rr(rr_list, 0));
2721  } else {
2722  return NULL;
2723  }
2724 }
ldns_rr_rdf
ldns_rdf * ldns_rr_rdf(const ldns_rr *rr, size_t nr)
returns the rdata field member counter.
Definition: rr.c:898
ldns_schwartzian_compare_struct::transformed_object
void * transformed_object
Definition: util.h:146
LDNS_XREALLOC
#define LDNS_XREALLOC(ptr, type, count)
Definition: util.h:57
ldns_struct_rr_list
List or Set of Resource Records.
Definition: rr.h:330
ldns_rr_class
enum ldns_enum_rr_class ldns_rr_class
Definition: rr.h:64
LDNS_RR_OVERHEAD
#define LDNS_RR_OVERHEAD
The bytes TTL, CLASS and length use up in an rr.
Definition: rr.h:37
ldns_hexstring_to_data
int ldns_hexstring_to_data(uint8_t *data, const char *str)
Converts a hex string to binary data.
Definition: util.c:138
ldns_rr_list_pop_rr_list
ldns_rr_list * ldns_rr_list_pop_rr_list(ldns_rr_list *rr_list, size_t howmany)
pops an rr_list of size s from an rrlist.
Definition: rr.c:1198
ldns_rdf_size
size_t ldns_rdf_size(const ldns_rdf *rd)
returns the size of the rdf.
Definition: rdata.c:24
ldns_rr_list_subtype_by_rdf
ldns_rr_list * ldns_rr_list_subtype_by_rdf(const ldns_rr_list *l, const ldns_rdf *r, size_t pos)
Return the rr_list which matches the rdf at position field.
Definition: rr.c:1087
LDNS_RR_TYPE_EUI64
@ LDNS_RR_TYPE_EUI64
Definition: rr.h:211
LDNS_RR_TYPE_L32
@ LDNS_RR_TYPE_L32
Definition: rr.h:206
ldns_struct_buffer
implementation of buffers to ease operations
Definition: buffer.h:50
LDNS_MAX_PACKETLEN
#define LDNS_MAX_PACKETLEN
Definition: packet.h:24
LDNS_RDF_TYPE_MATCHING_TYPE
@ LDNS_RDF_TYPE_MATCHING_TYPE
Definition: rdata.h:140
ldns_buffer_new
ldns_buffer * ldns_buffer_new(size_t capacity)
creates a new buffer with the specified capacity.
Definition: buffer.c:16
LDNS_RDF_TYPE_HEX
@ LDNS_RDF_TYPE_HEX
hex string
Definition: rdata.h:70
ldns_hash
enum ldns_enum_hash ldns_hash
Definition: keys.h:84
ldns_schwartzian_compare_struct::original_object
void * original_object
Definition: util.h:145
ldns_struct_rr::_rr_class
ldns_rr_class _rr_class
Class of the resource record.
Definition: rr.h:313
LDNS_RR_TYPE_HIP
@ LDNS_RR_TYPE_HIP
Definition: rr.h:185
LDNS_RDF_TYPE_INT32
@ LDNS_RDF_TYPE_INT32
32 bits
Definition: rdata.h:56
LDNS_STATUS_SYNTAX_ORIGIN
@ LDNS_STATUS_SYNTAX_ORIGIN
Definition: error.h:89
ldns_get_rr_type_by_name
ldns_rr_type ldns_get_rr_type_by_name(const char *name)
retrieves a rrtype by looking up its name.
Definition: rr.c:2630
LDNS_RR_TYPE_NINFO
@ LDNS_RR_TYPE_NINFO
draft-reid-dnsext-zs
Definition: rr.h:188
LDNS_STATUS_SYNTAX_TYPE_ERR
@ LDNS_STATUS_SYNTAX_TYPE_ERR
Definition: error.h:79
ldns_struct_rr_descriptor::_maximum
uint8_t _maximum
Maximum number of rdata fields in the RRs of this type.
Definition: rr.h:352
LDNS_RDF_TYPE_BITMAP
@ LDNS_RDF_TYPE_BITMAP
Definition: rdata.h:143
LDNS_RR_TYPE_AVC
@ LDNS_RR_TYPE_AVC
Definition: rr.h:225
LDNS_RR_TYPE_APL
@ LDNS_RR_TYPE_APL
RFC3123.
Definition: rr.h:165
ldns_struct_rr
Resource Record.
Definition: rr.h:302
ldns_rdf_bitmap_known_rr_types
ldns_status ldns_rdf_bitmap_known_rr_types(ldns_rdf **rdf)
Create a rr type bitmap rdf with at least all known (to ldns) rr types set.
Definition: rr.c:2563
LDNS_RR_TYPE_MF
@ LDNS_RR_TYPE_MF
a mail forwarder (Obsolete - use MX)
Definition: rr.h:89
LDNS_FREE
#define LDNS_FREE(ptr)
Definition: util.h:60
ldns_struct_rr_descriptor::_variable
ldns_rdf_type _variable
Special rdf types.
Definition: rr.h:356
ldns_bget_token
ssize_t ldns_bget_token(ldns_buffer *b, char *token, const char *delim, size_t limit)
returns a token/char from the buffer b.
Definition: parse.c:223
ldns_struct_lookup_table::id
int id
Definition: util.h:157
LDNS_RDF_TYPE_INT16
@ LDNS_RDF_TYPE_INT16
16 bits
Definition: rdata.h:54
LDNS_RR_TYPE_KX
@ LDNS_RR_TYPE_KX
RFC2230.
Definition: rr.h:153
ldns_rdf2rr_type
ldns_rr_type ldns_rdf2rr_type(const ldns_rdf *rd)
convert an rdf of type LDNS_RDF_TYPE_TYPE to an actual LDNS_RR_TYPE.
Definition: rr.c:2690
LDNS_RR_TYPE_MINFO
@ LDNS_RR_TYPE_MINFO
mailbox or mail list information
Definition: rr.h:109
LDNS_RR_TYPE_TALINK
@ LDNS_RR_TYPE_TALINK
draft-ietf-dnsop-trust-history
Definition: rr.h:192
LDNS_STATUS_OK
@ LDNS_STATUS_OK
Definition: error.h:26
LDNS_RR_TYPE_DHCID
@ LDNS_RR_TYPE_DHCID
Definition: rr.h:177
LDNS_TTL_DATALEN
#define LDNS_TTL_DATALEN
Definition: rr.c:20
ldns_rr_list_pop_rr
ldns_rr * ldns_rr_list_pop_rr(ldns_rr_list *rr_list)
pops the last rr from an rrlist.
Definition: rr.c:1166
ldns_str2period
uint32_t ldns_str2period(const char *nptr, const char **endptr)
converts a ttl value (like 5d2h) to a long.
Definition: rdata.c:685
ldns_struct_rr::_rd_count
size_t _rd_count
Number of data fields.
Definition: rr.h:309
ldns_rr_pop_rdf
ldns_rdf * ldns_rr_pop_rdf(ldns_rr *rr)
removes a rd_field member, it will be popped from the last position.
Definition: rr.c:869
LDNS_RDF_TYPE_NSAP
@ LDNS_RDF_TYPE_NSAP
NSAP.
Definition: rdata.h:103
ldns_rr_classes
ldns_lookup_table ldns_rr_classes[]
rr types
Definition: host2str.c:88
LDNS_RDF_TYPE_LOC
@ LDNS_RDF_TYPE_LOC
location data
Definition: rdata.h:99
LDNS_STATUS_SYNTAX_SUPERFLUOUS_TEXT_ERR
@ LDNS_STATUS_SYNTAX_SUPERFLUOUS_TEXT_ERR
Definition: error.h:130
LDNS_RDF_TYPE_TAG
@ LDNS_RDF_TYPE_TAG
A non-zero sequence of US-ASCII letters and numbers in lower case.
Definition: rdata.h:126
ldns_rr_list_push_rr
bool ldns_rr_list_push_rr(ldns_rr_list *rr_list, const ldns_rr *rr)
pushes an rr to an rrlist.
Definition: rr.c:1121
LDNS_RR_TYPE_SSHFP
@ LDNS_RR_TYPE_SSHFP
SSH Key Fingerprint.
Definition: rr.h:169
ldns_wire2rdf
ldns_status ldns_wire2rdf(ldns_rr *rr, const uint8_t *wire, size_t max, size_t *pos)
converts the data on the uint8_t bytearray (in wire format) to DNS rdata fields, and adds them to the...
Definition: wire2host.c:158
LDNS_RR_TYPE_HINFO
@ LDNS_RR_TYPE_HINFO
host information
Definition: rr.h:107
LDNS_RDF_TYPE_A
@ LDNS_RDF_TYPE_A
A record.
Definition: rdata.h:58
ldns_rdf_type
enum ldns_enum_rdf_type ldns_rdf_type
Definition: rdata.h:145
LDNS_RR_TYPE_NAPTR
@ LDNS_RR_TYPE_NAPTR
RFC2915.
Definition: rr.h:151
LDNS_RR_TYPE_L64
@ LDNS_RR_TYPE_L64
Definition: rr.h:207
LDNS_RDF_TYPE_NONE
@ LDNS_RDF_TYPE_NONE
none
Definition: rdata.h:48
ldns_struct_rr_list::_rr_capacity
size_t _rr_capacity
Definition: rr.h:333
LDNS_RR_TYPE_TSIG
@ LDNS_RR_TYPE_TSIG
Definition: rr.h:214
ldns_rr_set_ttl
void ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl)
sets the ttl in the rr structure.
Definition: rr.c:805
LDNS_RR_CLASS_IN
@ LDNS_RR_CLASS_IN
the Internet
Definition: rr.h:50
ldns_rr_set_class
void ldns_rr_set_class(ldns_rr *rr, ldns_rr_class rr_class)
sets the class in the rr.
Definition: rr.c:823
ldns_rr_set_question
void ldns_rr_set_question(ldns_rr *rr, bool question)
Definition: rr.c:799
ldns_rr_is_question
bool ldns_rr_is_question(const ldns_rr *rr)
returns the question flag of an rr structure.
Definition: rr.c:914
ldns_rr2buffer_wire
ldns_status ldns_rr2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr, int section)
Copies the rr data to the buffer in wire format.
Definition: host2wire.c:234
ldns_rr_set_pop_rr
ldns_rr * ldns_rr_set_pop_rr(ldns_rr_list *rr_list)
pops the last rr from an rrset.
Definition: rr.c:1330
LDNS_RDF_TYPE_CERT_ALG
@ LDNS_RDF_TYPE_CERT_ALG
certificate algorithm
Definition: rdata.h:78
ldns_rr_new
ldns_rr * ldns_rr_new(void)
creates a new rr structure.
Definition: rr.c:24
ldns_rr_list_deep_free
void ldns_rr_list_deep_free(ldns_rr_list *rr_list)
frees an rr_list structure and all rrs contained therein.
Definition: rr.c:1009
LDNS_RDF_TYPE_APL
@ LDNS_RDF_TYPE_APL
apl data
Definition: rdata.h:64
LDNS_RR_TYPE_OPT
@ LDNS_RR_TYPE_OPT
Pseudo OPT record...
Definition: rr.h:163
LDNS_RR_TYPE_SMIMEA
@ LDNS_RR_TYPE_SMIMEA
Definition: rr.h:183
LDNS_RR_TYPE_CDS
@ LDNS_RR_TYPE_CDS
Definition: rr.h:193
ldns_rr2canonical
void ldns_rr2canonical(ldns_rr *rr)
converts each dname in a rr to its canonical form.
Definition: rr.c:1769
ldns_dname_new_frm_str
ldns_rdf * ldns_dname_new_frm_str(const char *str)
creates a new dname rdf from a string.
Definition: dname.c:268
ldns_struct_rr_list::_rr_count
size_t _rr_count
Definition: rr.h:332
LDNS_RDF_TYPE_CERTIFICATE_USAGE
@ LDNS_RDF_TYPE_CERTIFICATE_USAGE
Since RFC7218 TLSA records can be given with mnemonics, hence these rdata field types.
Definition: rdata.h:138
LDNS_RR_TYPE_CDNSKEY
@ LDNS_RR_TYPE_CDNSKEY
Definition: rr.h:194
LDNS_RR_TYPE_NXT
@ LDNS_RR_TYPE_NXT
2535typecode
Definition: rr.h:141
ldns_rr_descriptor_field_type
ldns_rdf_type ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor, size_t index)
returns the rdf type for the given rdata field number of the rr type for the given descriptor.
Definition: rr.c:2616
LDNS_STATUS_SYNTAX_INCLUDE
@ LDNS_STATUS_SYNTAX_INCLUDE
Definition: error.h:90
LDNS_RR_TYPE_TA
@ LDNS_RR_TYPE_TA
DNSSEC Trust Authorities.
Definition: rr.h:228
ldns_schwartzian_compare_struct
Structure to do a Schwartzian-like transformation, for instance when sorting.
Definition: util.h:144
LDNS_RR_TYPE_WKS
@ LDNS_RR_TYPE_WKS
a well known service description
Definition: rr.h:103
LDNS_STATUS_SYNTAX_CLASS_ERR
@ LDNS_STATUS_SYNTAX_CLASS_ERR
Definition: error.h:80
ldns_rr_list_compare
int ldns_rr_list_compare(const ldns_rr_list *rrl1, const ldns_rr_list *rrl2)
compares two rr listss.
Definition: rr.c:1725
LDNS_RR_TYPE_NSEC3PARAM
@ LDNS_RR_TYPE_NSEC3PARAM
Definition: rr.h:180
LDNS_RR_TYPE_MR
@ LDNS_RR_TYPE_MR
a mail rename domain name (EXPERIMENTAL)
Definition: rr.h:99
ldns_rr_compare
int ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2)
compares two rrs.
Definition: rr.c:1626
LDNS_RR_TYPE_RP
@ LDNS_RR_TYPE_RP
RFC1183.
Definition: rr.h:115
ldns_rr_get_class
ldns_rr_class ldns_rr_get_class(const ldns_rr *rr)
returns the class of the rr.
Definition: rr.c:938
ldns_rr_free
void ldns_rr_free(ldns_rr *rr)
frees an RR structure
Definition: rr.c:75
ldns_rr_list_owner
ldns_rdf * ldns_rr_list_owner(const ldns_rr_list *rr_list)
Returns the owner domain name rdf of the first element of the RR If there are no elements present,...
Definition: rr.c:2717
ldns_rdf_new
ldns_rdf * ldns_rdf_new(ldns_rdf_type type, size_t size, void *data)
allocates a new rdf structure and fills it.
Definition: rdata.c:179
LDNS_RRLIST_INIT
#define LDNS_RRLIST_INIT
Definition: rr.c:21
LDNS_STATUS_SYNTAX_EMPTY
@ LDNS_STATUS_SYNTAX_EMPTY
Definition: error.h:91
LDNS_RR_TYPE_DS
@ LDNS_RR_TYPE_DS
RFC4034, RFC3658.
Definition: rr.h:167
LDNS_RR_TYPE_NULL
@ LDNS_RR_TYPE_NULL
a null RR (EXPERIMENTAL)
Definition: rr.h:101
ldns_rdf_set_type
void ldns_rdf_set_type(ldns_rdf *rd, ldns_rdf_type type)
sets the size of the rdf.
Definition: rdata.c:53
ldns_rr_list_push_rr_list
bool ldns_rr_list_push_rr_list(ldns_rr_list *rr_list, const ldns_rr_list *push_list)
pushes an rr_list to an rrlist.
Definition: rr.c:1152
ldns_rdf2native_int8
uint8_t ldns_rdf2native_int8(const ldns_rdf *rd)
returns the native uint8_t representation from the rdf.
Definition: rdata.c:70
LDNS_RDF_TYPE_ILNP64
@ LDNS_RDF_TYPE_ILNP64
4 shorts represented as 4 * 16 bit hex numbers separated by colons.
Definition: rdata.h:116
ldns_rdf_bitmap_known_rr_types_space
ldns_status ldns_rdf_bitmap_known_rr_types_space(ldns_rdf **rdf)
Create a rr type bitmap rdf providing enough space to set all known (to ldns) rr types.
Definition: rr.c:2557
LDNS_RR_TYPE_NSAP
@ LDNS_RR_TYPE_NSAP
RFC1706.
Definition: rr.h:125
ldns_rr_label_count
uint8_t ldns_rr_label_count(const ldns_rr *rr)
counts the number of labels of the ownername.
Definition: rr.c:1830
LDNS_RDF_TYPE_ATMA
@ LDNS_RDF_TYPE_ATMA
ATMA.
Definition: rdata.h:105
LDNS_RR_TYPE_NS
@ LDNS_RR_TYPE_NS
an authoritative name server
Definition: rr.h:85
LDNS_RR_TYPE_CAA
@ LDNS_RR_TYPE_CAA
Definition: rr.h:224
LDNS_RR_TYPE_EUI48
@ LDNS_RR_TYPE_EUI48
Definition: rr.h:210
ldns_rr_list_clone
ldns_rr_list * ldns_rr_list_clone(const ldns_rr_list *rrlist)
clones an rrlist.
Definition: rr.c:1419
ldns_rr_type
enum ldns_enum_rr_type ldns_rr_type
Definition: rr.h:239
ldns_buffer_free
void ldns_buffer_free(ldns_buffer *buffer)
frees the buffer.
Definition: buffer.c:137
LDNS_RR_TYPE_A6
@ LDNS_RR_TYPE_A6
RFC2874.
Definition: rr.h:157
LDNS_RR_TYPE_DLV
@ LDNS_RR_TYPE_DLV
Definition: rr.h:230
ldns_rr_list_cat
bool ldns_rr_list_cat(ldns_rr_list *left, const ldns_rr_list *right)
concatenates two ldns_rr_lists together.
Definition: rr.c:1025
LDNS_STATUS_SYNTAX_ERR
@ LDNS_STATUS_SYNTAX_ERR
Definition: error.h:97
LDNS_RR_TYPE_NIMLOC
@ LDNS_RR_TYPE_NIMLOC
draft-ietf-nimrod-dns-01.txt
Definition: rr.h:145
LDNS_RR_TYPE_SOA
@ LDNS_RR_TYPE_SOA
marks the start of a zone of authority
Definition: rr.h:93
ldns_rr_clone
ldns_rr * ldns_rr_clone(const ldns_rr *rr)
clones a rr and all its data
Definition: rr.c:1388
LDNS_RR_TYPE_MB
@ LDNS_RR_TYPE_MB
a mailbox domain name (EXPERIMENTAL)
Definition: rr.h:95
LDNS_PARSE_SKIP_SPACE
#define LDNS_PARSE_SKIP_SPACE
Definition: parse.h:20
ldns_rdf_compare
int ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2)
compares two rdf's on their wire formats.
Definition: rdata.c:651
ldns_lookup_by_name
ldns_lookup_table * ldns_lookup_by_name(ldns_lookup_table *table, const char *name)
Definition: util.c:30
LDNS_RR_TYPE_CERT
@ LDNS_RR_TYPE_CERT
RFC2538.
Definition: rr.h:155
ldns_rr_compare_wire
int ldns_rr_compare_wire(const ldns_buffer *rr1_buf, const ldns_buffer *rr2_buf)
compares the wireformat of two rrs, contained in the given buffers.
Definition: rr.c:1588
ldns_rdf_deep_free
void ldns_rdf_deep_free(ldns_rdf *rd)
frees a rdf structure and frees the data.
Definition: rdata.c:230
ldns_dname2canonical
void ldns_dname2canonical(const ldns_rdf *rd)
Put a dname into canonical fmt - ie.
Definition: dname.c:280
ldns_rdf_clone
ldns_rdf * ldns_rdf_clone(const ldns_rdf *rd)
clones a rdf structure.
Definition: rdata.c:222
LDNS_RR_NO_COMPRESS
@ LDNS_RR_NO_COMPRESS
Definition: rr.h:73
LDNS_RDATA_FIELD_DESCRIPTORS_COMMON
#define LDNS_RDATA_FIELD_DESCRIPTORS_COMMON
Definition: rr.h:40
LDNS_MALLOC
#define LDNS_MALLOC(type)
Memory management macros.
Definition: util.h:49
LDNS_RR_TYPE_DNAME
@ LDNS_RR_TYPE_DNAME
RFC2672.
Definition: rr.h:159
LDNS_RR_TYPE_GPOS
@ LDNS_RR_TYPE_GPOS
RFC1712.
Definition: rr.h:135
LDNS_RDF_TYPE_TSIGTIME
@ LDNS_RDF_TYPE_TSIGTIME
tsig time 48 bits
Definition: rdata.h:88
ldns_rr_new_frm_type
ldns_rr * ldns_rr_new_frm_type(ldns_rr_type t)
creates a new rr structure, based on the given type.
Definition: rr.c:42
LDNS_RDF_TYPE_HIP
@ LDNS_RDF_TYPE_HIP
Represents the Public Key Algorithm, HIT and Public Key fields for the HIP RR types.
Definition: rdata.h:92
ldns_rr_set_owner
void ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner)
sets the owner in the rr structure.
Definition: rr.c:793
ldns_rr_list_sort
void ldns_rr_list_sort(ldns_rr_list *unsorted)
sorts an rr_list (canonical wire format).
Definition: rr.c:1504
ldns_rr_list_contains_rr
bool ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, const ldns_rr *rr)
returns true if the given rr is one of the rrs in the list, or if it is equal to one
Definition: rr.c:1228
LDNS_RR_TYPE_RT
@ LDNS_RR_TYPE_RT
RFC1183.
Definition: rr.h:123
ldns_status
enum ldns_enum_status ldns_status
Definition: error.h:134
LDNS_RDF_TYPE_B64
@ LDNS_RDF_TYPE_B64
b64 string
Definition: rdata.h:68
ldns_dname_str_absolute
bool ldns_dname_str_absolute(const char *dname_str)
Checks whether the given dname string is absolute (i.e.
Definition: dname.c:518
LDNS_RDF_TYPE_LONG_STR
@ LDNS_RDF_TYPE_LONG_STR
A <character-string> encoding of the value field as specified [RFC1035], Section 5....
Definition: rdata.h:132
LDNS_XMALLOC
#define LDNS_XMALLOC(type, count)
Definition: util.h:51
ldns_struct_rr_descriptor::_name
const char * _name
Textual name of the RR type.
Definition: rr.h:348
LDNS_RDF_TYPE_DNAME
@ LDNS_RDF_TYPE_DNAME
domain name
Definition: rdata.h:50
INLINE
#define INLINE
splint static inline workaround
Definition: util.h:42
ldns_struct_lookup_table
A general purpose lookup table.
Definition: util.h:156
LDNS_RR_TYPE_SPF
@ LDNS_RR_TYPE_SPF
Definition: rr.h:198
config.h
LDNS_SECTION_ANY
@ LDNS_SECTION_ANY
bogus section, if not interested
Definition: packet.h:280
LDNS_RDF_TYPE_EUI64
@ LDNS_RDF_TYPE_EUI64
8 * 8 bit hex numbers separated by dashes.
Definition: rdata.h:121
ldns_rr_list_cat_clone
ldns_rr_list * ldns_rr_list_cat_clone(const ldns_rr_list *left, const ldns_rr_list *right)
concatenates two ldns_rr_lists together, but makes clones of the rr's (instead of pointer copying).
Definition: rr.c:1048
ldns_rr_rd_count
size_t ldns_rr_rd_count(const ldns_rr *rr)
returns the rd_count of an rr structure.
Definition: rr.c:926
LDNS_RDF_TYPE_EUI48
@ LDNS_RDF_TYPE_EUI48
6 * 8 bit hex numbers separated by dashes.
Definition: rdata.h:119
LDNS_RDF_TYPE_NSEC3_NEXT_OWNER
@ LDNS_RDF_TYPE_NSEC3_NEXT_OWNER
nsec3 base32 string (with length byte on wire
Definition: rdata.h:111
LDNS_RDF_TYPE_WKS
@ LDNS_RDF_TYPE_WKS
well known services
Definition: rdata.h:101
LDNS_RR_TYPE_PX
@ LDNS_RR_TYPE_PX
RFC2163.
Definition: rr.h:133
ldns_rr_new_question_frm_str
ldns_status ldns_rr_new_question_frm_str(ldns_rr **newrr, const char *str, const ldns_rdf *origin, ldns_rdf **prev)
creates an rr for the question section from a string, i.e.
Definition: rr.c:675
ldns_struct_rdf
Resource record data field.
Definition: rdata.h:174
LDNS_STATUS_SYNTAX_DNAME_ERR
@ LDNS_STATUS_SYNTAX_DNAME_ERR
Definition: error.h:84
ldns_rr_compare_ds
bool ldns_rr_compare_ds(const ldns_rr *orr1, const ldns_rr *orr2)
returns true of the given rr's are equal.
Definition: rr.c:1698
ldns_rdf2native_int16
uint16_t ldns_rdf2native_int16(const ldns_rdf *rd)
returns the native uint16_t representation from the rdf.
Definition: rdata.c:84
ldns_struct_rr::_ttl
uint32_t _ttl
Time to live
Definition: rr.h:307
LDNS_MAX_RDFLEN
#define LDNS_MAX_RDFLEN
Definition: rdata.h:31
LDNS_RR_TYPE_OPENPGPKEY
@ LDNS_RR_TYPE_OPENPGPKEY
Definition: rr.h:195
ldns_struct_rr_descriptor
Contains all information about resource record types.
Definition: rr.h:343
ldns_dname_cat
ldns_status ldns_dname_cat(ldns_rdf *rd1, const ldns_rdf *rd2)
concatenates rd2 after rd1 (rd2 is copied, rd1 is modified)
Definition: dname.c:90
ldns_rr_ttl
uint32_t ldns_rr_ttl(const ldns_rr *rr)
returns the ttl of an rr structure.
Definition: rr.c:920
LDNS_RR_TYPE_TLSA
@ LDNS_RR_TYPE_TLSA
Definition: rr.h:182
LDNS_RR_TYPE_SINK
@ LDNS_RR_TYPE_SINK
dnsind-kitchen-sink-02.txt
Definition: rr.h:161
LDNS_RDF_TYPE_INT8
@ LDNS_RDF_TYPE_INT8
8 bits
Definition: rdata.h:52
ldns_rr_list_type
ldns_rr_type ldns_rr_list_type(const ldns_rr_list *rr_list)
Returns the type of the first element of the RR If there are no elements present, 0 is returned.
Definition: rr.c:2707
ldns_rdf_data
uint8_t * ldns_rdf_data(const ldns_rdf *rd)
returns the data of the rdf.
Definition: rdata.c:38
LDNS_RDF_TYPE_UNKNOWN
@ LDNS_RDF_TYPE_UNKNOWN
unknown types
Definition: rdata.h:82
LDNS_MAX_LINELEN
#define LDNS_MAX_LINELEN
Definition: parse.h:23
ldns_struct_rr_descriptor::_type
ldns_rr_type _type
Type of the RR that is described here.
Definition: rr.h:346
ldns_rr_new_frm_str
ldns_status ldns_rr_new_frm_str(ldns_rr **newrr, const char *str, uint32_t default_ttl, const ldns_rdf *origin, ldns_rdf **prev)
creates an rr from a string.
Definition: rr.c:662
LDNS_RDF_TYPE_SELECTOR
@ LDNS_RDF_TYPE_SELECTOR
Definition: rdata.h:139
LDNS_RDF_TYPE_PERIOD
@ LDNS_RDF_TYPE_PERIOD
period
Definition: rdata.h:86
ldns_struct_rr::_owner
ldns_rdf * _owner
Owner name, uncompressed.
Definition: rr.h:305
LDNS_RDF_TYPE_INT16_DATA
@ LDNS_RDF_TYPE_INT16_DATA
variable length any type rdata where the length is specified by the first 2 bytes
Definition: rdata.h:95
LDNS_RDF_TYPE_STR
@ LDNS_RDF_TYPE_STR
txt string
Definition: rdata.h:62
LDNS_SYNTAX_DATALEN
#define LDNS_SYNTAX_DATALEN
Definition: rr.c:19
ldns.h
ldns_key_rr2ds
ldns_rr * ldns_key_rr2ds(const ldns_rr *key, ldns_hash h)
returns a new DS rr that represents the given key rr.
Definition: dnssec.c:501
ldns_rr_push_rdf
bool ldns_rr_push_rdf(ldns_rr *rr, const ldns_rdf *f)
sets rd_field member, it will be placed in the next available spot.
Definition: rr.c:846
ldns_dname_label_count
uint8_t ldns_dname_label_count(const ldns_rdf *r)
count the number of labels inside a LDNS_RDF_DNAME type rdf.
Definition: dname.c:214
ldns_rr_descriptor_maximum
size_t ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor)
returns the maximum number of rdata fields of the rr type this descriptor describes.
Definition: rr.c:2601
LDNS_DEFAULT_TTL
#define LDNS_DEFAULT_TTL
Definition: ldns.h:135
LDNS_RDF_TYPE_IPSECKEY
@ LDNS_RDF_TYPE_IPSECKEY
IPSECKEY.
Definition: rdata.h:107
LDNS_RR_TYPE_LOC
@ LDNS_RR_TYPE_LOC
LOC record RFC1876.
Definition: rr.h:139
ldns_rr_list_new
ldns_rr_list * ldns_rr_list_new(void)
creates a new rr_list structure.
Definition: rr.c:989
ldns_rr_set_push_rr
bool ldns_rr_set_push_rr(ldns_rr_list *rr_list, ldns_rr *rr)
pushes an rr to an rrset (which really are rr_list's).
Definition: rr.c:1282
LDNS_RR_TYPE_RRSIG
@ LDNS_RR_TYPE_RRSIG
DNSSEC.
Definition: rr.h:173
LDNS_RDF_TYPE_NSEC
@ LDNS_RDF_TYPE_NSEC
nsec type codes
Definition: rdata.h:72
LDNS_RR_TYPE_AFSDB
@ LDNS_RR_TYPE_AFSDB
RFC1183.
Definition: rr.h:117
LDNS_RR_TYPE_A
@ LDNS_RR_TYPE_A
a host address
Definition: rr.h:83
ldns_rr_list_set_rr_count
void ldns_rr_list_set_rr_count(ldns_rr_list *rr_list, size_t count)
sets the number of rr's in an rr_list.
Definition: rr.c:972
ldns_struct_buffer::_data
uint8_t * _data
The data contained in the buffer.
Definition: buffer.h:62
LDNS_RR_TYPE_URI
@ LDNS_RR_TYPE_URI
Definition: rr.h:223
LDNS_RR_TYPE_SRV
@ LDNS_RR_TYPE_SRV
SRV record RFC2782.
Definition: rr.h:147
ldns_rr_set_rdf
ldns_rdf * ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position)
sets a rdf member, it will be set on the position given.
Definition: rr.c:829
ldns_rr_list2canonical
void ldns_rr_list2canonical(const ldns_rr_list *rr_list)
converts each dname in each rr in a rr_list to its canonical form.
Definition: rr.c:1821
ldns_rr_new_frm_fp
ldns_status ldns_rr_new_frm_fp(ldns_rr **newrr, FILE *fp, uint32_t *ttl, ldns_rdf **origin, ldns_rdf **prev)
creates a new rr from a file containing a string.
Definition: rr.c:703
ldns_rdf_new_frm_str
ldns_rdf * ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str)
creates a new rdf from a string.
Definition: rdata.c:249
LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR
@ LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR
Definition: error.h:93
ldns_is_rrset
bool ldns_is_rrset(const ldns_rr_list *rr_list)
checks if an rr_list is a rrset.
Definition: rr.c:1247
LDNS_STATUS_SYNTAX_TTL
@ LDNS_STATUS_SYNTAX_TTL
Definition: error.h:88
LDNS_STATUS_SYNTAX_TTL_ERR
@ LDNS_STATUS_SYNTAX_TTL_ERR
Definition: error.h:81
ldns_struct_rr::_rdata_fields
ldns_rdf ** _rdata_fields
The array of rdata's.
Definition: rr.h:316
ldns_dname_compare
int ldns_dname_compare(const ldns_rdf *dname1, const ldns_rdf *dname2)
Compares the two dname rdf's according to the algorithm for ordering in RFC4034 Section 6.
Definition: dname.c:359
LDNS_RR_TYPE_EID
@ LDNS_RR_TYPE_EID
draft-ietf-nimrod-dns-01.txt
Definition: rr.h:143
LDNS_RR_TYPE_MD
@ LDNS_RR_TYPE_MD
a mail destination (Obsolete - use MX)
Definition: rr.h:87
ldns_rr_list_rr
ldns_rr * ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr)
returns a specific rr of an rrlist.
Definition: rr.c:979
LDNS_RR_COMPRESS
@ LDNS_RR_COMPRESS
compression is allowed
Definition: rr.h:72
LDNS_STATUS_MEM_ERR
@ LDNS_STATUS_MEM_ERR
Definition: error.h:34
LDNS_RR_TYPE_DNSKEY
@ LDNS_RR_TYPE_DNSKEY
Definition: rr.h:175
ldns_rr2buffer_wire_canonical
ldns_status ldns_rr2buffer_wire_canonical(ldns_buffer *buffer, const ldns_rr *rr, int section)
Copies the rr data to the buffer in wire format, in canonical format according to RFC3597 (every dnam...
Definition: host2wire.c:161
LDNS_RDF_TYPE_AAAA
@ LDNS_RDF_TYPE_AAAA
AAAA record.
Definition: rdata.h:60
ldns_rr_list_free
void ldns_rr_list_free(ldns_rr_list *rr_list)
frees an rr_list structure.
Definition: rr.c:1000
LDNS_RR_TYPE_NSEC
@ LDNS_RR_TYPE_NSEC
Definition: rr.h:174
LDNS_RR_TYPE_ATMA
@ LDNS_RR_TYPE_ATMA
http://www.jhsoft.com/rfc/af-saa-0069.000.rtf
Definition: rr.h:149
ldns_struct_rr_list::_rrs
ldns_rr ** _rrs
Definition: rr.h:334
LDNS_RR_TYPE_PTR
@ LDNS_RR_TYPE_PTR
a domain name pointer
Definition: rr.h:105
ldns_struct_rr_descriptor::_wireformat
const ldns_rdf_type * _wireformat
Wireformat specification for the rr, i.e.
Definition: rr.h:354
ldns_rr_descriptor_minimum
size_t ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor)
returns the minimum number of rdata fields of the rr type this descriptor describes.
Definition: rr.c:2591
LDNS_STATUS_SYNTAX_RDATA_ERR
@ LDNS_STATUS_SYNTAX_RDATA_ERR
Definition: error.h:83
LDNS_RR_TYPE_X25
@ LDNS_RR_TYPE_X25
RFC1183.
Definition: rr.h:119
LDNS_RDF_TYPE_NSEC3_SALT
@ LDNS_RDF_TYPE_NSEC3_SALT
nsec3 hash salt
Definition: rdata.h:109
LDNS_RDF_TYPE_TYPE
@ LDNS_RDF_TYPE_TYPE
a RR type
Definition: rdata.h:74
LDNS_RR_TYPE_KEY
@ LDNS_RR_TYPE_KEY
2535typecode
Definition: rr.h:131
LDNS_RR_TYPE_IPSECKEY
@ LDNS_RR_TYPE_IPSECKEY
IPsec Key.
Definition: rr.h:171
ldns_rr_uncompressed_size
size_t ldns_rr_uncompressed_size(const ldns_rr *r)
calculates the uncompressed size of an RR.
Definition: rr.c:1752
ldns_rdf_get_type
ldns_rdf_type ldns_rdf_get_type(const ldns_rdf *rd)
returns the type of the rdf.
Definition: rdata.c:31
LDNS_RR_TYPE_MX
@ LDNS_RR_TYPE_MX
mail exchange
Definition: rr.h:111
LDNS_RR_TYPE_CSYNC
@ LDNS_RR_TYPE_CSYNC
Definition: rr.h:196
ldns_struct_rr::_rr_question
signed char _rr_question
question rr [it would be nicer if thous is after _rd_count] ABI change: Fix this in next major releas...
Definition: rr.h:320
ldns_rr_descript
const ldns_rr_descriptor * ldns_rr_descript(uint16_t type)
returns the resource record descriptor for the given rr type.
Definition: rr.c:2572
ldns_rr_owner
ldns_rdf * ldns_rr_owner(const ldns_rr *rr)
returns the owner name of an rr structure.
Definition: rr.c:908
LDNS_RR_TYPE_ISDN
@ LDNS_RR_TYPE_ISDN
RFC1183.
Definition: rr.h:121
ldns_rr_set_type
void ldns_rr_set_type(ldns_rr *rr, ldns_rr_type rr_type)
sets the type in the rr.
Definition: rr.c:817
LDNS_RR_TYPE_LP
@ LDNS_RR_TYPE_LP
Definition: rr.h:208
LDNS_RDF_TYPE_TIME
@ LDNS_RDF_TYPE_TIME
time (32 bits)
Definition: rdata.h:84
LDNS_RR_TYPE_NSEC3
@ LDNS_RR_TYPE_NSEC3
Definition: rr.h:179
LDNS_MAX_DOMAINLEN
#define LDNS_MAX_DOMAINLEN
Maximum length of a complete dname.
Definition: rr.h:33
LDNS_RDATA_FIELD_DESCRIPTORS_COUNT
#define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT
Definition: rr.c:2449
LDNS_RR_TYPE_TXT
@ LDNS_RR_TYPE_TXT
text strings
Definition: rr.h:113
LDNS_RR_TYPE_TKEY
@ LDNS_RR_TYPE_TKEY
Definition: rr.h:213
LDNS_RR_TYPE_SIG
@ LDNS_RR_TYPE_SIG
2535typecode
Definition: rr.h:129
ldns_struct_rr_descriptor::_minimum
uint8_t _minimum
Minimum number of rdata fields in the RRs of this type.
Definition: rr.h:350
ldns_rr_list_set_rr
ldns_rr * ldns_rr_list_set_rr(ldns_rr_list *rr_list, const ldns_rr *r, size_t count)
set a rr on a specific index in a ldns_rr_list
Definition: rr.c:956
LDNS_RR_TYPE_AAAA
@ LDNS_RR_TYPE_AAAA
ipv6 address
Definition: rr.h:137
ldns_rr_set_rd_count
void ldns_rr_set_rd_count(ldns_rr *rr, size_t count)
sets the rd_count in the rr.
Definition: rr.c:811
LDNS_RR_TYPE_NSAP_PTR
@ LDNS_RR_TYPE_NSAP_PTR
RFC1348.
Definition: rr.h:127
LDNS_RR_TYPE_NID
@ LDNS_RR_TYPE_NID
Definition: rr.h:205
ldns_rr_list_pop_rrset
ldns_rr_list * ldns_rr_list_pop_rrset(ldns_rr_list *rr_list)
pops the first rrset from the list, the list must be sorted, so that all rr's from each rrset are nex...
Definition: rr.c:1336
ldns_rr_compare_no_rdata
int ldns_rr_compare_no_rdata(const ldns_rr *rr1, const ldns_rr *rr2)
compares two rrs, up to the rdata.
Definition: rr.c:1547
ldns_get_rr_class_by_name
ldns_rr_class ldns_get_rr_class_by_name(const char *name)
retrieves a class by looking up its name.
Definition: rr.c:2670
ldns_buffer_new_frm_data
void ldns_buffer_new_frm_data(ldns_buffer *buffer, const void *data, size_t size)
creates a buffer with the specified data.
Definition: buffer.c:41
ldns_rr_new_frm_fp_l
ldns_status ldns_rr_new_frm_fp_l(ldns_rr **newrr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev, int *line_nr)
creates a new rr from a file containing a string.
Definition: rr.c:709
LDNS_RDF_TYPE_ALG
@ LDNS_RDF_TYPE_ALG
a key algorithm
Definition: rdata.h:80
LDNS_RR_TYPE_RKEY
@ LDNS_RR_TYPE_RKEY
draft-reid-dnsext-rkey
Definition: rr.h:190
LDNS_RR_TYPE_MG
@ LDNS_RR_TYPE_MG
a mail group member (EXPERIMENTAL)
Definition: rr.h:97
LDNS_RR_TYPE_CNAME
@ LDNS_RR_TYPE_CNAME
the canonical name for an alias
Definition: rr.h:91
ldns_struct_rr::_rr_type
ldns_rr_type _rr_type
the type of the RR.
Definition: rr.h:311
ldns_rr_get_type
ldns_rr_type ldns_rr_get_type(const ldns_rr *rr)
returns the type of the rr.
Definition: rr.c:932
ldns_rr_list_rr_count
size_t ldns_rr_list_rr_count(const ldns_rr_list *rr_list)
returns the number of rr's in an rr_list.
Definition: rr.c:946
ldns_fget_token_l
ssize_t ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr)
returns a token/char from the stream F.
Definition: parse.c:31