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 
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 
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 /*
91  * trailing spaces are allowed
92  * leading spaces are not allowed
93  * allow ttl to be optional
94  * class is optional too
95  * if ttl is missing, and default_ttl is 0, use DEF_TTL
96  * allow ttl to be written as 1d3h
97  * So the RR should look like. e.g.
98  * miek.nl. 3600 IN MX 10 elektron.atoom.net
99  * or
100  * miek.nl. 1h IN MX 10 elektron.atoom.net
101  * or
102  * miek.nl. IN MX 10 elektron.atoom.net
103  */
104 static ldns_status
105 ldns_rr_new_frm_str_internal(ldns_rr **newrr, const char *str,
106  uint32_t default_ttl, ldns_rdf *origin,
107  ldns_rdf **prev, bool question)
108 {
109  ldns_rr *new;
110  const ldns_rr_descriptor *desc;
111  ldns_rr_type rr_type;
112  ldns_buffer *rr_buf = NULL;
113  ldns_buffer *rd_buf = NULL;
114  uint32_t ttl_val;
115  char *owner = NULL;
116  char *ttl = NULL;
117  ldns_rr_class clas_val;
118  char *clas = NULL;
119  char *type = NULL;
120  char *rdata = NULL;
121  char *rd = NULL;
122  char * b64 = NULL;
123  size_t rd_strlen;
124  const char *delimiters;
125  ssize_t c;
126  ldns_rdf *owner_dname;
127  const char* endptr;
128  int was_unknown_rr_format = 0;
129  ldns_status status = LDNS_STATUS_OK;
130 
131  /* used for types with unknown number of rdatas */
132  bool done;
133  bool quoted;
134 
135  ldns_rdf *r = NULL;
136  uint16_t r_cnt;
137  uint16_t r_min;
138  uint16_t r_max;
139  size_t pre_data_pos;
140 
141  new = ldns_rr_new();
142 
143  owner = LDNS_XMALLOC(char, LDNS_MAX_DOMAINLEN + 1);
144  ttl = LDNS_XMALLOC(char, LDNS_TTL_DATALEN);
145  clas = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN);
146  rdata = LDNS_XMALLOC(char, LDNS_MAX_PACKETLEN + 1);
147  rr_buf = LDNS_MALLOC(ldns_buffer);
148  rd_buf = LDNS_MALLOC(ldns_buffer);
149  rd = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
150  b64 = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
151  if (!new || !owner || !ttl || !clas || !rdata || !rr_buf || !rd_buf || !rd || !b64 ) {
152  status = LDNS_STATUS_MEM_ERR;
153  LDNS_FREE(rr_buf);
154  goto ldnserror;
155  }
156 
157  ldns_buffer_new_frm_data(rr_buf, (char*)str, strlen(str));
158 
159  /* split the rr in its parts -1 signals trouble */
160  if (ldns_bget_token(rr_buf, owner, "\t\n ", LDNS_MAX_DOMAINLEN) == -1) {
161  status = LDNS_STATUS_SYNTAX_ERR;
162  ldns_buffer_free(rr_buf);
163  goto ldnserror;
164  }
165 
166  if (ldns_bget_token(rr_buf, ttl, "\t\n ", LDNS_TTL_DATALEN) == -1) {
168  ldns_buffer_free(rr_buf);
169  goto ldnserror;
170  }
171  ttl_val = (uint32_t) ldns_str2period(ttl, &endptr);
172 
173  if (strlen(ttl) > 0 && !isdigit((int) ttl[0])) {
174  /* ah, it's not there or something */
175  if (default_ttl == 0) {
176  ttl_val = LDNS_DEFAULT_TTL;
177  } else {
178  ttl_val = default_ttl;
179  }
180  /* we not ASSUMING the TTL is missing and that
181  * the rest of the RR is still there. That is
182  * CLASS TYPE RDATA
183  * so ttl value we read is actually the class
184  */
185  clas_val = ldns_get_rr_class_by_name(ttl);
186  /* class can be left out too, assume IN, current
187  * token must be type
188  */
189  if (clas_val == 0) {
190  clas_val = LDNS_RR_CLASS_IN;
191  type = LDNS_XMALLOC(char, strlen(ttl) + 1);
192  if(!type) {
193  status = LDNS_STATUS_MEM_ERR;
194  ldns_buffer_free(rr_buf);
195  goto ldnserror;
196  }
197  strncpy(type, ttl, strlen(ttl) + 1);
198  }
199  } else {
200  if (ldns_bget_token(rr_buf, clas, "\t\n ", LDNS_SYNTAX_DATALEN) == -1) {
202  ldns_buffer_free(rr_buf);
203  goto ldnserror;
204  }
205  clas_val = ldns_get_rr_class_by_name(clas);
206  /* class can be left out too, assume IN, current
207  * token must be type
208  */
209  if (clas_val == 0) {
210  clas_val = LDNS_RR_CLASS_IN;
211  type = LDNS_XMALLOC(char, strlen(clas) + 1);
212  if(!type) {
213  status = LDNS_STATUS_MEM_ERR;
214  ldns_buffer_free(rr_buf);
215  goto ldnserror;
216  }
217  strncpy(type, clas, strlen(clas) + 1);
218  }
219  }
220  /* the rest should still be waiting for us */
221 
222  if (!type) {
223  type = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN);
224  if(!type) {
225  status = LDNS_STATUS_MEM_ERR;
226  ldns_buffer_free(rr_buf);
227  goto ldnserror;
228  }
229  if (ldns_bget_token(rr_buf, type, "\t\n ", LDNS_SYNTAX_DATALEN) == -1) {
231  ldns_buffer_free(rr_buf);
232  goto ldnserror;
233  }
234  }
235 
236  if (ldns_bget_token(rr_buf, rdata, "\0", LDNS_MAX_PACKETLEN) == -1) {
237  /* apparently we are done, and it's only a question RR
238  * so do not set status and go to ldnserror here
239  */
240  }
241 
242  ldns_buffer_new_frm_data(rd_buf, rdata, strlen(rdata));
243 
244  if (strlen(owner) <= 1 && strncmp(owner, "@", 1) == 0) {
245  if (origin) {
246  ldns_rr_set_owner(new, ldns_rdf_clone(origin));
247  } else if (prev && *prev) {
248  ldns_rr_set_owner(new, ldns_rdf_clone(*prev));
249  } else {
250  /* default to root */
252  }
253 
254  /* @ also overrides prev */
255  if (prev) {
256  ldns_rdf_deep_free(*prev);
257  *prev = ldns_rdf_clone(ldns_rr_owner(new));
258  if (!*prev) {
259  status = LDNS_STATUS_MEM_ERR;
260  ldns_buffer_free(rr_buf);
261  goto ldnserror;
262  }
263  }
264  } else {
265  if (strlen(owner) == 0) {
266  /* no ownername was given, try prev, if that fails
267  * origin, else default to root */
268  if (prev && *prev) {
269  ldns_rr_set_owner(new, ldns_rdf_clone(*prev));
270  } else if (origin) {
271  ldns_rr_set_owner(new, ldns_rdf_clone(origin));
272  } else {
274  }
275  if(!ldns_rr_owner(new)) {
276  status = LDNS_STATUS_MEM_ERR;
277  ldns_buffer_free(rr_buf);
278  goto ldnserror;
279  }
280  } else {
281  owner_dname = ldns_dname_new_frm_str(owner);
282  if (!owner_dname) {
283  status = LDNS_STATUS_SYNTAX_ERR;
284  ldns_buffer_free(rr_buf);
285  goto ldnserror;
286  }
287 
288  ldns_rr_set_owner(new, owner_dname);
289  if (!ldns_dname_str_absolute(owner) && origin) {
291  origin) != LDNS_STATUS_OK) {
292  status = LDNS_STATUS_SYNTAX_ERR;
293  ldns_buffer_free(rr_buf);
294  goto ldnserror;
295  }
296  }
297  if (prev) {
298  ldns_rdf_deep_free(*prev);
299  *prev = ldns_rdf_clone(ldns_rr_owner(new));
300  if(!*prev) {
301  status = LDNS_STATUS_MEM_ERR;
302  ldns_buffer_free(rr_buf);
303  goto ldnserror;
304  }
305  }
306  }
307  }
308  LDNS_FREE(owner);
309  owner = NULL;
310 
311  ldns_rr_set_question(new, question);
312 
313  ldns_rr_set_ttl(new, ttl_val);
314  LDNS_FREE(ttl);
315  ttl = NULL;
316 
317  ldns_rr_set_class(new, clas_val);
318  LDNS_FREE(clas);
319  clas = NULL;
320 
321  rr_type = ldns_get_rr_type_by_name(type);
322  LDNS_FREE(type);
323  type = NULL;
324 
325  desc = ldns_rr_descript((uint16_t)rr_type);
326  ldns_rr_set_type(new, rr_type);
327  if (desc) {
328  /* only the rdata remains */
329  r_max = ldns_rr_descriptor_maximum(desc);
330  r_min = ldns_rr_descriptor_minimum(desc);
331  } else {
332  r_min = 0;
333  r_max = 1;
334  }
335 
336  /* depending on the rr_type we need to extract
337  * the rdata differently, e.g. NSEC/NSEC3 */
338  switch(rr_type) {
339  default:
340  done = false;
341 
342  for (r_cnt = 0; !done && r_cnt < r_max; r_cnt++) {
343  quoted = false;
344  /* if type = B64, the field may contain spaces */
346  r_cnt) == LDNS_RDF_TYPE_B64 ||
348  r_cnt) == LDNS_RDF_TYPE_HEX ||
350  r_cnt) == LDNS_RDF_TYPE_LOC ||
352  r_cnt) == LDNS_RDF_TYPE_WKS ||
354  r_cnt) == LDNS_RDF_TYPE_IPSECKEY ||
356  r_cnt) == LDNS_RDF_TYPE_NSEC) {
357  delimiters = "\n\t";
358  } else {
359  delimiters = "\n\t ";
360  }
361 
363  r_cnt) == LDNS_RDF_TYPE_STR &&
364  ldns_buffer_remaining(rd_buf) > 0) {
365  /* skip spaces */
366  while (*(ldns_buffer_current(rd_buf)) == ' ') {
367  ldns_buffer_skip(rd_buf, 1);
368  }
369 
370  if (*(ldns_buffer_current(rd_buf)) == '\"') {
371  delimiters = "\"\0";
372  ldns_buffer_skip(rd_buf, 1);
373  quoted = true;
374  }
375  }
376 
377  /* because number of fields can be variable, we can't
378  rely on _maximum() only */
379  /* skip spaces */
380  while (ldns_buffer_position(rd_buf) < ldns_buffer_limit(rd_buf) &&
381  *(ldns_buffer_current(rd_buf)) == ' ' && !quoted
382  ) {
383  ldns_buffer_skip(rd_buf, 1);
384  }
385 
386  pre_data_pos = ldns_buffer_position(rd_buf);
387  if ((c = ldns_bget_token(rd_buf, rd, delimiters,
388  LDNS_MAX_RDFLEN)) != -1) {
389  /* hmmz, rfc3597 specifies that any type can be represented with
390  * \# method, which can contain spaces...
391  * it does specify size though...
392  */
393  rd_strlen = strlen(rd);
394 
395  /* unknown RR data */
396  if (strncmp(rd, "\\#", 2) == 0 && !quoted && (rd_strlen == 2 || rd[2]==' ')) {
397  uint16_t hex_data_size;
398  char *hex_data_str;
399  uint16_t cur_hex_data_size;
400 
401  was_unknown_rr_format = 1;
402  /* go back to before \# and skip it while setting delimiters better */
403  ldns_buffer_set_position(rd_buf, pre_data_pos);
404  delimiters = "\n\t ";
405  (void)ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN);
406  /* read rdata octet length */
407  c = ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN);
408  if (c == -1) {
409  /* something goes very wrong here */
410  LDNS_FREE(rd);
411  LDNS_FREE(b64);
412  ldns_buffer_free(rd_buf);
413  ldns_buffer_free(rr_buf);
414  LDNS_FREE(rdata);
415  ldns_rr_free(new);
417  }
418  hex_data_size = (uint16_t) atoi(rd);
419  /* copy the hex chars into hex str (which is 2 chars per byte) */
420  hex_data_str = LDNS_XMALLOC(char, 2 * hex_data_size + 1);
421  if (!hex_data_str) {
422  /* malloc error */
423  LDNS_FREE(rd);
424  LDNS_FREE(b64);
425  ldns_buffer_free(rd_buf);
426  ldns_buffer_free(rr_buf);
427  LDNS_FREE(rdata);
428  ldns_rr_free(new);
430  }
431  cur_hex_data_size = 0;
432  while(cur_hex_data_size < 2 * hex_data_size) {
433  c = ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN);
434  if (c != -1) {
435  rd_strlen = strlen(rd);
436  }
437  if (c == -1 || (size_t)cur_hex_data_size + rd_strlen > 2 * (size_t)hex_data_size) {
438  LDNS_FREE(hex_data_str);
439  LDNS_FREE(rd);
440  LDNS_FREE(b64);
441  ldns_buffer_free(rd_buf);
442  ldns_buffer_free(rr_buf);
443  LDNS_FREE(rdata);
444  ldns_rr_free(new);
446  }
447  strncpy(hex_data_str + cur_hex_data_size, rd, rd_strlen);
448  cur_hex_data_size += rd_strlen;
449  }
450  hex_data_str[cur_hex_data_size] = '\0';
451 
452  /* correct the rdf type */
453  /* if *we* know the type, interpret it as wireformat */
454  if (desc) {
455  size_t hex_pos = 0;
456  uint8_t *hex_data = LDNS_XMALLOC(uint8_t, hex_data_size + 2);
457  ldns_status s;
458  if(!hex_data) {
459  LDNS_FREE(hex_data_str);
460  LDNS_FREE(rd);
461  LDNS_FREE(b64);
462  ldns_buffer_free(rd_buf);
463  ldns_buffer_free(rr_buf);
464  LDNS_FREE(rdata);
465  ldns_rr_free(new);
466  return LDNS_STATUS_MEM_ERR;
467  }
468  ldns_write_uint16(hex_data, hex_data_size);
469  ldns_hexstring_to_data(hex_data + 2, hex_data_str);
470  s = ldns_wire2rdf(new, hex_data,
471  hex_data_size+2, &hex_pos);
472  if(s != LDNS_STATUS_OK) {
473  LDNS_FREE(hex_data_str);
474  LDNS_FREE(rd);
475  LDNS_FREE(b64);
476  ldns_buffer_free(rd_buf);
477  ldns_buffer_free(rr_buf);
478  LDNS_FREE(rdata);
479  ldns_rr_free(new);
480  LDNS_FREE(hex_data);
481  return s;
482  }
483  LDNS_FREE(hex_data);
484  } else {
485  r = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_HEX, hex_data_str);
486  if(!r) {
487  LDNS_FREE(hex_data_str);
488  LDNS_FREE(rd);
489  LDNS_FREE(b64);
490  ldns_buffer_free(rd_buf);
491  ldns_buffer_free(rr_buf);
492  LDNS_FREE(rdata);
493  ldns_rr_free(new);
494  return LDNS_STATUS_MEM_ERR;
495  }
497  if(!ldns_rr_push_rdf(new, r)) {
498  LDNS_FREE(hex_data_str);
499  LDNS_FREE(rd);
500  LDNS_FREE(b64);
501  ldns_buffer_free(rd_buf);
502  ldns_buffer_free(rr_buf);
503  LDNS_FREE(rdata);
504  ldns_rr_free(new);
505  return LDNS_STATUS_MEM_ERR;
506  }
507  }
508  LDNS_FREE(hex_data_str);
509  } else {
510  /* Normal RR */
511  switch(ldns_rr_descriptor_field_type(desc, r_cnt)) {
512  case LDNS_RDF_TYPE_HEX:
513  case LDNS_RDF_TYPE_B64:
514  /* can have spaces, and will always be the last
515  * record of the rrdata. Read in the rest */
516  if ((c = ldns_bget_token(rd_buf,
517  b64,
518  "\n",
520  != -1) {
521  rd = strncat(rd,
522  b64,
524  - strlen(rd) - 1);
525  }
527  ldns_rr_descriptor_field_type(desc, r_cnt),
528  rd);
529  break;
530  case LDNS_RDF_TYPE_DNAME:
532  ldns_rr_descriptor_field_type(desc, r_cnt),
533  rd);
534 
535  /* check if the origin should be used or concatenated */
536  if (r && ldns_rdf_size(r) > 1 && ldns_rdf_data(r)[0] == 1
537  && ldns_rdf_data(r)[1] == '@') {
539  if (origin) {
540  r = ldns_rdf_clone(origin);
541  } else {
542  /* if this is the SOA, use its own owner name */
543  if (rr_type == LDNS_RR_TYPE_SOA) {
544  r = ldns_rdf_clone(ldns_rr_owner(new));
545  } else {
547  }
548  }
549  } else if (r && rd_strlen >= 1 && !ldns_dname_str_absolute(rd) && origin) {
550  if (ldns_dname_cat(r, origin) != LDNS_STATUS_OK) {
551  LDNS_FREE(rd);
552  LDNS_FREE(b64);
553  ldns_buffer_free(rd_buf);
554  ldns_buffer_free(rr_buf);
555  LDNS_FREE(rdata);
556  ldns_rr_free(new);
557  return LDNS_STATUS_ERR;
558  }
559  }
560  break;
561  default:
563  ldns_rr_descriptor_field_type(desc, r_cnt),
564  rd);
565  break;
566  }
567  if (r) {
568  ldns_rr_push_rdf(new, r);
569  } else {
570  LDNS_FREE(rd);
571  LDNS_FREE(b64);
572  ldns_buffer_free(rd_buf);
573  ldns_buffer_free(rr_buf);
574  LDNS_FREE(rdata);
575  ldns_rr_free(new);
577  }
578  }
579  if (quoted) {
580  if (ldns_buffer_available(rd_buf, 1)) {
581  ldns_buffer_skip(rd_buf, 1);
582  } else {
583  done = true;
584  }
585  }
586  } else {
587  done = true;
588  }
589  }
590  }
591  LDNS_FREE(rd);
592  LDNS_FREE(b64);
593  ldns_buffer_free(rd_buf);
594  ldns_buffer_free(rr_buf);
595  LDNS_FREE(rdata);
596 
597  if (!question && desc && !was_unknown_rr_format && ldns_rr_rd_count(new) < r_min) {
598  ldns_rr_free(new);
600  }
601 
602  if (newrr) {
603  *newrr = new;
604  } else {
605  /* Maybe the caller just wanted to see if it would parse? */
606  ldns_rr_free(new);
607  }
608  return LDNS_STATUS_OK;
609 
610 ldnserror:
611  LDNS_FREE(type);
612  LDNS_FREE(owner);
613  LDNS_FREE(ttl);
614  LDNS_FREE(clas);
615  LDNS_FREE(rdata);
616  LDNS_FREE(rd);
617  LDNS_FREE(rd_buf);
618  LDNS_FREE(b64);
619  ldns_rr_free(new);
620  return status;
621 }
622 
624 ldns_rr_new_frm_str(ldns_rr **newrr, const char *str,
625  uint32_t default_ttl, ldns_rdf *origin,
626  ldns_rdf **prev)
627 {
628  return ldns_rr_new_frm_str_internal(newrr,
629  str,
630  default_ttl,
631  origin,
632  prev,
633  false);
634 }
635 
637 ldns_rr_new_question_frm_str(ldns_rr **newrr, const char *str,
638  ldns_rdf *origin, ldns_rdf **prev)
639 {
640  return ldns_rr_new_frm_str_internal(newrr,
641  str,
642  0,
643  origin,
644  prev,
645  true);
646 }
647 
649 ldns_rr_new_frm_fp(ldns_rr **newrr, FILE *fp, uint32_t *ttl, ldns_rdf **origin, ldns_rdf **prev)
650 {
651  return ldns_rr_new_frm_fp_l(newrr, fp, ttl, origin, prev, NULL);
652 }
653 
655 ldns_rr_new_frm_fp_l(ldns_rr **newrr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev, int *line_nr)
656 {
657  char *line;
658  const char *endptr; /* unused */
659  ldns_rr *rr;
660  uint32_t ttl;
661  ldns_rdf *tmp;
662  ldns_status s;
663  ssize_t size;
664  int offset = 0;
665 
666  if (default_ttl) {
667  ttl = *default_ttl;
668  } else {
669  ttl = 0;
670  }
671 
672  line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
673  if (!line) {
674  return LDNS_STATUS_MEM_ERR;
675  }
676 
677  /* read an entire line in from the file */
678  if ((size = ldns_fget_token_l(fp, line, LDNS_PARSE_SKIP_SPACE, LDNS_MAX_LINELEN, line_nr)) == -1) {
679  LDNS_FREE(line);
680  /* if last line was empty, we are now at feof, which is not
681  * always a parse error (happens when for instance last line
682  * was a comment)
683  */
684  return LDNS_STATUS_SYNTAX_ERR;
685  }
686 
687  /* we can have the situation, where we've read ok, but still got
688  * no bytes to play with, in this case size is 0
689  */
690  if (size == 0) {
691  LDNS_FREE(line);
693  }
694 
695  if (strncmp(line, "$ORIGIN", 7) == 0 && isspace(line[7])) {
696  if (*origin) {
697  ldns_rdf_deep_free(*origin);
698  *origin = NULL;
699  }
700  offset = 8;
701  while (isspace(line[offset])) {
702  offset++;
703  }
704  tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, line + offset);
705  if (!tmp) {
706  /* could not parse what next to $ORIGIN */
707  LDNS_FREE(line);
709  }
710  *origin = tmp;
712  } else if (strncmp(line, "$TTL", 4) == 0 && isspace(line[4])) {
713  offset = 5;
714  while (isspace(line[offset])) {
715  offset++;
716  }
717  if (default_ttl) {
718  *default_ttl = ldns_str2period(line + offset, &endptr);
719  }
721  } else if (strncmp(line, "$INCLUDE", 8) == 0) {
723  } else {
724  if (origin && *origin) {
725  s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, *origin, prev);
726  } else {
727  s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, NULL, prev);
728  }
729  }
730  LDNS_FREE(line);
731  if (s == LDNS_STATUS_OK) {
732  if (newrr) {
733  *newrr = rr;
734  } else {
735  /* Just testing if it would parse? */
736  ldns_rr_free(rr);
737  }
738  }
739  return s;
740 }
741 
742 void
744 {
745  rr->_owner = owner;
746 }
747 
748 void
749 ldns_rr_set_question(ldns_rr *rr, bool question)
750 {
751  rr->_rr_question = question;
752 }
753 
754 void
755 ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl)
756 {
757  rr->_ttl = ttl;
758 }
759 
760 void
761 ldns_rr_set_rd_count(ldns_rr *rr, size_t count)
762 {
763  rr->_rd_count = count;
764 }
765 
766 void
768 {
769  rr->_rr_type = rr_type;
770 }
771 
772 void
774 {
775  rr->_rr_class = rr_class;
776 }
777 
778 ldns_rdf *
779 ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position)
780 {
781  size_t rd_count;
782  ldns_rdf *pop;
783 
784  rd_count = ldns_rr_rd_count(rr);
785  if (position < rd_count) {
786  /* dicard the old one */
787  pop = rr->_rdata_fields[position];
788  rr->_rdata_fields[position] = (ldns_rdf*)f;
789  return pop;
790  } else {
791  return NULL;
792  }
793 }
794 
795 bool
797 {
798  size_t rd_count;
799  ldns_rdf **rdata_fields;
800 
801  rd_count = ldns_rr_rd_count(rr);
802 
803  /* grow the array */
804  rdata_fields = LDNS_XREALLOC(
805  rr->_rdata_fields, ldns_rdf *, rd_count + 1);
806  if (!rdata_fields) {
807  return false;
808  }
809 
810  /* add the new member */
811  rr->_rdata_fields = rdata_fields;
812  rr->_rdata_fields[rd_count] = (ldns_rdf*)f;
813 
814  ldns_rr_set_rd_count(rr, rd_count + 1);
815  return true;
816 }
817 
818 ldns_rdf *
820 {
821  size_t rd_count;
822  ldns_rdf *pop;
823  ldns_rdf** newrd;
824 
825  rd_count = ldns_rr_rd_count(rr);
826 
827  if (rd_count == 0) {
828  return NULL;
829  }
830 
831  pop = rr->_rdata_fields[rd_count - 1];
832 
833  /* try to shrink the array */
834  if(rd_count > 1) {
835  newrd = LDNS_XREALLOC(
836  rr->_rdata_fields, ldns_rdf *, rd_count - 1);
837  if(newrd)
838  rr->_rdata_fields = newrd;
839  } else {
841  }
842 
843  ldns_rr_set_rd_count(rr, rd_count - 1);
844  return pop;
845 }
846 
847 ldns_rdf *
848 ldns_rr_rdf(const ldns_rr *rr, size_t nr)
849 {
850  if (rr && nr < ldns_rr_rd_count(rr)) {
851  return rr->_rdata_fields[nr];
852  } else {
853  return NULL;
854  }
855 }
856 
857 ldns_rdf *
859 {
860  return rr->_owner;
861 }
862 
863 bool
865 {
866  return rr->_rr_question;
867 }
868 
869 uint32_t
871 {
872  return rr->_ttl;
873 }
874 
875 size_t
877 {
878  return rr->_rd_count;
879 }
880 
883 {
884  return rr->_rr_type;
885 }
886 
889 {
890  return rr->_rr_class;
891 }
892 
893 /* rr_lists */
894 
895 size_t
897 {
898  if (rr_list) {
899  return rr_list->_rr_count;
900  } else {
901  return 0;
902  }
903 }
904 
905 ldns_rr *
906 ldns_rr_list_set_rr(ldns_rr_list *rr_list, const ldns_rr *r, size_t count)
907 {
908  ldns_rr *old;
909 
910  if (count > ldns_rr_list_rr_count(rr_list)) {
911  return NULL;
912  }
913 
914  old = ldns_rr_list_rr(rr_list, count);
915 
916  /* overwrite old's pointer */
917  rr_list->_rrs[count] = (ldns_rr*)r;
918  return old;
919 }
920 
921 void
923 {
924  assert(count <= rr_list->_rr_capacity);
925  rr_list->_rr_count = count;
926 }
927 
928 ldns_rr *
929 ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr)
930 {
931  if (nr < ldns_rr_list_rr_count(rr_list)) {
932  return rr_list->_rrs[nr];
933  } else {
934  return NULL;
935  }
936 }
937 
938 ldns_rr_list *
940 {
942  if(!rr_list) return NULL;
943  rr_list->_rr_count = 0;
944  rr_list->_rr_capacity = 0;
945  rr_list->_rrs = NULL;
946  return rr_list;
947 }
948 
949 void
951 {
952  if (rr_list) {
953  LDNS_FREE(rr_list->_rrs);
954  LDNS_FREE(rr_list);
955  }
956 }
957 
958 void
960 {
961  size_t i;
962 
963  if (rr_list) {
964  for (i=0; i < ldns_rr_list_rr_count(rr_list); i++) {
965  ldns_rr_free(ldns_rr_list_rr(rr_list, i));
966  }
967  LDNS_FREE(rr_list->_rrs);
968  LDNS_FREE(rr_list);
969  }
970 }
971 
972 
973 /* add right to left. So we modify *left! */
974 bool
976 {
977  size_t r_rr_count;
978  size_t i;
979 
980  if (!left) {
981  return false;
982  }
983 
984  if (right) {
985  r_rr_count = ldns_rr_list_rr_count(right);
986  } else {
987  r_rr_count = 0;
988  }
989 
990  /* push right to left */
991  for(i = 0; i < r_rr_count; i++) {
992  ldns_rr_list_push_rr(left, ldns_rr_list_rr(right, i));
993  }
994  return true;
995 }
996 
997 ldns_rr_list *
999 {
1000  size_t l_rr_count;
1001  size_t r_rr_count;
1002  size_t i;
1003  ldns_rr_list *cat;
1004 
1005  if (left) {
1006  l_rr_count = ldns_rr_list_rr_count(left);
1007  } else {
1008  return ldns_rr_list_clone(right);
1009  }
1010 
1011  if (right) {
1012  r_rr_count = ldns_rr_list_rr_count(right);
1013  } else {
1014  r_rr_count = 0;
1015  }
1016 
1017  cat = ldns_rr_list_new();
1018 
1019  if (!cat) {
1020  return NULL;
1021  }
1022 
1023  /* left */
1024  for(i = 0; i < l_rr_count; i++) {
1026  ldns_rr_clone(ldns_rr_list_rr(left, i)));
1027  }
1028  /* right */
1029  for(i = 0; i < r_rr_count; i++) {
1031  ldns_rr_clone(ldns_rr_list_rr(right, i)));
1032  }
1033  return cat;
1034 }
1035 
1036 ldns_rr_list *
1038 {
1039  size_t i;
1040  ldns_rr_list *subtyped;
1041  ldns_rdf *list_rdf;
1042 
1043  subtyped = ldns_rr_list_new();
1044 
1045  for(i = 0; i < ldns_rr_list_rr_count(l); i++) {
1046  list_rdf = ldns_rr_rdf(
1047  ldns_rr_list_rr(l, i),
1048  pos);
1049  if (!list_rdf) {
1050  /* pos is too large or any other error */
1051  ldns_rr_list_deep_free(subtyped);
1052  return NULL;
1053  }
1054 
1055  if (ldns_rdf_compare(list_rdf, r) == 0) {
1056  /* a match */
1057  ldns_rr_list_push_rr(subtyped,
1059  }
1060  }
1061 
1062  if (ldns_rr_list_rr_count(subtyped) > 0) {
1063  return subtyped;
1064  } else {
1065  ldns_rr_list_free(subtyped);
1066  return NULL;
1067  }
1068 }
1069 
1070 bool
1072 {
1073  size_t rr_count;
1074  size_t cap;
1075 
1076  rr_count = ldns_rr_list_rr_count(rr_list);
1077  cap = rr_list->_rr_capacity;
1078 
1079  /* grow the array */
1080  if(rr_count+1 > cap) {
1081  ldns_rr **rrs;
1082 
1083  if(cap == 0)
1084  cap = LDNS_RRLIST_INIT; /* initial list size */
1085  else cap *= 2;
1086  rrs = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap);
1087  if (!rrs) {
1088  return false;
1089  }
1090  rr_list->_rrs = rrs;
1091  rr_list->_rr_capacity = cap;
1092  }
1093 
1094  /* add the new member */
1095  rr_list->_rrs[rr_count] = (ldns_rr*)rr;
1096 
1097  ldns_rr_list_set_rr_count(rr_list, rr_count + 1);
1098  return true;
1099 }
1100 
1101 bool
1103 {
1104  size_t i;
1105 
1106  for(i = 0; i < ldns_rr_list_rr_count(push_list); i++) {
1107  if (!ldns_rr_list_push_rr(rr_list,
1108  ldns_rr_list_rr(push_list, i))) {
1109  return false;
1110  }
1111  }
1112  return true;
1113 }
1114 
1115 ldns_rr *
1117 {
1118  size_t rr_count;
1119  size_t cap;
1120  ldns_rr *pop;
1121 
1122  rr_count = ldns_rr_list_rr_count(rr_list);
1123 
1124  if (rr_count == 0) {
1125  return NULL;
1126  }
1127 
1128  cap = rr_list->_rr_capacity;
1129  pop = ldns_rr_list_rr(rr_list, rr_count - 1);
1130 
1131  /* shrink the array */
1132  if(cap > LDNS_RRLIST_INIT && rr_count-1 <= cap/2) {
1133  ldns_rr** a;
1134  cap /= 2;
1135  a = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap);
1136  if(a) {
1137  rr_list->_rrs = a;
1138  rr_list->_rr_capacity = cap;
1139  }
1140  }
1141 
1142  ldns_rr_list_set_rr_count(rr_list, rr_count - 1);
1143 
1144  return pop;
1145 }
1146 
1147 ldns_rr_list *
1148 ldns_rr_list_pop_rr_list(ldns_rr_list *rr_list, size_t howmany)
1149 {
1150  /* pop a number of rr's and put them in a rr_list */
1151  ldns_rr_list *popped;
1152  ldns_rr *p;
1153  size_t i = howmany;
1154 
1155  popped = ldns_rr_list_new();
1156 
1157  if (!popped) {
1158  return NULL;
1159  }
1160 
1161 
1162  while(i > 0 &&
1163  (p = ldns_rr_list_pop_rr(rr_list)) != NULL) {
1164  ldns_rr_list_push_rr(popped, p);
1165  i--;
1166  }
1167 
1168  if (i == howmany) { /* so i <= 0 */
1169  ldns_rr_list_free(popped);
1170  return NULL;
1171  } else {
1172  return popped;
1173  }
1174 }
1175 
1176 
1177 bool
1179 {
1180  size_t i;
1181 
1182  if (!rr_list || !rr || ldns_rr_list_rr_count(rr_list) == 0) {
1183  return false;
1184  }
1185 
1186  for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
1187  if (rr == ldns_rr_list_rr(rr_list, i)) {
1188  return true;
1189  } else if (ldns_rr_compare(rr, ldns_rr_list_rr(rr_list, i)) == 0) {
1190  return true;
1191  }
1192  }
1193  return false;
1194 }
1195 
1196 bool
1198 {
1199  ldns_rr_type t;
1200  ldns_rr_class c;
1201  ldns_rdf *o;
1202  ldns_rr *tmp;
1203  size_t i;
1204 
1205  if (!rr_list || ldns_rr_list_rr_count(rr_list) == 0) {
1206  return false;
1207  }
1208 
1209  tmp = ldns_rr_list_rr(rr_list, 0);
1210 
1211  t = ldns_rr_get_type(tmp);
1212  c = ldns_rr_get_class(tmp);
1213  o = ldns_rr_owner(tmp);
1214 
1215  /* compare these with the rest of the rr_list, start with 1 */
1216  for (i = 1; i < ldns_rr_list_rr_count(rr_list); i++) {
1217  tmp = ldns_rr_list_rr(rr_list, i);
1218  if (t != ldns_rr_get_type(tmp)) {
1219  return false;
1220  }
1221  if (c != ldns_rr_get_class(tmp)) {
1222  return false;
1223  }
1224  if (ldns_rdf_compare(o, ldns_rr_owner(tmp)) != 0) {
1225  return false;
1226  }
1227  }
1228  return true;
1229 }
1230 
1231 bool
1233 {
1234  size_t rr_count;
1235  size_t i;
1236  ldns_rr *last;
1237 
1238  assert(rr != NULL);
1239 
1240  rr_count = ldns_rr_list_rr_count(rr_list);
1241 
1242  if (rr_count == 0) {
1243  /* nothing there, so checking it is
1244  * not needed */
1245  return ldns_rr_list_push_rr(rr_list, rr);
1246  } else {
1247  /* check with the final rr in the rr_list */
1248  last = ldns_rr_list_rr(rr_list, rr_count - 1);
1249 
1250  if (ldns_rr_get_class(last) != ldns_rr_get_class(rr)) {
1251  return false;
1252  }
1253  if (ldns_rr_get_type(last) != ldns_rr_get_type(rr)) {
1254  return false;
1255  }
1256  /* only check if not equal to RRSIG */
1257  if (ldns_rr_get_type(rr) != LDNS_RR_TYPE_RRSIG) {
1258  if (ldns_rr_ttl(last) != ldns_rr_ttl(rr)) {
1259  return false;
1260  }
1261  }
1262  if (ldns_rdf_compare(ldns_rr_owner(last),
1263  ldns_rr_owner(rr)) != 0) {
1264  return false;
1265  }
1266  /* ok, still alive - check if the rr already
1267  * exists - if so, dont' add it */
1268  for(i = 0; i < rr_count; i++) {
1269  if(ldns_rr_compare(
1270  ldns_rr_list_rr(rr_list, i), rr) == 0) {
1271  return false;
1272  }
1273  }
1274  /* it's safe, push it */
1275  return ldns_rr_list_push_rr(rr_list, rr);
1276  }
1277 }
1278 
1279 ldns_rr *
1281 {
1282  return ldns_rr_list_pop_rr(rr_list);
1283 }
1284 
1285 ldns_rr_list *
1287 {
1288  ldns_rr_list *rrset;
1289  ldns_rr *last_rr = NULL;
1290  ldns_rr *next_rr;
1291 
1292  if (!rr_list) {
1293  return NULL;
1294  }
1295 
1296  rrset = ldns_rr_list_new();
1297  if (!last_rr) {
1298  last_rr = ldns_rr_list_pop_rr(rr_list);
1299  if (!last_rr) {
1300  ldns_rr_list_free(rrset);
1301  return NULL;
1302  } else {
1303  ldns_rr_list_push_rr(rrset, last_rr);
1304  }
1305  }
1306 
1307  if (ldns_rr_list_rr_count(rr_list) > 0) {
1308  next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1);
1309  } else {
1310  next_rr = NULL;
1311  }
1312 
1313  while (next_rr) {
1314  if (
1316  ldns_rr_owner(last_rr)) == 0
1317  &&
1318  ldns_rr_get_type(next_rr) == ldns_rr_get_type(last_rr)
1319  &&
1320  ldns_rr_get_class(next_rr) == ldns_rr_get_class(last_rr)
1321  ) {
1322  ldns_rr_list_push_rr(rrset, ldns_rr_list_pop_rr(rr_list));
1323  if (ldns_rr_list_rr_count(rr_list) > 0) {
1324  last_rr = next_rr;
1325  next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1);
1326  } else {
1327  next_rr = NULL;
1328  }
1329  } else {
1330  next_rr = NULL;
1331  }
1332  }
1333 
1334  return rrset;
1335 }
1336 
1337 ldns_rr *
1339 {
1340  size_t i;
1341  ldns_rr *new_rr;
1342 
1343  if (!rr) {
1344  return NULL;
1345  }
1346 
1347  new_rr = ldns_rr_new();
1348  if (!new_rr) {
1349  return NULL;
1350  }
1351  if (ldns_rr_owner(rr)) {
1353  }
1354  ldns_rr_set_ttl(new_rr, ldns_rr_ttl(rr));
1355  ldns_rr_set_type(new_rr, ldns_rr_get_type(rr));
1356  ldns_rr_set_class(new_rr, ldns_rr_get_class(rr));
1358 
1359  for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1360  if (ldns_rr_rdf(rr,i)) {
1361  ldns_rr_push_rdf(new_rr, ldns_rdf_clone(ldns_rr_rdf(rr, i)));
1362  }
1363  }
1364 
1365  return new_rr;
1366 }
1367 
1368 ldns_rr_list *
1370 {
1371  size_t i;
1372  ldns_rr_list *new_list;
1373  ldns_rr *r;
1374 
1375  if (!rrlist) {
1376  return NULL;
1377  }
1378 
1379  new_list = ldns_rr_list_new();
1380  if (!new_list) {
1381  return NULL;
1382  }
1383  for (i = 0; i < ldns_rr_list_rr_count(rrlist); i++) {
1384  r = ldns_rr_clone(
1385  ldns_rr_list_rr(rrlist, i)
1386  );
1387  if (!r) {
1388  /* huh, failure in cloning */
1389  ldns_rr_list_deep_free(new_list);
1390  return NULL;
1391  }
1392  ldns_rr_list_push_rr(new_list, r);
1393  }
1394  return new_list;
1395 }
1396 
1397 
1398 int
1399 qsort_rr_compare(const void *a, const void *b)
1400 {
1401  const ldns_rr *rr1 = * (const ldns_rr **) a;
1402  const ldns_rr *rr2 = * (const ldns_rr **) b;
1403 
1404  if (rr1 == NULL && rr2 == NULL) {
1405  return 0;
1406  }
1407  if (rr1 == NULL) {
1408  return -1;
1409  }
1410  if (rr2 == NULL) {
1411  return 1;
1412  }
1413  return ldns_rr_compare(rr1, rr2);
1414 }
1415 
1416 int
1417 qsort_schwartz_rr_compare(const void *a, const void *b)
1418 {
1419  int result = 0;
1420  ldns_rr *rr1, *rr2;
1421  ldns_buffer *rr1_buf, *rr2_buf;
1424  /* if we are doing 2wire, we need to do lowercasing on the dname (and maybe on the rdata)
1425  * this must be done for comparison only, so we need to have a temp var for both buffers,
1426  * which is only used when the transformed object value isn't there yet
1427  */
1428  ldns_rr *canonical_a, *canonical_b;
1429 
1430  rr1 = (ldns_rr *) sa->original_object;
1431  rr2 = (ldns_rr *) sb->original_object;
1432 
1433  result = ldns_rr_compare_no_rdata(rr1, rr2);
1434 
1435  if (result == 0) {
1436  if (!sa->transformed_object) {
1437  canonical_a = ldns_rr_clone(sa->original_object);
1438  ldns_rr2canonical(canonical_a);
1442  sa->transformed_object = NULL;
1443  ldns_rr_free(canonical_a);
1444  return 0;
1445  }
1446  ldns_rr_free(canonical_a);
1447  }
1448  if (!sb->transformed_object) {
1449  canonical_b = ldns_rr_clone(sb->original_object);
1450  ldns_rr2canonical(canonical_b);
1455  sa->transformed_object = NULL;
1456  sb->transformed_object = NULL;
1457  ldns_rr_free(canonical_b);
1458  return 0;
1459  }
1460  ldns_rr_free(canonical_b);
1461  }
1462  rr1_buf = (ldns_buffer *) sa->transformed_object;
1463  rr2_buf = (ldns_buffer *) sb->transformed_object;
1464 
1465  result = ldns_rr_compare_wire(rr1_buf, rr2_buf);
1466  }
1467 
1468  return result;
1469 }
1470 
1471 void
1473 {
1474  struct ldns_schwartzian_compare_struct **sortables;
1475  size_t item_count;
1476  size_t i;
1477 
1478  if (unsorted) {
1479  item_count = ldns_rr_list_rr_count(unsorted);
1480 
1481  sortables = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct *,
1482  item_count);
1483  if(!sortables) return; /* no way to return error */
1484  for (i = 0; i < item_count; i++) {
1485  sortables[i] = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct, 1);
1486  if(!sortables[i]) {
1487  /* free the allocated parts */
1488  while(i>0) {
1489  i--;
1490  LDNS_FREE(sortables[i]);
1491  }
1492  /* no way to return error */
1493  LDNS_FREE(sortables);
1494  return;
1495  }
1496  sortables[i]->original_object = ldns_rr_list_rr(unsorted, i);
1497  sortables[i]->transformed_object = NULL;
1498  }
1499  qsort(sortables,
1500  item_count,
1501  sizeof(struct ldns_schwartzian_compare_struct *),
1503  for (i = 0; i < item_count; i++) {
1504  unsorted->_rrs[i] = sortables[i]->original_object;
1505  if (sortables[i]->transformed_object) {
1506  ldns_buffer_free(sortables[i]->transformed_object);
1507  }
1508  LDNS_FREE(sortables[i]);
1509  }
1510  LDNS_FREE(sortables);
1511  }
1512 }
1513 
1514 int
1516 {
1517  size_t rr1_len;
1518  size_t rr2_len;
1519  size_t offset;
1520 
1521  assert(rr1 != NULL);
1522  assert(rr2 != NULL);
1523 
1524  rr1_len = ldns_rr_uncompressed_size(rr1);
1525  rr2_len = ldns_rr_uncompressed_size(rr2);
1526 
1527  if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) < 0) {
1528  return -1;
1529  } else if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) > 0) {
1530  return 1;
1531  }
1532 
1533  /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */
1534  if (ldns_rr_get_class(rr1) != ldns_rr_get_class(rr2)) {
1535  return ldns_rr_get_class(rr1) - ldns_rr_get_class(rr2);
1536  }
1537 
1538  /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */
1539  if (ldns_rr_get_type(rr1) != ldns_rr_get_type(rr2)) {
1540  return ldns_rr_get_type(rr1) - ldns_rr_get_type(rr2);
1541  }
1542 
1543  /* offset is the owername length + ttl + type + class + rdlen == start of wire format rdata */
1544  offset = ldns_rdf_size(ldns_rr_owner(rr1)) + 4 + 2 + 2 + 2;
1545  /* if either record doesn't have any RDATA... */
1546  if (offset > rr1_len || offset > rr2_len) {
1547  if (rr1_len == rr2_len) {
1548  return 0;
1549  }
1550  return ((int) rr2_len - (int) rr1_len);
1551  }
1552 
1553  return 0;
1554 }
1555 
1557 {
1558  size_t rr1_len, rr2_len, min_len, i, offset;
1559 
1560  rr1_len = ldns_buffer_capacity(rr1_buf);
1561  rr2_len = ldns_buffer_capacity(rr2_buf);
1562 
1563  /* jump past dname (checked in earlier part)
1564  * and especially past TTL */
1565  offset = 0;
1566  while (offset < rr1_len && *ldns_buffer_at(rr1_buf, offset) != 0) {
1567  offset += *ldns_buffer_at(rr1_buf, offset) + 1;
1568  }
1569  /* jump to rdata section (PAST the rdata length field, otherwise
1570  rrs with different lengths might be sorted erroneously */
1571  offset += 11;
1572  min_len = (rr1_len < rr2_len) ? rr1_len : rr2_len;
1573  /* Compare RRs RDATA byte for byte. */
1574  for(i = offset; i < min_len; i++) {
1575  if (*ldns_buffer_at(rr1_buf,i) < *ldns_buffer_at(rr2_buf,i)) {
1576  return -1;
1577  } else if (*ldns_buffer_at(rr1_buf,i) > *ldns_buffer_at(rr2_buf,i)) {
1578  return +1;
1579  }
1580  }
1581 
1582  /* If both RDATAs are the same up to min_len, then the shorter one sorts first. */
1583  if (rr1_len < rr2_len) {
1584  return -1;
1585  } else if (rr1_len > rr2_len) {
1586  return +1;
1587  }
1588  /* The RDATAs are equal. */
1589  return 0;
1590 
1591 }
1592 
1593 int
1594 ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2)
1595 {
1596  int result;
1597  size_t rr1_len, rr2_len;
1598 
1599  ldns_buffer *rr1_buf;
1600  ldns_buffer *rr2_buf;
1601 
1602  result = ldns_rr_compare_no_rdata(rr1, rr2);
1603  if (result == 0) {
1604  rr1_len = ldns_rr_uncompressed_size(rr1);
1605  rr2_len = ldns_rr_uncompressed_size(rr2);
1606 
1607  rr1_buf = ldns_buffer_new(rr1_len);
1608  rr2_buf = ldns_buffer_new(rr2_len);
1609 
1610  if (ldns_rr2buffer_wire_canonical(rr1_buf,
1611  rr1,
1613  != LDNS_STATUS_OK) {
1614  ldns_buffer_free(rr1_buf);
1615  ldns_buffer_free(rr2_buf);
1616  return 0;
1617  }
1618  if (ldns_rr2buffer_wire_canonical(rr2_buf,
1619  rr2,
1621  != LDNS_STATUS_OK) {
1622  ldns_buffer_free(rr1_buf);
1623  ldns_buffer_free(rr2_buf);
1624  return 0;
1625  }
1626 
1627  result = ldns_rr_compare_wire(rr1_buf, rr2_buf);
1628 
1629  ldns_buffer_free(rr1_buf);
1630  ldns_buffer_free(rr2_buf);
1631  }
1632 
1633  return result;
1634 }
1635 
1636 /* convert dnskey to a ds with the given algorithm,
1637  * then compare the result with the given ds */
1638 static int
1639 ldns_rr_compare_ds_dnskey(ldns_rr *ds,
1640  ldns_rr *dnskey)
1641 {
1642  ldns_rr *ds_gen;
1643  bool result = false;
1644  ldns_hash algo;
1645 
1646  if (!dnskey || !ds ||
1649  return false;
1650  }
1651 
1652  if (ldns_rr_rdf(ds, 2) == NULL) {
1653  return false;
1654  }
1655  algo = ldns_rdf2native_int8(ldns_rr_rdf(ds, 2));
1656 
1657  ds_gen = ldns_key_rr2ds(dnskey, algo);
1658  if (ds_gen) {
1659  result = ldns_rr_compare(ds, ds_gen) == 0;
1660  ldns_rr_free(ds_gen);
1661  }
1662  return result;
1663 }
1664 
1665 bool
1666 ldns_rr_compare_ds(const ldns_rr *orr1, const ldns_rr *orr2)
1667 {
1668  bool result;
1669  ldns_rr *rr1 = ldns_rr_clone(orr1);
1670  ldns_rr *rr2 = ldns_rr_clone(orr2);
1671 
1672  /* set ttls to zero */
1673  ldns_rr_set_ttl(rr1, 0);
1674  ldns_rr_set_ttl(rr2, 0);
1675 
1676  if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DS &&
1678  result = ldns_rr_compare_ds_dnskey(rr1, rr2);
1679  } else if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DNSKEY &&
1681  result = ldns_rr_compare_ds_dnskey(rr2, rr1);
1682  } else {
1683  result = (ldns_rr_compare(rr1, rr2) == 0);
1684  }
1685 
1686  ldns_rr_free(rr1);
1687  ldns_rr_free(rr2);
1688 
1689  return result;
1690 }
1691 
1692 int
1694 {
1695  size_t i = 0;
1696  int rr_cmp;
1697 
1698  assert(rrl1 != NULL);
1699  assert(rrl2 != NULL);
1700 
1701  for (i = 0; i < ldns_rr_list_rr_count(rrl1) && i < ldns_rr_list_rr_count(rrl2); i++) {
1702  rr_cmp = ldns_rr_compare(ldns_rr_list_rr(rrl1, i), ldns_rr_list_rr(rrl2, i));
1703  if (rr_cmp != 0) {
1704  return rr_cmp;
1705  }
1706  }
1707 
1708  if (i == ldns_rr_list_rr_count(rrl1) &&
1709  i != ldns_rr_list_rr_count(rrl2)) {
1710  return 1;
1711  } else if (i == ldns_rr_list_rr_count(rrl2) &&
1712  i != ldns_rr_list_rr_count(rrl1)) {
1713  return -1;
1714  } else {
1715  return 0;
1716  }
1717 }
1718 
1719 size_t
1721 {
1722  size_t rrsize;
1723  size_t i;
1724 
1725  rrsize = 0;
1726  /* add all the rdf sizes */
1727  for(i = 0; i < ldns_rr_rd_count(r); i++) {
1728  rrsize += ldns_rdf_size(ldns_rr_rdf(r, i));
1729  }
1730  /* ownername */
1731  rrsize += ldns_rdf_size(ldns_rr_owner(r));
1732  rrsize += LDNS_RR_OVERHEAD;
1733  return rrsize;
1734 }
1735 
1736 void
1738 {
1739  uint16_t i;
1740 
1741  if (!rr) {
1742  return;
1743  }
1744 
1746 
1747  /*
1748  * lowercase the rdata dnames if the rr type is one
1749  * of the list in chapter 7 of RFC3597
1750  * Also added RRSIG, because a "Signer's Name" should be canonicalized
1751  * too. See dnssec-bis-updates-16. We can add it to this list because
1752  * the "Signer's Name" is the only dname type rdata field in a RRSIG.
1753  */
1754  switch(ldns_rr_get_type(rr)) {
1755  case LDNS_RR_TYPE_NS:
1756  case LDNS_RR_TYPE_MD:
1757  case LDNS_RR_TYPE_MF:
1758  case LDNS_RR_TYPE_CNAME:
1759  case LDNS_RR_TYPE_SOA:
1760  case LDNS_RR_TYPE_MB:
1761  case LDNS_RR_TYPE_MG:
1762  case LDNS_RR_TYPE_MR:
1763  case LDNS_RR_TYPE_PTR:
1764  case LDNS_RR_TYPE_MINFO:
1765  case LDNS_RR_TYPE_MX:
1766  case LDNS_RR_TYPE_RP:
1767  case LDNS_RR_TYPE_AFSDB:
1768  case LDNS_RR_TYPE_RT:
1769  case LDNS_RR_TYPE_SIG:
1770  case LDNS_RR_TYPE_PX:
1771  case LDNS_RR_TYPE_NXT:
1772  case LDNS_RR_TYPE_NAPTR:
1773  case LDNS_RR_TYPE_KX:
1774  case LDNS_RR_TYPE_SRV:
1775  case LDNS_RR_TYPE_DNAME:
1776  case LDNS_RR_TYPE_A6:
1777  case LDNS_RR_TYPE_RRSIG:
1778  for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1780  }
1781  return;
1782  default:
1783  /* do nothing */
1784  return;
1785  }
1786 }
1787 
1788 void
1790 {
1791  size_t i;
1792  for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
1793  ldns_rr2canonical(ldns_rr_list_rr(rr_list, i));
1794  }
1795 }
1796 
1797 uint8_t
1799 {
1800  if (!rr) {
1801  return 0;
1802  }
1803  return ldns_dname_label_count(
1804  ldns_rr_owner(rr));
1805 }
1806 
1808 static const ldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
1809 static const ldns_rdf_type type_a_wireformat[] = { LDNS_RDF_TYPE_A };
1810 static const ldns_rdf_type type_ns_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1811 static const ldns_rdf_type type_md_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1812 static const ldns_rdf_type type_mf_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1813 static const ldns_rdf_type type_cname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1814 static const ldns_rdf_type type_soa_wireformat[] = {
1817  LDNS_RDF_TYPE_PERIOD
1818 };
1819 static const ldns_rdf_type type_mb_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1820 static const ldns_rdf_type type_mg_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1821 static const ldns_rdf_type type_mr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1822 static const ldns_rdf_type type_wks_wireformat[] = {
1824 };
1825 static const ldns_rdf_type type_ptr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1826 static const ldns_rdf_type type_hinfo_wireformat[] = {
1828 };
1829 static const ldns_rdf_type type_minfo_wireformat[] = {
1831 };
1832 static const ldns_rdf_type type_mx_wireformat[] = {
1834 };
1835 static const ldns_rdf_type type_rp_wireformat[] = {
1837 };
1838 static const ldns_rdf_type type_afsdb_wireformat[] = {
1840 };
1841 static const ldns_rdf_type type_x25_wireformat[] = { LDNS_RDF_TYPE_STR };
1842 static const ldns_rdf_type type_isdn_wireformat[] = {
1844 };
1845 static const ldns_rdf_type type_rt_wireformat[] = {
1847 };
1848 static const ldns_rdf_type type_nsap_wireformat[] = {
1850 };
1851 static const ldns_rdf_type type_nsap_ptr_wireformat[] = {
1853 };
1854 static const ldns_rdf_type type_sig_wireformat[] = {
1858 };
1859 static const ldns_rdf_type type_key_wireformat[] = {
1861 };
1862 static const ldns_rdf_type type_px_wireformat[] = {
1863  LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
1864 };
1865 static const ldns_rdf_type type_gpos_wireformat[] = {
1868  LDNS_RDF_TYPE_STR
1869 };
1870 static const ldns_rdf_type type_aaaa_wireformat[] = { LDNS_RDF_TYPE_AAAA };
1871 static const ldns_rdf_type type_loc_wireformat[] = { LDNS_RDF_TYPE_LOC };
1872 static const ldns_rdf_type type_nxt_wireformat[] = {
1874 };
1875 static const ldns_rdf_type type_eid_wireformat[] = {
1877 };
1878 static const ldns_rdf_type type_nimloc_wireformat[] = {
1880 };
1881 static const ldns_rdf_type type_srv_wireformat[] = {
1883 };
1884 static const ldns_rdf_type type_atma_wireformat[] = {
1886 };
1887 static const ldns_rdf_type type_naptr_wireformat[] = {
1889 };
1890 static const ldns_rdf_type type_kx_wireformat[] = {
1892 };
1893 static const ldns_rdf_type type_cert_wireformat[] = {
1895 };
1896 static const ldns_rdf_type type_a6_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
1897 static const ldns_rdf_type type_dname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1898 static const ldns_rdf_type type_sink_wireformat[] = { LDNS_RDF_TYPE_INT8,
1900 };
1901 static const ldns_rdf_type type_apl_wireformat[] = {
1903 };
1904 static const ldns_rdf_type type_ds_wireformat[] = {
1906 };
1907 static const ldns_rdf_type type_sshfp_wireformat[] = {
1909 };
1910 static const ldns_rdf_type type_ipseckey_wireformat[] = {
1912 };
1913 static const ldns_rdf_type type_rrsig_wireformat[] = {
1916 };
1917 static const ldns_rdf_type type_nsec_wireformat[] = {
1919 };
1920 static const ldns_rdf_type type_dhcid_wireformat[] = {
1922 };
1923 static const ldns_rdf_type type_talink_wireformat[] = {
1925 };
1926 /* nsec3 is some vars, followed by same type of data of nsec */
1927 static const ldns_rdf_type type_nsec3_wireformat[] = {
1928 /* LDNS_RDF_TYPE_NSEC3_VARS, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC*/
1930 };
1931 
1932 static const ldns_rdf_type type_nsec3param_wireformat[] = {
1933 /* LDNS_RDF_TYPE_NSEC3_PARAMS_VARS*/
1938 };
1939 
1940 static const ldns_rdf_type type_dnskey_wireformat[] = {
1945 };
1946 static const ldns_rdf_type type_tsig_wireformat[] = {
1953  LDNS_RDF_TYPE_INT16_DATA
1954 };
1955 static const ldns_rdf_type type_tlsa_wireformat[] = {
1960 };
1964 /* All RR's defined in 1035 are well known and can thus
1965  * be compressed. See RFC3597. These RR's are:
1966  * CNAME HINFO MB MD MF MG MINFO MR MX NULL NS PTR SOA TXT
1967  */
1968 static ldns_rr_descriptor rdata_field_descriptors[] = {
1969  /* 0 */
1970  { 0, NULL, 0, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1971  /* 1 */
1972  {LDNS_RR_TYPE_A, "A", 1, 1, type_a_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1973  /* 2 */
1974  {LDNS_RR_TYPE_NS, "NS", 1, 1, type_ns_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1975  /* 3 */
1976  {LDNS_RR_TYPE_MD, "MD", 1, 1, type_md_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1977  /* 4 */
1978  {LDNS_RR_TYPE_MF, "MF", 1, 1, type_mf_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1979  /* 5 */
1980  {LDNS_RR_TYPE_CNAME, "CNAME", 1, 1, type_cname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1981  /* 6 */
1982  {LDNS_RR_TYPE_SOA, "SOA", 7, 7, type_soa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 },
1983  /* 7 */
1984  {LDNS_RR_TYPE_MB, "MB", 1, 1, type_mb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1985  /* 8 */
1986  {LDNS_RR_TYPE_MG, "MG", 1, 1, type_mg_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1987  /* 9 */
1988  {LDNS_RR_TYPE_MR, "MR", 1, 1, type_mr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1989  /* 10 */
1990  {LDNS_RR_TYPE_NULL, "NULL", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1991  /* 11 */
1992  {LDNS_RR_TYPE_WKS, "WKS", 2, 2, type_wks_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1993  /* 12 */
1994  {LDNS_RR_TYPE_PTR, "PTR", 1, 1, type_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1995  /* 13 */
1996  {LDNS_RR_TYPE_HINFO, "HINFO", 2, 2, type_hinfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1997  /* 14 */
1998  {LDNS_RR_TYPE_MINFO, "MINFO", 2, 2, type_minfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 },
1999  /* 15 */
2000  {LDNS_RR_TYPE_MX, "MX", 2, 2, type_mx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2001  /* 16 */
2003  /* 17 */
2004  {LDNS_RR_TYPE_RP, "RP", 2, 2, type_rp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
2005  /* 18 */
2006  {LDNS_RR_TYPE_AFSDB, "AFSDB", 2, 2, type_afsdb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2007  /* 19 */
2008  {LDNS_RR_TYPE_X25, "X25", 1, 1, type_x25_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2009  /* 20 */
2010  {LDNS_RR_TYPE_ISDN, "ISDN", 1, 2, type_isdn_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2011  /* 21 */
2012  {LDNS_RR_TYPE_RT, "RT", 2, 2, type_rt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2013  /* 22 */
2014  {LDNS_RR_TYPE_NSAP, "NSAP", 1, 1, type_nsap_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2015  /* 23 */
2016  {LDNS_RR_TYPE_NSAP_PTR, "NSAP-PTR", 1, 1, type_nsap_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2017  /* 24 */
2018  {LDNS_RR_TYPE_SIG, "SIG", 9, 9, type_sig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2019  /* 25 */
2020  {LDNS_RR_TYPE_KEY, "KEY", 4, 4, type_key_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2021  /* 26 */
2022  {LDNS_RR_TYPE_PX, "PX", 3, 3, type_px_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
2023  /* 27 */
2024  {LDNS_RR_TYPE_GPOS, "GPOS", 1, 1, type_gpos_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2025  /* 28 */
2026  {LDNS_RR_TYPE_AAAA, "AAAA", 1, 1, type_aaaa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2027  /* 29 */
2028  {LDNS_RR_TYPE_LOC, "LOC", 1, 1, type_loc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2029  /* 30 */
2030  {LDNS_RR_TYPE_NXT, "NXT", 2, 2, type_nxt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2031  /* 31 */
2032  {LDNS_RR_TYPE_EID, "EID", 1, 1, type_eid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2033  /* 32 */
2034  {LDNS_RR_TYPE_NIMLOC, "NIMLOC", 1, 1, type_nimloc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2035  /* 33 */
2036  {LDNS_RR_TYPE_SRV, "SRV", 4, 4, type_srv_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2037  /* 34 */
2038  {LDNS_RR_TYPE_ATMA, "ATMA", 1, 1, type_atma_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2039  /* 35 */
2040  {LDNS_RR_TYPE_NAPTR, "NAPTR", 6, 6, type_naptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2041  /* 36 */
2042  {LDNS_RR_TYPE_KX, "KX", 2, 2, type_kx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2043  /* 37 */
2044  {LDNS_RR_TYPE_CERT, "CERT", 4, 4, type_cert_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2045  /* 38 */
2046  {LDNS_RR_TYPE_A6, "A6", 1, 1, type_a6_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2047  /* 39 */
2048  {LDNS_RR_TYPE_DNAME, "DNAME", 1, 1, type_dname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2049  /* 40 */
2050  {LDNS_RR_TYPE_SINK, "SINK", 1, 1, type_sink_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2051  /* 41 */
2052  {LDNS_RR_TYPE_OPT, "OPT", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2053  /* 42 */
2054  {LDNS_RR_TYPE_APL, "APL", 0, 0, type_apl_wireformat, LDNS_RDF_TYPE_APL, LDNS_RR_NO_COMPRESS, 0 },
2055  /* 43 */
2056  {LDNS_RR_TYPE_DS, "DS", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2057  /* 44 */
2058  {LDNS_RR_TYPE_SSHFP, "SSHFP", 3, 3, type_sshfp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2059  /* 45 */
2060  {LDNS_RR_TYPE_IPSECKEY, "IPSECKEY", 1, 1, type_ipseckey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2061  /* 46 */
2062  {LDNS_RR_TYPE_RRSIG, "RRSIG", 9, 9, type_rrsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2063  /* 47 */
2064  {LDNS_RR_TYPE_NSEC, "NSEC", 1, 2, type_nsec_wireformat, LDNS_RDF_TYPE_NSEC, LDNS_RR_NO_COMPRESS, 1 },
2065  /* 48 */
2066  {LDNS_RR_TYPE_DNSKEY, "DNSKEY", 4, 4, type_dnskey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2067  /* 49 */
2068  {LDNS_RR_TYPE_DHCID, "DHCID", 1, 1, type_dhcid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2069  /* 50 */
2070  {LDNS_RR_TYPE_NSEC3, "NSEC3", 5, 6, type_nsec3_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2071  /* 51 */
2072  {LDNS_RR_TYPE_NSEC3PARAM, "NSEC3PARAM", 4, 4, type_nsec3param_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2073  /* 52 */
2074  {LDNS_RR_TYPE_TLSA, "TLSA", 4, 4, type_tlsa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2075 
2076 {LDNS_RR_TYPE_NULL, "TYPE53", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2077 {LDNS_RR_TYPE_NULL, "TYPE54", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2078 {LDNS_RR_TYPE_NULL, "TYPE55", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2079 {LDNS_RR_TYPE_NULL, "TYPE56", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2080 {LDNS_RR_TYPE_NULL, "TYPE57", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2081  /* 58 */
2082 {LDNS_RR_TYPE_TALINK, "TALINK", 2, 2, type_talink_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
2083 {LDNS_RR_TYPE_NULL, "TYPE59", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2084 {LDNS_RR_TYPE_NULL, "TYPE60", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2085 {LDNS_RR_TYPE_NULL, "TYPE61", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2086 {LDNS_RR_TYPE_NULL, "TYPE62", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2087 {LDNS_RR_TYPE_NULL, "TYPE63", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2088 {LDNS_RR_TYPE_NULL, "TYPE64", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2089 {LDNS_RR_TYPE_NULL, "TYPE65", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2090 {LDNS_RR_TYPE_NULL, "TYPE66", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2091 {LDNS_RR_TYPE_NULL, "TYPE67", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2092 {LDNS_RR_TYPE_NULL, "TYPE68", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2093 {LDNS_RR_TYPE_NULL, "TYPE69", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2094 {LDNS_RR_TYPE_NULL, "TYPE70", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2095 {LDNS_RR_TYPE_NULL, "TYPE71", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2096 {LDNS_RR_TYPE_NULL, "TYPE72", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2097 {LDNS_RR_TYPE_NULL, "TYPE73", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2098 {LDNS_RR_TYPE_NULL, "TYPE74", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2099 {LDNS_RR_TYPE_NULL, "TYPE75", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2100 {LDNS_RR_TYPE_NULL, "TYPE76", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2101 {LDNS_RR_TYPE_NULL, "TYPE77", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2102 {LDNS_RR_TYPE_NULL, "TYPE78", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2103 {LDNS_RR_TYPE_NULL, "TYPE79", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2104 {LDNS_RR_TYPE_NULL, "TYPE80", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2105 {LDNS_RR_TYPE_NULL, "TYPE81", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2106 {LDNS_RR_TYPE_NULL, "TYPE82", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2107 {LDNS_RR_TYPE_NULL, "TYPE83", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2108 {LDNS_RR_TYPE_NULL, "TYPE84", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2109 {LDNS_RR_TYPE_NULL, "TYPE85", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2110 {LDNS_RR_TYPE_NULL, "TYPE86", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2111 {LDNS_RR_TYPE_NULL, "TYPE87", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2112 {LDNS_RR_TYPE_NULL, "TYPE88", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2113 {LDNS_RR_TYPE_NULL, "TYPE89", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2114 {LDNS_RR_TYPE_NULL, "TYPE90", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2115 {LDNS_RR_TYPE_NULL, "TYPE91", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2116 {LDNS_RR_TYPE_NULL, "TYPE92", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2117 {LDNS_RR_TYPE_NULL, "TYPE93", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2118 {LDNS_RR_TYPE_NULL, "TYPE94", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2119 {LDNS_RR_TYPE_NULL, "TYPE95", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2120 {LDNS_RR_TYPE_NULL, "TYPE96", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2121 {LDNS_RR_TYPE_NULL, "TYPE97", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2122 {LDNS_RR_TYPE_NULL, "TYPE98", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2124 {LDNS_RR_TYPE_NULL, "TYPE100", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2125 {LDNS_RR_TYPE_NULL, "TYPE101", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2126 {LDNS_RR_TYPE_NULL, "TYPE102", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2127 {LDNS_RR_TYPE_NULL, "TYPE103", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2128 {LDNS_RR_TYPE_NULL, "TYPE104", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2129 {LDNS_RR_TYPE_NULL, "TYPE105", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2130 {LDNS_RR_TYPE_NULL, "TYPE106", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2131 {LDNS_RR_TYPE_NULL, "TYPE107", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2132 {LDNS_RR_TYPE_NULL, "TYPE108", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2133 {LDNS_RR_TYPE_NULL, "TYPE109", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2134 {LDNS_RR_TYPE_NULL, "TYPE110", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2135 {LDNS_RR_TYPE_NULL, "TYPE111", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2136 {LDNS_RR_TYPE_NULL, "TYPE112", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2137 {LDNS_RR_TYPE_NULL, "TYPE113", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2138 {LDNS_RR_TYPE_NULL, "TYPE114", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2139 {LDNS_RR_TYPE_NULL, "TYPE115", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2140 {LDNS_RR_TYPE_NULL, "TYPE116", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2141 {LDNS_RR_TYPE_NULL, "TYPE117", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2142 {LDNS_RR_TYPE_NULL, "TYPE118", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2143 {LDNS_RR_TYPE_NULL, "TYPE119", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2144 {LDNS_RR_TYPE_NULL, "TYPE120", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2145 {LDNS_RR_TYPE_NULL, "TYPE121", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2146 {LDNS_RR_TYPE_NULL, "TYPE122", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2147 {LDNS_RR_TYPE_NULL, "TYPE123", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2148 {LDNS_RR_TYPE_NULL, "TYPE124", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2149 {LDNS_RR_TYPE_NULL, "TYPE125", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2150 {LDNS_RR_TYPE_NULL, "TYPE126", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2151 {LDNS_RR_TYPE_NULL, "TYPE127", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2152 {LDNS_RR_TYPE_NULL, "TYPE128", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2153 {LDNS_RR_TYPE_NULL, "TYPE129", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2154 {LDNS_RR_TYPE_NULL, "TYPE130", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2155 {LDNS_RR_TYPE_NULL, "TYPE131", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2156 {LDNS_RR_TYPE_NULL, "TYPE132", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2157 {LDNS_RR_TYPE_NULL, "TYPE133", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2158 {LDNS_RR_TYPE_NULL, "TYPE134", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2159 {LDNS_RR_TYPE_NULL, "TYPE135", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2160 {LDNS_RR_TYPE_NULL, "TYPE136", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2161 {LDNS_RR_TYPE_NULL, "TYPE137", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2162 {LDNS_RR_TYPE_NULL, "TYPE138", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2163 {LDNS_RR_TYPE_NULL, "TYPE139", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2164 {LDNS_RR_TYPE_NULL, "TYPE140", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2165 {LDNS_RR_TYPE_NULL, "TYPE141", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2166 {LDNS_RR_TYPE_NULL, "TYPE142", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2167 {LDNS_RR_TYPE_NULL, "TYPE143", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2168 {LDNS_RR_TYPE_NULL, "TYPE144", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2169 {LDNS_RR_TYPE_NULL, "TYPE145", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2170 {LDNS_RR_TYPE_NULL, "TYPE146", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2171 {LDNS_RR_TYPE_NULL, "TYPE147", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2172 {LDNS_RR_TYPE_NULL, "TYPE148", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2173 {LDNS_RR_TYPE_NULL, "TYPE149", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2174 {LDNS_RR_TYPE_NULL, "TYPE150", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2175 {LDNS_RR_TYPE_NULL, "TYPE151", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2176 {LDNS_RR_TYPE_NULL, "TYPE152", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2177 {LDNS_RR_TYPE_NULL, "TYPE153", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2178 {LDNS_RR_TYPE_NULL, "TYPE154", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2179 {LDNS_RR_TYPE_NULL, "TYPE155", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2180 {LDNS_RR_TYPE_NULL, "TYPE156", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2181 {LDNS_RR_TYPE_NULL, "TYPE157", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2182 {LDNS_RR_TYPE_NULL, "TYPE158", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2183 {LDNS_RR_TYPE_NULL, "TYPE159", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2184 {LDNS_RR_TYPE_NULL, "TYPE160", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2185 {LDNS_RR_TYPE_NULL, "TYPE161", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2186 {LDNS_RR_TYPE_NULL, "TYPE162", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2187 {LDNS_RR_TYPE_NULL, "TYPE163", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2188 {LDNS_RR_TYPE_NULL, "TYPE164", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2189 {LDNS_RR_TYPE_NULL, "TYPE165", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2190 {LDNS_RR_TYPE_NULL, "TYPE166", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2191 {LDNS_RR_TYPE_NULL, "TYPE167", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2192 {LDNS_RR_TYPE_NULL, "TYPE168", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2193 {LDNS_RR_TYPE_NULL, "TYPE169", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2194 {LDNS_RR_TYPE_NULL, "TYPE170", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2195 {LDNS_RR_TYPE_NULL, "TYPE171", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2196 {LDNS_RR_TYPE_NULL, "TYPE172", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2197 {LDNS_RR_TYPE_NULL, "TYPE173", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2198 {LDNS_RR_TYPE_NULL, "TYPE174", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2199 {LDNS_RR_TYPE_NULL, "TYPE175", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2200 {LDNS_RR_TYPE_NULL, "TYPE176", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2201 {LDNS_RR_TYPE_NULL, "TYPE177", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2202 {LDNS_RR_TYPE_NULL, "TYPE178", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2203 {LDNS_RR_TYPE_NULL, "TYPE179", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2204 {LDNS_RR_TYPE_NULL, "TYPE180", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2205 {LDNS_RR_TYPE_NULL, "TYPE181", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2206 {LDNS_RR_TYPE_NULL, "TYPE182", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2207 {LDNS_RR_TYPE_NULL, "TYPE183", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2208 {LDNS_RR_TYPE_NULL, "TYPE184", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2209 {LDNS_RR_TYPE_NULL, "TYPE185", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2210 {LDNS_RR_TYPE_NULL, "TYPE186", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2211 {LDNS_RR_TYPE_NULL, "TYPE187", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2212 {LDNS_RR_TYPE_NULL, "TYPE188", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2213 {LDNS_RR_TYPE_NULL, "TYPE189", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2214 {LDNS_RR_TYPE_NULL, "TYPE190", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2215 {LDNS_RR_TYPE_NULL, "TYPE191", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2216 {LDNS_RR_TYPE_NULL, "TYPE192", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2217 {LDNS_RR_TYPE_NULL, "TYPE193", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2218 {LDNS_RR_TYPE_NULL, "TYPE194", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2219 {LDNS_RR_TYPE_NULL, "TYPE195", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2220 {LDNS_RR_TYPE_NULL, "TYPE196", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2221 {LDNS_RR_TYPE_NULL, "TYPE197", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2222 {LDNS_RR_TYPE_NULL, "TYPE198", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2223 {LDNS_RR_TYPE_NULL, "TYPE199", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2224 {LDNS_RR_TYPE_NULL, "TYPE200", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2225 {LDNS_RR_TYPE_NULL, "TYPE201", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2226 {LDNS_RR_TYPE_NULL, "TYPE202", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2227 {LDNS_RR_TYPE_NULL, "TYPE203", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2228 {LDNS_RR_TYPE_NULL, "TYPE204", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2229 {LDNS_RR_TYPE_NULL, "TYPE205", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2230 {LDNS_RR_TYPE_NULL, "TYPE206", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2231 {LDNS_RR_TYPE_NULL, "TYPE207", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2232 {LDNS_RR_TYPE_NULL, "TYPE208", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2233 {LDNS_RR_TYPE_NULL, "TYPE209", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2234 {LDNS_RR_TYPE_NULL, "TYPE210", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2235 {LDNS_RR_TYPE_NULL, "TYPE211", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2236 {LDNS_RR_TYPE_NULL, "TYPE212", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2237 {LDNS_RR_TYPE_NULL, "TYPE213", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2238 {LDNS_RR_TYPE_NULL, "TYPE214", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2239 {LDNS_RR_TYPE_NULL, "TYPE215", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2240 {LDNS_RR_TYPE_NULL, "TYPE216", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2241 {LDNS_RR_TYPE_NULL, "TYPE217", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2242 {LDNS_RR_TYPE_NULL, "TYPE218", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2243 {LDNS_RR_TYPE_NULL, "TYPE219", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2244 {LDNS_RR_TYPE_NULL, "TYPE220", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2245 {LDNS_RR_TYPE_NULL, "TYPE221", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2246 {LDNS_RR_TYPE_NULL, "TYPE222", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2247 {LDNS_RR_TYPE_NULL, "TYPE223", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2248 {LDNS_RR_TYPE_NULL, "TYPE224", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2249 {LDNS_RR_TYPE_NULL, "TYPE225", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2250 {LDNS_RR_TYPE_NULL, "TYPE226", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2251 {LDNS_RR_TYPE_NULL, "TYPE227", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2252 {LDNS_RR_TYPE_NULL, "TYPE228", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2253 {LDNS_RR_TYPE_NULL, "TYPE229", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2254 {LDNS_RR_TYPE_NULL, "TYPE230", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2255 {LDNS_RR_TYPE_NULL, "TYPE231", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2256 {LDNS_RR_TYPE_NULL, "TYPE232", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2257 {LDNS_RR_TYPE_NULL, "TYPE233", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2258 {LDNS_RR_TYPE_NULL, "TYPE234", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2259 {LDNS_RR_TYPE_NULL, "TYPE235", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2260 {LDNS_RR_TYPE_NULL, "TYPE236", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2261 {LDNS_RR_TYPE_NULL, "TYPE237", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2262 {LDNS_RR_TYPE_NULL, "TYPE238", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2263 {LDNS_RR_TYPE_NULL, "TYPE239", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2264 {LDNS_RR_TYPE_NULL, "TYPE240", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2265 {LDNS_RR_TYPE_NULL, "TYPE241", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2266 {LDNS_RR_TYPE_NULL, "TYPE242", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2267 {LDNS_RR_TYPE_NULL, "TYPE243", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2268 {LDNS_RR_TYPE_NULL, "TYPE244", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2269 {LDNS_RR_TYPE_NULL, "TYPE245", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2270 {LDNS_RR_TYPE_NULL, "TYPE246", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2271 {LDNS_RR_TYPE_NULL, "TYPE247", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2272 {LDNS_RR_TYPE_NULL, "TYPE248", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2273 {LDNS_RR_TYPE_NULL, "TYPE249", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2274 /* LDNS_RDF_TYPE_INT16_DATA essentially takes two fields (length and data) and
2275  * makes them into one. So, while in rfc 2845 is specified that a TSIG may have
2276  * 8 or 9 rdata fields, by this implementation, the min/max are 7 each.
2277  */
2278 {LDNS_RR_TYPE_TSIG, "TSIG", 7, 7, type_tsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2279 /* split in array, no longer contiguous */
2280 {LDNS_RR_TYPE_DLV, "DLV", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }
2281 };
2288 #define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \
2289  (sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0]))
2290 
2291 const ldns_rr_descriptor *
2292 ldns_rr_descript(uint16_t type)
2293 {
2294  size_t i;
2296  return &rdata_field_descriptors[type];
2297  } else {
2298  /* because not all array index equals type code */
2301  i++) {
2302  if (rdata_field_descriptors[i]._type == type) {
2303  return &rdata_field_descriptors[i];
2304  }
2305  }
2306  return &rdata_field_descriptors[0];
2307  }
2308 }
2309 
2310 size_t
2312 {
2313  if (descriptor) {
2314  return descriptor->_minimum;
2315  } else {
2316  return 0;
2317  }
2318 }
2319 
2320 size_t
2322 {
2323  if (descriptor) {
2324  if (descriptor->_variable != LDNS_RDF_TYPE_NONE) {
2325  /* Should really be SIZE_MAX... bad FreeBSD. */
2326  return UINT_MAX;
2327  } else {
2328  return descriptor->_maximum;
2329  }
2330  } else {
2331  return 0;
2332  }
2333 }
2334 
2337  size_t index)
2338 {
2339  assert(descriptor != NULL);
2340  assert(index < descriptor->_maximum
2341  || descriptor->_variable != LDNS_RDF_TYPE_NONE);
2342  if (index < descriptor->_maximum) {
2343  return descriptor->_wireformat[index];
2344  } else {
2345  return descriptor->_variable;
2346  }
2347 }
2348 
2350 ldns_get_rr_type_by_name(const char *name)
2351 {
2352  unsigned int i;
2353  const char *desc_name;
2354  const ldns_rr_descriptor *desc;
2355 
2356  /* TYPEXX representation */
2357  if (strlen(name) > 4 && strncasecmp(name, "TYPE", 4) == 0) {
2358  return atoi(name + 4);
2359  }
2360 
2361  /* Normal types */
2362  for (i = 0; i < (unsigned int) LDNS_RDATA_FIELD_DESCRIPTORS_COUNT; i++) {
2363  desc = &rdata_field_descriptors[i];
2364  desc_name = desc->_name;
2365  if(desc_name &&
2366  strlen(name) == strlen(desc_name) &&
2367  strncasecmp(name, desc_name, strlen(desc_name)) == 0) {
2368  /* because not all array index equals type code */
2369  return desc->_type;
2370  }
2371  }
2372 
2373  /* special cases for query types */
2374  if (strlen(name) == 4 && strncasecmp(name, "IXFR", 4) == 0) {
2375  return 251;
2376  } else if (strlen(name) == 4 && strncasecmp(name, "AXFR", 4) == 0) {
2377  return 252;
2378  } else if (strlen(name) == 5 && strncasecmp(name, "MAILB", 5) == 0) {
2379  return 253;
2380  } else if (strlen(name) == 5 && strncasecmp(name, "MAILA", 5) == 0) {
2381  return 254;
2382  } else if (strlen(name) == 3 && strncasecmp(name, "ANY", 3) == 0) {
2383  return 255;
2384  }
2385 
2386  return 0;
2387 }
2388 
2390 ldns_get_rr_class_by_name(const char *name)
2391 {
2392  ldns_lookup_table *lt;
2393 
2394  /* CLASSXX representation */
2395  if (strlen(name) > 5 && strncasecmp(name, "CLASS", 5) == 0) {
2396  return atoi(name + 5);
2397  }
2398 
2399  /* Normal types */
2401 
2402  if (lt) {
2403  return lt->id;
2404  }
2405  return 0;
2406 }
2407 
2408 
2411 {
2412  ldns_rr_type r;
2413 
2414  if (!rd) {
2415  return 0;
2416  }
2417 
2419  return 0;
2420  }
2421 
2423  return r;
2424 }
2425 
2428 {
2429  if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) {
2430  return ldns_rr_get_type(ldns_rr_list_rr(rr_list, 0));
2431  } else {
2432  return 0;
2433  }
2434 }
2435 
2436 ldns_rdf *
2438 {
2439  if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) {
2440  return ldns_rr_owner(ldns_rr_list_rr(rr_list, 0));
2441  } else {
2442  return NULL;
2443  }
2444 }
ldns_rdf * ldns_rr_rdf(const ldns_rr *rr, size_t nr)
returns the rdata field member counter.
Definition: rr.c:848
RFC1183.
Definition: rr.h:121
implementation of buffers to ease operations
Definition: buffer.h:50
mailbox or mail list information
Definition: rr.h:109
RFC1183.
Definition: rr.h:123
time (32 bits)
Definition: rdata.h:83
ldns_rr_list * ldns_rr_list_new()
creates a new rr_list structure.
Definition: rr.c:939
bool ldns_is_rrset(ldns_rr_list *rr_list)
checks if an rr_list is a rrset.
Definition: rr.c:1197
size_t _rr_count
Definition: rr.h:308
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:779
ldns_rr * ldns_rr_clone(const ldns_rr *rr)
clones a rr and all its data
Definition: rr.c:1338
void ldns_rdf_deep_free(ldns_rdf *rd)
frees a rdf structure and frees the data.
Definition: rdata.c:230
2535typecode
Definition: rr.h:141
void ldns_rr_set_rd_count(ldns_rr *rr, size_t count)
sets the rd_count in the rr.
Definition: rr.c:761
void ldns_rr_set_type(ldns_rr *rr, ldns_rr_type rr_type)
sets the type in the rr.
Definition: rr.c:767
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
RFC1183.
Definition: rr.h:117
bool ldns_rr_compare_ds(const ldns_rr *orr1, const ldns_rr *orr2)
returns true of the given rr&#39;s are equal.
Definition: rr.c:1666
void ldns_rr2canonical(ldns_rr *rr)
converts each dname in a rr to its canonical form.
Definition: rr.c:1737
the canonical name for an alias
Definition: rr.h:91
a host address
Definition: rr.h:83
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&#39;s).
Definition: rr.c:1232
#define LDNS_DEFAULT_TTL
Definition: ldns.h:134
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:2410
DNSSEC.
Definition: rr.h:173
b64 string
Definition: rdata.h:67
int ldns_dname_compare(const ldns_rdf *dname1, const ldns_rdf *dname2)
Compares the two dname rdf&#39;s according to the algorithm for ordering in RFC4034 Section 6...
Definition: dname.c:356
Pseudo OPT record...
Definition: rr.h:163
enum ldns_enum_rr_class ldns_rr_class
Definition: rr.h:64
bool ldns_rr_list_push_rr(ldns_rr_list *rr_list, const ldns_rr *rr)
pushes an rr to an rrlist.
Definition: rr.c:1071
compression is allowed
Definition: rr.h:72
bool ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, 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:1178
List or Set of Resource Records.
Definition: rr.h:306
bool ldns_rr_is_question(const ldns_rr *rr)
returns the question flag of an rr structure.
Definition: rr.c:864
a null RR (EXPERIMENTAL)
Definition: rr.h:101
uint8_t ldns_rdf2native_int8(const ldns_rdf *rd)
returns the native uint8_t representation from the rdf.
Definition: rdata.c:70
unknown types
Definition: rdata.h:81
#define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT
computes the number of rdata fields
Definition: rr.c:2288
RFC2163.
Definition: rr.h:133
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:2336
RFC2538.
Definition: rr.h:155
a RR type
Definition: rdata.h:73
#define LDNS_XMALLOC(type, count)
Definition: util.h:51
#define LDNS_TTL_DATALEN
Definition: rr.c:20
RFC2230.
Definition: rr.h:153
size_t ldns_rdf_size(const ldns_rdf *rd)
returns the size of the rdf.
Definition: rdata.c:24
enum ldns_enum_hash ldns_hash
Definition: keys.h:74
void ldns_rr_list_deep_free(ldns_rr_list *rr_list)
frees an rr_list structure and all rrs contained therein.
Definition: rr.c:959
void ldns_buffer_free(ldns_buffer *buffer)
frees the buffer.
Definition: buffer.c:137
ldns_rr_class _rr_class
Class of the resource record.
Definition: rr.h:289
ldns_rr_list * ldns_rr_list_subtype_by_rdf(ldns_rr_list *l, ldns_rdf *r, size_t pos)
Return the rr_list which matches the rdf at position field.
Definition: rr.c:1037
ldns_rr * ldns_rr_new_frm_type(ldns_rr_type t)
creates a new rr structure, based on the given type.
Definition: rr.c:42
ldns_rdf * ldns_rdf_clone(const ldns_rdf *rd)
clones a rdf structure.
Definition: rdata.c:222
http://www.jhsoft.com/rfc/af-saa-0069.000.rtf
Definition: rr.h:149
void ldns_dname2canonical(const ldns_rdf *rd)
Put a dname into canonical fmt - ie.
Definition: dname.c:277
uint8_t _maximum
Maximum number of rdata fields in the RRs of this type.
Definition: rr.h:328
int qsort_rr_compare(const void *a, const void *b)
Definition: rr.c:1399
size_t ldns_rr_rd_count(const ldns_rr *rr)
returns the rd_count of an rr structure.
Definition: rr.c:876
#define LDNS_MAX_PACKETLEN
Definition: packet.h:24
void ldns_rr_free(ldns_rr *rr)
frees an RR structure
Definition: rr.c:75
ldns_lookup_table ldns_rr_classes[]
rr types
Definition: host2str.c:82
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:217
ldns_rr_type ldns_get_rr_type_by_name(const char *name)
retrieves a rrtype by looking up its name.
Definition: rr.c:2350
IPSECKEY.
Definition: rdata.h:103
2535typecode
Definition: rr.h:131
int qsort_schwartz_rr_compare(const void *a, const void *b)
Definition: rr.c:1417
void ldns_rr_list_free(ldns_rr_list *rr_list)
frees an rr_list structure.
Definition: rr.c:950
size_t ldns_rr_uncompressed_size(const ldns_rr *r)
calculates the uncompressed size of an RR.
Definition: rr.c:1720
#define LDNS_XREALLOC(ptr, type, count)
Definition: util.h:57
const ldns_rr_descriptor * ldns_rr_descript(uint16_t type)
returns the resource record descriptor for the given rr type.
Definition: rr.c:2292
apl data
Definition: rdata.h:63
Resource Record.
Definition: rr.h:278
text strings
Definition: rr.h:113
a mailbox domain name (EXPERIMENTAL)
Definition: rr.h:95
size_t _rd_count
Number of data fields.
Definition: rr.h:285
ldns_status ldns_rr_new_frm_str(ldns_rr **newrr, const char *str, uint32_t default_ttl, ldns_rdf *origin, ldns_rdf **prev)
creates an rr from a string.
Definition: rr.c:624
Including this file will include all ldns files, and define some lookup tables.
ldns_rdf * ldns_dname_new_frm_str(const char *str)
creates a new dname rdf from a string.
Definition: dname.c:265
ipv6 address
Definition: rr.h:137
certificate algorithm
Definition: rdata.h:77
marks the start of a zone of authority
Definition: rr.h:93
SSH Key Fingerprint.
Definition: rr.h:169
uint8_t * ldns_rdf_data(const ldns_rdf *rd)
returns the data of the rdf.
Definition: rdata.c:38
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:929
size_t _rr_capacity
Definition: rr.h:309
void ldns_rr_set_class(ldns_rr *rr, ldns_rr_class rr_class)
sets the class in the rr.
Definition: rr.c:773
enum ldns_enum_rdf_type ldns_rdf_type
Definition: rdata.h:109
void ldns_rdf_set_type(ldns_rdf *rd, ldns_rdf_type type)
sets the size of the rdf.
Definition: rdata.c:53
#define LDNS_RRLIST_INIT
Definition: rr.c:21
16 bits
Definition: rdata.h:53
ldns_rdf_type _variable
Special rdf types.
Definition: rr.h:332
void ldns_rr_set_question(ldns_rr *rr, bool question)
Definition: rr.c:749
RFC1183.
Definition: rr.h:119
#define LDNS_MAX_DOMAINLEN
Maximum length of a complete dname.
Definition: rr.h:33
bogus section, if not interested
Definition: packet.h:278
ldns_rr * ldns_rr_list_pop_rr(ldns_rr_list *rr_list)
pops the last rr from an rrlist.
Definition: rr.c:1116
variable length any type rdata where the length is specified by the first 2 bytes ...
Definition: rdata.h:91
a key algorithm
Definition: rdata.h:79
uint16_t ldns_rdf2native_int16(const ldns_rdf *rd)
returns the native uint16_t representation from the rdf.
Definition: rdata.c:84
A record.
Definition: rdata.h:57
Structure to do a Schwartzian-like transformation, for instance when sorting.
Definition: util.h:144
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:819
nsec type codes
Definition: rdata.h:71
return NULL
Definition: keys.c:738
ldns_rr * ldns_rr_set_pop_rr(ldns_rr_list *rr_list)
pops the last rr from an rrset.
Definition: rr.c:1280
the Internet
Definition: rr.h:50
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:85
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:2321
AAAA record.
Definition: rdata.h:59
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:1102
a well known service description
Definition: rr.h:103
draft-ietf-dane-protocol
Definition: rr.h:183
32 bits
Definition: rdata.h:55
ldns_rdf * ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str)
creates a new rdf from a string.
Definition: rdata.c:249
ldns_status ldns_dname_cat(ldns_rdf *rd1, ldns_rdf *rd2)
concatenates rd2 after rd1 (rd2 is copied, rd1 is modified)
Definition: dname.c:90
dnsind-kitchen-sink-02.txt
Definition: rr.h:161
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:160
Contains all information about resource record types.
Definition: rr.h:319
int ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2)
compares two rrs.
Definition: rr.c:1594
IPsec Key.
Definition: rr.h:171
draft-ietf-dnsext-delegation
Definition: rr.h:167
void ldns_rr_list_set_rr_count(ldns_rr_list *rr_list, size_t count)
sets the number of rr&#39;s in an rr_list.
Definition: rr.c:922
#define LDNS_RDATA_FIELD_DESCRIPTORS_COMMON
Definition: rr.h:40
ldns_rr_list * ldns_rr_list_clone(const ldns_rr_list *rrlist)
clones an rrlist.
Definition: rr.c:1369
RFC1706.
Definition: rr.h:125
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:1148
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:2437
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
hex string
Definition: rdata.h:69
ldns_rr_list * ldns_rr_list_cat_clone(ldns_rr_list *left, ldns_rr_list *right)
concatenates two ldns_rr_lists together, but makes clones of the rr&#39;s (instead of pointer copying)...
Definition: rr.c:998
ldns_rdf_type ldns_rdf_get_type(const ldns_rdf *rd)
returns the type of the rdf.
Definition: rdata.c:31
a domain name pointer
Definition: rr.h:105
void ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner)
sets the owner in the rr structure.
Definition: rr.c:743
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:906
txt string
Definition: rdata.h:61
RFC2874.
Definition: rr.h:157
ldns_rr_type ldns_rr_get_type(const ldns_rr *rr)
returns the type of the rr.
Definition: rr.c:882
tsig time 48 bits
Definition: rdata.h:87
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&#39;s from each rrset are nex...
Definition: rr.c:1286
uint32_t ldns_str2period(const char *nptr, const char **endptr)
converts a ttl value (like 5d2h) to a long.
Definition: rdata.c:603
int ldns_rr_compare_no_rdata(const ldns_rr *rr1, const ldns_rr *rr2)
compares two rrs, up to the rdata.
Definition: rr.c:1515
RFC1712.
Definition: rr.h:135
draft-ietf-nimrod-dns-01.txt
Definition: rr.h:143
nsec3 base32 string (with length byte on wire
Definition: rdata.h:107
a mail group member (EXPERIMENTAL)
Definition: rr.h:97
void ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl)
sets the ttl in the rr structure.
Definition: rr.c:755
enum ldns_enum_status ldns_status
Definition: error.h:122
a mail destination (Obsolete - use MX)
Definition: rr.h:87
#define LDNS_MALLOC(type)
Memory management macros.
Definition: util.h:49
2535typecode
Definition: rr.h:129
bool ldns_dname_str_absolute(const char *dname_str)
Checks whether the given dname string is absolute (i.e.
Definition: dname.c:515
ldns_buffer * ldns_buffer_new(size_t capacity)
creates a new buffer with the specified capacity.
Definition: buffer.c:16
A general purpose lookup table.
Definition: util.h:156
ldns_rr ** _rrs
Definition: rr.h:310
#define LDNS_PARSE_SKIP_SPACE
Definition: parse.h:20
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:655
LOC record RFC1876.
Definition: rr.h:139
ldns_rdf * _owner
Owner name, uncompressed.
Definition: rr.h:281
SRV record RFC2782.
Definition: rr.h:147
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:2311
int ldns_hexstring_to_data(uint8_t *data, const char *str)
Converts a hex string to binary data.
Definition: util.c:174
uint8_t _minimum
Minimum number of rdata fields in the RRs of this type.
Definition: rr.h:326
host information
Definition: rr.h:107
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:796
RFC1348.
Definition: rr.h:127
a mail rename domain name (EXPERIMENTAL)
Definition: rr.h:99
uint32_t _ttl
Time to live.
Definition: rr.h:283
#define LDNS_MAX_LINELEN
Definition: parse.h:23
RFC2915.
Definition: rr.h:151
Resource record data field.
Definition: rdata.h:138
ldns_lookup_table * ldns_lookup_by_name(ldns_lookup_table *table, const char *name)
Definition: util.c:66
RFC3123.
Definition: rr.h:165
uint8_t ldns_rr_label_count(ldns_rr *rr)
counts the number of labels of the ownername.
Definition: rr.c:1798
nsec3 hash salt
Definition: rdata.h:105
ldns_rr_class ldns_get_rr_class_by_name(const char *name)
retrieves a class by looking up its name.
Definition: rr.c:2390
8 bits
Definition: rdata.h:51
ldns_rdf * ldns_rr_owner(const ldns_rr *rr)
returns the owner name of an rr structure.
Definition: rr.c:858
ldns_rr * ldns_rr_new(void)
creates a new rr structure.
Definition: rr.c:24
ldns_status ldns_rr_new_question_frm_str(ldns_rr **newrr, const char *str, ldns_rdf *origin, ldns_rdf **prev)
creates an rr for the question section from a string, i.e.
Definition: rr.c:637
size_t ldns_rr_list_rr_count(const ldns_rr_list *rr_list)
returns the number of rr&#39;s in an rr_list.
Definition: rr.c:896
enum ldns_enum_rr_type ldns_rr_type
Definition: rr.h:215
const char * _name
Textual name of the RR type.
Definition: rr.h:324
#define LDNS_FREE(ptr)
Definition: util.h:60
an authoritative name server
Definition: rr.h:85
ldns_rdf ** _rdata_fields
The array of rdata&#39;s.
Definition: rr.h:292
signed char _rr_question
question rr [it would be nicer if thous is after _rd_count] ABI change: Fix this in next major releas...
Definition: rr.h:296
void ldns_rr_list2canonical(ldns_rr_list *rr_list)
converts each dname in each rr in a rr_list to its canonical form.
Definition: rr.c:1789
int ldns_rr_list_compare(const ldns_rr_list *rrl1, const ldns_rr_list *rrl2)
compares two rr listss.
Definition: rr.c:1693
uint32_t ldns_rr_ttl(const ldns_rr *rr)
returns the ttl of an rr structure.
Definition: rr.c:870
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:2427
#define LDNS_SYNTAX_DATALEN
Definition: rr.c:19
ldns_rr_class ldns_rr_get_class(const ldns_rr *rr)
returns the class of the rr.
Definition: rr.c:888
draft-ietf-dnsop-trust-history
Definition: rr.h:186
domain name
Definition: rdata.h:49
bool ldns_rr_list_cat(ldns_rr_list *left, ldns_rr_list *right)
concatenates two ldns_rr_lists together.
Definition: rr.c:975
location data
Definition: rdata.h:95
mail exchange
Definition: rr.h:111
void ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size)
creates a buffer with the specified data.
Definition: buffer.c:41
#define LDNS_RR_OVERHEAD
The bytes TTL, CLASS and length use up in an rr.
Definition: rr.h:37
#define LDNS_MAX_RDFLEN
Definition: rdata.h:31
RFC1183.
Definition: rr.h:115
ldns_rr_type _rr_type
the type of the RR.
Definition: rr.h:287
void ldns_rr_list_sort(ldns_rr_list *unsorted)
sorts an rr_list (canonical wire format).
Definition: rr.c:1472
draft-ietf-nimrod-dns-01.txt
Definition: rr.h:145
well known services
Definition: rdata.h:97
dsa p
Definition: keys.c:683
RFC2672.
Definition: rr.h:159
int ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2)
compares two rdf&#39;s on their wire formats.
Definition: rdata.c:569
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:649
a mail forwarder (Obsolete - use MX)
Definition: rr.h:89
int
Definition: dnssec.c:1575
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:156
int ldns_rr_compare_wire(ldns_buffer *rr1_buf, ldns_buffer *rr2_buf)
compares the wireformat of two rrs, contained in the given buffers.
Definition: rr.c:1556
i
Definition: keys.c:681
ldns_rr_type _type
Type of the RR that is described here.
Definition: rr.h:322
const ldns_rdf_type * _wireformat
Wireformat specification for the rr, i.e.
Definition: rr.h:330
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:474