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