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  uint16_t *r = NULL;
61  struct tm tm;
62  uint32_t l;
63  char *end;
64 
65  /* Try to scan the time... */
66  r = (uint16_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  uint16_t *r = NULL;
201  uint32_t l;
202 
203  r = (uint16_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) {
449  }
450  length = (size_t)(dp - data);
451  /* Fix last length byte */
452  data[0] = (uint8_t)length;
453 
454  /* Lose the overmeasure */
455  data = LDNS_XREALLOC(dp = data, uint8_t, length + 1);
456  if (! data) {
457  LDNS_FREE(dp);
458  return LDNS_STATUS_MEM_ERR;
459  }
460 
461  /* Create rdf */
462  *rd = ldns_rdf_new(LDNS_RDF_TYPE_STR, length + 1, data);
463  if (! *rd) {
464  LDNS_FREE(data);
465  return LDNS_STATUS_MEM_ERR;
466  }
467  return LDNS_STATUS_OK;
468 }
469 
471 ldns_str2rdf_apl(ldns_rdf **rd, const char *str)
472 {
473  const char *my_str = str;
474 
475  char *my_ip_str;
476  size_t ip_str_len;
477 
478  uint16_t family;
479  bool negation;
480  uint8_t afdlength = 0;
481  uint8_t *afdpart;
482  uint8_t prefix;
483 
484  uint8_t *data;
485 
486  size_t i = 0;
487 
488  /* [!]afi:address/prefix */
489  if (strlen(my_str) < 2
490  || strchr(my_str, ':') == NULL
491  || strchr(my_str, '/') == NULL
492  || strchr(my_str, ':') > strchr(my_str, '/')) {
494  }
495 
496  if (my_str[0] == '!') {
497  negation = true;
498  my_str += 1;
499  } else {
500  negation = false;
501  }
502 
503  family = (uint16_t) atoi(my_str);
504 
505  my_str = strchr(my_str, ':') + 1;
506 
507  /* need ip addr and only ip addr for inet_pton */
508  ip_str_len = (size_t) (strchr(my_str, '/') - my_str);
509  my_ip_str = LDNS_XMALLOC(char, ip_str_len + 1);
510  if(!my_ip_str) return LDNS_STATUS_MEM_ERR;
511  strncpy(my_ip_str, my_str, ip_str_len + 1);
512  my_ip_str[ip_str_len] = '\0';
513 
514  if (family == 1) {
515  /* ipv4 */
516  afdpart = LDNS_XMALLOC(uint8_t, 4);
517  if(!afdpart) {
518  LDNS_FREE(my_ip_str);
519  return LDNS_STATUS_MEM_ERR;
520  }
521  if (inet_pton(AF_INET, my_ip_str, afdpart) == 0) {
522  LDNS_FREE(my_ip_str);
523  LDNS_FREE(afdpart);
525  }
526  for (i = 0; i < 4; i++) {
527  if (afdpart[i] != 0) {
528  afdlength = i + 1;
529  }
530  }
531  } else if (family == 2) {
532  /* ipv6 */
533  afdpart = LDNS_XMALLOC(uint8_t, 16);
534  if(!afdpart) {
535  LDNS_FREE(my_ip_str);
536  return LDNS_STATUS_MEM_ERR;
537  }
538  if (inet_pton(AF_INET6, my_ip_str, afdpart) == 0) {
539  LDNS_FREE(my_ip_str);
540  LDNS_FREE(afdpart);
542  }
543  for (i = 0; i < 16; i++) {
544  if (afdpart[i] != 0) {
545  afdlength = i + 1;
546  }
547  }
548  } else {
549  /* unknown family */
550  LDNS_FREE(my_ip_str);
552  }
553 
554  my_str = strchr(my_str, '/') + 1;
555  prefix = (uint8_t) atoi(my_str);
556 
557  data = LDNS_XMALLOC(uint8_t, 4 + afdlength);
558  if(!data) {
559  LDNS_FREE(afdpart);
560  LDNS_FREE(my_ip_str);
562  }
563  ldns_write_uint16(data, family);
564  data[2] = prefix;
565  data[3] = afdlength;
566  if (negation) {
567  /* set bit 1 of byte 3 */
568  data[3] = data[3] | 0x80;
569  }
570 
571  memcpy(data + 4, afdpart, afdlength);
572 
573  *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_APL, afdlength + 4, data);
574  LDNS_FREE(afdpart);
575  LDNS_FREE(data);
576  LDNS_FREE(my_ip_str);
577 
579 }
580 
582 ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
583 {
584  uint8_t *buffer;
585  int16_t i;
586 
587  buffer = LDNS_XMALLOC(uint8_t, ldns_b64_ntop_calculate_size(strlen(str)));
588  if(!buffer) {
589  return LDNS_STATUS_MEM_ERR;
590  }
591 
592  i = (uint16_t)ldns_b64_pton((const char*)str, buffer,
593  ldns_b64_ntop_calculate_size(strlen(str)));
594  if (-1 == i) {
595  LDNS_FREE(buffer);
597  } else {
598  *rd = ldns_rdf_new_frm_data(
599  LDNS_RDF_TYPE_B64, (uint16_t) i, buffer);
600  }
601  LDNS_FREE(buffer);
602 
604 }
605 
607 ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str)
608 {
609  uint8_t *buffer;
610  int i;
611  /* first byte contains length of actual b32 data */
612  uint8_t len = ldns_b32_pton_calculate_size(strlen(str));
613  buffer = LDNS_XMALLOC(uint8_t, len + 1);
614  if(!buffer) {
615  return LDNS_STATUS_MEM_ERR;
616  }
617  buffer[0] = len;
618 
619  i = ldns_b32_pton_extended_hex((const char*)str, strlen(str), buffer + 1,
620  ldns_b32_ntop_calculate_size(strlen(str)));
621  if (i < 0) {
622  LDNS_FREE(buffer);
624  } else {
625  *rd = ldns_rdf_new_frm_data(
626  LDNS_RDF_TYPE_B32_EXT, (uint16_t) i + 1, buffer);
627  }
628  LDNS_FREE(buffer);
629 
631 }
632 
634 ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
635 {
636  uint8_t *t, *t_orig;
637  int i;
638  size_t len;
639 
640  len = strlen(str);
641 
642  if (len > LDNS_MAX_RDFLEN * 2) {
644  } else {
645  t = LDNS_XMALLOC(uint8_t, (len / 2) + 1);
646  if(!t) {
647  return LDNS_STATUS_MEM_ERR;
648  }
649  t_orig = t;
650  /* Now process octet by octet... */
651  while (*str) {
652  *t = 0;
653  if (isspace((int) *str)) {
654  str++;
655  } else {
656  for (i = 16; i >= 1; i -= 15) {
657  while (*str && isspace((int) *str)) { str++; }
658  if (*str) {
659  if (isxdigit((int) *str)) {
660  *t += ldns_hexdigit_to_int(*str) * i;
661  } else {
662  LDNS_FREE(t_orig);
663  return LDNS_STATUS_ERR;
664  }
665  ++str;
666  }
667  }
668  ++t;
669  }
670  }
672  (size_t) (t - t_orig),
673  t_orig);
674  LDNS_FREE(t_orig);
675  }
677 }
678 
680 ldns_str2rdf_nsec(ldns_rdf **rd, const char *str)
681 {
682  const char *delimiters = "\n\t ";
683  char *token = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
684  ldns_buffer *str_buf;
685  ssize_t c;
686  uint16_t cur_type;
687  size_t type_count = 0;
688  ldns_rr_type type_list[65536];
689  if(!token) return LDNS_STATUS_MEM_ERR;
690  if(rd == NULL) {
691  LDNS_FREE(token);
692  return LDNS_STATUS_NULL;
693  }
694 
695  str_buf = LDNS_MALLOC(ldns_buffer);
696  if(!str_buf) {
697  LDNS_FREE(token);
698  return LDNS_STATUS_MEM_ERR;
699  }
700  ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
701  if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
702  LDNS_FREE(str_buf);
703  LDNS_FREE(token);
704  return LDNS_STATUS_MEM_ERR;
705  }
706 
707  while ((c = ldns_bget_token(str_buf, token, delimiters, LDNS_MAX_RDFLEN)) != -1 && c != 0) {
708  if(type_count >= sizeof(type_list)) {
709  LDNS_FREE(str_buf);
710  LDNS_FREE(token);
711  return LDNS_STATUS_ERR;
712  }
713  cur_type = ldns_get_rr_type_by_name(token);
714  type_list[type_count] = cur_type;
715  type_count++;
716  }
717 
718  *rd = ldns_dnssec_create_nsec_bitmap(type_list,
719  type_count,
721 
722  LDNS_FREE(token);
723  ldns_buffer_free(str_buf);
725 }
726 
728 ldns_str2rdf_type(ldns_rdf **rd, const char *str)
729 {
730  uint16_t type;
731  type = htons(ldns_get_rr_type_by_name(str));
732  /* ldns_rr_type is a 16 bit value */
733  *rd = ldns_rdf_new_frm_data(
734  LDNS_RDF_TYPE_TYPE, sizeof(uint16_t), &type);
736 }
737 
739 ldns_str2rdf_class(ldns_rdf **rd, const char *str)
740 {
741  uint16_t klass;
742  klass = htons(ldns_get_rr_class_by_name(str));
743  /* class is 16 bit */
744  *rd = ldns_rdf_new_frm_data(
745  LDNS_RDF_TYPE_CLASS, sizeof(uint16_t), &klass);
747 }
748 
749 /* An certificate alg field can either be specified as a 8 bits number
750  * or by its symbolic name. Handle both
751  */
753 ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str)
754 {
755  ldns_lookup_table *lt;
756  ldns_status st;
757  uint8_t idd[2];
759  st = LDNS_STATUS_OK;
760 
761  if (lt) {
762  ldns_write_uint16(idd, (uint16_t) lt->id);
763  *rd = ldns_rdf_new_frm_data(
764  LDNS_RDF_TYPE_INT16, sizeof(uint16_t), idd);
765  if (!*rd) {
766  st = LDNS_STATUS_ERR;
767  }
768  } else {
769  /* try as-is (a number) */
770  st = ldns_str2rdf_int16(rd, str);
771  if (st == LDNS_STATUS_OK &&
772  ldns_rdf2native_int16(*rd) == 0) {
774  }
775  }
776 
777  return st;
778 }
779 
780 static ldns_lookup_table ldns_tlsa_certificate_usages[] = {
781  { LDNS_TLSA_USAGE_PKIX_TA , "PKIX-TA" },
782  { LDNS_TLSA_USAGE_PKIX_EE , "PKIX-EE" },
783  { LDNS_TLSA_USAGE_DANE_TA , "DANE-TA" },
784  { LDNS_TLSA_USAGE_DANE_EE , "DANE-EE" },
785  { LDNS_TLSA_USAGE_PRIVCERT , "PrivCert" },
786  { 0, NULL }
787 };
788 
789 static ldns_lookup_table ldns_tlsa_selectors[] = {
790  { LDNS_TLSA_SELECTOR_CERT , "Cert" },
791  { LDNS_TLSA_SELECTOR_SPKI , "SPKI" },
792  { LDNS_TLSA_SELECTOR_PRIVSEL , "PrivSel" },
793  { 0, NULL }
794 };
795 
796 static ldns_lookup_table ldns_tlsa_matching_types[] = {
797  { LDNS_TLSA_MATCHING_TYPE_FULL , "Full" },
798  { LDNS_TLSA_MATCHING_TYPE_SHA2_256 , "SHA2-256" },
799  { LDNS_TLSA_MATCHING_TYPE_SHA2_512 , "SHA2-512" },
800  { LDNS_TLSA_MATCHING_TYPE_PRIVMATCH , "PrivMatch" },
801  { 0, NULL }
802 };
803 
804 static ldns_status
805 ldns_str2rdf_mnemonic4int8(ldns_lookup_table *lt,
806  ldns_rdf **rd, const char *str)
807 {
808  if ((lt = ldns_lookup_by_name(lt, str))) {
809  /* it was given as a integer */
810  *rd = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t) lt->id);
811  if (!*rd)
812  return LDNS_STATUS_ERR;
813  else
814  return LDNS_STATUS_OK;
815  }
816  return ldns_str2rdf_int8(rd, str);
817 }
818 
819 /* An alg field can either be specified as a 8 bits number
820  * or by its symbolic name. Handle both
821  */
823 ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
824 {
825  return ldns_str2rdf_mnemonic4int8(ldns_algorithms, rd, str);
826 }
827 
830 {
831  return ldns_str2rdf_mnemonic4int8(
832  ldns_tlsa_certificate_usages, rd, str);
833 }
834 
836 ldns_str2rdf_selector(ldns_rdf **rd, const char *str)
837 {
838  return ldns_str2rdf_mnemonic4int8(ldns_tlsa_selectors, rd, str);
839 }
840 
842 ldns_str2rdf_matching_type(ldns_rdf **rd, const char *str)
843 {
844  return ldns_str2rdf_mnemonic4int8(ldns_tlsa_matching_types, rd, str);
845 }
846 
849  , ATTR_UNUSED(const char *str)
850  )
851 {
852  /* this should be caught in an earlier time (general str2host for
853  rr's */
854  return LDNS_STATUS_NOT_IMPL;
855 }
856 
859  , ATTR_UNUSED(const char *str)
860  )
861 {
862  /* is this used? is this actually WKS? or SRV? */
863  return LDNS_STATUS_NOT_IMPL;
864 }
865 
866 static int
867 loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e)
868 {
869  /* read <digits>[.<digits>][mM] */
870  /* into mantissa exponent format for LOC type */
871  uint32_t meters = 0, cm = 0, val;
872  while (isblank((unsigned char)*my_str)) {
873  my_str++;
874  }
875  meters = (uint32_t)strtol(my_str, &my_str, 10);
876  if (*my_str == '.') {
877  my_str++;
878  cm = (uint32_t)strtol(my_str, &my_str, 10);
879  }
880  if (meters >= 1) {
881  *e = 2;
882  val = meters;
883  } else {
884  *e = 0;
885  val = cm;
886  }
887  while(val >= 10) {
888  (*e)++;
889  val /= 10;
890  }
891  *m = (uint8_t)val;
892 
893  if (*e > 9)
894  return 0;
895  if (*my_str == 'm' || *my_str == 'M') {
896  my_str++;
897  }
898  *endstr = my_str;
899  return 1;
900 }
901 
903 ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
904 {
905  uint32_t latitude = 0;
906  uint32_t longitude = 0;
907  uint32_t altitude = 0;
908 
909  uint8_t *data;
910  uint32_t equator = (uint32_t) ldns_power(2, 31);
911 
912  uint32_t h = 0;
913  uint32_t m = 0;
914  uint8_t size_b = 1, size_e = 2;
915  uint8_t horiz_pre_b = 1, horiz_pre_e = 6;
916  uint8_t vert_pre_b = 1, vert_pre_e = 3;
917 
918  double s = 0.0;
919  bool northerness;
920  bool easterness;
921 
922  char *my_str = (char *) str;
923 
924  /* only support version 0 */
925  if (isdigit((int) *my_str)) {
926  h = (uint32_t) strtol(my_str, &my_str, 10);
927  } else {
929  }
930 
931  while (isblank((int) *my_str)) {
932  my_str++;
933  }
934 
935  if (isdigit((int) *my_str)) {
936  m = (uint32_t) strtol(my_str, &my_str, 10);
937  } else if (*my_str == 'N' || *my_str == 'S') {
938  goto north;
939  } else {
941  }
942 
943  while (isblank((int) *my_str)) {
944  my_str++;
945  }
946 
947  if (isdigit((int) *my_str)) {
948  s = strtod(my_str, &my_str);
949  }
950 north:
951  while (isblank((int) *my_str)) {
952  my_str++;
953  }
954 
955  if (*my_str == 'N') {
956  northerness = true;
957  } else if (*my_str == 'S') {
958  northerness = false;
959  } else {
961  }
962 
963  my_str++;
964 
965  /* store number */
966  s = 1000.0 * s;
967  /* add a little to make floor in conversion a round */
968  s += 0.0005;
969  latitude = (uint32_t) s;
970  latitude += 1000 * 60 * m;
971  latitude += 1000 * 60 * 60 * h;
972  if (northerness) {
973  latitude = equator + latitude;
974  } else {
975  latitude = equator - latitude;
976  }
977  while (isblank((unsigned char)*my_str)) {
978  my_str++;
979  }
980 
981  if (isdigit((int) *my_str)) {
982  h = (uint32_t) strtol(my_str, &my_str, 10);
983  } else {
985  }
986 
987  while (isblank((int) *my_str)) {
988  my_str++;
989  }
990 
991  if (isdigit((int) *my_str)) {
992  m = (uint32_t) strtol(my_str, &my_str, 10);
993  } else if (*my_str == 'E' || *my_str == 'W') {
994  goto east;
995  } else {
997  }
998 
999  while (isblank((unsigned char)*my_str)) {
1000  my_str++;
1001  }
1002 
1003  if (isdigit((int) *my_str)) {
1004  s = strtod(my_str, &my_str);
1005  }
1006 
1007 east:
1008  while (isblank((unsigned char)*my_str)) {
1009  my_str++;
1010  }
1011 
1012  if (*my_str == 'E') {
1013  easterness = true;
1014  } else if (*my_str == 'W') {
1015  easterness = false;
1016  } else {
1017  return LDNS_STATUS_INVALID_STR;
1018  }
1019 
1020  my_str++;
1021 
1022  /* store number */
1023  s *= 1000.0;
1024  /* add a little to make floor in conversion a round */
1025  s += 0.0005;
1026  longitude = (uint32_t) s;
1027  longitude += 1000 * 60 * m;
1028  longitude += 1000 * 60 * 60 * h;
1029 
1030  if (easterness) {
1031  longitude += equator;
1032  } else {
1033  longitude = equator - longitude;
1034  }
1035 
1036  altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 +
1037  10000000.0 + 0.5);
1038  if (*my_str == 'm' || *my_str == 'M') {
1039  my_str++;
1040  }
1041 
1042  if (strlen(my_str) > 0) {
1043  if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e))
1044  return LDNS_STATUS_INVALID_STR;
1045  }
1046 
1047  if (strlen(my_str) > 0) {
1048  if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e))
1049  return LDNS_STATUS_INVALID_STR;
1050  }
1051 
1052  if (strlen(my_str) > 0) {
1053  if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e))
1054  return LDNS_STATUS_INVALID_STR;
1055  }
1056 
1057  data = LDNS_XMALLOC(uint8_t, 16);
1058  if(!data) {
1059  return LDNS_STATUS_MEM_ERR;
1060  }
1061  data[0] = 0;
1062  data[1] = 0;
1063  data[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f);
1064  data[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f);
1065  data[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f);
1066  ldns_write_uint32(data + 4, latitude);
1067  ldns_write_uint32(data + 8, longitude);
1068  ldns_write_uint32(data + 12, altitude);
1069 
1070  *rd = ldns_rdf_new_frm_data(
1071  LDNS_RDF_TYPE_LOC, 16, data);
1072 
1073  LDNS_FREE(data);
1075 }
1076 
1078 ldns_str2rdf_wks(ldns_rdf **rd, const char *str)
1079 {
1080  uint8_t *bitmap = NULL;
1081  uint8_t *data;
1082  int bm_len = 0;
1083 
1084  struct protoent *proto = NULL;
1085  struct servent *serv = NULL;
1086  int serv_port;
1087 
1088  ldns_buffer *str_buf;
1089 
1090  char *proto_str = NULL;
1091  char *token;
1092  if(strlen(str) == 0)
1093  token = LDNS_XMALLOC(char, 50);
1094  else token = LDNS_XMALLOC(char, strlen(str)+2);
1095  if(!token) return LDNS_STATUS_MEM_ERR;
1096 
1097  str_buf = LDNS_MALLOC(ldns_buffer);
1098  if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1099  ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1100  if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1101  LDNS_FREE(str_buf);
1102  LDNS_FREE(token);
1103  return LDNS_STATUS_MEM_ERR;
1104  }
1105 
1106  while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1107  if (!proto_str) {
1108  proto_str = strdup(token);
1109  if (!proto_str) {
1110  LDNS_FREE(bitmap);
1111  LDNS_FREE(token);
1112  ldns_buffer_free(str_buf);
1113  return LDNS_STATUS_INVALID_STR;
1114  }
1115  } else {
1116  serv = getservbyname(token, proto_str);
1117  if (serv) {
1118  serv_port = (int) ntohs((uint16_t) serv->s_port);
1119  } else {
1120  serv_port = atoi(token);
1121  }
1122  if (serv_port / 8 >= bm_len) {
1123  uint8_t *b2 = LDNS_XREALLOC(bitmap, uint8_t, (serv_port / 8) + 1);
1124  if(!b2) {
1125  LDNS_FREE(bitmap);
1126  LDNS_FREE(token);
1127  ldns_buffer_free(str_buf);
1128  free(proto_str);
1129  return LDNS_STATUS_INVALID_STR;
1130  }
1131  bitmap = b2;
1132  /* set to zero to be sure */
1133  for (; bm_len <= serv_port / 8; bm_len++) {
1134  bitmap[bm_len] = 0;
1135  }
1136  }
1137  ldns_set_bit(bitmap + (serv_port / 8), 7 - (serv_port % 8), true);
1138  }
1139  }
1140 
1141  if (!proto_str || !bitmap) {
1142  LDNS_FREE(bitmap);
1143  LDNS_FREE(token);
1144  ldns_buffer_free(str_buf);
1145  free(proto_str);
1146  return LDNS_STATUS_INVALID_STR;
1147  }
1148 
1149  data = LDNS_XMALLOC(uint8_t, bm_len + 1);
1150  if(!data) {
1151  LDNS_FREE(token);
1152  ldns_buffer_free(str_buf);
1153  LDNS_FREE(bitmap);
1154  free(proto_str);
1155  return LDNS_STATUS_INVALID_STR;
1156  }
1157  if (proto_str)
1158  proto = getprotobyname(proto_str);
1159  if (proto) {
1160  data[0] = (uint8_t) proto->p_proto;
1161  } else if (proto_str) {
1162  data[0] = (uint8_t) atoi(proto_str);
1163  }
1164  memcpy(data + 1, bitmap, (size_t) bm_len);
1165 
1166  *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_WKS, (uint16_t) (bm_len + 1), data);
1167 
1168  LDNS_FREE(data);
1169  LDNS_FREE(token);
1170  ldns_buffer_free(str_buf);
1171  LDNS_FREE(bitmap);
1172  free(proto_str);
1173 #ifdef HAVE_ENDSERVENT
1174  endservent();
1175 #endif
1176 #ifdef HAVE_ENDPROTOENT
1177  endprotoent();
1178 #endif
1179 
1180  if(!*rd) return LDNS_STATUS_MEM_ERR;
1181 
1182  return LDNS_STATUS_OK;
1183 }
1184 
1186 ldns_str2rdf_nsap(ldns_rdf **rd, const char *str)
1187 {
1188  size_t len, i;
1189  char* nsap_str = (char*) str;
1190 
1191  /* just a hex string with optional dots? */
1192  if (str[0] != '0' || str[1] != 'x') {
1193  return LDNS_STATUS_INVALID_STR;
1194  } else {
1195  len = strlen(str);
1196  for (i=0; i < len; i++) {
1197  if (nsap_str[i] == '.')
1198  nsap_str[i] = ' ';
1199  }
1200  return ldns_str2rdf_hex(rd, str+2);
1201  }
1202 }
1203 
1205 ldns_str2rdf_atma(ldns_rdf **rd, const char *str)
1206 {
1207  size_t len, i;
1208  char* atma_str = (char*) str;
1209  ldns_status status;
1210 
1211  /* just a hex string with optional dots? */
1212  len = strlen(str);
1213  for (i=0; i < len; i++) {
1214  if (atma_str[i] == '.')
1215  atma_str[i] = ' ';
1216  }
1217  status = ldns_str2rdf_hex(rd, str);
1218  if (status != LDNS_STATUS_OK) {
1219  ; /* probably in e.164 format than */
1220  }
1221  return status;
1222 }
1223 
1225 ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
1226 {
1227  uint8_t precedence = 0;
1228  uint8_t gateway_type = 0;
1229  uint8_t algorithm = 0;
1230  char* gateway = NULL;
1231  char* publickey = NULL;
1232  uint8_t *data;
1233  ldns_buffer *str_buf;
1234  char *token;
1235  int token_count = 0;
1236  int ipseckey_len = 0;
1237  ldns_rdf* gateway_rdf = NULL;
1238  ldns_rdf* publickey_rdf = NULL;
1239  ldns_status status = LDNS_STATUS_OK;
1240 
1241  if(strlen(str) == 0)
1242  token = LDNS_XMALLOC(char, 256);
1243  else token = LDNS_XMALLOC(char, strlen(str)+2);
1244  if(!token) return LDNS_STATUS_MEM_ERR;
1245 
1246  str_buf = LDNS_MALLOC(ldns_buffer);
1247  if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1248  ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1249  if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1250  LDNS_FREE(str_buf);
1251  LDNS_FREE(token);
1252  return LDNS_STATUS_MEM_ERR;
1253  }
1254  while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1255  switch (token_count) {
1256  case 0:
1257  precedence = (uint8_t)atoi(token);
1258  break;
1259  case 1:
1260  gateway_type = (uint8_t)atoi(token);
1261  break;
1262  case 2:
1263  algorithm = (uint8_t)atoi(token);
1264  break;
1265  case 3:
1266  gateway = strdup(token);
1267  if (!gateway || (gateway_type == 0 &&
1268  (token[0] != '.' || token[1] != '\0'))) {
1269  LDNS_FREE(gateway);
1270  LDNS_FREE(token);
1271  ldns_buffer_free(str_buf);
1272  return LDNS_STATUS_INVALID_STR;
1273  }
1274  break;
1275  case 4:
1276  publickey = strdup(token);
1277  break;
1278  default:
1279  LDNS_FREE(token);
1280  ldns_buffer_free(str_buf);
1281  return LDNS_STATUS_INVALID_STR;
1282  break;
1283  }
1284  token_count++;
1285  }
1286 
1287  if (!gateway || !publickey) {
1288  if (gateway)
1289  LDNS_FREE(gateway);
1290  if (publickey)
1291  LDNS_FREE(publickey);
1292  LDNS_FREE(token);
1293  ldns_buffer_free(str_buf);
1294  return LDNS_STATUS_INVALID_STR;
1295  }
1296 
1297  if (gateway_type == 1) {
1298  status = ldns_str2rdf_a(&gateway_rdf, gateway);
1299  } else if (gateway_type == 2) {
1300  status = ldns_str2rdf_aaaa(&gateway_rdf, gateway);
1301  } else if (gateway_type == 3) {
1302  status = ldns_str2rdf_dname(&gateway_rdf, gateway);
1303  }
1304 
1305  if (status != LDNS_STATUS_OK) {
1306  if (gateway)
1307  LDNS_FREE(gateway);
1308  if (publickey)
1309  LDNS_FREE(publickey);
1310  LDNS_FREE(token);
1311  ldns_buffer_free(str_buf);
1312  return LDNS_STATUS_INVALID_STR;
1313  }
1314 
1315  status = ldns_str2rdf_b64(&publickey_rdf, publickey);
1316 
1317  if (status != LDNS_STATUS_OK) {
1318  if (gateway)
1319  LDNS_FREE(gateway);
1320  if (publickey)
1321  LDNS_FREE(publickey);
1322  LDNS_FREE(token);
1323  ldns_buffer_free(str_buf);
1324  if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1325  return LDNS_STATUS_INVALID_STR;
1326  }
1327 
1328  /* now copy all into one ipseckey rdf */
1329  if (gateway_type)
1330  ipseckey_len = 3 + (int)ldns_rdf_size(gateway_rdf) + (int)ldns_rdf_size(publickey_rdf);
1331  else
1332  ipseckey_len = 3 + (int)ldns_rdf_size(publickey_rdf);
1333 
1334  data = LDNS_XMALLOC(uint8_t, ipseckey_len);
1335  if(!data) {
1336  if (gateway)
1337  LDNS_FREE(gateway);
1338  if (publickey)
1339  LDNS_FREE(publickey);
1340  LDNS_FREE(token);
1341  ldns_buffer_free(str_buf);
1342  if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1343  if (publickey_rdf) ldns_rdf_free(publickey_rdf);
1344  return LDNS_STATUS_MEM_ERR;
1345  }
1346 
1347  data[0] = precedence;
1348  data[1] = gateway_type;
1349  data[2] = algorithm;
1350 
1351  if (gateway_type) {
1352  memcpy(data + 3,
1353  ldns_rdf_data(gateway_rdf), ldns_rdf_size(gateway_rdf));
1354  memcpy(data + 3 + ldns_rdf_size(gateway_rdf),
1355  ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1356  } else {
1357  memcpy(data + 3,
1358  ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1359  }
1360 
1361  *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_IPSECKEY, (uint16_t) ipseckey_len, data);
1362 
1363  if (gateway)
1364  LDNS_FREE(gateway);
1365  if (publickey)
1366  LDNS_FREE(publickey);
1367  LDNS_FREE(token);
1368  ldns_buffer_free(str_buf);
1369  ldns_rdf_free(gateway_rdf);
1370  ldns_rdf_free(publickey_rdf);
1371  LDNS_FREE(data);
1372  if(!*rd) return LDNS_STATUS_MEM_ERR;
1373  return LDNS_STATUS_OK;
1374 }
1375 
1377 ldns_str2rdf_ilnp64(ldns_rdf **rd, const char *str)
1378 {
1379  unsigned int a, b, c, d;
1380  uint16_t shorts[4];
1381  int l;
1382 
1383  if (sscanf(str, "%4x:%4x:%4x:%4x%n", &a, &b, &c, &d, &l) != 4 ||
1384  l != (int)strlen(str) || /* more data to read */
1385  strpbrk(str, "+-") /* signed hexes */
1386  ) {
1388  } else {
1389  shorts[0] = htons(a);
1390  shorts[1] = htons(b);
1391  shorts[2] = htons(c);
1392  shorts[3] = htons(d);
1393  *rd = ldns_rdf_new_frm_data(
1394  LDNS_RDF_TYPE_ILNP64, 4 * sizeof(uint16_t), &shorts);
1395  }
1396  return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
1397 }
1398 
1400 ldns_str2rdf_eui48(ldns_rdf **rd, const char *str)
1401 {
1402  unsigned int a, b, c, d, e, f;
1403  uint8_t bytes[6];
1404  int l;
1405 
1406  if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x%n",
1407  &a, &b, &c, &d, &e, &f, &l) != 6 ||
1408  l != (int)strlen(str)) {
1410  } else {
1411  bytes[0] = a;
1412  bytes[1] = b;
1413  bytes[2] = c;
1414  bytes[3] = d;
1415  bytes[4] = e;
1416  bytes[5] = f;
1417  *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI48, 6, &bytes);
1418  }
1419  return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
1420 }
1421 
1423 ldns_str2rdf_eui64(ldns_rdf **rd, const char *str)
1424 {
1425  unsigned int a, b, c, d, e, f, g, h;
1426  uint8_t bytes[8];
1427  int l;
1428 
1429  if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x-%2x-%2x%n",
1430  &a, &b, &c, &d, &e, &f, &g, &h, &l) != 8 ||
1431  l != (int)strlen(str)) {
1433  } else {
1434  bytes[0] = a;
1435  bytes[1] = b;
1436  bytes[2] = c;
1437  bytes[3] = d;
1438  bytes[4] = e;
1439  bytes[5] = f;
1440  bytes[6] = g;
1441  bytes[7] = h;
1442  *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI64, 8, &bytes);
1443  }
1444  return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
1445 }
1446 
1448 ldns_str2rdf_tag(ldns_rdf **rd, const char *str)
1449 {
1450  uint8_t *data;
1451  const char* ptr;
1452 
1453  if (strlen(str) > 255) {
1454  return LDNS_STATUS_INVALID_TAG;
1455  }
1456  for (ptr = str; *ptr; ptr++) {
1457  if (! isalnum((unsigned char)*ptr)) {
1458  return LDNS_STATUS_INVALID_TAG;
1459  }
1460  }
1461  data = LDNS_XMALLOC(uint8_t, strlen(str) + 1);
1462  if (!data) {
1463  return LDNS_STATUS_MEM_ERR;
1464  }
1465  data[0] = strlen(str);
1466  memcpy(data + 1, str, strlen(str));
1467 
1468  *rd = ldns_rdf_new(LDNS_RDF_TYPE_TAG, strlen(str) + 1, data);
1469  if (!*rd) {
1470  LDNS_FREE(data);
1471  return LDNS_STATUS_MEM_ERR;
1472  }
1473  return LDNS_STATUS_OK;
1474 }
1475 
1477 ldns_str2rdf_long_str(ldns_rdf **rd, const char *str)
1478 {
1479  uint8_t *data, *dp, ch = 0;
1480  size_t length;
1481 
1482  /* Worst case space requirement. We'll realloc to actual size later. */
1483  dp = data = LDNS_XMALLOC(uint8_t, strlen(str));
1484  if (! data) {
1485  return LDNS_STATUS_MEM_ERR;
1486  }
1487 
1488  /* Fill data with parsed bytes */
1489  while (parse_char(&ch, &str)) {
1490  *dp++ = ch;
1491  if (dp - data > LDNS_MAX_RDFLEN) {
1492  LDNS_FREE(data);
1493  return LDNS_STATUS_INVALID_STR;
1494  }
1495  }
1496  if (! str) {
1498  }
1499  length = (size_t)(dp - data);
1500 
1501  /* Lose the overmeasure */
1502  data = LDNS_XREALLOC(dp = data, uint8_t, length);
1503  if (! data) {
1504  LDNS_FREE(dp);
1505  return LDNS_STATUS_MEM_ERR;
1506  }
1507 
1508  /* Create rdf */
1509  *rd = ldns_rdf_new(LDNS_RDF_TYPE_LONG_STR, length, data);
1510  if (! *rd) {
1511  LDNS_FREE(data);
1512  return LDNS_STATUS_MEM_ERR;
1513  }
1514  return LDNS_STATUS_OK;
1515 }
1516 
1518 ldns_str2rdf_hip(ldns_rdf **rd, const char *str)
1519 {
1520  const char *hit = strchr(str, ' ') + 1;
1521  const char *pk = hit == NULL ? NULL : strchr(hit, ' ') + 1;
1522  size_t hit_size = hit == NULL ? 0
1523  : pk == NULL ? strlen(hit) : (size_t) (pk - hit) - 1;
1524  size_t pk_size = pk == NULL ? 0 : strlen(pk);
1525  size_t hit_wire_size = (hit_size + 1) / 2;
1526  size_t pk_wire_size = ldns_b64_pton_calculate_size(pk_size);
1527  size_t rdf_size = 4 + hit_wire_size + pk_wire_size;
1528 
1529  char *endptr; /* utility var for strtol usage */
1530  int algorithm = strtol(str, &endptr, 10);
1531 
1532  uint8_t *data, *dp;
1533  int hi, lo, written;
1534 
1535  if (hit_size == 0 || pk_size == 0 || (hit_size + 1) / 2 > 255
1536  || rdf_size > LDNS_MAX_RDFLEN
1537  || algorithm < 0 || algorithm > 255
1538  || (errno != 0 && algorithm == 0) /* out of range */
1539  || endptr == str /* no digits */) {
1540 
1541  return LDNS_STATUS_SYNTAX_ERR;
1542  }
1543  if ((data = LDNS_XMALLOC(uint8_t, rdf_size)) == NULL) {
1544 
1545  return LDNS_STATUS_MEM_ERR;
1546  }
1547  /* From RFC 5205 section 5. HIP RR Storage Format:
1548  *************************************************
1549 
1550  0 1 2 3
1551  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
1552  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1553  | HIT length | PK algorithm | PK length |
1554  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1555  | |
1556  ~ HIT ~
1557  | |
1558  + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1559  | | |
1560  +-+-+-+-+-+-+-+-+-+-+-+ +
1561  | Public Key |
1562  ~ ~
1563  | |
1564  + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1565  | | |
1566  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +
1567  | |
1568  ~ Rendezvous Servers ~
1569  | |
1570  + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1571  | |
1572  +-+-+-+-+-+-+-+ */
1573 
1574  data[0] = (uint8_t) hit_wire_size;
1575  data[1] = (uint8_t) algorithm;
1576 
1577  for (dp = data + 4; *hit && *hit != ' '; dp++) {
1578 
1579  if ((hi = ldns_hexdigit_to_int(*hit++)) == -1 ||
1580  (lo = ldns_hexdigit_to_int(*hit++)) == -1) {
1581 
1582  LDNS_FREE(data);
1583  return LDNS_STATUS_INVALID_HEX;
1584  }
1585  *dp = (uint8_t) hi << 4 | lo;
1586  }
1587  if ((written = ldns_b64_pton(pk, dp, pk_wire_size)) <= 0) {
1588 
1589  LDNS_FREE(data);
1590  return LDNS_STATUS_INVALID_B64;
1591  }
1592 
1593  /* Because ldns_b64_pton_calculate_size isn't always correct:
1594  * (we have to fix it at some point)
1595  */
1596  pk_wire_size = (uint16_t) written;
1597  ldns_write_uint16(data + 2, pk_wire_size);
1598  rdf_size = 4 + hit_wire_size + pk_wire_size;
1599 
1600  /* Create rdf */
1601  if (! (*rd = ldns_rdf_new(LDNS_RDF_TYPE_HIP, rdf_size, data))) {
1602 
1603  LDNS_FREE(data);
1604  return LDNS_STATUS_MEM_ERR;
1605  }
1606  return LDNS_STATUS_OK;
1607 }
SHA-512 hash of selected content [RFC6234].
Definition: dane.h:96
implementation of buffers to ease operations
Definition: buffer.h:50
time (32 bits)
Definition: rdata.h:84
ldns_status ldns_str2rdf_atma(ldns_rdf **rd, const char *str)
convert a str with a ATMA RR into wireformat
Definition: str2host.c:1205
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_nsec3_salt(ldns_rdf **rd, const char *salt_str)
Definition: str2host.c:126
Full certificate: the Certificate binary structure as defined in [RFC5280].
Definition: dane.h:69
void ldns_set_bit(uint8_t *byte, int bit_nr, bool value)
Definition: util.c:72
b64 string
Definition: rdata.h:68
ldns_status ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
convert a string with a LOC RR into wireformat
Definition: str2host.c:903
ldns_status ldns_str2rdf_dname(ldns_rdf **d, const char *str)
convert a dname string into wireformat
Definition: str2host.c:311
time_t ldns_mktime_from_utc(const struct tm *tm)
Convert TM to seconds since epoch (midnight, January 1st, 1970).
Definition: util.c:194
a RR type
Definition: rdata.h:74
ldns_status ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
convert an algorithm value into wireformat
Definition: str2host.c:823
ldns_status ldns_str2rdf_matching_type(ldns_rdf **rd, const char *str)
convert a tlsa matching type value into wireformat
Definition: str2host.c:842
#define LDNS_XMALLOC(type, count)
Definition: util.h:51
size_t ldns_rdf_size(const ldns_rdf *rd)
returns the size of the rdf.
Definition: rdata.c:24
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:607
void ldns_buffer_free(ldns_buffer *buffer)
frees the buffer.
Definition: buffer.c:137
ldns_status ldns_str2rdf_nsec(ldns_rdf **rd, const char *str)
convert string with nsec into wireformat
Definition: str2host.c:680
ldns_status ldns_str2rdf_eui48(ldns_rdf **rd, const char *str)
convert 6 hex bytes separated by dashes into wireformat
Definition: str2host.c:1400
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:1518
Reserved for Private Use.
Definition: dane.h:99
a class
Definition: rdata.h:76
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:219
ldns_rr_type ldns_get_rr_type_by_name(const char *name)
retrieves a rrtype by looking up its name.
Definition: rr.c:2627
IPSECKEY.
Definition: rdata.h:107
SubjectPublicKeyInfo: DER-encoded binary structure as defined in [RFC5280].
Definition: dane.h:76
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
#define LDNS_XREALLOC(ptr, type, count)
Definition: util.h:57
A non-zero sequence of US-ASCII letters and numbers in lower case.
Definition: rdata.h:126
A <character-string> encoding of the value field as specified [RFC1035], Section 5.1., encoded as remaining rdata.
Definition: rdata.h:132
apl data
Definition: rdata.h:64
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
void ldns_rdf_free(ldns_rdf *rd)
frees a rdf structure, leaving the data pointer intact.
Definition: rdata.c:241
#define INLINE
splint static inline workaround
Definition: util.h:42
Including this file will include all ldns files, and define some lookup tables.
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
uint8_t * ldns_rdf_data(const ldns_rdf *rd)
returns the data of the rdf.
Definition: rdata.c:38
ldns_status ldns_str2rdf_apl(ldns_rdf **rd, const char *str)
convert str with the apl record into wireformat
Definition: str2host.c:471
ldns_status ldns_str2rdf_selector(ldns_rdf **rd, const char *str)
convert a tlsa selector value into wireformat
Definition: str2host.c:836
16 bits
Definition: rdata.h:54
ldns_status ldns_str2rdf_service(ldns_rdf **rd __attribute__((unused)), const char *str __attribute__((unused)))
Definition: str2host.c:858
#define LDNS_MAX_DOMAINLEN
Maximum length of a complete dname.
Definition: rr.h:33
#define ATTR_UNUSED(x)
Definition: common.h:69
ldns_status ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
convert a hex value into wireformat
Definition: str2host.c:634
uint16_t ldns_rdf2native_int16(const ldns_rdf *rd)
returns the native uint16_t representation from the rdf.
Definition: rdata.c:84
b32 string
Definition: rdata.h:66
A record.
Definition: rdata.h:58
#define LDNS_IP6ADDRLEN
Definition: ldns.h:132
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:1477
ldns_lookup_table ldns_algorithms[]
Taken from RFC 2535, section 7.
Definition: host2str.c:41
Trust anchor assertion.
Definition: dane.h:50
AAAA record.
Definition: rdata.h:60
#define LDNS_MAX_LABELLEN
Maximum length of a dname label.
Definition: rr.h:31
32 bits
Definition: rdata.h:56
Reserved for Private Use.
Definition: dane.h:80
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:1448
ldns_status ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str)
convert an certificate algorithm value into wireformat
Definition: str2host.c:753
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_nsap(ldns_rdf **rd, const char *str)
convert a str with a NSAP RR into wireformat
Definition: str2host.c:1186
hex string
Definition: rdata.h:70
Exact match on selected content.
Definition: dane.h:90
txt string
Definition: rdata.h:62
ldns_status ldns_str2rdf_wks(ldns_rdf **rd, const char *str)
convert string with a WKS RR into wireformat
Definition: str2host.c:1078
CA constraint.
Definition: dane.h:44
ldns_status ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
convert a str with a IPSECKEY RR into wireformat
Definition: str2host.c:1225
Reserved for Private Use.
Definition: dane.h:56
uint32_t ldns_str2period(const char *nptr, const char **endptr)
converts a ttl value (like 5d2h) to a long.
Definition: rdata.c:685
enum ldns_enum_status ldns_status
Definition: error.h:134
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_MALLOC(type)
Memory management macros.
Definition: util.h:49
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_rdf_new(ldns_rdf_type type, size_t size, void *data)
allocates a new rdf structure and fills it.
Definition: rdata.c:179
A general purpose lookup table.
Definition: util.h:156
int ldns_b32_pton_extended_hex(const char *src, size_t src_sz, uint8_t *dst, size_t dst_sz)
Definition: util.c:751
ldns_status ldns_str2rdf_unknown(ldns_rdf **rd __attribute__((unused)), const char *str __attribute__((unused)))
Definition: str2host.c:848
ldns_status ldns_str2rdf_ilnp64(ldns_rdf **rd, const char *str)
convert 4 * 16bit hex separated by colons into wireformat
Definition: str2host.c:1377
4 shorts represented as 4 * 16 bit hex numbers separated by colons.
Definition: rdata.h:116
Domain issued certificate.
Definition: dane.h:53
ldns_status ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
convert the string with the b64 data into wireformat
Definition: str2host.c:582
int ldns_hexdigit_to_int(char ch)
Returns the int value of the given (hex) digit.
Definition: util.c:88
Resource record data field.
Definition: rdata.h:174
ldns_status ldns_str2rdf_eui64(ldns_rdf **rd, const char *str)
convert 8 hex bytes separated by dashes into wireformat
Definition: str2host.c:1423
Sevice certificate constraint.
Definition: dane.h:47
ldns_lookup_table * ldns_lookup_by_name(ldns_lookup_table *table, const char *name)
Definition: util.c:30
Represents the Public Key Algorithm, HIT and Public Key fields for the HIP RR types.
Definition: rdata.h:92
nsec3 hash salt
Definition: rdata.h:109
ldns_rr_class ldns_get_rr_class_by_name(const char *name)
retrieves a class by looking up its name.
Definition: rr.c:2667
ldns_status ldns_str2rdf_a(ldns_rdf **rd, const char *str)
convert str with an A record into wireformat
Definition: str2host.c:401
ldns_lookup_table ldns_cert_algorithms[]
Taken from RFC 2538.
Definition: host2str.c:73
8 bits
Definition: rdata.h:52
ldns_status ldns_str2rdf_period(ldns_rdf **rd, const char *period)
Definition: str2host.c:178
enum ldns_enum_rr_type ldns_rr_type
Definition: rr.h:239
#define LDNS_FREE(ptr)
Definition: util.h:60
ldns_status ldns_str2rdf_certificate_usage(ldns_rdf **rd, const char *str)
convert a tlsa certificate usage value into wireformat
Definition: str2host.c:829
ldns_status ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr)
convert a byte into wireformat
Definition: str2host.c:228
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:712
SHA-256 hash of selected content [RFC6234].
Definition: dane.h:93
ldns_status ldns_str2rdf_class(ldns_rdf **rd, const char *str)
convert string with a classname into wireformat
Definition: str2host.c:739
int ldns_b64_pton(char const *src, uint8_t *target, size_t targsize)
domain name
Definition: rdata.h:50
location data
Definition: rdata.h:99
8 * 8 bit hex numbers separated by dashes.
Definition: rdata.h:121
#define LDNS_MAX_RDFLEN
Definition: rdata.h:31
6 * 8 bit hex numbers separated by dashes.
Definition: rdata.h:119
well known services
Definition: rdata.h:101
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_type(ldns_rdf **rd, const char *str)
convert a rrtype into wireformat
Definition: str2host.c:728