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