ldns  1.7.0
str2host.c
Go to the documentation of this file.
1 /*
2  * str2host.c
3  *
4  * conversion routines from the presentation format
5  * to the host format
6  *
7  * a Net::DNS like library for C
8  *
9  * (c) NLnet Labs, 2004-2006
10  *
11  * See the file LICENSE for the license
12  */
13 #include <ldns/config.h>
14 
15 #include <ldns/ldns.h>
16 
17 #ifdef HAVE_SYS_SOCKET_H
18 #include <sys/socket.h>
19 #endif
20 #ifdef HAVE_ARPA_INET_H
21 #include <arpa/inet.h>
22 #endif
23 #include <time.h>
24 
25 #include <errno.h>
26 #ifdef HAVE_NETDB_H
27 #include <netdb.h>
28 #endif
29 
30 #include <limits.h>
31 #ifdef HAVE_SYS_PARAM_H
32 #include <sys/param.h>
33 #endif
34 
36 ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr)
37 {
38  char *end = NULL;
39  uint16_t *r;
40  r = LDNS_MALLOC(uint16_t);
41  if(!r) return LDNS_STATUS_MEM_ERR;
42 
43  *r = htons((uint16_t)strtol((char *)shortstr, &end, 10));
44 
45  if(*end != 0) {
46  LDNS_FREE(r);
48  } else {
50  LDNS_RDF_TYPE_INT16, sizeof(uint16_t), r);
51  LDNS_FREE(r);
53  }
54 }
55 
57 ldns_str2rdf_time(ldns_rdf **rd, const char *time)
58 {
59  /* convert a time YYYYDDMMHHMMSS to wireformat */
60  uint32_t *r = NULL;
61  struct tm tm;
62  uint32_t l;
63  char *end;
64 
65  /* Try to scan the time... */
66  r = (uint32_t *)LDNS_MALLOC(uint32_t);
67  if(!r) return LDNS_STATUS_MEM_ERR;
68 
69  memset(&tm, 0, sizeof(tm));
70 
71  if (strlen(time) == 14 &&
72  sscanf(time, "%4d%2d%2d%2d%2d%2d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec) == 6
73  ) {
74  tm.tm_year -= 1900;
75  tm.tm_mon--;
76  /* Check values */
77  if (tm.tm_year < 70) {
78  goto bad_format;
79  }
80  if (tm.tm_mon < 0 || tm.tm_mon > 11) {
81  goto bad_format;
82  }
83  if (tm.tm_mday < 1 || tm.tm_mday > 31) {
84  goto bad_format;
85  }
86 
87  if (tm.tm_hour < 0 || tm.tm_hour > 23) {
88  goto bad_format;
89  }
90 
91  if (tm.tm_min < 0 || tm.tm_min > 59) {
92  goto bad_format;
93  }
94 
95  if (tm.tm_sec < 0 || tm.tm_sec > 59) {
96  goto bad_format;
97  }
98 
99  l = htonl(ldns_mktime_from_utc(&tm));
100  memcpy(r, &l, sizeof(uint32_t));
101  *rd = ldns_rdf_new_frm_data(
102  LDNS_RDF_TYPE_TIME, sizeof(uint32_t), r);
103  LDNS_FREE(r);
105  } else {
106  /* handle it as 32 bits timestamp */
107  l = htonl((uint32_t)strtol((char*)time, &end, 10));
108  if(*end != 0) {
109  LDNS_FREE(r);
110  return LDNS_STATUS_ERR;
111  } else {
112  memcpy(r, &l, sizeof(uint32_t));
113  *rd = ldns_rdf_new_frm_data(
114  LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
115  LDNS_FREE(r);
117  }
118  }
119 
120  bad_format:
121  LDNS_FREE(r);
123 }
124 
126 ldns_str2rdf_nsec3_salt(ldns_rdf **rd, const char *salt_str)
127 {
128  uint8_t salt_length;
129  int c;
130  int salt_length_str;
131 
132  uint8_t *salt;
133  uint8_t *data;
134  if(rd == NULL) {
135  return LDNS_STATUS_NULL;
136  }
137 
138  salt_length_str = (int)strlen(salt_str);
139  if (salt_length_str == 1 && salt_str[0] == '-') {
140  salt_length_str = 0;
141  } else if (salt_length_str % 2 != 0) {
143  }
144  if (salt_length_str > 512) {
146  }
147 
148  salt = LDNS_XMALLOC(uint8_t, salt_length_str / 2);
149  if(!salt) {
150  return LDNS_STATUS_MEM_ERR;
151  }
152  for (c = 0; c < salt_length_str; c += 2) {
153  if (isxdigit((int) salt_str[c]) && isxdigit((int) salt_str[c+1])) {
154  salt[c/2] = (uint8_t) ldns_hexdigit_to_int(salt_str[c]) * 16 +
155  ldns_hexdigit_to_int(salt_str[c+1]);
156  } else {
157  LDNS_FREE(salt);
159  }
160  }
161  salt_length = (uint8_t) (salt_length_str / 2);
162 
163  data = LDNS_XMALLOC(uint8_t, 1 + salt_length);
164  if(!data) {
165  LDNS_FREE(salt);
166  return LDNS_STATUS_MEM_ERR;
167  }
168  data[0] = salt_length;
169  memcpy(&data[1], salt, salt_length);
170  *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_NSEC3_SALT, 1 + salt_length, data);
171  LDNS_FREE(data);
172  LDNS_FREE(salt);
173 
175 }
176 
178 ldns_str2rdf_period(ldns_rdf **rd,const char *period)
179 {
180  uint32_t p;
181  const char *end;
182 
183  /* Allocate required space... */
184  p = ldns_str2period(period, &end);
185 
186  if (*end != 0) {
187  return LDNS_STATUS_ERR;
188  } else {
189  p = (uint32_t) htonl(p);
190  *rd = ldns_rdf_new_frm_data(
191  LDNS_RDF_TYPE_PERIOD, sizeof(uint32_t), &p);
192  }
194 }
195 
197 ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr)
198 {
199  char *end;
200  uint32_t *r = NULL;
201  uint32_t l;
202 
203  r = (uint32_t*)LDNS_MALLOC(uint32_t);
204  if(!r) return LDNS_STATUS_MEM_ERR;
205  errno = 0; /* must set to zero before call,
206  note race condition on errno */
207  if(*longstr == '-')
208  l = htonl((uint32_t)strtol((char*)longstr, &end, 10));
209  else l = htonl((uint32_t)strtoul((char*)longstr, &end, 10));
210 
211  if(*end != 0) {
212  LDNS_FREE(r);
213  return LDNS_STATUS_ERR;
214  } else {
215  if (errno == ERANGE) {
216  LDNS_FREE(r);
218  }
219  memcpy(r, &l, sizeof(uint32_t));
220  *rd = ldns_rdf_new_frm_data(
221  LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
222  LDNS_FREE(r);
224  }
225 }
226 
228 ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr)
229 {
230  char *end;
231  uint8_t *r = NULL;
232 
233  r = LDNS_MALLOC(uint8_t);
234  if(!r) return LDNS_STATUS_MEM_ERR;
235 
236  *r = (uint8_t)strtol((char*)bytestr, &end, 10);
237 
238  if(*end != 0) {
239  LDNS_FREE(r);
240  return LDNS_STATUS_ERR;
241  } else {
242  *rd = ldns_rdf_new_frm_data(
243  LDNS_RDF_TYPE_INT8, sizeof(uint8_t), r);
244  LDNS_FREE(r);
246  }
247 }
248 
249 
250 /*
251  * Checks whether the escaped value at **s is an decimal value or
252  * a 'normally' escaped character (and not eos)
253  *
254  * The string pointer at *s is increased by either 0 (on error), 1 (on
255  * normal escapes), or 3 (on decimals)
256  *
257  * Returns the number of bytes read from the escaped string, or
258  * 0 on error
259  */
260 INLINE bool
261 parse_escape(uint8_t *ch_p, const char** str_p)
262 {
263  uint16_t val;
264 
265  if ((*str_p)[0] && isdigit((unsigned char)(*str_p)[0]) &&
266  (*str_p)[1] && isdigit((unsigned char)(*str_p)[1]) &&
267  (*str_p)[2] && isdigit((unsigned char)(*str_p)[2])) {
268 
269  val = (uint16_t)(((*str_p)[0] - '0') * 100 +
270  ((*str_p)[1] - '0') * 10 +
271  ((*str_p)[2] - '0'));
272 
273  if (val > 255) {
274  goto error;
275  }
276  *ch_p = (uint8_t)val;
277  *str_p += 3;
278  return true;
279 
280  } else if ((*str_p)[0] && !isdigit((unsigned char)(*str_p)[0])) {
281 
282  *ch_p = (uint8_t)*(*str_p)++;
283  return true;
284  }
285 error:
286  *str_p = NULL;
287  return false; /* LDNS_STATUS_SYNTAX_BAD_ESCAPE */
288 }
289 
290 INLINE bool
291 parse_char(uint8_t *ch_p, const char** str_p)
292 {
293  switch (**str_p) {
294 
295  case '\0': return false;
296 
297  case '\\': *str_p += 1;
298  return parse_escape(ch_p, str_p);
299 
300  default: *ch_p = (uint8_t)*(*str_p)++;
301  return true;
302  }
303 }
304 
305 /*
306  * No special care is taken, all dots are translated into
307  * label seperators.
308  * Could be made more efficient....we do 3 memcpy's in total...
309  */
311 ldns_str2rdf_dname(ldns_rdf **d, const char *str)
312 {
313  size_t len;
314 
315  const char *s;
316  uint8_t *q, *pq, label_len;
317  uint8_t buf[LDNS_MAX_DOMAINLEN + 1];
318  *d = NULL;
319 
320  len = strlen((char*)str);
321  /* octet representation can make strings a lot longer than actual length */
322  if (len > LDNS_MAX_DOMAINLEN * 4) {
324  }
325  if (0 == len) {
327  }
328 
329  /* root label */
330  if (1 == len && *str == '.') {
332  return LDNS_STATUS_OK;
333  }
334 
335  /* get on with the rest */
336 
337  /* s is on the current character in the string
338  * pq points to where the labellength is going to go
339  * label_len keeps track of the current label's length
340  * q builds the dname inside the buf array
341  */
342  len = 0;
343  q = buf+1;
344  pq = buf;
345  label_len = 0;
346  for (s = str; *s; s++, q++) {
347  if (q > buf + LDNS_MAX_DOMAINLEN) {
349  }
350  *q = 0;
351  switch (*s) {
352  case '.':
353  if (label_len > LDNS_MAX_LABELLEN) {
355  }
356  if (label_len == 0) {
358  }
359  len += label_len + 1;
360  *pq = label_len;
361  label_len = 0;
362  pq = q;
363  break;
364  case '\\':
365  /* octet value or literal char */
366  s += 1;
367  if (! parse_escape(q, &s)) {
369  }
370  s -= 1;
371  label_len++;
372  break;
373  default:
374  *q = (uint8_t)*s;
375  label_len++;
376  }
377  }
378 
379  /* add root label if last char was not '.' */
380  if (!ldns_dname_str_absolute(str)) {
381  if (q > buf + LDNS_MAX_DOMAINLEN) {
383  }
384  if (label_len > LDNS_MAX_LABELLEN) {
386  }
387  if (label_len == 0) { /* label_len 0 but not . at end? */
389  }
390  len += label_len + 1;
391  *pq = label_len;
392  *q = 0;
393  }
394  len++;
395 
397  return LDNS_STATUS_OK;
398 }
399 
401 ldns_str2rdf_a(ldns_rdf **rd, const char *str)
402 {
403  in_addr_t address;
404  if (inet_pton(AF_INET, (char*)str, &address) != 1) {
406  } else {
407  *rd = ldns_rdf_new_frm_data(
408  LDNS_RDF_TYPE_A, sizeof(address), &address);
409  }
411 }
412 
414 ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str)
415 {
416  uint8_t address[LDNS_IP6ADDRLEN + 1];
417 
418  if (inet_pton(AF_INET6, (char*)str, address) != 1) {
420  } else {
421  *rd = ldns_rdf_new_frm_data(
422  LDNS_RDF_TYPE_AAAA, sizeof(address) - 1, &address);
423  }
425 }
426 
428 ldns_str2rdf_str(ldns_rdf **rd, const char *str)
429 {
430  uint8_t *data, *dp, ch = 0;
431  size_t length;
432 
433  /* Worst case space requirement. We'll realloc to actual size later. */
434  dp = data = LDNS_XMALLOC(uint8_t, strlen(str) > 255 ? 256 : (strlen(str) + 1));
435  if (! data) {
436  return LDNS_STATUS_MEM_ERR;
437  }
438 
439  /* Fill data (up to 255 characters) */
440  while (parse_char(&ch, &str)) {
441  if (dp - data >= 255) {
442  LDNS_FREE(data);
444  }
445  *++dp = ch;
446  }
447  if (! str) {
448  LDNS_FREE(data);
450  }
451  length = (size_t)(dp - data);
452  /* Fix last length byte */
453  data[0] = (uint8_t)length;
454 
455  /* Lose the overmeasure */
456  data = LDNS_XREALLOC(dp = data, uint8_t, length + 1);
457  if (! data) {
458  LDNS_FREE(dp);
459  return LDNS_STATUS_MEM_ERR;
460  }
461 
462  /* Create rdf */
463  *rd = ldns_rdf_new(LDNS_RDF_TYPE_STR, length + 1, data);
464  if (! *rd) {
465  LDNS_FREE(data);
466  return LDNS_STATUS_MEM_ERR;
467  }
468  return LDNS_STATUS_OK;
469 }
470 
472 ldns_str2rdf_apl(ldns_rdf **rd, const char *str)
473 {
474  const char *my_str = str;
475 
476  char *my_ip_str;
477  size_t ip_str_len;
478 
479  uint16_t family;
480  bool negation;
481  uint8_t afdlength = 0;
482  uint8_t *afdpart;
483  uint8_t prefix;
484 
485  uint8_t *data;
486 
487  size_t i = 0;
488 
489  /* [!]afi:address/prefix */
490  if (strlen(my_str) < 2
491  || strchr(my_str, ':') == NULL
492  || strchr(my_str, '/') == NULL
493  || strchr(my_str, ':') > strchr(my_str, '/')) {
495  }
496 
497  if (my_str[0] == '!') {
498  negation = true;
499  my_str += 1;
500  } else {
501  negation = false;
502  }
503 
504  family = (uint16_t) atoi(my_str);
505 
506  my_str = strchr(my_str, ':') + 1;
507 
508  /* need ip addr and only ip addr for inet_pton */
509  ip_str_len = (size_t) (strchr(my_str, '/') - my_str);
510  my_ip_str = LDNS_XMALLOC(char, ip_str_len + 1);
511  if(!my_ip_str) return LDNS_STATUS_MEM_ERR;
512  strncpy(my_ip_str, my_str, ip_str_len + 1);
513  my_ip_str[ip_str_len] = '\0';
514 
515  if (family == 1) {
516  /* ipv4 */
517  afdpart = LDNS_XMALLOC(uint8_t, 4);
518  if(!afdpart) {
519  LDNS_FREE(my_ip_str);
520  return LDNS_STATUS_MEM_ERR;
521  }
522  if (inet_pton(AF_INET, my_ip_str, afdpart) == 0) {
523  LDNS_FREE(my_ip_str);
524  LDNS_FREE(afdpart);
526  }
527  for (i = 0; i < 4; i++) {
528  if (afdpart[i] != 0) {
529  afdlength = i + 1;
530  }
531  }
532  } else if (family == 2) {
533  /* ipv6 */
534  afdpart = LDNS_XMALLOC(uint8_t, 16);
535  if(!afdpart) {
536  LDNS_FREE(my_ip_str);
537  return LDNS_STATUS_MEM_ERR;
538  }
539  if (inet_pton(AF_INET6, my_ip_str, afdpart) == 0) {
540  LDNS_FREE(my_ip_str);
541  LDNS_FREE(afdpart);
543  }
544  for (i = 0; i < 16; i++) {
545  if (afdpart[i] != 0) {
546  afdlength = i + 1;
547  }
548  }
549  } else {
550  /* unknown family */
551  LDNS_FREE(my_ip_str);
553  }
554 
555  my_str = strchr(my_str, '/') + 1;
556  prefix = (uint8_t) atoi(my_str);
557 
558  data = LDNS_XMALLOC(uint8_t, 4 + afdlength);
559  if(!data) {
560  LDNS_FREE(afdpart);
561  LDNS_FREE(my_ip_str);
563  }
564  ldns_write_uint16(data, family);
565  data[2] = prefix;
566  data[3] = afdlength;
567  if (negation) {
568  /* set bit 1 of byte 3 */
569  data[3] = data[3] | 0x80;
570  }
571 
572  memcpy(data + 4, afdpart, afdlength);
573 
574  *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_APL, afdlength + 4, data);
575  LDNS_FREE(afdpart);
576  LDNS_FREE(data);
577  LDNS_FREE(my_ip_str);
578 
580 }
581 
583 ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
584 {
585  uint8_t *buffer;
586  int16_t i;
587 
588  if ((*str == '-' || *str == '0') && str[1] == '\0') {
590  return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
591  }
592 
593  buffer = LDNS_XMALLOC(uint8_t, ldns_b64_ntop_calculate_size(strlen(str)));
594  if(!buffer) {
595  return LDNS_STATUS_MEM_ERR;
596  }
597 
598  i = (uint16_t)ldns_b64_pton((const char*)str, buffer,
599  ldns_b64_ntop_calculate_size(strlen(str)));
600  if (-1 == i) {
601  LDNS_FREE(buffer);
603  } else {
604  *rd = ldns_rdf_new_frm_data(
605  LDNS_RDF_TYPE_B64, (uint16_t) i, buffer);
606  }
607  LDNS_FREE(buffer);
608 
610 }
611 
613 ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str)
614 {
615  uint8_t *buffer;
616  int i;
617  /* first byte contains length of actual b32 data */
618  size_t slen = strlen(str);
619  size_t len = ldns_b32_pton_calculate_size(slen);
620  if (len > 255) {
622  }
623  buffer = LDNS_XMALLOC(uint8_t, len + 1);
624  if(!buffer) {
625  return LDNS_STATUS_MEM_ERR;
626  }
627  buffer[0] = len;
628 
629  i = ldns_b32_pton_extended_hex((const char*)str, slen, buffer + 1,
630  ldns_b32_ntop_calculate_size(slen));
631  if (i < 0) {
632  LDNS_FREE(buffer);
634  } else {
635  *rd = ldns_rdf_new_frm_data(
636  LDNS_RDF_TYPE_B32_EXT, (uint16_t) i + 1, buffer);
637  }
638  LDNS_FREE(buffer);
639 
641 }
642 
644 ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
645 {
646  uint8_t *t, *t_orig;
647  int i;
648  size_t len;
649 
650  len = strlen(str);
651 
652  if (len > LDNS_MAX_RDFLEN * 2) {
654  } else {
655  t = LDNS_XMALLOC(uint8_t, (len / 2) + 1);
656  if(!t) {
657  return LDNS_STATUS_MEM_ERR;
658  }
659  t_orig = t;
660  /* Now process octet by octet... */
661  while (*str) {
662  *t = 0;
663  if (isspace((int) *str)) {
664  str++;
665  } else {
666  for (i = 16; i >= 1; i -= 15) {
667  while (*str && isspace((int) *str)) { str++; }
668  if (*str) {
669  if (isxdigit((int) *str)) {
670  *t += ldns_hexdigit_to_int(*str) * i;
671  } else {
672  LDNS_FREE(t_orig);
673  return LDNS_STATUS_ERR;
674  }
675  ++str;
676  }
677  }
678  ++t;
679  }
680  }
682  (size_t) (t - t_orig),
683  t_orig);
684  LDNS_FREE(t_orig);
685  }
687 }
688 
690 ldns_str2rdf_nsec(ldns_rdf **rd, const char *str)
691 {
692  const char *delimiters = "\n\t ";
693  char *token = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
694  ldns_buffer *str_buf;
695  ssize_t c;
696  uint16_t cur_type;
697  size_t type_count = 0;
698  ldns_rr_type type_list[65536];
699  if(!token) return LDNS_STATUS_MEM_ERR;
700  if(rd == NULL) {
701  LDNS_FREE(token);
702  return LDNS_STATUS_NULL;
703  }
704 
705  str_buf = LDNS_MALLOC(ldns_buffer);
706  if(!str_buf) {
707  LDNS_FREE(token);
708  return LDNS_STATUS_MEM_ERR;
709  }
710  ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
711  if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
712  LDNS_FREE(str_buf);
713  LDNS_FREE(token);
714  return LDNS_STATUS_MEM_ERR;
715  }
716 
717  while ((c = ldns_bget_token(str_buf, token, delimiters, LDNS_MAX_RDFLEN)) != -1 && c != 0) {
718  if(type_count >= sizeof(type_list)) {
719  LDNS_FREE(str_buf);
720  LDNS_FREE(token);
721  return LDNS_STATUS_ERR;
722  }
723  cur_type = ldns_get_rr_type_by_name(token);
724  type_list[type_count] = cur_type;
725  type_count++;
726  }
727 
728  *rd = ldns_dnssec_create_nsec_bitmap(type_list,
729  type_count,
731 
732  LDNS_FREE(token);
733  ldns_buffer_free(str_buf);
735 }
736 
738 ldns_str2rdf_type(ldns_rdf **rd, const char *str)
739 {
740  uint16_t type;
741  type = htons(ldns_get_rr_type_by_name(str));
742  /* ldns_rr_type is a 16 bit value */
743  *rd = ldns_rdf_new_frm_data(
744  LDNS_RDF_TYPE_TYPE, sizeof(uint16_t), &type);
746 }
747 
749 ldns_str2rdf_class(ldns_rdf **rd, const char *str)
750 {
751  uint16_t klass;
752  klass = htons(ldns_get_rr_class_by_name(str));
753  /* class is 16 bit */
754  *rd = ldns_rdf_new_frm_data(
755  LDNS_RDF_TYPE_CLASS, sizeof(uint16_t), &klass);
757 }
758 
759 /* An certificate alg field can either be specified as a 8 bits number
760  * or by its symbolic name. Handle both
761  */
763 ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str)
764 {
765  ldns_lookup_table *lt;
766  ldns_status st;
767  uint8_t idd[2];
769  st = LDNS_STATUS_OK;
770 
771  if (lt) {
772  ldns_write_uint16(idd, (uint16_t) lt->id);
773  *rd = ldns_rdf_new_frm_data(
774  LDNS_RDF_TYPE_INT16, sizeof(uint16_t), idd);
775  if (!*rd) {
776  st = LDNS_STATUS_ERR;
777  }
778  } else {
779  /* try as-is (a number) */
780  st = ldns_str2rdf_int16(rd, str);
781  if (st == LDNS_STATUS_OK &&
782  ldns_rdf2native_int16(*rd) == 0) {
784  }
785  }
786 
787  return st;
788 }
789 
790 static ldns_lookup_table ldns_tlsa_certificate_usages[] = {
791  { LDNS_TLSA_USAGE_PKIX_TA , "PKIX-TA" },
792  { LDNS_TLSA_USAGE_PKIX_EE , "PKIX-EE" },
793  { LDNS_TLSA_USAGE_DANE_TA , "DANE-TA" },
794  { LDNS_TLSA_USAGE_DANE_EE , "DANE-EE" },
795  { LDNS_TLSA_USAGE_PRIVCERT , "PrivCert" },
796  { 0, NULL }
797 };
798 
799 static ldns_lookup_table ldns_tlsa_selectors[] = {
800  { LDNS_TLSA_SELECTOR_CERT , "Cert" },
801  { LDNS_TLSA_SELECTOR_SPKI , "SPKI" },
802  { LDNS_TLSA_SELECTOR_PRIVSEL , "PrivSel" },
803  { 0, NULL }
804 };
805 
806 static ldns_lookup_table ldns_tlsa_matching_types[] = {
807  { LDNS_TLSA_MATCHING_TYPE_FULL , "Full" },
808  { LDNS_TLSA_MATCHING_TYPE_SHA2_256 , "SHA2-256" },
809  { LDNS_TLSA_MATCHING_TYPE_SHA2_512 , "SHA2-512" },
810  { LDNS_TLSA_MATCHING_TYPE_PRIVMATCH , "PrivMatch" },
811  { 0, NULL }
812 };
813 
814 static ldns_status
815 ldns_str2rdf_mnemonic4int8(ldns_lookup_table *lt,
816  ldns_rdf **rd, const char *str)
817 {
818  if ((lt = ldns_lookup_by_name(lt, str))) {
819  /* it was given as a integer */
820  *rd = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t) lt->id);
821  if (!*rd)
822  return LDNS_STATUS_ERR;
823  else
824  return LDNS_STATUS_OK;
825  }
826  return ldns_str2rdf_int8(rd, str);
827 }
828 
829 /* An alg field can either be specified as a 8 bits number
830  * or by its symbolic name. Handle both
831  */
833 ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
834 {
835  return ldns_str2rdf_mnemonic4int8(ldns_algorithms, rd, str);
836 }
837 
840 {
841  return ldns_str2rdf_mnemonic4int8(
842  ldns_tlsa_certificate_usages, rd, str);
843 }
844 
846 ldns_str2rdf_selector(ldns_rdf **rd, const char *str)
847 {
848  return ldns_str2rdf_mnemonic4int8(ldns_tlsa_selectors, rd, str);
849 }
850 
852 ldns_str2rdf_matching_type(ldns_rdf **rd, const char *str)
853 {
854  return ldns_str2rdf_mnemonic4int8(ldns_tlsa_matching_types, rd, str);
855 }
856 
859  , ATTR_UNUSED(const char *str)
860  )
861 {
862  /* this should be caught in an earlier time (general str2host for
863  rr's */
864  return LDNS_STATUS_NOT_IMPL;
865 }
866 
869  , ATTR_UNUSED(const char *str)
870  )
871 {
872  /* is this used? is this actually WKS? or SRV? */
873  return LDNS_STATUS_NOT_IMPL;
874 }
875 
876 static int
877 loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e)
878 {
879  /* read <digits>[.<digits>][mM] */
880  /* into mantissa exponent format for LOC type */
881  uint32_t meters = 0, cm = 0, val;
882  while (isblank((unsigned char)*my_str)) {
883  my_str++;
884  }
885  meters = (uint32_t)strtol(my_str, &my_str, 10);
886  if (*my_str == '.') {
887  my_str++;
888  cm = (uint32_t)strtol(my_str, &my_str, 10);
889  }
890  if (meters >= 1) {
891  *e = 2;
892  val = meters;
893  } else {
894  *e = 0;
895  val = cm;
896  }
897  while(val >= 10) {
898  (*e)++;
899  val /= 10;
900  }
901  *m = (uint8_t)val;
902 
903  if (*e > 9)
904  return 0;
905  if (*my_str == 'm' || *my_str == 'M') {
906  my_str++;
907  }
908  *endstr = my_str;
909  return 1;
910 }
911 
913 ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
914 {
915  uint32_t latitude = 0;
916  uint32_t longitude = 0;
917  uint32_t altitude = 0;
918 
919  uint8_t *data;
920  uint32_t equator = (uint32_t) ldns_power(2, 31);
921 
922  uint32_t h = 0;
923  uint32_t m = 0;
924  uint8_t size_b = 1, size_e = 2;
925  uint8_t horiz_pre_b = 1, horiz_pre_e = 6;
926  uint8_t vert_pre_b = 1, vert_pre_e = 3;
927 
928  double s = 0.0;
929  bool northerness;
930  bool easterness;
931 
932  char *my_str = (char *) str;
933 
934  /* only support version 0 */
935  if (isdigit((int) *my_str)) {
936  h = (uint32_t) strtol(my_str, &my_str, 10);
937  } else {
939  }
940 
941  while (isblank((int) *my_str)) {
942  my_str++;
943  }
944 
945  if (isdigit((int) *my_str)) {
946  m = (uint32_t) strtol(my_str, &my_str, 10);
947  } else if (*my_str == 'N' || *my_str == 'S') {
948  goto north;
949  } else {
951  }
952 
953  while (isblank((int) *my_str)) {
954  my_str++;
955  }
956 
957  if (isdigit((int) *my_str)) {
958  s = strtod(my_str, &my_str);
959  }
960 north:
961  while (isblank((int) *my_str)) {
962  my_str++;
963  }
964 
965  if (*my_str == 'N') {
966  northerness = true;
967  } else if (*my_str == 'S') {
968  northerness = false;
969  } else {
971  }
972 
973  my_str++;
974 
975  /* store number */
976  s = 1000.0 * s;
977  /* add a little to make floor in conversion a round */
978  s += 0.0005;
979  latitude = (uint32_t) s;
980  latitude += 1000 * 60 * m;
981  latitude += 1000 * 60 * 60 * h;
982  if (northerness) {
983  latitude = equator + latitude;
984  } else {
985  latitude = equator - latitude;
986  }
987  while (isblank((unsigned char)*my_str)) {
988  my_str++;
989  }
990 
991  if (isdigit((int) *my_str)) {
992  h = (uint32_t) strtol(my_str, &my_str, 10);
993  } else {
995  }
996 
997  while (isblank((int) *my_str)) {
998  my_str++;
999  }
1000 
1001  if (isdigit((int) *my_str)) {
1002  m = (uint32_t) strtol(my_str, &my_str, 10);
1003  } else if (*my_str == 'E' || *my_str == 'W') {
1004  goto east;
1005  } else {
1006  return LDNS_STATUS_INVALID_STR;
1007  }
1008 
1009  while (isblank((unsigned char)*my_str)) {
1010  my_str++;
1011  }
1012 
1013  if (isdigit((int) *my_str)) {
1014  s = strtod(my_str, &my_str);
1015  }
1016 
1017 east:
1018  while (isblank((unsigned char)*my_str)) {
1019  my_str++;
1020  }
1021 
1022  if (*my_str == 'E') {
1023  easterness = true;
1024  } else if (*my_str == 'W') {
1025  easterness = false;
1026  } else {
1027  return LDNS_STATUS_INVALID_STR;
1028  }
1029 
1030  my_str++;
1031 
1032  /* store number */
1033  s *= 1000.0;
1034  /* add a little to make floor in conversion a round */
1035  s += 0.0005;
1036  longitude = (uint32_t) s;
1037  longitude += 1000 * 60 * m;
1038  longitude += 1000 * 60 * 60 * h;
1039 
1040  if (easterness) {
1041  longitude += equator;
1042  } else {
1043  longitude = equator - longitude;
1044  }
1045 
1046  altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 +
1047  10000000.0 + 0.5);
1048  if (*my_str == 'm' || *my_str == 'M') {
1049  my_str++;
1050  }
1051 
1052  if (strlen(my_str) > 0) {
1053  if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e))
1054  return LDNS_STATUS_INVALID_STR;
1055  }
1056 
1057  if (strlen(my_str) > 0) {
1058  if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e))
1059  return LDNS_STATUS_INVALID_STR;
1060  }
1061 
1062  if (strlen(my_str) > 0) {
1063  if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e))
1064  return LDNS_STATUS_INVALID_STR;
1065  }
1066 
1067  data = LDNS_XMALLOC(uint8_t, 16);
1068  if(!data) {
1069  return LDNS_STATUS_MEM_ERR;
1070  }
1071  data[0] = 0;
1072  data[1] = 0;
1073  data[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f);
1074  data[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f);
1075  data[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f);
1076  ldns_write_uint32(data + 4, latitude);
1077  ldns_write_uint32(data + 8, longitude);
1078  ldns_write_uint32(data + 12, altitude);
1079 
1080  *rd = ldns_rdf_new_frm_data(
1081  LDNS_RDF_TYPE_LOC, 16, data);
1082 
1083  LDNS_FREE(data);
1085 }
1086 
1088 ldns_str2rdf_wks(ldns_rdf **rd, const char *str)
1089 {
1090  uint8_t *bitmap = NULL;
1091  uint8_t *data;
1092  int bm_len = 0;
1093 
1094  struct protoent *proto = NULL;
1095  struct servent *serv = NULL;
1096  int serv_port;
1097 
1098  ldns_buffer *str_buf;
1099 
1100  char *proto_str = NULL;
1101  char *lc_proto_str = NULL;
1102  char *token;
1103  char *lc_token;
1104  char *c;
1105  if(strlen(str) == 0)
1106  token = LDNS_XMALLOC(char, 50);
1107  else token = LDNS_XMALLOC(char, strlen(str)+2);
1108  if(!token) return LDNS_STATUS_MEM_ERR;
1109 
1110  str_buf = LDNS_MALLOC(ldns_buffer);
1111  if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1112  ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1113  if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1114  LDNS_FREE(str_buf);
1115  LDNS_FREE(token);
1116  return LDNS_STATUS_MEM_ERR;
1117  }
1118 
1119  while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1120  if (!proto_str) {
1121  proto_str = strdup(token);
1122  lc_proto_str = strdup(token);
1123  for (c = lc_proto_str; *c; c++) {
1124  *c = tolower((unsigned char)*c);
1125  }
1126  if (!proto_str || !lc_proto_str) {
1127  free(proto_str);
1128  free(lc_proto_str);
1129  LDNS_FREE(bitmap);
1130  LDNS_FREE(token);
1131  ldns_buffer_free(str_buf);
1132  return LDNS_STATUS_INVALID_STR;
1133  }
1134  } else {
1135  serv = getservbyname(token, proto_str);
1136  if (!serv) {
1137  serv = getservbyname(token, lc_proto_str);
1138  }
1139  if (!serv && (lc_token = strdup(token))) {
1140  for (c = lc_token; *c; c++) {
1141  *c = tolower((unsigned char)*c);
1142  }
1143  serv = getservbyname(lc_token, proto_str);
1144  if (!serv) {
1145  serv = getservbyname(lc_token, lc_proto_str);
1146  }
1147  free(lc_token);
1148  }
1149  if (serv) {
1150  serv_port = (int) ntohs((uint16_t) serv->s_port);
1151  } else {
1152  serv_port = atoi(token);
1153  }
1154  if (serv_port < 0 || serv_port > 65535) {
1155  LDNS_FREE(bitmap);
1156  LDNS_FREE(token);
1157  ldns_buffer_free(str_buf);
1158  free(proto_str);
1159  free(lc_proto_str);
1160  return LDNS_STATUS_INVALID_STR;
1161  }
1162  if (serv_port / 8 >= bm_len) {
1163  uint8_t *b2 = LDNS_XREALLOC(bitmap, uint8_t, (serv_port / 8) + 1);
1164  if(!b2) {
1165  LDNS_FREE(bitmap);
1166  LDNS_FREE(token);
1167  ldns_buffer_free(str_buf);
1168  free(proto_str);
1169  free(lc_proto_str);
1170  return LDNS_STATUS_INVALID_STR;
1171  }
1172  bitmap = b2;
1173  /* set to zero to be sure */
1174  for (; bm_len <= serv_port / 8; bm_len++) {
1175  bitmap[bm_len] = 0;
1176  }
1177  }
1178  ldns_set_bit(bitmap + (serv_port / 8), 7 - (serv_port % 8), true);
1179  }
1180  }
1181 
1182  if (!proto_str || !bitmap) {
1183  LDNS_FREE(bitmap);
1184  LDNS_FREE(token);
1185  ldns_buffer_free(str_buf);
1186  free(proto_str);
1187  free(lc_proto_str);
1188  return LDNS_STATUS_INVALID_STR;
1189  }
1190 
1191  data = LDNS_XMALLOC(uint8_t, bm_len + 1);
1192  if(!data) {
1193  LDNS_FREE(token);
1194  ldns_buffer_free(str_buf);
1195  LDNS_FREE(bitmap);
1196  free(proto_str);
1197  free(lc_proto_str);
1198  return LDNS_STATUS_INVALID_STR;
1199  }
1200  if (proto_str)
1201  proto = getprotobyname(proto_str);
1202  if (!proto) {
1203  proto = getprotobyname(lc_proto_str);
1204  }
1205  if (proto) {
1206  data[0] = (uint8_t) proto->p_proto;
1207  } else if (proto_str) {
1208  data[0] = (uint8_t) atoi(proto_str);
1209  }
1210  memcpy(data + 1, bitmap, (size_t) bm_len);
1211 
1212  *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_WKS, (uint16_t) (bm_len + 1), data);
1213 
1214  LDNS_FREE(data);
1215  LDNS_FREE(token);
1216  ldns_buffer_free(str_buf);
1217  LDNS_FREE(bitmap);
1218  free(proto_str);
1219  free(lc_proto_str);
1220 #ifdef HAVE_ENDSERVENT
1221  endservent();
1222 #endif
1223 #ifdef HAVE_ENDPROTOENT
1224  endprotoent();
1225 #endif
1226 
1227  if(!*rd) return LDNS_STATUS_MEM_ERR;
1228 
1229  return LDNS_STATUS_OK;
1230 }
1231 
1233 ldns_str2rdf_nsap(ldns_rdf **rd, const char *str)
1234 {
1235  size_t len, i;
1236  char* nsap_str = (char*) str;
1237 
1238  /* just a hex string with optional dots? */
1239  if (str[0] != '0' || str[1] != 'x') {
1240  return LDNS_STATUS_INVALID_STR;
1241  } else {
1242  len = strlen(str);
1243  for (i=0; i < len; i++) {
1244  if (nsap_str[i] == '.')
1245  nsap_str[i] = ' ';
1246  }
1247  return ldns_str2rdf_hex(rd, str+2);
1248  }
1249 }
1250 
1252 ldns_str2rdf_atma(ldns_rdf **rd, const char *str)
1253 {
1254  size_t len, i;
1255  char* atma_str = (char*) str;
1256  ldns_status status;
1257 
1258  /* just a hex string with optional dots? */
1259  len = strlen(str);
1260  for (i=0; i < len; i++) {
1261  if (atma_str[i] == '.')
1262  atma_str[i] = ' ';
1263  }
1264  status = ldns_str2rdf_hex(rd, str);
1265  if (status != LDNS_STATUS_OK) {
1266  ; /* probably in e.164 format than */
1267  }
1268  return status;
1269 }
1270 
1272 ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
1273 {
1274  uint8_t precedence = 0;
1275  uint8_t gateway_type = 0;
1276  uint8_t algorithm = 0;
1277  char* gateway = NULL;
1278  char* publickey = NULL;
1279  uint8_t *data;
1280  ldns_buffer *str_buf;
1281  char *token;
1282  int token_count = 0;
1283  int ipseckey_len = 0;
1284  ldns_rdf* gateway_rdf = NULL;
1285  ldns_rdf* publickey_rdf = NULL;
1286  ldns_status status = LDNS_STATUS_OK;
1287 
1288  if(strlen(str) == 0)
1289  token = LDNS_XMALLOC(char, 256);
1290  else token = LDNS_XMALLOC(char, strlen(str)+2);
1291  if(!token) return LDNS_STATUS_MEM_ERR;
1292 
1293  str_buf = LDNS_MALLOC(ldns_buffer);
1294  if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1295  ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1296  if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1297  LDNS_FREE(str_buf);
1298  LDNS_FREE(token);
1299  return LDNS_STATUS_MEM_ERR;
1300  }
1301  while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1302  switch (token_count) {
1303  case 0:
1304  precedence = (uint8_t)atoi(token);
1305  break;
1306  case 1:
1307  gateway_type = (uint8_t)atoi(token);
1308  break;
1309  case 2:
1310  algorithm = (uint8_t)atoi(token);
1311  break;
1312  case 3:
1313  gateway = strdup(token);
1314  if (!gateway || (gateway_type == 0 &&
1315  (token[0] != '.' || token[1] != '\0'))) {
1316  LDNS_FREE(gateway);
1317  LDNS_FREE(token);
1318  ldns_buffer_free(str_buf);
1319  return LDNS_STATUS_INVALID_STR;
1320  }
1321  break;
1322  case 4:
1323  publickey = strdup(token);
1324  break;
1325  default:
1326  LDNS_FREE(token);
1327  ldns_buffer_free(str_buf);
1328  return LDNS_STATUS_INVALID_STR;
1329  break;
1330  }
1331  token_count++;
1332  }
1333 
1334  if (!gateway || !publickey) {
1335  if (gateway)
1336  LDNS_FREE(gateway);
1337  if (publickey)
1338  LDNS_FREE(publickey);
1339  LDNS_FREE(token);
1340  ldns_buffer_free(str_buf);
1341  return LDNS_STATUS_INVALID_STR;
1342  }
1343 
1344  if (gateway_type == 1) {
1345  status = ldns_str2rdf_a(&gateway_rdf, gateway);
1346  } else if (gateway_type == 2) {
1347  status = ldns_str2rdf_aaaa(&gateway_rdf, gateway);
1348  } else if (gateway_type == 3) {
1349  status = ldns_str2rdf_dname(&gateway_rdf, gateway);
1350  } else if (gateway_type > 3) {
1351  status = LDNS_STATUS_INVALID_STR;
1352  }
1353 
1354  if (status != LDNS_STATUS_OK) {
1355  if (gateway)
1356  LDNS_FREE(gateway);
1357  if (publickey)
1358  LDNS_FREE(publickey);
1359  LDNS_FREE(token);
1360  ldns_buffer_free(str_buf);
1361  return LDNS_STATUS_INVALID_STR;
1362  }
1363 
1364  status = ldns_str2rdf_b64(&publickey_rdf, publickey);
1365 
1366  if (status != LDNS_STATUS_OK) {
1367  if (gateway)
1368  LDNS_FREE(gateway);
1369  if (publickey)
1370  LDNS_FREE(publickey);
1371  LDNS_FREE(token);
1372  ldns_buffer_free(str_buf);
1373  if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1374  return LDNS_STATUS_INVALID_STR;
1375  }
1376 
1377  /* now copy all into one ipseckey rdf */
1378  if (gateway_type)
1379  ipseckey_len = 3 + (int)ldns_rdf_size(gateway_rdf) + (int)ldns_rdf_size(publickey_rdf);
1380  else
1381  ipseckey_len = 3 + (int)ldns_rdf_size(publickey_rdf);
1382 
1383  data = LDNS_XMALLOC(uint8_t, ipseckey_len);
1384  if(!data) {
1385  if (gateway)
1386  LDNS_FREE(gateway);
1387  if (publickey)
1388  LDNS_FREE(publickey);
1389  LDNS_FREE(token);
1390  ldns_buffer_free(str_buf);
1391  if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1392  if (publickey_rdf) ldns_rdf_free(publickey_rdf);
1393  return LDNS_STATUS_MEM_ERR;
1394  }
1395 
1396  data[0] = precedence;
1397  data[1] = gateway_type;
1398  data[2] = algorithm;
1399 
1400  if (gateway_type) {
1401  memcpy(data + 3,
1402  ldns_rdf_data(gateway_rdf), ldns_rdf_size(gateway_rdf));
1403  memcpy(data + 3 + ldns_rdf_size(gateway_rdf),
1404  ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1405  } else {
1406  memcpy(data + 3,
1407  ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1408  }
1409 
1410  *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_IPSECKEY, (uint16_t) ipseckey_len, data);
1411 
1412  if (gateway)
1413  LDNS_FREE(gateway);
1414  if (publickey)
1415  LDNS_FREE(publickey);
1416  LDNS_FREE(token);
1417  ldns_buffer_free(str_buf);
1418  ldns_rdf_free(gateway_rdf);
1419  ldns_rdf_free(publickey_rdf);
1420  LDNS_FREE(data);
1421  if(!*rd) return LDNS_STATUS_MEM_ERR;
1422  return LDNS_STATUS_OK;
1423 }
1424 
1426 ldns_str2rdf_ilnp64(ldns_rdf **rd, const char *str)
1427 {
1428  unsigned int a, b, c, d;
1429  uint16_t shorts[4];
1430  int l;
1431 
1432  if (sscanf(str, "%4x:%4x:%4x:%4x%n", &a, &b, &c, &d, &l) != 4 ||
1433  l != (int)strlen(str) || /* more data to read */
1434  strpbrk(str, "+-") /* signed hexes */
1435  ) {
1437  } else {
1438  shorts[0] = htons(a);
1439  shorts[1] = htons(b);
1440  shorts[2] = htons(c);
1441  shorts[3] = htons(d);
1442  *rd = ldns_rdf_new_frm_data(
1443  LDNS_RDF_TYPE_ILNP64, 4 * sizeof(uint16_t), &shorts);
1444  }
1445  return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
1446 }
1447 
1449 ldns_str2rdf_eui48(ldns_rdf **rd, const char *str)
1450 {
1451  unsigned int a, b, c, d, e, f;
1452  uint8_t bytes[6];
1453  int l;
1454 
1455  if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x%n",
1456  &a, &b, &c, &d, &e, &f, &l) != 6 ||
1457  l != (int)strlen(str)) {
1459  } else {
1460  bytes[0] = a;
1461  bytes[1] = b;
1462  bytes[2] = c;
1463  bytes[3] = d;
1464  bytes[4] = e;
1465  bytes[5] = f;
1466  *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI48, 6, &bytes);
1467  }
1468  return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
1469 }
1470 
1472 ldns_str2rdf_eui64(ldns_rdf **rd, const char *str)
1473 {
1474  unsigned int a, b, c, d, e, f, g, h;
1475  uint8_t bytes[8];
1476  int l;
1477 
1478  if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x-%2x-%2x%n",
1479  &a, &b, &c, &d, &e, &f, &g, &h, &l) != 8 ||
1480  l != (int)strlen(str)) {
1482  } else {
1483  bytes[0] = a;
1484  bytes[1] = b;
1485  bytes[2] = c;
1486  bytes[3] = d;
1487  bytes[4] = e;
1488  bytes[5] = f;
1489  bytes[6] = g;
1490  bytes[7] = h;
1491  *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI64, 8, &bytes);
1492  }
1493  return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
1494 }
1495 
1497 ldns_str2rdf_tag(ldns_rdf **rd, const char *str)
1498 {
1499  uint8_t *data;
1500  const char* ptr;
1501 
1502  if (strlen(str) > 255) {
1503  return LDNS_STATUS_INVALID_TAG;
1504  }
1505  for (ptr = str; *ptr; ptr++) {
1506  if (! isalnum((unsigned char)*ptr)) {
1507  return LDNS_STATUS_INVALID_TAG;
1508  }
1509  }
1510  data = LDNS_XMALLOC(uint8_t, strlen(str) + 1);
1511  if (!data) {
1512  return LDNS_STATUS_MEM_ERR;
1513  }
1514  data[0] = strlen(str);
1515  memcpy(data + 1, str, strlen(str));
1516 
1517  *rd = ldns_rdf_new(LDNS_RDF_TYPE_TAG, strlen(str) + 1, data);
1518  if (!*rd) {
1519  LDNS_FREE(data);
1520  return LDNS_STATUS_MEM_ERR;
1521  }
1522  return LDNS_STATUS_OK;
1523 }
1524 
1526 ldns_str2rdf_long_str(ldns_rdf **rd, const char *str)
1527 {
1528  uint8_t *data, *dp, ch = 0;
1529  size_t length;
1530 
1531  /* Worst case space requirement. We'll realloc to actual size later. */
1532  dp = data = LDNS_XMALLOC(uint8_t, strlen(str));
1533  if (! data) {
1534  return LDNS_STATUS_MEM_ERR;
1535  }
1536 
1537  /* Fill data with parsed bytes */
1538  while (parse_char(&ch, &str)) {
1539  *dp++ = ch;
1540  if (dp - data > LDNS_MAX_RDFLEN) {
1541  LDNS_FREE(data);
1542  return LDNS_STATUS_INVALID_STR;
1543  }
1544  }
1545  if (! str) {
1546  LDNS_FREE(data);
1548  }
1549  if (!(length = (size_t)(dp - data))) {
1550  LDNS_FREE(data);
1551  return LDNS_STATUS_SYNTAX_EMPTY;
1552  }
1553  /* Lose the overmeasure */
1554  data = LDNS_XREALLOC(dp = data, uint8_t, length);
1555  if (! data) {
1556  LDNS_FREE(dp);
1557  return LDNS_STATUS_MEM_ERR;
1558  }
1559 
1560  /* Create rdf */
1561  *rd = ldns_rdf_new(LDNS_RDF_TYPE_LONG_STR, length, data);
1562  if (! *rd) {
1563  LDNS_FREE(data);
1564  return LDNS_STATUS_MEM_ERR;
1565  }
1566  return LDNS_STATUS_OK;
1567 }
1568 
1570 ldns_str2rdf_hip(ldns_rdf **rd, const char *str)
1571 {
1572  const char *hit = str == NULL ? NULL : strchr(str, ' ');
1573  const char *pk = hit == NULL ? NULL : strchr(hit + 1, ' ');
1574  size_t hit_size = hit == NULL ? 0
1575  : pk == NULL ? strlen(hit + 1) : (size_t) (pk - hit) - 1;
1576  size_t pk_size = pk == NULL ? 0 : strlen(pk + 1);
1577  size_t hit_wire_size = (hit_size + 1) / 2;
1578  size_t pk_wire_size = ldns_b64_pton_calculate_size(pk_size);
1579  size_t rdf_size = 4 + hit_wire_size + pk_wire_size;
1580 
1581  char *endptr; /* utility var for strtol usage */
1582  int algorithm = str == NULL ? 0 : strtol(str, &endptr, 10);
1583 
1584  uint8_t *data, *dp;
1585  int hi, lo, written;
1586 
1587  if (hit_size == 0 || pk_size == 0 || (hit_size + 1) / 2 > 255
1588  || rdf_size > LDNS_MAX_RDFLEN
1589  || algorithm < 0 || algorithm > 255
1590  || (errno != 0 && algorithm == 0) /* out of range */
1591  || endptr == str /* no digits */) {
1592 
1593  return LDNS_STATUS_SYNTAX_ERR;
1594  }
1595  hit += 1;
1596  pk += 1;
1597  if ((data = LDNS_XMALLOC(uint8_t, rdf_size)) == NULL) {
1598 
1599  return LDNS_STATUS_MEM_ERR;
1600  }
1601  /* From RFC 5205 section 5. HIP RR Storage Format:
1602  *************************************************
1603 
1604  0 1 2 3
1605  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1606  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1607  | HIT length | PK algorithm | PK length |
1608  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1609  | |
1610  ~ HIT ~
1611  | |
1612  + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1613  | | |
1614  +-+-+-+-+-+-+-+-+-+-+-+ +
1615  | Public Key |
1616  ~ ~
1617  | |
1618  + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1619  | | |
1620  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +
1621  | |
1622  ~ Rendezvous Servers ~
1623  | |
1624  + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1625  | |
1626  +-+-+-+-+-+-+-+ */
1627 
1628  data[0] = (uint8_t) hit_wire_size;
1629  data[1] = (uint8_t) algorithm;
1630 
1631  for (dp = data + 4; *hit && *hit != ' '; dp++) {
1632 
1633  if ((hi = ldns_hexdigit_to_int(*hit++)) == -1 ||
1634  (lo = ldns_hexdigit_to_int(*hit++)) == -1) {
1635 
1636  LDNS_FREE(data);
1637  return LDNS_STATUS_INVALID_HEX;
1638  }
1639  *dp = (uint8_t) hi << 4 | lo;
1640  }
1641  if ((written = ldns_b64_pton(pk, dp, pk_wire_size)) <= 0) {
1642 
1643  LDNS_FREE(data);
1644  return LDNS_STATUS_INVALID_B64;
1645  }
1646 
1647  /* Because ldns_b64_pton_calculate_size isn't always correct:
1648  * (we have to fix it at some point)
1649  */
1650  pk_wire_size = (uint16_t) written;
1651  ldns_write_uint16(data + 2, pk_wire_size);
1652  rdf_size = 4 + hit_wire_size + pk_wire_size;
1653 
1654  /* Create rdf */
1655  if (! (*rd = ldns_rdf_new(LDNS_RDF_TYPE_HIP, rdf_size, data))) {
1656 
1657  LDNS_FREE(data);
1658  return LDNS_STATUS_MEM_ERR;
1659  }
1660  return LDNS_STATUS_OK;
1661 }
1662 
1663 
1664 /* Implementation mimics ldns_str2rdf_ipseckey */
1666 ldns_str2rdf_amtrelay(ldns_rdf **rd, const char *str)
1667 {
1668  /* From draft-ietf-mboned-driad-amt-discovery
1669  * Section 4.2. AMTRELAY RData Format
1670  *************************************************
1671 
1672  0 1 2 3
1673  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1674  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1675  | precedence |D| type | |
1676  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +
1677  ~ relay ~
1678  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */
1679 
1680  uint8_t precedence = 0;
1681  uint8_t relay_type = 0;
1682  uint8_t discovery_optional = 0;
1683  char* relay = NULL;
1684  uint8_t *data;
1685  ldns_buffer *str_buf;
1686  char *token;
1687  int token_count = 0;
1688  int amtrelay_len = 0;
1689  ldns_rdf* relay_rdf = NULL;
1690  ldns_status status = LDNS_STATUS_OK;
1691 
1692  if(strlen(str) == 0)
1693  token = LDNS_XMALLOC(char, 256);
1694  else token = LDNS_XMALLOC(char, strlen(str)+2);
1695  if(!token) return LDNS_STATUS_MEM_ERR;
1696 
1697  str_buf = LDNS_MALLOC(ldns_buffer);
1698  if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1699  ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1700  if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1701  LDNS_FREE(str_buf);
1702  LDNS_FREE(token);
1703  return LDNS_STATUS_MEM_ERR;
1704  }
1705  while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1706  switch (token_count) {
1707  case 0:
1708  precedence = (uint8_t)atoi(token);
1709  break;
1710  case 1:
1711  discovery_optional = (uint8_t)atoi(token);
1712  if (discovery_optional != 0 &&
1713  discovery_optional != 1) {
1714  LDNS_FREE(relay);
1715  LDNS_FREE(token);
1716  ldns_buffer_free(str_buf);
1717  return LDNS_STATUS_INVALID_STR;
1718  }
1719  break;
1720  case 2:
1721  relay_type = (uint8_t)atoi(token);
1722  break;
1723  case 3:
1724  relay = strdup(token);
1725  if (!relay || (relay_type == 0 &&
1726  (token[0] != '.' || token[1] != '\0'))) {
1727  LDNS_FREE(relay);
1728  LDNS_FREE(token);
1729  ldns_buffer_free(str_buf);
1730  return LDNS_STATUS_INVALID_STR;
1731  }
1732  break;
1733  default:
1734  LDNS_FREE(token);
1735  ldns_buffer_free(str_buf);
1736  return LDNS_STATUS_INVALID_STR;
1737  break;
1738  }
1739  token_count++;
1740  }
1741  if (!relay && relay_type > 0) {
1742  if (relay)
1743  LDNS_FREE(relay);
1744  LDNS_FREE(token);
1745  ldns_buffer_free(str_buf);
1746  return LDNS_STATUS_INVALID_STR;
1747  }
1748 
1749  if (relay_type == 1) {
1750  status = ldns_str2rdf_a(&relay_rdf, relay);
1751  } else if (relay_type == 2) {
1752  status = ldns_str2rdf_aaaa(&relay_rdf, relay);
1753  } else if (relay_type == 3) {
1754  status = ldns_str2rdf_dname(&relay_rdf, relay);
1755  } else if (relay_type > 3) {
1756  status = LDNS_STATUS_INVALID_STR;
1757  }
1758 
1759  if (status != LDNS_STATUS_OK) {
1760  if (relay)
1761  LDNS_FREE(relay);
1762  LDNS_FREE(token);
1763  ldns_buffer_free(str_buf);
1764  return LDNS_STATUS_INVALID_STR;
1765  }
1766 
1767  /* now copy all into one amtrelay rdf */
1768  if (relay_type)
1769  amtrelay_len = 2 + (int)ldns_rdf_size(relay_rdf);
1770  else
1771  amtrelay_len = 2;
1772 
1773  data = LDNS_XMALLOC(uint8_t, amtrelay_len);
1774  if(!data) {
1775  if (relay)
1776  LDNS_FREE(relay);
1777  LDNS_FREE(token);
1778  ldns_buffer_free(str_buf);
1779  if (relay_rdf) ldns_rdf_free(relay_rdf);
1780  return LDNS_STATUS_MEM_ERR;
1781  }
1782 
1783  data[0] = precedence;
1784  data[1] = relay_type;
1785  data[1] |= (discovery_optional << 7);
1786 
1787  if (relay_type) {
1788  memcpy(data + 2,
1789  ldns_rdf_data(relay_rdf), ldns_rdf_size(relay_rdf));
1790  }
1792  , (uint16_t) amtrelay_len, data);
1793 
1794  if (relay)
1795  LDNS_FREE(relay);
1796  LDNS_FREE(token);
1797  ldns_buffer_free(str_buf);
1798  ldns_rdf_free(relay_rdf);
1799  LDNS_FREE(data);
1800  if(!*rd) return LDNS_STATUS_MEM_ERR;
1801  return LDNS_STATUS_OK;
1802 }
void ldns_buffer_free(ldns_buffer *buffer)
frees the buffer.
Definition: buffer.c:137
void ldns_buffer_new_frm_data(ldns_buffer *buffer, const void *data, size_t size)
creates a buffer with the specified data.
Definition: buffer.c:41
#define ATTR_UNUSED(x)
Definition: common.h:69
int ldns_b64_pton(char const *src, uint8_t *target, size_t targsize)
@ LDNS_TLSA_SELECTOR_PRIVSEL
Reserved for Private Use.
Definition: dane.h:80
@ LDNS_TLSA_SELECTOR_SPKI
SubjectPublicKeyInfo: DER-encoded binary structure as defined in [RFC5280].
Definition: dane.h:76
@ LDNS_TLSA_SELECTOR_CERT
Full certificate: the Certificate binary structure as defined in [RFC5280].
Definition: dane.h:69
@ LDNS_TLSA_USAGE_PRIVCERT
Reserved for Private Use.
Definition: dane.h:56
@ LDNS_TLSA_USAGE_DANE_EE
Domain issued certificate.
Definition: dane.h:53
@ LDNS_TLSA_USAGE_PKIX_EE
Sevice certificate constraint.
Definition: dane.h:47
@ LDNS_TLSA_USAGE_PKIX_TA
CA constraint.
Definition: dane.h:44
@ LDNS_TLSA_USAGE_DANE_TA
Trust anchor assertion.
Definition: dane.h:50
@ LDNS_TLSA_MATCHING_TYPE_FULL
Exact match on selected content.
Definition: dane.h:90
@ LDNS_TLSA_MATCHING_TYPE_SHA2_512
SHA-512 hash of selected content [RFC6234].
Definition: dane.h:96
@ LDNS_TLSA_MATCHING_TYPE_SHA2_256
SHA-256 hash of selected content [RFC6234].
Definition: dane.h:93
@ LDNS_TLSA_MATCHING_TYPE_PRIVMATCH
Reserved for Private Use.
Definition: dane.h:99
bool ldns_dname_str_absolute(const char *dname_str)
Checks whether the given dname string is absolute (i.e.
Definition: dname.c:518
ldns_rdf * ldns_dnssec_create_nsec_bitmap(ldns_rr_type rr_type_list[], size_t size, ldns_rr_type nsec_type)
Create the type bitmap for an NSEC(3) record.
Definition: dnssec.c:717
@ LDNS_STATUS_INVALID_STR
Definition: error.h:41
@ LDNS_STATUS_DOMAINNAME_UNDERFLOW
Definition: error.h:30
@ LDNS_STATUS_INVALID_EUI48
Definition: error.h:123
@ LDNS_STATUS_INVALID_IP4
Definition: error.h:39
@ LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW
Definition: error.h:94
@ LDNS_STATUS_SYNTAX_ERR
Definition: error.h:97
@ LDNS_STATUS_INVALID_TIME
Definition: error.h:45
@ LDNS_STATUS_INVALID_EUI64
Definition: error.h:124
@ LDNS_STATUS_INVALID_B32_EXT
Definition: error.h:42
@ LDNS_STATUS_LABEL_OVERFLOW
Definition: error.h:28
@ LDNS_STATUS_NULL
Definition: error.h:51
@ LDNS_STATUS_INVALID_IP6
Definition: error.h:40
@ LDNS_STATUS_ERR
Definition: error.h:37
@ LDNS_STATUS_MEM_ERR
Definition: error.h:34
@ LDNS_STATUS_INVALID_ILNP64
Definition: error.h:122
@ LDNS_STATUS_INVALID_HEX
Definition: error.h:44
@ LDNS_STATUS_SYNTAX_BAD_ESCAPE
Definition: error.h:95
@ LDNS_STATUS_INVALID_INT
Definition: error.h:38
@ LDNS_STATUS_OK
Definition: error.h:26
@ LDNS_STATUS_EMPTY_LABEL
Definition: error.h:27
@ LDNS_STATUS_SYNTAX_EMPTY
Definition: error.h:91
@ LDNS_STATUS_DOMAINNAME_OVERFLOW
Definition: error.h:29
@ LDNS_STATUS_INVALID_B64
Definition: error.h:43
@ LDNS_STATUS_INVALID_TAG
Definition: error.h:126
@ LDNS_STATUS_CERT_BAD_ALGORITHM
Definition: error.h:78
@ LDNS_STATUS_NOT_IMPL
Definition: error.h:50
enum ldns_enum_status ldns_status
Definition: error.h:134
ldns_lookup_table ldns_algorithms[]
Taken from RFC 2535, section 7.
Definition: host2str.c:49
ldns_lookup_table ldns_cert_algorithms[]
Taken from RFC 2538.
Definition: host2str.c:81
Including this file will include all ldns files, and define some lookup tables.
#define LDNS_IP6ADDRLEN
Definition: ldns.h:132
ssize_t ldns_bget_token(ldns_buffer *b, char *token, const char *delim, size_t limit)
returns a token/char from the buffer b.
Definition: parse.c:223
uint32_t ldns_str2period(const char *nptr, const char **endptr)
converts a ttl value (like 5d2h) to a long.
Definition: rdata.c:688
ldns_rdf * ldns_native2rdf_int8(ldns_rdf_type type, uint8_t value)
returns the rdf containing the native uint8_t repr.
Definition: rdata.c:126
ldns_rdf * ldns_rdf_new(ldns_rdf_type type, size_t size, void *data)
allocates a new rdf structure and fills it.
Definition: rdata.c:179
uint16_t ldns_rdf2native_int16(const ldns_rdf *rd)
returns the native uint16_t representation from the rdf.
Definition: rdata.c:84
size_t ldns_rdf_size(const ldns_rdf *rd)
returns the size of the rdf.
Definition: rdata.c:24
uint8_t * ldns_rdf_data(const ldns_rdf *rd)
returns the data of the rdf.
Definition: rdata.c:38
void ldns_rdf_free(ldns_rdf *rd)
frees a rdf structure, leaving the data pointer intact.
Definition: rdata.c:241
ldns_rdf * ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data)
allocates a new rdf structure and fills it.
Definition: rdata.c:193
#define LDNS_MAX_RDFLEN
Definition: rdata.h:31
@ LDNS_RDF_TYPE_INT32
32 bits
Definition: rdata.h:56
@ LDNS_RDF_TYPE_TAG
A non-zero sequence of US-ASCII letters and numbers in lower case.
Definition: rdata.h:126
@ LDNS_RDF_TYPE_HIP
Represents the Public Key Algorithm, HIT and Public Key fields for the HIP RR types.
Definition: rdata.h:92
@ LDNS_RDF_TYPE_B32_EXT
b32 string
Definition: rdata.h:66
@ LDNS_RDF_TYPE_EUI48
6 * 8 bit hex numbers separated by dashes.
Definition: rdata.h:119
@ LDNS_RDF_TYPE_EUI64
8 * 8 bit hex numbers separated by dashes.
Definition: rdata.h:121
@ LDNS_RDF_TYPE_PERIOD
period
Definition: rdata.h:86
@ LDNS_RDF_TYPE_B64
b64 string
Definition: rdata.h:68
@ LDNS_RDF_TYPE_AAAA
AAAA record.
Definition: rdata.h:60
@ LDNS_RDF_TYPE_WKS
well known services
Definition: rdata.h:101
@ LDNS_RDF_TYPE_DNAME
domain name
Definition: rdata.h:50
@ LDNS_RDF_TYPE_TIME
time (32 bits)
Definition: rdata.h:84
@ LDNS_RDF_TYPE_NSEC3_SALT
nsec3 hash salt
Definition: rdata.h:109
@ LDNS_RDF_TYPE_APL
apl data
Definition: rdata.h:64
@ LDNS_RDF_TYPE_A
A record.
Definition: rdata.h:58
@ LDNS_RDF_TYPE_LONG_STR
A <character-string> encoding of the value field as specified [RFC1035], Section 5....
Definition: rdata.h:132
@ LDNS_RDF_TYPE_LOC
location data
Definition: rdata.h:99
@ LDNS_RDF_TYPE_ILNP64
4 shorts represented as 4 * 16 bit hex numbers separated by colons.
Definition: rdata.h:116
@ LDNS_RDF_TYPE_HEX
hex string
Definition: rdata.h:70
@ LDNS_RDF_TYPE_CLASS
a class
Definition: rdata.h:76
@ LDNS_RDF_TYPE_INT8
8 bits
Definition: rdata.h:52
@ LDNS_RDF_TYPE_IPSECKEY
IPSECKEY.
Definition: rdata.h:107
@ LDNS_RDF_TYPE_STR
txt string
Definition: rdata.h:62
@ LDNS_RDF_TYPE_INT16
16 bits
Definition: rdata.h:54
@ LDNS_RDF_TYPE_AMTRELAY
draft-ietf-mboned-driad-amt-discovery
Definition: rdata.h:143
@ LDNS_RDF_TYPE_TYPE
a RR type
Definition: rdata.h:74
ldns_rr_class ldns_get_rr_class_by_name(const char *name)
retrieves a class by looking up its name.
Definition: rr.c:2706
ldns_rr_type ldns_get_rr_type_by_name(const char *name)
retrieves a rrtype by looking up its name.
Definition: rr.c:2666
#define LDNS_MAX_LABELLEN
Maximum length of a dname label.
Definition: rr.h:31
enum ldns_enum_rr_type ldns_rr_type
Definition: rr.h:241
@ LDNS_RR_TYPE_NSEC
Definition: rr.h:171
#define LDNS_MAX_DOMAINLEN
Maximum length of a complete dname.
Definition: rr.h:33
ldns_status ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
convert a hex value into wireformat
Definition: str2host.c:644
ldns_status ldns_str2rdf_amtrelay(ldns_rdf **rd, const char *str)
Concert a"<precedence> <D-bit> <type> <relay>" encoding of the value field as specified in Section 4....
Definition: str2host.c:1666
ldns_status ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr)
convert a byte into wireformat
Definition: str2host.c:228
ldns_status ldns_str2rdf_certificate_usage(ldns_rdf **rd, const char *str)
convert a tlsa certificate usage value into wireformat
Definition: str2host.c:839
ldns_status ldns_str2rdf_hip(ldns_rdf **rd, const char *str)
Convert a "<algorithm> <hit> <pk>" encoding of the value field as specified in Section 6.
Definition: str2host.c:1570
ldns_status ldns_str2rdf_atma(ldns_rdf **rd, const char *str)
convert a str with a ATMA RR into wireformat
Definition: str2host.c:1252
ldns_status ldns_str2rdf_type(ldns_rdf **rd, const char *str)
convert a rrtype into wireformat
Definition: str2host.c:738
ldns_status ldns_str2rdf_nsec3_salt(ldns_rdf **rd, const char *salt_str)
Definition: str2host.c:126
ldns_status ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str)
convert the str with an AAAA record into wireformat
Definition: str2host.c:414
ldns_status ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str)
convert the string with the b32 ext hex data into wireformat
Definition: str2host.c:613
ldns_status ldns_str2rdf_period(ldns_rdf **rd, const char *period)
Definition: str2host.c:178
ldns_status ldns_str2rdf_long_str(ldns_rdf **rd, const char *str)
Convert a <character-string> encoding of the value field as specified [RFC1035], Section 5....
Definition: str2host.c:1526
ldns_status ldns_str2rdf_class(ldns_rdf **rd, const char *str)
convert string with a classname into wireformat
Definition: str2host.c:749
ldns_status ldns_str2rdf_dname(ldns_rdf **d, const char *str)
convert a dname string into wireformat
Definition: str2host.c:311
ldns_status ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
convert an algorithm value into wireformat
Definition: str2host.c:833
ldns_status ldns_str2rdf_nsec(ldns_rdf **rd, const char *str)
convert string with nsec into wireformat
Definition: str2host.c:690
ldns_status ldns_str2rdf_a(ldns_rdf **rd, const char *str)
convert str with an A record into wireformat
Definition: str2host.c:401
ldns_status ldns_str2rdf_matching_type(ldns_rdf **rd, const char *str)
convert a tlsa matching type value into wireformat
Definition: str2host.c:852
ldns_status ldns_str2rdf_wks(ldns_rdf **rd, const char *str)
convert string with a WKS RR into wireformat
Definition: str2host.c:1088
ldns_status ldns_str2rdf_ilnp64(ldns_rdf **rd, const char *str)
convert 4 * 16bit hex separated by colons into wireformat
Definition: str2host.c:1426
ldns_status ldns_str2rdf_unknown(ldns_rdf **rd __attribute__((unused)), const char *str __attribute__((unused)))
Definition: str2host.c:858
ldns_status ldns_str2rdf_service(ldns_rdf **rd __attribute__((unused)), const char *str __attribute__((unused)))
Definition: str2host.c:868
ldns_status ldns_str2rdf_time(ldns_rdf **rd, const char *time)
convert a time string to a time value in wireformat
Definition: str2host.c:57
ldns_status ldns_str2rdf_nsap(ldns_rdf **rd, const char *str)
convert a str with a NSAP RR into wireformat
Definition: str2host.c:1233
ldns_status ldns_str2rdf_eui64(ldns_rdf **rd, const char *str)
convert 8 hex bytes separated by dashes into wireformat
Definition: str2host.c:1472
ldns_status ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
convert a string with a LOC RR into wireformat
Definition: str2host.c:913
ldns_status ldns_str2rdf_str(ldns_rdf **rd, const char *str)
convert a string into wireformat (think txt record)
Definition: str2host.c:428
ldns_status ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
convert a str with a IPSECKEY RR into wireformat
Definition: str2host.c:1272
ldns_status ldns_str2rdf_selector(ldns_rdf **rd, const char *str)
convert a tlsa selector value into wireformat
Definition: str2host.c:846
ldns_status ldns_str2rdf_tag(ldns_rdf **rd, const char *str)
Convert a non-zero sequence of US-ASCII letters and numbers into wireformat.
Definition: str2host.c:1497
ldns_status ldns_str2rdf_apl(ldns_rdf **rd, const char *str)
convert str with the apl record into wireformat
Definition: str2host.c:472
ldns_status ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
convert the string with the b64 data into wireformat
Definition: str2host.c:583
ldns_status ldns_str2rdf_eui48(ldns_rdf **rd, const char *str)
convert 6 hex bytes separated by dashes into wireformat
Definition: str2host.c:1449
ldns_status ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr)
convert a strings into a 4 byte int in wireformat
Definition: str2host.c:197
ldns_status ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr)
convert a string to a int16 in wireformat
Definition: str2host.c:36
ldns_status ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str)
convert an certificate algorithm value into wireformat
Definition: str2host.c:763
implementation of buffers to ease operations
Definition: buffer.h:51
A general purpose lookup table.
Definition: util.h:156
Resource record data field.
Definition: rdata.h:178
int ldns_hexdigit_to_int(char ch)
Returns the int value of the given (hex) digit.
Definition: util.c:88
time_t ldns_mktime_from_utc(const struct tm *tm)
Convert TM to seconds since epoch (midnight, January 1st, 1970).
Definition: util.c:194
void ldns_set_bit(uint8_t *byte, int bit_nr, bool value)
sets the specified bit in the specified byte to 1 if value is true, 0 if false The bits are counted f...
Definition: util.c:72
int ldns_b32_pton_extended_hex(const char *src, size_t src_sz, uint8_t *dst, size_t dst_sz)
Definition: util.c:760
ldns_lookup_table * ldns_lookup_by_name(ldns_lookup_table *table, const char *name)
Definition: util.c:30
#define INLINE
splint static inline workaround
Definition: util.h:42
#define LDNS_FREE(ptr)
Definition: util.h:60
#define LDNS_MALLOC(type)
Memory management macros.
Definition: util.h:49
#define LDNS_XMALLOC(type, count)
Definition: util.h:51
#define LDNS_XREALLOC(ptr, type, count)
Definition: util.h:57