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 #include <ldns/internal.h>
17
18 #ifdef HAVE_SYS_SOCKET_H
19 #include <sys/socket.h>
20 #endif
21 #ifdef HAVE_ARPA_INET_H
22 #include <arpa/inet.h>
23 #endif
24 #include <time.h>
25
26 #include <errno.h>
27 #ifdef HAVE_NETDB_H
28 #include <netdb.h>
29 #endif
30
31 #include <limits.h>
32 #ifdef HAVE_SYS_PARAM_H
33 #include <sys/param.h>
34 #endif
35
36 ldns_status
ldns_str2rdf_int16(ldns_rdf ** rd,const char * shortstr)37 ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr)
38 {
39 char *end = NULL;
40 uint16_t *r;
41 r = LDNS_MALLOC(uint16_t);
42 if(!r) return LDNS_STATUS_MEM_ERR;
43
44 *r = htons((uint16_t)strtol((char *)shortstr, &end, 10));
45
46 if(*end != 0) {
47 LDNS_FREE(r);
48 return LDNS_STATUS_INVALID_INT;
49 } else {
50 *rd = ldns_rdf_new_frm_data(
51 LDNS_RDF_TYPE_INT16, sizeof(uint16_t), r);
52 LDNS_FREE(r);
53 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
54 }
55 }
56
57 ldns_status
ldns_str2rdf_time(ldns_rdf ** rd,const char * time)58 ldns_str2rdf_time(ldns_rdf **rd, const char *time)
59 {
60 /* convert a time YYYYDDMMHHMMSS to wireformat */
61 uint32_t *r = NULL;
62 struct tm tm;
63 uint32_t l;
64 char *end;
65
66 /* Try to scan the time... */
67 r = (uint32_t *)LDNS_MALLOC(uint32_t);
68 if(!r) return LDNS_STATUS_MEM_ERR;
69
70 memset(&tm, 0, sizeof(tm));
71
72 if (strlen(time) == 14 &&
73 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
74 ) {
75 tm.tm_year -= 1900;
76 tm.tm_mon--;
77 /* Check values */
78 if (tm.tm_year < 70) {
79 goto bad_format;
80 }
81 if (tm.tm_mon < 0 || tm.tm_mon > 11) {
82 goto bad_format;
83 }
84 if (tm.tm_mday < 1 || tm.tm_mday > 31) {
85 goto bad_format;
86 }
87
88 if (tm.tm_hour < 0 || tm.tm_hour > 23) {
89 goto bad_format;
90 }
91
92 if (tm.tm_min < 0 || tm.tm_min > 59) {
93 goto bad_format;
94 }
95
96 if (tm.tm_sec < 0 || tm.tm_sec > 59) {
97 goto bad_format;
98 }
99
100 l = htonl(ldns_mktime_from_utc(&tm));
101 memcpy(r, &l, sizeof(uint32_t));
102 *rd = ldns_rdf_new_frm_data(
103 LDNS_RDF_TYPE_TIME, sizeof(uint32_t), r);
104 LDNS_FREE(r);
105 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
106 } else {
107 /* handle it as 32 bits timestamp */
108 l = htonl((uint32_t)strtol((char*)time, &end, 10));
109 if(*end != 0) {
110 LDNS_FREE(r);
111 return LDNS_STATUS_ERR;
112 } else {
113 memcpy(r, &l, sizeof(uint32_t));
114 *rd = ldns_rdf_new_frm_data(
115 LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
116 LDNS_FREE(r);
117 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
118 }
119 }
120
121 bad_format:
122 LDNS_FREE(r);
123 return LDNS_STATUS_INVALID_TIME;
124 }
125
126 ldns_status
ldns_str2rdf_nsec3_salt(ldns_rdf ** rd,const char * salt_str)127 ldns_str2rdf_nsec3_salt(ldns_rdf **rd, const char *salt_str)
128 {
129 uint8_t salt_length;
130 int c;
131 int salt_length_str;
132
133 uint8_t *salt;
134 uint8_t *data;
135 if(rd == NULL) {
136 return LDNS_STATUS_NULL;
137 }
138
139 salt_length_str = (int)strlen(salt_str);
140 if (salt_length_str == 1 && salt_str[0] == '-') {
141 salt_length_str = 0;
142 } else if (salt_length_str % 2 != 0) {
143 return LDNS_STATUS_INVALID_HEX;
144 }
145 if (salt_length_str > 512) {
146 return LDNS_STATUS_INVALID_HEX;
147 }
148
149 salt = LDNS_XMALLOC(uint8_t, salt_length_str / 2);
150 if(!salt) {
151 return LDNS_STATUS_MEM_ERR;
152 }
153 for (c = 0; c < salt_length_str; c += 2) {
154 if (isxdigit((int) salt_str[c]) && isxdigit((int) salt_str[c+1])) {
155 salt[c/2] = (uint8_t) ldns_hexdigit_to_int(salt_str[c]) * 16 +
156 ldns_hexdigit_to_int(salt_str[c+1]);
157 } else {
158 LDNS_FREE(salt);
159 return LDNS_STATUS_INVALID_HEX;
160 }
161 }
162 salt_length = (uint8_t) (salt_length_str / 2);
163
164 data = LDNS_XMALLOC(uint8_t, 1 + salt_length);
165 if(!data) {
166 LDNS_FREE(salt);
167 return LDNS_STATUS_MEM_ERR;
168 }
169 data[0] = salt_length;
170 memcpy(&data[1], salt, salt_length);
171 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_NSEC3_SALT, 1 + salt_length, data);
172 LDNS_FREE(data);
173 LDNS_FREE(salt);
174
175 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
176 }
177
178 ldns_status
ldns_str2rdf_period(ldns_rdf ** rd,const char * period)179 ldns_str2rdf_period(ldns_rdf **rd,const char *period)
180 {
181 uint32_t p;
182 const char *end;
183
184 /* Allocate required space... */
185 p = ldns_str2period(period, &end);
186
187 if (*end != 0) {
188 return LDNS_STATUS_ERR;
189 } else {
190 p = (uint32_t) htonl(p);
191 *rd = ldns_rdf_new_frm_data(
192 LDNS_RDF_TYPE_PERIOD, sizeof(uint32_t), &p);
193 }
194 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
195 }
196
197 ldns_status
ldns_str2rdf_int32(ldns_rdf ** rd,const char * longstr)198 ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr)
199 {
200 char *end;
201 uint32_t *r = NULL;
202 uint32_t l;
203
204 r = (uint32_t*)LDNS_MALLOC(uint32_t);
205 if(!r) return LDNS_STATUS_MEM_ERR;
206 errno = 0; /* must set to zero before call,
207 note race condition on errno */
208 if(*longstr == '-')
209 l = htonl((uint32_t)strtol((char*)longstr, &end, 10));
210 else l = htonl((uint32_t)strtoul((char*)longstr, &end, 10));
211
212 if(*end != 0) {
213 LDNS_FREE(r);
214 return LDNS_STATUS_ERR;
215 } else {
216 if (errno == ERANGE) {
217 LDNS_FREE(r);
218 return LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW;
219 }
220 memcpy(r, &l, sizeof(uint32_t));
221 *rd = ldns_rdf_new_frm_data(
222 LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
223 LDNS_FREE(r);
224 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
225 }
226 }
227
228 #ifdef __BYTE_ORDER__
229 # if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
230 # define htonll(x) (x)
231 # define ntohll(x) (x)
232 # else
233 # define htonll(x) (((uint64_t)htonl((x) & 0xFFFFFFFF) << 32) | htonl((x) >> 32))
234 # define ntohll(x) (((uint64_t)ntohl((x) & 0xFFFFFFFF) << 32) | ntohl((x) >> 32))
235 # endif
236 #else
237 # define htonll(x) ((1==htonl(1)) ? (x) : ((uint64_t)htonl((x) & 0xFFFFFFFF) << 32) | htonl((x) >> 32))
238 # define ntohll(x) ((1==ntohl(1)) ? (x) : ((uint64_t)ntohl((x) & 0xFFFFFFFF) << 32) | ntohl((x) >> 32))
239 #endif
240
241 ldns_status
ldns_str2rdf_ipn(ldns_rdf ** rd,const char * ipnstr)242 ldns_str2rdf_ipn(ldns_rdf **rd, const char *ipnstr)
243 {
244 char *end;
245 uint8_t r[sizeof(uint64_t)];
246 char left[21], *right;
247
248 if(strlen(ipnstr) > 21)
249 return LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW;
250 errno = 0; /* must set to zero before call,
251 note race condition on errno */
252 if((right = strchr(ipnstr, '.'))) {
253 uint32_t u32 = strtoul(right + 1, &end, 10);
254
255 if(*end != 0)
256 return LDNS_STATUS_ERR;
257
258 if(errno == ERANGE)
259 return LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW;
260
261 u32 = htonl(u32);
262 memcpy(r + sizeof(uint32_t), &u32, sizeof(uint32_t));
263 memcpy(left, ipnstr, right - ipnstr);
264 left[right - ipnstr] = 0;
265
266 u32 = strtoul(left, &end, 10);
267 if(*end != 0)
268 return LDNS_STATUS_ERR;
269
270 if(errno == ERANGE)
271 return LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW;
272
273 u32 = htonl(u32);
274 memcpy(r, &u32, sizeof(uint32_t));
275 } else {
276 uint64_t u64 = strtoull(ipnstr, &end, 10);
277
278 if(*end != 0)
279 return LDNS_STATUS_ERR;
280
281 if(u64 == ULLONG_MAX && errno == ERANGE)
282 return LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW;
283
284 u64 = htonll(u64);
285 memcpy(r, &u64, sizeof(uint64_t));
286 }
287 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_IPN, sizeof(r), r);
288 return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
289 }
290
291 ldns_status
ldns_str2rdf_int8(ldns_rdf ** rd,const char * bytestr)292 ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr)
293 {
294 char *end;
295 uint8_t *r = NULL;
296
297 r = LDNS_MALLOC(uint8_t);
298 if(!r) return LDNS_STATUS_MEM_ERR;
299
300 *r = (uint8_t)strtol((char*)bytestr, &end, 10);
301
302 if(*end != 0) {
303 LDNS_FREE(r);
304 return LDNS_STATUS_ERR;
305 } else {
306 *rd = ldns_rdf_new_frm_data(
307 LDNS_RDF_TYPE_INT8, sizeof(uint8_t), r);
308 LDNS_FREE(r);
309 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
310 }
311 }
312
313
314 /*
315 * Checks whether the escaped value at **s is an decimal value or
316 * a 'normally' escaped character (and not eos)
317 *
318 * The string pointer at *s is increased by either 0 (on error), 1 (on
319 * normal escapes), or 3 (on decimals)
320 *
321 * Returns the number of bytes read from the escaped string, or
322 * 0 on error
323 */
324 INLINE bool
parse_escape(uint8_t * ch_p,const char ** str_p)325 parse_escape(uint8_t *ch_p, const char** str_p)
326 {
327 uint16_t val;
328
329 if ((*str_p)[0] && isdigit((unsigned char)(*str_p)[0]) &&
330 (*str_p)[1] && isdigit((unsigned char)(*str_p)[1]) &&
331 (*str_p)[2] && isdigit((unsigned char)(*str_p)[2])) {
332
333 val = (uint16_t)(((*str_p)[0] - '0') * 100 +
334 ((*str_p)[1] - '0') * 10 +
335 ((*str_p)[2] - '0'));
336
337 if (val > 255) {
338 goto error;
339 }
340 *ch_p = (uint8_t)val;
341 *str_p += 3;
342 return true;
343
344 } else if ((*str_p)[0] && !isdigit((unsigned char)(*str_p)[0])) {
345
346 *ch_p = (uint8_t)*(*str_p)++;
347 return true;
348 }
349 error:
350 *str_p = NULL;
351 return false; /* LDNS_STATUS_SYNTAX_BAD_ESCAPE */
352 }
353
354 INLINE bool
parse_char(uint8_t * ch_p,const char ** str_p)355 parse_char(uint8_t *ch_p, const char** str_p)
356 {
357 switch (**str_p) {
358
359 case '\0': return false;
360
361 case '\\': *str_p += 1;
362 return parse_escape(ch_p, str_p);
363
364 default: *ch_p = (uint8_t)*(*str_p)++;
365 return true;
366 }
367 }
368
369 /*
370 * No special care is taken, all dots are translated into
371 * label separators.
372 * Could be made more efficient....we do 3 memcpy's in total...
373 */
374 ldns_status
ldns_str2rdf_dname(ldns_rdf ** d,const char * str)375 ldns_str2rdf_dname(ldns_rdf **d, const char *str)
376 {
377 size_t len;
378
379 const char *s;
380 uint8_t *q, *pq, label_len;
381 uint8_t buf[LDNS_MAX_DOMAINLEN + 1];
382 *d = NULL;
383
384 len = strlen((char*)str);
385 /* octet representation can make strings a lot longer than actual length */
386 if (len > LDNS_MAX_DOMAINLEN * 4) {
387 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
388 }
389 if (0 == len) {
390 return LDNS_STATUS_DOMAINNAME_UNDERFLOW;
391 }
392
393 /* root label */
394 if (1 == len && *str == '.') {
395 *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, 1, "\0");
396 return LDNS_STATUS_OK;
397 }
398
399 /* get on with the rest */
400
401 /* s is on the current character in the string
402 * pq points to where the labellength is going to go
403 * label_len keeps track of the current label's length
404 * q builds the dname inside the buf array
405 */
406 len = 0;
407 q = buf+1;
408 pq = buf;
409 label_len = 0;
410 for (s = str; *s; s++, q++) {
411 if (q >= buf + LDNS_MAX_DOMAINLEN) {
412 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
413 }
414 *q = 0;
415 switch (*s) {
416 case '.':
417 if (label_len > LDNS_MAX_LABELLEN) {
418 return LDNS_STATUS_LABEL_OVERFLOW;
419 }
420 if (label_len == 0) {
421 return LDNS_STATUS_EMPTY_LABEL;
422 }
423 len += label_len + 1;
424 *pq = label_len;
425 label_len = 0;
426 pq = q;
427 break;
428 case '\\':
429 /* octet value or literal char */
430 s += 1;
431 if (! parse_escape(q, &s)) {
432 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
433 }
434 s -= 1;
435 label_len++;
436 break;
437 default:
438 *q = (uint8_t)*s;
439 label_len++;
440 }
441 }
442
443 /* add root label if last char was not '.' */
444 if (!ldns_dname_str_absolute(str)) {
445 if (q >= buf + LDNS_MAX_DOMAINLEN) {
446 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
447 }
448 if (label_len > LDNS_MAX_LABELLEN) {
449 return LDNS_STATUS_LABEL_OVERFLOW;
450 }
451 if (label_len == 0) { /* label_len 0 but not . at end? */
452 return LDNS_STATUS_EMPTY_LABEL;
453 }
454 len += label_len + 1;
455 *pq = label_len;
456 *q = 0;
457 }
458 len++;
459
460 *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, len, buf);
461 return LDNS_STATUS_OK;
462 }
463
464 ldns_status
ldns_str2rdf_a(ldns_rdf ** rd,const char * str)465 ldns_str2rdf_a(ldns_rdf **rd, const char *str)
466 {
467 in_addr_t address;
468 if (inet_pton(AF_INET, (char*)str, &address) != 1) {
469 return LDNS_STATUS_INVALID_IP4;
470 } else {
471 *rd = ldns_rdf_new_frm_data(
472 LDNS_RDF_TYPE_A, sizeof(address), &address);
473 }
474 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
475 }
476
477 ldns_status
ldns_str2rdf_aaaa(ldns_rdf ** rd,const char * str)478 ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str)
479 {
480 uint8_t address[LDNS_IP6ADDRLEN + 1];
481
482 if (inet_pton(AF_INET6, (char*)str, address) != 1) {
483 return LDNS_STATUS_INVALID_IP6;
484 } else {
485 *rd = ldns_rdf_new_frm_data(
486 LDNS_RDF_TYPE_AAAA, sizeof(address) - 1, &address);
487 }
488 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
489 }
490
491 ldns_status
ldns_str2rdf_str(ldns_rdf ** rd,const char * str)492 ldns_str2rdf_str(ldns_rdf **rd, const char *str)
493 {
494 uint8_t *data, *dp, ch = 0;
495 size_t length;
496
497 /* Worst case space requirement. We'll realloc to actual size later. */
498 dp = data = LDNS_XMALLOC(uint8_t, strlen(str) > 255 ? 256 : (strlen(str) + 1));
499 if (! data) {
500 return LDNS_STATUS_MEM_ERR;
501 }
502
503 /* Fill data (up to 255 characters) */
504 while (parse_char(&ch, &str)) {
505 if (dp - data >= 255) {
506 LDNS_FREE(data);
507 return LDNS_STATUS_INVALID_STR;
508 }
509 *++dp = ch;
510 }
511 if (! str) {
512 LDNS_FREE(data);
513 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
514 }
515 length = (size_t)(dp - data);
516 /* Fix last length byte */
517 data[0] = (uint8_t)length;
518
519 /* Lose the overmeasure */
520 data = LDNS_XREALLOC(dp = data, uint8_t, length + 1);
521 if (! data) {
522 LDNS_FREE(dp);
523 return LDNS_STATUS_MEM_ERR;
524 }
525
526 /* Create rdf */
527 *rd = ldns_rdf_new(LDNS_RDF_TYPE_STR, length + 1, data);
528 if (! *rd) {
529 LDNS_FREE(data);
530 return LDNS_STATUS_MEM_ERR;
531 }
532 return LDNS_STATUS_OK;
533 }
534
535 ldns_status
ldns_str2rdf_apl(ldns_rdf ** rd,const char * str)536 ldns_str2rdf_apl(ldns_rdf **rd, const char *str)
537 {
538 const char *my_str = str;
539
540 char *my_ip_str;
541 size_t ip_str_len;
542
543 uint16_t family;
544 bool negation;
545 uint8_t afdlength = 0;
546 uint8_t *afdpart;
547 uint8_t prefix;
548
549 uint8_t *data;
550
551 size_t i = 0;
552
553 /* [!]afi:address/prefix */
554 if (strlen(my_str) < 2
555 || strchr(my_str, ':') == NULL
556 || strchr(my_str, '/') == NULL
557 || strchr(my_str, ':') > strchr(my_str, '/')) {
558 return LDNS_STATUS_INVALID_STR;
559 }
560
561 if (my_str[0] == '!') {
562 negation = true;
563 my_str += 1;
564 } else {
565 negation = false;
566 }
567
568 family = (uint16_t) atoi(my_str);
569
570 my_str = strchr(my_str, ':') + 1;
571
572 /* need ip addr and only ip addr for inet_pton */
573 ip_str_len = (size_t) (strchr(my_str, '/') - my_str);
574 my_ip_str = LDNS_XMALLOC(char, ip_str_len + 1);
575 if(!my_ip_str) return LDNS_STATUS_MEM_ERR;
576 strncpy(my_ip_str, my_str, ip_str_len + 1);
577 my_ip_str[ip_str_len] = '\0';
578
579 if (family == 1) {
580 /* ipv4 */
581 afdpart = LDNS_XMALLOC(uint8_t, 4);
582 if(!afdpart) {
583 LDNS_FREE(my_ip_str);
584 return LDNS_STATUS_MEM_ERR;
585 }
586 if (inet_pton(AF_INET, my_ip_str, afdpart) == 0) {
587 LDNS_FREE(my_ip_str);
588 LDNS_FREE(afdpart);
589 return LDNS_STATUS_INVALID_STR;
590 }
591 for (i = 0; i < 4; i++) {
592 if (afdpart[i] != 0) {
593 afdlength = i + 1;
594 }
595 }
596 } else if (family == 2) {
597 /* ipv6 */
598 afdpart = LDNS_XMALLOC(uint8_t, 16);
599 if(!afdpart) {
600 LDNS_FREE(my_ip_str);
601 return LDNS_STATUS_MEM_ERR;
602 }
603 if (inet_pton(AF_INET6, my_ip_str, afdpart) == 0) {
604 LDNS_FREE(my_ip_str);
605 LDNS_FREE(afdpart);
606 return LDNS_STATUS_INVALID_STR;
607 }
608 for (i = 0; i < 16; i++) {
609 if (afdpart[i] != 0) {
610 afdlength = i + 1;
611 }
612 }
613 } else {
614 /* unknown family */
615 LDNS_FREE(my_ip_str);
616 return LDNS_STATUS_INVALID_STR;
617 }
618
619 my_str = strchr(my_str, '/') + 1;
620 prefix = (uint8_t) atoi(my_str);
621
622 data = LDNS_XMALLOC(uint8_t, 4 + afdlength);
623 if(!data) {
624 LDNS_FREE(afdpart);
625 LDNS_FREE(my_ip_str);
626 return LDNS_STATUS_INVALID_STR;
627 }
628 ldns_write_uint16(data, family);
629 data[2] = prefix;
630 data[3] = afdlength;
631 if (negation) {
632 /* set bit 1 of byte 3 */
633 data[3] = data[3] | 0x80;
634 }
635
636 memcpy(data + 4, afdpart, afdlength);
637
638 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_APL, afdlength + 4, data);
639 LDNS_FREE(afdpart);
640 LDNS_FREE(data);
641 LDNS_FREE(my_ip_str);
642
643 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
644 }
645
646 ldns_status
ldns_str2rdf_b64(ldns_rdf ** rd,const char * str)647 ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
648 {
649 uint8_t *buffer;
650 int16_t i;
651
652 if ((*str == '-' || *str == '0') && str[1] == '\0') {
653 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, 0, NULL);
654 return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
655 }
656
657 buffer = LDNS_XMALLOC(uint8_t, ldns_b64_ntop_calculate_size(strlen(str)));
658 if(!buffer) {
659 return LDNS_STATUS_MEM_ERR;
660 }
661
662 i = (uint16_t)ldns_b64_pton((const char*)str, buffer,
663 ldns_b64_ntop_calculate_size(strlen(str)));
664 if (-1 == i) {
665 LDNS_FREE(buffer);
666 return LDNS_STATUS_INVALID_B64;
667 } else {
668 *rd = ldns_rdf_new_frm_data(
669 LDNS_RDF_TYPE_B64, (uint16_t) i, buffer);
670 }
671 LDNS_FREE(buffer);
672
673 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
674 }
675
676 ldns_status
ldns_str2rdf_b32_ext(ldns_rdf ** rd,const char * str)677 ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str)
678 {
679 uint8_t *buffer;
680 int i;
681 /* first byte contains length of actual b32 data */
682 size_t slen = strlen(str);
683 size_t len = ldns_b32_pton_calculate_size(slen);
684 if (len > 255) {
685 return LDNS_STATUS_INVALID_B32_EXT;
686 }
687 buffer = LDNS_XMALLOC(uint8_t, len + 1);
688 if(!buffer) {
689 return LDNS_STATUS_MEM_ERR;
690 }
691 buffer[0] = len;
692
693 i = ldns_b32_pton_extended_hex((const char*)str, slen, buffer + 1,
694 ldns_b32_ntop_calculate_size(slen));
695 if (i < 0) {
696 LDNS_FREE(buffer);
697 return LDNS_STATUS_INVALID_B32_EXT;
698 } else {
699 *rd = ldns_rdf_new_frm_data(
700 LDNS_RDF_TYPE_B32_EXT, (uint16_t) i + 1, buffer);
701 }
702 LDNS_FREE(buffer);
703
704 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
705 }
706
707 ldns_status
ldns_str2rdf_hex(ldns_rdf ** rd,const char * str)708 ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
709 {
710 uint8_t *t, *t_orig;
711 int i;
712 size_t len;
713
714 len = strlen(str);
715
716 if (len > LDNS_MAX_RDFLEN * 2) {
717 return LDNS_STATUS_LABEL_OVERFLOW;
718 } else {
719 t = LDNS_XMALLOC(uint8_t, (len / 2) + 1);
720 if(!t) {
721 return LDNS_STATUS_MEM_ERR;
722 }
723 t_orig = t;
724 /* Now process octet by octet... */
725 while (*str) {
726 *t = 0;
727 if (isspace((int) *str)) {
728 str++;
729 } else {
730 for (i = 16; i >= 1; i -= 15) {
731 while (*str && isspace((int) *str)) { str++; }
732 if (*str) {
733 if (isxdigit((int) *str)) {
734 *t += ldns_hexdigit_to_int(*str) * i;
735 } else {
736 LDNS_FREE(t_orig);
737 return LDNS_STATUS_ERR;
738 }
739 ++str;
740 }
741 }
742 ++t;
743 }
744 }
745 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX,
746 (size_t) (t - t_orig),
747 t_orig);
748 LDNS_FREE(t_orig);
749 }
750 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
751 }
752
753 ldns_status
ldns_str2rdf_nsec(ldns_rdf ** rd,const char * str)754 ldns_str2rdf_nsec(ldns_rdf **rd, const char *str)
755 {
756 const char *delimiters = "\n\t ";
757 char *token = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
758 ldns_buffer *str_buf;
759 ssize_t c;
760 uint16_t cur_type;
761 size_t type_count = 0;
762 ldns_rr_type type_list[65536];
763 if(!token) return LDNS_STATUS_MEM_ERR;
764 if(rd == NULL) {
765 LDNS_FREE(token);
766 return LDNS_STATUS_NULL;
767 }
768
769 str_buf = LDNS_MALLOC(ldns_buffer);
770 if(!str_buf) {
771 LDNS_FREE(token);
772 return LDNS_STATUS_MEM_ERR;
773 }
774 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
775 if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
776 LDNS_FREE(str_buf);
777 LDNS_FREE(token);
778 return LDNS_STATUS_MEM_ERR;
779 }
780
781 while ((c = ldns_bget_token(str_buf, token, delimiters, LDNS_MAX_RDFLEN)) != -1 && c != 0) {
782 if(type_count >= sizeof(type_list)) {
783 LDNS_FREE(str_buf);
784 LDNS_FREE(token);
785 return LDNS_STATUS_ERR;
786 }
787 cur_type = ldns_get_rr_type_by_name(token);
788 type_list[type_count] = cur_type;
789 type_count++;
790 }
791
792 *rd = ldns_dnssec_create_nsec_bitmap(type_list,
793 type_count,
794 LDNS_RR_TYPE_NSEC);
795
796 LDNS_FREE(token);
797 ldns_buffer_free(str_buf);
798 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
799 }
800
801 ldns_status
ldns_str2rdf_type(ldns_rdf ** rd,const char * str)802 ldns_str2rdf_type(ldns_rdf **rd, const char *str)
803 {
804 uint16_t type;
805 type = htons(ldns_get_rr_type_by_name(str));
806 /* ldns_rr_type is a 16 bit value */
807 *rd = ldns_rdf_new_frm_data(
808 LDNS_RDF_TYPE_TYPE, sizeof(uint16_t), &type);
809 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
810 }
811
812 ldns_status
ldns_str2rdf_class(ldns_rdf ** rd,const char * str)813 ldns_str2rdf_class(ldns_rdf **rd, const char *str)
814 {
815 uint16_t klass;
816 klass = htons(ldns_get_rr_class_by_name(str));
817 /* class is 16 bit */
818 *rd = ldns_rdf_new_frm_data(
819 LDNS_RDF_TYPE_CLASS, sizeof(uint16_t), &klass);
820 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
821 }
822
823 /* An certificate alg field can either be specified as a 8 bits number
824 * or by its symbolic name. Handle both
825 */
826 ldns_status
ldns_str2rdf_cert_alg(ldns_rdf ** rd,const char * str)827 ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str)
828 {
829 ldns_lookup_table *lt;
830 ldns_status st;
831 uint8_t idd[2];
832 lt = ldns_lookup_by_name(ldns_cert_algorithms, str);
833 st = LDNS_STATUS_OK;
834
835 if (lt) {
836 ldns_write_uint16(idd, (uint16_t) lt->id);
837 *rd = ldns_rdf_new_frm_data(
838 LDNS_RDF_TYPE_INT16, sizeof(uint16_t), idd);
839 if (!*rd) {
840 st = LDNS_STATUS_ERR;
841 }
842 } else {
843 /* try as-is (a number) */
844 st = ldns_str2rdf_int16(rd, str);
845 if (st == LDNS_STATUS_OK &&
846 ldns_rdf2native_int16(*rd) == 0) {
847 st = LDNS_STATUS_CERT_BAD_ALGORITHM;
848 }
849 }
850
851 return st;
852 }
853
854 static ldns_lookup_table ldns_tlsa_certificate_usages[] = {
855 { LDNS_TLSA_USAGE_PKIX_TA , "PKIX-TA" },
856 { LDNS_TLSA_USAGE_PKIX_EE , "PKIX-EE" },
857 { LDNS_TLSA_USAGE_DANE_TA , "DANE-TA" },
858 { LDNS_TLSA_USAGE_DANE_EE , "DANE-EE" },
859 { LDNS_TLSA_USAGE_PRIVCERT , "PrivCert" },
860 { 0, NULL }
861 };
862
863 static ldns_lookup_table ldns_tlsa_selectors[] = {
864 { LDNS_TLSA_SELECTOR_CERT , "Cert" },
865 { LDNS_TLSA_SELECTOR_SPKI , "SPKI" },
866 { LDNS_TLSA_SELECTOR_PRIVSEL , "PrivSel" },
867 { 0, NULL }
868 };
869
870 static ldns_lookup_table ldns_tlsa_matching_types[] = {
871 { LDNS_TLSA_MATCHING_TYPE_FULL , "Full" },
872 { LDNS_TLSA_MATCHING_TYPE_SHA2_256 , "SHA2-256" },
873 { LDNS_TLSA_MATCHING_TYPE_SHA2_512 , "SHA2-512" },
874 { LDNS_TLSA_MATCHING_TYPE_PRIVMATCH , "PrivMatch" },
875 { 0, NULL }
876 };
877
878 static ldns_status
ldns_str2rdf_mnemonic4int8(ldns_lookup_table * lt,ldns_rdf ** rd,const char * str)879 ldns_str2rdf_mnemonic4int8(ldns_lookup_table *lt,
880 ldns_rdf **rd, const char *str)
881 {
882 if ((lt = ldns_lookup_by_name(lt, str))) {
883 /* it was given as a integer */
884 *rd = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t) lt->id);
885 if (!*rd)
886 return LDNS_STATUS_ERR;
887 else
888 return LDNS_STATUS_OK;
889 }
890 return ldns_str2rdf_int8(rd, str);
891 }
892
893 /* An alg field can either be specified as a 8 bits number
894 * or by its symbolic name. Handle both
895 */
896 ldns_status
ldns_str2rdf_alg(ldns_rdf ** rd,const char * str)897 ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
898 {
899 return ldns_str2rdf_mnemonic4int8(ldns_algorithms, rd, str);
900 }
901
902 ldns_status
ldns_str2rdf_certificate_usage(ldns_rdf ** rd,const char * str)903 ldns_str2rdf_certificate_usage(ldns_rdf **rd, const char *str)
904 {
905 return ldns_str2rdf_mnemonic4int8(
906 ldns_tlsa_certificate_usages, rd, str);
907 }
908
909 ldns_status
ldns_str2rdf_selector(ldns_rdf ** rd,const char * str)910 ldns_str2rdf_selector(ldns_rdf **rd, const char *str)
911 {
912 return ldns_str2rdf_mnemonic4int8(ldns_tlsa_selectors, rd, str);
913 }
914
915 ldns_status
ldns_str2rdf_matching_type(ldns_rdf ** rd,const char * str)916 ldns_str2rdf_matching_type(ldns_rdf **rd, const char *str)
917 {
918 return ldns_str2rdf_mnemonic4int8(ldns_tlsa_matching_types, rd, str);
919 }
920
921 ldns_status
ldns_str2rdf_unknown(ATTR_UNUSED (ldns_rdf ** rd),ATTR_UNUSED (const char * str))922 ldns_str2rdf_unknown( ATTR_UNUSED(ldns_rdf **rd)
923 , ATTR_UNUSED(const char *str)
924 )
925 {
926 /* this should be caught in an earlier time (general str2host for
927 rr's */
928 return LDNS_STATUS_NOT_IMPL;
929 }
930
931 ldns_status
ldns_str2rdf_service(ATTR_UNUSED (ldns_rdf ** rd),ATTR_UNUSED (const char * str))932 ldns_str2rdf_service( ATTR_UNUSED(ldns_rdf **rd)
933 , ATTR_UNUSED(const char *str)
934 )
935 {
936 /* is this used? is this actually WKS? or SRV? */
937 return LDNS_STATUS_NOT_IMPL;
938 }
939
940 static int
loc_parse_cm(char * my_str,char ** endstr,uint8_t * m,uint8_t * e)941 loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e)
942 {
943 /* read <digits>[.<digits>][mM] */
944 /* into mantissa exponent format for LOC type */
945 uint32_t meters = 0, cm = 0, val;
946 char* cm_endstr;
947 while (isblank((unsigned char)*my_str)) {
948 my_str++;
949 }
950 meters = (uint32_t)strtol(my_str, &my_str, 10);
951 if (*my_str == '.') {
952 my_str++;
953 cm = (uint32_t)strtol(my_str, &cm_endstr, 10);
954 if (cm_endstr - my_str == 1) cm *= 10;
955 my_str = cm_endstr;
956 }
957 if (meters >= 1) {
958 *e = 2;
959 val = meters;
960 } else {
961 *e = 0;
962 val = cm;
963 }
964 while(val >= 10) {
965 (*e)++;
966 val /= 10;
967 }
968 *m = (uint8_t)val;
969
970 if (*e > 9)
971 return 0;
972 if (*my_str == 'm' || *my_str == 'M') {
973 my_str++;
974 }
975 *endstr = my_str;
976 return 1;
977 }
978
979 ldns_status
ldns_str2rdf_loc(ldns_rdf ** rd,const char * str)980 ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
981 {
982 uint32_t latitude = 0;
983 uint32_t longitude = 0;
984 uint32_t altitude = 0;
985
986 uint8_t *data;
987 uint32_t equator = (uint32_t) ldns_power(2, 31);
988
989 uint32_t h = 0;
990 uint32_t m = 0;
991 uint8_t size_b = 1, size_e = 2;
992 uint8_t horiz_pre_b = 1, horiz_pre_e = 6;
993 uint8_t vert_pre_b = 1, vert_pre_e = 3;
994
995 double s = 0.0;
996 bool northern_hemisphere;
997 bool eastern_hemisphere;
998
999 char *my_str = (char *) str;
1000
1001 /* only support version 0 */
1002 if (isdigit((int) *my_str)) {
1003 h = (uint32_t) strtol(my_str, &my_str, 10);
1004 } else {
1005 return LDNS_STATUS_INVALID_STR;
1006 }
1007
1008 while (isblank((int) *my_str)) {
1009 my_str++;
1010 }
1011
1012 if (isdigit((int) *my_str)) {
1013 m = (uint32_t) strtol(my_str, &my_str, 10);
1014 } else if (*my_str == 'N' || *my_str == 'S') {
1015 goto north;
1016 } else {
1017 return LDNS_STATUS_INVALID_STR;
1018 }
1019
1020 while (isblank((int) *my_str)) {
1021 my_str++;
1022 }
1023
1024 if (isdigit((int) *my_str)) {
1025 s = strtod(my_str, &my_str);
1026 }
1027 north:
1028 while (isblank((int) *my_str)) {
1029 my_str++;
1030 }
1031
1032 if (*my_str == 'N') {
1033 northern_hemisphere = true;
1034 } else if (*my_str == 'S') {
1035 northern_hemisphere = false;
1036 } else {
1037 return LDNS_STATUS_INVALID_STR;
1038 }
1039
1040 my_str++;
1041
1042 /* store number */
1043 s = 1000.0 * s;
1044 /* add a little to make floor in conversion a round */
1045 s += 0.0005;
1046 latitude = (uint32_t) s;
1047 latitude += 1000 * 60 * m;
1048 latitude += 1000 * 60 * 60 * h;
1049 if (northern_hemisphere) {
1050 latitude = equator + latitude;
1051 } else {
1052 latitude = equator - latitude;
1053 }
1054 while (isblank((unsigned char)*my_str)) {
1055 my_str++;
1056 }
1057
1058 if (isdigit((int) *my_str)) {
1059 h = (uint32_t) strtol(my_str, &my_str, 10);
1060 } else {
1061 return LDNS_STATUS_INVALID_STR;
1062 }
1063
1064 while (isblank((int) *my_str)) {
1065 my_str++;
1066 }
1067
1068 if (isdigit((int) *my_str)) {
1069 m = (uint32_t) strtol(my_str, &my_str, 10);
1070 } else if (*my_str == 'E' || *my_str == 'W') {
1071 goto east;
1072 } else {
1073 return LDNS_STATUS_INVALID_STR;
1074 }
1075
1076 while (isblank((unsigned char)*my_str)) {
1077 my_str++;
1078 }
1079
1080 if (isdigit((int) *my_str)) {
1081 s = strtod(my_str, &my_str);
1082 }
1083
1084 east:
1085 while (isblank((unsigned char)*my_str)) {
1086 my_str++;
1087 }
1088
1089 if (*my_str == 'E') {
1090 eastern_hemisphere = true;
1091 } else if (*my_str == 'W') {
1092 eastern_hemisphere = false;
1093 } else {
1094 return LDNS_STATUS_INVALID_STR;
1095 }
1096
1097 my_str++;
1098
1099 /* store number */
1100 s *= 1000.0;
1101 /* add a little to make floor in conversion a round */
1102 s += 0.0005;
1103 longitude = (uint32_t) s;
1104 longitude += 1000 * 60 * m;
1105 longitude += 1000 * 60 * 60 * h;
1106
1107 if (eastern_hemisphere) {
1108 longitude += equator;
1109 } else {
1110 longitude = equator - longitude;
1111 }
1112
1113 altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 +
1114 10000000.0 + 0.5);
1115 if (*my_str == 'm' || *my_str == 'M') {
1116 my_str++;
1117 }
1118
1119 if (strlen(my_str) > 0) {
1120 if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e))
1121 return LDNS_STATUS_INVALID_STR;
1122 }
1123
1124 if (strlen(my_str) > 0) {
1125 if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e))
1126 return LDNS_STATUS_INVALID_STR;
1127 }
1128
1129 if (strlen(my_str) > 0) {
1130 if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e))
1131 return LDNS_STATUS_INVALID_STR;
1132 }
1133
1134 data = LDNS_XMALLOC(uint8_t, 16);
1135 if(!data) {
1136 return LDNS_STATUS_MEM_ERR;
1137 }
1138 data[0] = 0;
1139 data[1] = 0;
1140 data[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f);
1141 data[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f);
1142 data[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f);
1143 ldns_write_uint32(data + 4, latitude);
1144 ldns_write_uint32(data + 8, longitude);
1145 ldns_write_uint32(data + 12, altitude);
1146
1147 *rd = ldns_rdf_new_frm_data(
1148 LDNS_RDF_TYPE_LOC, 16, data);
1149
1150 LDNS_FREE(data);
1151 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
1152 }
1153
1154 ldns_status
ldns_str2rdf_wks(ldns_rdf ** rd,const char * str)1155 ldns_str2rdf_wks(ldns_rdf **rd, const char *str)
1156 {
1157 uint8_t *bitmap = NULL;
1158 uint8_t *data;
1159 int bm_len = 0;
1160
1161 struct protoent *proto = NULL;
1162 struct servent *serv = NULL;
1163 int serv_port;
1164
1165 ldns_buffer *str_buf;
1166
1167 char *proto_str = NULL;
1168 char *lc_proto_str = NULL;
1169 char *token;
1170 char *lc_token;
1171 char *c;
1172 if(strlen(str) == 0)
1173 token = LDNS_XMALLOC(char, 50);
1174 else token = LDNS_XMALLOC(char, strlen(str)+2);
1175 if(!token) return LDNS_STATUS_MEM_ERR;
1176
1177 str_buf = LDNS_MALLOC(ldns_buffer);
1178 if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1179 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1180 if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1181 LDNS_FREE(str_buf);
1182 LDNS_FREE(token);
1183 return LDNS_STATUS_MEM_ERR;
1184 }
1185
1186 while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1187 if (!proto_str) {
1188 proto_str = strdup(token);
1189 lc_proto_str = strdup(token);
1190 for (c = lc_proto_str; *c; c++) {
1191 *c = tolower((unsigned char)*c);
1192 }
1193 if (!proto_str || !lc_proto_str) {
1194 free(proto_str);
1195 free(lc_proto_str);
1196 LDNS_FREE(bitmap);
1197 LDNS_FREE(token);
1198 ldns_buffer_free(str_buf);
1199 return LDNS_STATUS_INVALID_STR;
1200 }
1201 } else {
1202 serv = getservbyname(token, proto_str);
1203 if (!serv) {
1204 serv = getservbyname(token, lc_proto_str);
1205 }
1206 if (!serv && (lc_token = strdup(token))) {
1207 for (c = lc_token; *c; c++) {
1208 *c = tolower((unsigned char)*c);
1209 }
1210 serv = getservbyname(lc_token, proto_str);
1211 if (!serv) {
1212 serv = getservbyname(lc_token, lc_proto_str);
1213 }
1214 free(lc_token);
1215 }
1216 if (serv) {
1217 serv_port = (int) ntohs((uint16_t) serv->s_port);
1218 } else {
1219 serv_port = atoi(token);
1220 }
1221 if (serv_port < 0 || serv_port > 65535) {
1222 LDNS_FREE(bitmap);
1223 LDNS_FREE(token);
1224 ldns_buffer_free(str_buf);
1225 free(proto_str);
1226 free(lc_proto_str);
1227 return LDNS_STATUS_INVALID_STR;
1228 }
1229 if (serv_port / 8 >= bm_len) {
1230 uint8_t *b2 = LDNS_XREALLOC(bitmap, uint8_t, (serv_port / 8) + 1);
1231 if(!b2) {
1232 LDNS_FREE(bitmap);
1233 LDNS_FREE(token);
1234 ldns_buffer_free(str_buf);
1235 free(proto_str);
1236 free(lc_proto_str);
1237 return LDNS_STATUS_INVALID_STR;
1238 }
1239 bitmap = b2;
1240 /* set to zero to be sure */
1241 for (; bm_len <= serv_port / 8; bm_len++) {
1242 bitmap[bm_len] = 0;
1243 }
1244 }
1245 ldns_set_bit(bitmap + (serv_port / 8), 7 - (serv_port % 8), true);
1246 }
1247 }
1248
1249 if (!proto_str || !bitmap) {
1250 LDNS_FREE(bitmap);
1251 LDNS_FREE(token);
1252 ldns_buffer_free(str_buf);
1253 free(proto_str);
1254 free(lc_proto_str);
1255 return LDNS_STATUS_INVALID_STR;
1256 }
1257
1258 data = LDNS_XMALLOC(uint8_t, bm_len + 1);
1259 if(!data) {
1260 LDNS_FREE(token);
1261 ldns_buffer_free(str_buf);
1262 LDNS_FREE(bitmap);
1263 free(proto_str);
1264 free(lc_proto_str);
1265 return LDNS_STATUS_INVALID_STR;
1266 }
1267 if (proto_str)
1268 proto = getprotobyname(proto_str);
1269 if (!proto) {
1270 proto = getprotobyname(lc_proto_str);
1271 }
1272 if (proto) {
1273 data[0] = (uint8_t) proto->p_proto;
1274 } else if (proto_str) {
1275 data[0] = (uint8_t) atoi(proto_str);
1276 }
1277 memcpy(data + 1, bitmap, (size_t) bm_len);
1278
1279 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_WKS, (uint16_t) (bm_len + 1), data);
1280
1281 LDNS_FREE(data);
1282 LDNS_FREE(token);
1283 ldns_buffer_free(str_buf);
1284 LDNS_FREE(bitmap);
1285 free(proto_str);
1286 free(lc_proto_str);
1287 #ifdef HAVE_ENDSERVENT
1288 endservent();
1289 #endif
1290 #ifdef HAVE_ENDPROTOENT
1291 endprotoent();
1292 #endif
1293
1294 if(!*rd) return LDNS_STATUS_MEM_ERR;
1295
1296 return LDNS_STATUS_OK;
1297 }
1298
1299 ldns_status
ldns_str2rdf_nsap(ldns_rdf ** rd,const char * str)1300 ldns_str2rdf_nsap(ldns_rdf **rd, const char *str)
1301 {
1302 size_t len, i;
1303 char* nsap_str = (char*) str;
1304
1305 /* just a hex string with optional dots? */
1306 if (str[0] != '0' || str[1] != 'x') {
1307 return LDNS_STATUS_INVALID_STR;
1308 } else {
1309 len = strlen(str);
1310 for (i=0; i < len; i++) {
1311 if (nsap_str[i] == '.')
1312 nsap_str[i] = ' ';
1313 }
1314 return ldns_str2rdf_hex(rd, str+2);
1315 }
1316 }
1317
1318 ldns_status
ldns_str2rdf_atma(ldns_rdf ** rd,const char * str)1319 ldns_str2rdf_atma(ldns_rdf **rd, const char *str)
1320 {
1321 size_t len, i;
1322 char* atma_str = (char*) str;
1323 ldns_status status;
1324
1325 /* just a hex string with optional dots? */
1326 len = strlen(str);
1327 for (i=0; i < len; i++) {
1328 if (atma_str[i] == '.')
1329 atma_str[i] = ' ';
1330 }
1331 status = ldns_str2rdf_hex(rd, str);
1332 if (status != LDNS_STATUS_OK) {
1333 ; /* probably in e.164 format than */
1334 }
1335 return status;
1336 }
1337
1338 ldns_status
ldns_str2rdf_ipseckey(ldns_rdf ** rd,const char * str)1339 ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
1340 {
1341 uint8_t precedence = 0;
1342 uint8_t gateway_type = 0;
1343 uint8_t algorithm = 0;
1344 char* gateway = NULL;
1345 char* publickey = NULL;
1346 uint8_t *data;
1347 ldns_buffer *str_buf;
1348 char *token;
1349 int token_count = 0;
1350 int ipseckey_len = 0;
1351 ldns_rdf* gateway_rdf = NULL;
1352 ldns_rdf* publickey_rdf = NULL;
1353 ldns_status status = LDNS_STATUS_OK;
1354
1355 if(strlen(str) == 0)
1356 token = LDNS_XMALLOC(char, 256);
1357 else token = LDNS_XMALLOC(char, strlen(str)+2);
1358 if(!token) return LDNS_STATUS_MEM_ERR;
1359
1360 str_buf = LDNS_MALLOC(ldns_buffer);
1361 if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1362 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1363 if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1364 LDNS_FREE(str_buf);
1365 LDNS_FREE(token);
1366 return LDNS_STATUS_MEM_ERR;
1367 }
1368 while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1369 switch (token_count) {
1370 case 0:
1371 precedence = (uint8_t)atoi(token);
1372 break;
1373 case 1:
1374 gateway_type = (uint8_t)atoi(token);
1375 break;
1376 case 2:
1377 algorithm = (uint8_t)atoi(token);
1378 break;
1379 case 3:
1380 gateway = strdup(token);
1381 if (!gateway || (gateway_type == 0 &&
1382 (token[0] != '.' || token[1] != '\0'))) {
1383 LDNS_FREE(gateway);
1384 LDNS_FREE(token);
1385 ldns_buffer_free(str_buf);
1386 return LDNS_STATUS_INVALID_STR;
1387 }
1388 break;
1389 case 4:
1390 publickey = strdup(token);
1391 break;
1392 default:
1393 LDNS_FREE(token);
1394 ldns_buffer_free(str_buf);
1395 return LDNS_STATUS_INVALID_STR;
1396 break;
1397 }
1398 token_count++;
1399 }
1400
1401 if (!gateway || !publickey) {
1402 if (gateway)
1403 LDNS_FREE(gateway);
1404 if (publickey)
1405 LDNS_FREE(publickey);
1406 LDNS_FREE(token);
1407 ldns_buffer_free(str_buf);
1408 return LDNS_STATUS_INVALID_STR;
1409 }
1410
1411 if (gateway_type == 1) {
1412 status = ldns_str2rdf_a(&gateway_rdf, gateway);
1413 } else if (gateway_type == 2) {
1414 status = ldns_str2rdf_aaaa(&gateway_rdf, gateway);
1415 } else if (gateway_type == 3) {
1416 status = ldns_str2rdf_dname(&gateway_rdf, gateway);
1417 } else if (gateway_type > 3) {
1418 status = LDNS_STATUS_INVALID_STR;
1419 }
1420
1421 if (status != LDNS_STATUS_OK) {
1422 if (gateway)
1423 LDNS_FREE(gateway);
1424 if (publickey)
1425 LDNS_FREE(publickey);
1426 LDNS_FREE(token);
1427 ldns_buffer_free(str_buf);
1428 return LDNS_STATUS_INVALID_STR;
1429 }
1430
1431 status = ldns_str2rdf_b64(&publickey_rdf, publickey);
1432
1433 if (status != LDNS_STATUS_OK) {
1434 if (gateway)
1435 LDNS_FREE(gateway);
1436 if (publickey)
1437 LDNS_FREE(publickey);
1438 LDNS_FREE(token);
1439 ldns_buffer_free(str_buf);
1440 if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1441 return LDNS_STATUS_INVALID_STR;
1442 }
1443
1444 /* now copy all into one ipseckey rdf */
1445 if (gateway_type)
1446 ipseckey_len = 3 + (int)ldns_rdf_size(gateway_rdf) + (int)ldns_rdf_size(publickey_rdf);
1447 else
1448 ipseckey_len = 3 + (int)ldns_rdf_size(publickey_rdf);
1449
1450 data = LDNS_XMALLOC(uint8_t, ipseckey_len);
1451 if(!data) {
1452 if (gateway)
1453 LDNS_FREE(gateway);
1454 if (publickey)
1455 LDNS_FREE(publickey);
1456 LDNS_FREE(token);
1457 ldns_buffer_free(str_buf);
1458 if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1459 if (publickey_rdf) ldns_rdf_free(publickey_rdf);
1460 return LDNS_STATUS_MEM_ERR;
1461 }
1462
1463 data[0] = precedence;
1464 data[1] = gateway_type;
1465 data[2] = algorithm;
1466
1467 if (gateway_type) {
1468 memcpy(data + 3,
1469 ldns_rdf_data(gateway_rdf), ldns_rdf_size(gateway_rdf));
1470 memcpy(data + 3 + ldns_rdf_size(gateway_rdf),
1471 ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1472 } else {
1473 memcpy(data + 3,
1474 ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1475 }
1476
1477 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_IPSECKEY, (uint16_t) ipseckey_len, data);
1478
1479 if (gateway)
1480 LDNS_FREE(gateway);
1481 if (publickey)
1482 LDNS_FREE(publickey);
1483 LDNS_FREE(token);
1484 ldns_buffer_free(str_buf);
1485 ldns_rdf_deep_free(gateway_rdf);
1486 ldns_rdf_deep_free(publickey_rdf);
1487 LDNS_FREE(data);
1488 if(!*rd) return LDNS_STATUS_MEM_ERR;
1489 return LDNS_STATUS_OK;
1490 }
1491
1492 ldns_status
ldns_str2rdf_ilnp64(ldns_rdf ** rd,const char * str)1493 ldns_str2rdf_ilnp64(ldns_rdf **rd, const char *str)
1494 {
1495 unsigned int a, b, c, d;
1496 uint16_t shorts[4];
1497 int l;
1498
1499 if (sscanf(str, "%4x:%4x:%4x:%4x%n", &a, &b, &c, &d, &l) != 4 ||
1500 l != (int)strlen(str) || /* more data to read */
1501 strpbrk(str, "+-") /* signed hexes */
1502 ) {
1503 return LDNS_STATUS_INVALID_ILNP64;
1504 } else {
1505 shorts[0] = htons(a);
1506 shorts[1] = htons(b);
1507 shorts[2] = htons(c);
1508 shorts[3] = htons(d);
1509 *rd = ldns_rdf_new_frm_data(
1510 LDNS_RDF_TYPE_ILNP64, 4 * sizeof(uint16_t), &shorts);
1511 }
1512 return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
1513 }
1514
1515 ldns_status
ldns_str2rdf_eui48(ldns_rdf ** rd,const char * str)1516 ldns_str2rdf_eui48(ldns_rdf **rd, const char *str)
1517 {
1518 unsigned int a, b, c, d, e, f;
1519 uint8_t bytes[6];
1520 int l;
1521
1522 if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x%n",
1523 &a, &b, &c, &d, &e, &f, &l) != 6 ||
1524 l != (int)strlen(str)) {
1525 return LDNS_STATUS_INVALID_EUI48;
1526 } else {
1527 bytes[0] = a;
1528 bytes[1] = b;
1529 bytes[2] = c;
1530 bytes[3] = d;
1531 bytes[4] = e;
1532 bytes[5] = f;
1533 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI48, 6, &bytes);
1534 }
1535 return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
1536 }
1537
1538 ldns_status
ldns_str2rdf_eui64(ldns_rdf ** rd,const char * str)1539 ldns_str2rdf_eui64(ldns_rdf **rd, const char *str)
1540 {
1541 unsigned int a, b, c, d, e, f, g, h;
1542 uint8_t bytes[8];
1543 int l;
1544
1545 if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x-%2x-%2x%n",
1546 &a, &b, &c, &d, &e, &f, &g, &h, &l) != 8 ||
1547 l != (int)strlen(str)) {
1548 return LDNS_STATUS_INVALID_EUI64;
1549 } else {
1550 bytes[0] = a;
1551 bytes[1] = b;
1552 bytes[2] = c;
1553 bytes[3] = d;
1554 bytes[4] = e;
1555 bytes[5] = f;
1556 bytes[6] = g;
1557 bytes[7] = h;
1558 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI64, 8, &bytes);
1559 }
1560 return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
1561 }
1562
1563 ldns_status
ldns_str2rdf_tag(ldns_rdf ** rd,const char * str)1564 ldns_str2rdf_tag(ldns_rdf **rd, const char *str)
1565 {
1566 uint8_t *data;
1567 const char* ptr;
1568
1569 if (strlen(str) > 255) {
1570 return LDNS_STATUS_INVALID_TAG;
1571 }
1572 for (ptr = str; *ptr; ptr++) {
1573 if (! isalnum((unsigned char)*ptr)) {
1574 return LDNS_STATUS_INVALID_TAG;
1575 }
1576 }
1577 data = LDNS_XMALLOC(uint8_t, strlen(str) + 1);
1578 if (!data) {
1579 return LDNS_STATUS_MEM_ERR;
1580 }
1581 data[0] = strlen(str);
1582 memcpy(data + 1, str, strlen(str));
1583
1584 *rd = ldns_rdf_new(LDNS_RDF_TYPE_TAG, strlen(str) + 1, data);
1585 if (!*rd) {
1586 LDNS_FREE(data);
1587 return LDNS_STATUS_MEM_ERR;
1588 }
1589 return LDNS_STATUS_OK;
1590 }
1591
1592 ldns_status
ldns_str2rdf_long_str(ldns_rdf ** rd,const char * str)1593 ldns_str2rdf_long_str(ldns_rdf **rd, const char *str)
1594 {
1595 uint8_t *data, *dp, ch = 0;
1596 size_t length;
1597
1598 /* Worst case space requirement. We'll realloc to actual size later. */
1599 dp = data = LDNS_XMALLOC(uint8_t, strlen(str));
1600 if (! data) {
1601 return LDNS_STATUS_MEM_ERR;
1602 }
1603
1604 /* Fill data with parsed bytes */
1605 while (parse_char(&ch, &str)) {
1606 *dp++ = ch;
1607 if (dp - data > LDNS_MAX_RDFLEN) {
1608 LDNS_FREE(data);
1609 return LDNS_STATUS_INVALID_STR;
1610 }
1611 }
1612 if (! str) {
1613 LDNS_FREE(data);
1614 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
1615 }
1616 if (!(length = (size_t)(dp - data))) {
1617 /* An empty string is a data buffer of 0 bytes. The rdf for
1618 * this long string has to have length 0 and point to NULL.
1619 */
1620 LDNS_FREE(data);
1621 data = NULL;
1622 } else {
1623 /* Lose the overmeasure */
1624 data = LDNS_XREALLOC(dp = data, uint8_t, length);
1625 if (! data) {
1626 LDNS_FREE(dp);
1627 return LDNS_STATUS_MEM_ERR;
1628 }
1629 }
1630 /* Create rdf */
1631 *rd = ldns_rdf_new(LDNS_RDF_TYPE_LONG_STR, length, data);
1632 if (! *rd) {
1633 LDNS_FREE(data);
1634 return LDNS_STATUS_MEM_ERR;
1635 }
1636 return LDNS_STATUS_OK;
1637 }
1638
1639 ldns_status
ldns_str2rdf_hip(ldns_rdf ** rd,const char * str)1640 ldns_str2rdf_hip(ldns_rdf **rd, const char *str)
1641 {
1642 const char *hit = str == NULL ? NULL : strchr(str, ' ');
1643 const char *pk = hit == NULL ? NULL : strchr(hit + 1, ' ');
1644 size_t hit_size = hit == NULL ? 0
1645 : pk == NULL ? strlen(hit + 1) : (size_t) (pk - hit) - 1;
1646 size_t pk_size = pk == NULL ? 0 : strlen(pk + 1);
1647 size_t hit_wire_size = (hit_size + 1) / 2;
1648 size_t pk_wire_size = ldns_b64_pton_calculate_size(pk_size);
1649 size_t rdf_size = 4 + hit_wire_size + pk_wire_size;
1650
1651 char *endptr; /* utility var for strtol usage */
1652 int algorithm = str == NULL ? 0 : strtol(str, &endptr, 10);
1653
1654 uint8_t *data, *dp;
1655 int hi, lo, written;
1656
1657 if (hit_size == 0 || pk_size == 0 || (hit_size + 1) / 2 > 255
1658 || rdf_size > LDNS_MAX_RDFLEN
1659 || algorithm < 0 || algorithm > 255
1660 || (errno != 0 && algorithm == 0) /* out of range */
1661 || endptr == str /* no digits */) {
1662
1663 return LDNS_STATUS_SYNTAX_ERR;
1664 }
1665 hit += 1;
1666 pk += 1;
1667 if ((data = LDNS_XMALLOC(uint8_t, rdf_size)) == NULL) {
1668
1669 return LDNS_STATUS_MEM_ERR;
1670 }
1671 /* From RFC 5205 section 5. HIP RR Storage Format:
1672 *************************************************
1673
1674 0 1 2 3
1675 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
1676 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1677 | HIT length | PK algorithm | PK length |
1678 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1679 | |
1680 ~ HIT ~
1681 | |
1682 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1683 | | |
1684 +-+-+-+-+-+-+-+-+-+-+-+ +
1685 | Public Key |
1686 ~ ~
1687 | |
1688 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1689 | | |
1690 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +
1691 | |
1692 ~ Rendezvous Servers ~
1693 | |
1694 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1695 | |
1696 +-+-+-+-+-+-+-+ */
1697
1698 data[0] = (uint8_t) hit_wire_size;
1699 data[1] = (uint8_t) algorithm;
1700
1701 for (dp = data + 4; *hit && *hit != ' '; dp++) {
1702
1703 if ((hi = ldns_hexdigit_to_int(*hit++)) == -1 ||
1704 (lo = ldns_hexdigit_to_int(*hit++)) == -1) {
1705
1706 LDNS_FREE(data);
1707 return LDNS_STATUS_INVALID_HEX;
1708 }
1709 *dp = (uint8_t) hi << 4 | lo;
1710 }
1711 if ((written = ldns_b64_pton(pk, dp, pk_wire_size)) <= 0) {
1712
1713 LDNS_FREE(data);
1714 return LDNS_STATUS_INVALID_B64;
1715 }
1716
1717 /* Because ldns_b64_pton_calculate_size isn't always correct:
1718 * (we have to fix it at some point)
1719 */
1720 pk_wire_size = (uint16_t) written;
1721 ldns_write_uint16(data + 2, pk_wire_size);
1722 rdf_size = 4 + hit_wire_size + pk_wire_size;
1723
1724 /* Create rdf */
1725 if (! (*rd = ldns_rdf_new(LDNS_RDF_TYPE_HIP, rdf_size, data))) {
1726
1727 LDNS_FREE(data);
1728 return LDNS_STATUS_MEM_ERR;
1729 }
1730 return LDNS_STATUS_OK;
1731 }
1732
1733
1734 /* Implementation mimics ldns_str2rdf_ipseckey */
1735 ldns_status
ldns_str2rdf_amtrelay(ldns_rdf ** rd,const char * str)1736 ldns_str2rdf_amtrelay(ldns_rdf **rd, const char *str)
1737 {
1738 /* From draft-ietf-mboned-driad-amt-discovery
1739 * Section 4.2. AMTRELAY RData Format
1740 *************************************************
1741
1742 0 1 2 3
1743 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
1744 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1745 | precedence |D| type | |
1746 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +
1747 ~ relay ~
1748 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */
1749
1750 uint8_t precedence = 0;
1751 uint8_t relay_type = 0;
1752 uint8_t discovery_optional = 0;
1753 char* relay = NULL;
1754 uint8_t *data;
1755 ldns_buffer *str_buf;
1756 char *token;
1757 int token_count = 0;
1758 int amtrelay_len = 0;
1759 ldns_rdf* relay_rdf = NULL;
1760 ldns_status status = LDNS_STATUS_OK;
1761
1762 if(strlen(str) == 0)
1763 token = LDNS_XMALLOC(char, 256);
1764 else token = LDNS_XMALLOC(char, strlen(str)+2);
1765 if(!token) return LDNS_STATUS_MEM_ERR;
1766
1767 str_buf = LDNS_MALLOC(ldns_buffer);
1768 if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1769 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1770 if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1771 LDNS_FREE(str_buf);
1772 LDNS_FREE(token);
1773 return LDNS_STATUS_MEM_ERR;
1774 }
1775 while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1776 switch (token_count) {
1777 case 0:
1778 precedence = (uint8_t)atoi(token);
1779 break;
1780 case 1:
1781 discovery_optional = (uint8_t)atoi(token);
1782 if (discovery_optional != 0 &&
1783 discovery_optional != 1) {
1784 LDNS_FREE(relay);
1785 LDNS_FREE(token);
1786 ldns_buffer_free(str_buf);
1787 return LDNS_STATUS_INVALID_STR;
1788 }
1789 break;
1790 case 2:
1791 relay_type = (uint8_t)atoi(token);
1792 break;
1793 case 3:
1794 relay = strdup(token);
1795 if (!relay || (relay_type == 0 &&
1796 (token[0] != '.' || token[1] != '\0'))) {
1797 LDNS_FREE(relay);
1798 LDNS_FREE(token);
1799 ldns_buffer_free(str_buf);
1800 return LDNS_STATUS_INVALID_STR;
1801 }
1802 break;
1803 default:
1804 LDNS_FREE(token);
1805 ldns_buffer_free(str_buf);
1806 return LDNS_STATUS_INVALID_STR;
1807 break;
1808 }
1809 token_count++;
1810 }
1811 if (!relay && relay_type > 0) {
1812 if (relay)
1813 LDNS_FREE(relay);
1814 LDNS_FREE(token);
1815 ldns_buffer_free(str_buf);
1816 return LDNS_STATUS_INVALID_STR;
1817 }
1818
1819 if (relay_type == 1) {
1820 status = ldns_str2rdf_a(&relay_rdf, relay);
1821 } else if (relay_type == 2) {
1822 status = ldns_str2rdf_aaaa(&relay_rdf, relay);
1823 } else if (relay_type == 3) {
1824 status = ldns_str2rdf_dname(&relay_rdf, relay);
1825 } else if (relay_type > 3) {
1826 status = LDNS_STATUS_INVALID_STR;
1827 }
1828
1829 if (status != LDNS_STATUS_OK) {
1830 if (relay)
1831 LDNS_FREE(relay);
1832 LDNS_FREE(token);
1833 ldns_buffer_free(str_buf);
1834 ldns_rdf_deep_free(relay_rdf);
1835 return LDNS_STATUS_INVALID_STR;
1836 }
1837
1838 /* now copy all into one amtrelay rdf */
1839 if (relay_type)
1840 amtrelay_len = 2 + (int)ldns_rdf_size(relay_rdf);
1841 else
1842 amtrelay_len = 2;
1843
1844 data = LDNS_XMALLOC(uint8_t, amtrelay_len);
1845 if(!data) {
1846 if (relay)
1847 LDNS_FREE(relay);
1848 LDNS_FREE(token);
1849 ldns_buffer_free(str_buf);
1850 ldns_rdf_deep_free(relay_rdf);
1851 return LDNS_STATUS_MEM_ERR;
1852 }
1853
1854 data[0] = precedence;
1855 data[1] = relay_type;
1856 data[1] |= (discovery_optional << 7);
1857
1858 if (relay_type) {
1859 memcpy(data + 2,
1860 ldns_rdf_data(relay_rdf), ldns_rdf_size(relay_rdf));
1861 }
1862 *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_AMTRELAY
1863 , (uint16_t) amtrelay_len, data);
1864
1865 if (relay)
1866 LDNS_FREE(relay);
1867 LDNS_FREE(token);
1868 ldns_buffer_free(str_buf);
1869 ldns_rdf_deep_free(relay_rdf);
1870 LDNS_FREE(data);
1871 if(!*rd) return LDNS_STATUS_MEM_ERR;
1872 return LDNS_STATUS_OK;
1873 }
1874
1875 #ifdef RRTYPE_SVCB_HTTPS
1876 static int
network_uint16_cmp(const void * a,const void * b)1877 network_uint16_cmp(const void *a, const void *b)
1878 {
1879 return ((int)ldns_read_uint16(a)) - ((int)ldns_read_uint16(b));
1880 }
1881
1882 static ldns_status parse_svcparam_key(const char **s, ldns_svcparam_key *key);
1883 static ldns_status
parse_svcparam_mandatory(const char ** s,uint8_t ** dp,uint8_t * eod)1884 parse_svcparam_mandatory(const char **s, uint8_t **dp, uint8_t *eod)
1885 {
1886 bool quoted = false;
1887 uint8_t *keys = *dp;
1888 int prev_key;
1889
1890 if (**s == '"') {
1891 *s += 1;
1892 quoted = true;
1893 }
1894 for (;;) {
1895 ldns_status st;
1896 ldns_svcparam_key key;
1897
1898 if ((st = parse_svcparam_key(s, &key)))
1899 return st;
1900
1901 if (*dp + 2 > eod)
1902 return LDNS_STATUS_RDATA_OVERFLOW;
1903
1904 ldns_write_uint16(*dp, key);
1905 *dp += 2;
1906
1907 if (**s == ',')
1908 *s += 1;
1909 else
1910 break;
1911 }
1912 if (quoted) {
1913 if (**s != '"')
1914 return LDNS_STATUS_INVALID_STR;
1915 *s += 1;
1916 }
1917 if (*dp - keys == 0)
1918 return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
1919
1920 if (**s && !isspace((unsigned char)**s))
1921 return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
1922
1923 /* In draft-ietf-dnsop-svcb-https-02 Section 7:
1924 *
1925 * In wire format, the keys are represented by their numeric
1926 * values in network byte order, concatenated in ascending order.
1927 */
1928 qsort(keys, (*dp - keys) / 2, 2, network_uint16_cmp);
1929
1930 /* In draft-ietf-dnsop-svcb-https-02 Section 7:
1931 *
1932 * Keys ...<snip>... MUST NOT appear more than once.
1933 */
1934 prev_key = -1;
1935 while (keys < *dp) {
1936 uint16_t key = ldns_read_uint16(keys);
1937
1938 if (key == prev_key) {
1939 /* "Be conservative in what you send,
1940 * be liberal in what you accept"
1941 *
1942 * Instead of
1943 * `return LDNS_STATUS_SVCPARAM_KEY_MORE_THAN_ONCE;`,
1944 *
1945 * we eliminate the double occurrence.
1946 */
1947 memmove(keys - 2, keys, *dp - keys);
1948 *dp -= 2;
1949 } else {
1950 prev_key = key;
1951 keys += 2;
1952 }
1953 }
1954 return LDNS_STATUS_OK;
1955 }
1956
parse_escape2(uint8_t * ch_p,const char ** str_p)1957 INLINE bool parse_escape2(uint8_t *ch_p, const char** str_p)
1958 { *str_p += 1; return parse_escape(ch_p, str_p); }
1959
1960 static ldns_status
parse_svcparam_alpn(const char ** s,uint8_t ** dp,uint8_t * eod)1961 parse_svcparam_alpn(const char **s, uint8_t **dp, uint8_t *eod)
1962 {
1963 uint8_t *val;
1964 size_t len;
1965
1966 if (*dp + 1 > eod)
1967 return LDNS_STATUS_RDATA_OVERFLOW;
1968 *dp += 1;
1969 val = *dp;
1970 if (**s == '"') {
1971 *s += 1;
1972 while (**s != '"') {
1973 if (**s == 0)
1974 return LDNS_STATUS_INVALID_STR;
1975
1976 else if (**s == ',') {
1977 len = *dp - val;
1978 if (len == 0 || len > 255)
1979 return LDNS_STATUS_INVALID_STR;
1980 val[-1] = len;
1981 if (*dp + 1 > eod)
1982 return LDNS_STATUS_RDATA_OVERFLOW;
1983 *dp += 1;
1984 val = *dp;
1985 *s += 1;
1986
1987 } else if (*dp + 1 > eod)
1988 return LDNS_STATUS_RDATA_OVERFLOW;
1989
1990 else if (**s != '\\')
1991 *(*dp)++ = (uint8_t)*(*s)++;
1992
1993 else if (!parse_escape2(*dp, s))
1994 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
1995 else
1996 *dp += 1;
1997 }
1998 *s += 1;
1999
2000 } else while (**s && !isspace((unsigned char)**s)) {
2001 if (**s == ',') {
2002 len = *dp - val;
2003 if (len == 0 || len > 255)
2004 return LDNS_STATUS_INVALID_STR;
2005 val[-1] = len;
2006 if (*dp + 1 > eod)
2007 return LDNS_STATUS_RDATA_OVERFLOW;
2008 *dp += 1;
2009 val = *dp;
2010 *s += 1;
2011
2012 } else if (*dp + 1 > eod)
2013 return LDNS_STATUS_RDATA_OVERFLOW;
2014
2015 else if (**s != '\\')
2016 *(*dp)++ = (uint8_t)*(*s)++;
2017
2018 else if (!parse_escape2(*dp, s))
2019 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
2020 else
2021 *dp += 1;
2022 }
2023 len = *dp - val;
2024 if (len == 0 || len > 255)
2025 return LDNS_STATUS_INVALID_STR;
2026 val[-1] = len;
2027 return **s && !isspace((unsigned char)**s)
2028 ? LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR
2029 : LDNS_STATUS_OK;
2030 }
2031
2032 static ldns_status
parse_svcparam_value(const char ** s,uint8_t ** dp,uint8_t * eod)2033 parse_svcparam_value(const char **s, uint8_t **dp, uint8_t *eod)
2034 {
2035 if (**s == '"') {
2036 *s += 1;
2037 while (**s != '"') {
2038 if (**s == 0)
2039 return LDNS_STATUS_INVALID_STR;
2040
2041 else if (*dp + 1 > eod)
2042 return LDNS_STATUS_RDATA_OVERFLOW;
2043
2044 else if (**s != '\\')
2045 *(*dp)++ = (uint8_t)*(*s)++;
2046
2047 else if (!parse_escape2(*dp, s))
2048 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
2049 else
2050 *dp += 1;
2051 }
2052 *s += 1;
2053
2054 } else while (**s && !isspace((unsigned char)**s)) {
2055 if (*dp + 1 > eod)
2056 return LDNS_STATUS_RDATA_OVERFLOW;
2057
2058 else if (**s != '\\')
2059 *(*dp)++ = (uint8_t)*(*s)++;
2060
2061 else if (!parse_escape2(*dp, s))
2062 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
2063 else
2064 *dp += 1;
2065 }
2066 return **s && !isspace((unsigned char)**s)
2067 ? LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR
2068 : LDNS_STATUS_OK;
2069 }
2070
2071 static ldns_status
parse_svcparam_port(const char ** s,uint8_t ** dp,uint8_t * eod)2072 parse_svcparam_port(const char **s, uint8_t **dp, uint8_t *eod)
2073 {
2074 uint8_t *val = *dp;
2075 ldns_status st;
2076 size_t len;
2077 char num_str[6];
2078 char *endptr;
2079 unsigned long int num;
2080
2081 if ((st = parse_svcparam_value(s, dp, eod)))
2082 return st;
2083 len = *dp - val;
2084 if (len == 0 || len > 5)
2085 return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2086
2087 memcpy(num_str, val, len);
2088 num_str[len] = 0;
2089 num = strtoul(num_str, &endptr, 10);
2090 if (*endptr)
2091 return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2092
2093 ldns_write_uint16(val, num);
2094 *dp = val + 2;
2095 return LDNS_STATUS_OK;
2096 }
2097
2098 static ldns_status
parse_svcparam_ipv4hint(const char ** s,uint8_t ** dp,uint8_t * eod)2099 parse_svcparam_ipv4hint(const char **s, uint8_t **dp, uint8_t *eod)
2100 {
2101 bool quoted = false;
2102
2103 if (**s == '"') {
2104 *s += 1;
2105 quoted = true;
2106 }
2107 for (;;) {
2108 const char *ipv4_start = *s;
2109 char ipv4_str[16];
2110 size_t len;
2111
2112 while (isdigit((unsigned char)**s) || **s == '.')
2113 *s += 1;
2114
2115 len = *s - ipv4_start;
2116 if (len == 0 || len > 15)
2117 return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2118
2119 if (*dp + 4 > eod)
2120 return LDNS_STATUS_RDATA_OVERFLOW;
2121
2122 memcpy(ipv4_str, ipv4_start, len);
2123 ipv4_str[len] = 0;
2124 if (inet_pton(AF_INET, ipv4_str, *dp) != 1)
2125 return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2126
2127 *dp += 4;
2128 if (**s == ',')
2129 *s += 1;
2130 else
2131 break;
2132 }
2133 if (quoted) {
2134 if (**s != '"')
2135 return LDNS_STATUS_INVALID_STR;
2136 *s += 1;
2137 }
2138 return **s && !isspace((unsigned char)**s)
2139 ? LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR
2140 : LDNS_STATUS_OK;
2141 }
2142
2143 static ldns_status
parse_svcparam_ech(const char ** s,uint8_t ** dp,uint8_t * eod)2144 parse_svcparam_ech(const char **s, uint8_t **dp, uint8_t *eod)
2145 {
2146 bool quoted = false;
2147 const char *b64_str;
2148 size_t len, pad, out_len;
2149 char in_buf[4096];
2150 char *in = in_buf;
2151 int out;
2152
2153 if (**s == '"') {
2154 *s += 1;
2155 quoted = true;
2156 }
2157 b64_str = *s;
2158 while (isalnum((unsigned char)**s) || **s == '+'
2159 || **s == '/'
2160 || **s == '=')
2161 *s += 1;
2162
2163 len = *s - b64_str;
2164 pad = len % 4;
2165 pad = pad ? 4 - pad : 0;
2166 if (len == 0 || pad == 3)
2167 return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2168
2169 if (quoted) {
2170 if (**s != '"')
2171 return LDNS_STATUS_INVALID_STR;
2172 *s += 1;
2173 }
2174 if (**s && !isspace((unsigned char)**s))
2175 return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2176
2177 out_len = ldns_b64_pton_calculate_size(len);
2178 if (*dp + out_len > eod)
2179 return LDNS_STATUS_RDATA_OVERFLOW;
2180
2181 if (len + pad > sizeof(in_buf) - 1
2182 && !(in = LDNS_XMALLOC(char, len + pad + 1)))
2183 return LDNS_STATUS_MEM_ERR;
2184
2185 memcpy(in, b64_str, len);
2186 while (pad--)
2187 in[len++] = '=';
2188 in[len] = 0;
2189 out = ldns_b64_pton(in, *dp, out_len);
2190 if (in != in_buf)
2191 LDNS_FREE(in);
2192
2193 if (out <= 0)
2194 return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2195
2196 *dp += out;
2197 return LDNS_STATUS_OK;
2198 }
2199
2200 static ldns_status
parse_svcparam_ipv6hint(const char ** s,uint8_t ** dp,uint8_t * eod)2201 parse_svcparam_ipv6hint(const char **s, uint8_t **dp, uint8_t *eod)
2202 {
2203 bool quoted = false;
2204
2205 if (**s == '"') {
2206 *s += 1;
2207 quoted = true;
2208 }
2209 for (;;) {
2210 const char *ipv6_start = *s;
2211 char ipv6_str[INET6_ADDRSTRLEN];
2212 size_t len;
2213
2214 while (isxdigit((unsigned char)**s) || **s == ':' || **s == '.')
2215 *s += 1;
2216
2217 len = *s - ipv6_start;
2218 if (len == 0 || len > INET6_ADDRSTRLEN)
2219 return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2220
2221 if (*dp + 16 > eod)
2222 return LDNS_STATUS_RDATA_OVERFLOW;
2223
2224 memcpy(ipv6_str, ipv6_start, len);
2225 ipv6_str[len] = 0;
2226 if (inet_pton(AF_INET6, ipv6_str, *dp) != 1)
2227 return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2228
2229 *dp += 16;
2230 if (**s == ',')
2231 *s += 1;
2232 else
2233 break;
2234 }
2235 if (quoted) {
2236 if (**s != '"')
2237 return LDNS_STATUS_INVALID_STR;
2238 *s += 1;
2239 }
2240 return **s && !isspace((unsigned char)**s)
2241 ? LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR
2242 : LDNS_STATUS_OK;
2243 }
2244
2245 struct struct_svcparam_key_def {
2246 const char *str;
2247 size_t len;
2248 };
2249 typedef struct struct_svcparam_key_def svcparam_key_def;
2250
2251 static svcparam_key_def svcparam_key_defs[] = { { "mandatory" , 9 }
2252 , { "alpn" , 4 }
2253 , { "no-default-alpn", 15 }
2254 , { "port" , 4 }
2255 , { "ipv4hint" , 8 }
2256 , { "ech" , 3 }
2257 , { "ipv6hint" , 8 }
2258 , { "dohpath" , 7 } };
2259
2260 static const size_t svcparam_key_defs_len = sizeof(svcparam_key_defs)
2261 / sizeof(svcparam_key_def);
2262
2263 /* svcparam_key2buffer_str() should actually be in host2str.c, but we need the
2264 * svcparam_key_defs for it and it is not an exposed symbol anyway.
2265 */
svcparam_key2buffer_str(ldns_buffer * output,uint16_t key)2266 ldns_status svcparam_key2buffer_str(ldns_buffer *output, uint16_t key)
2267 {
2268 if (key <= LDNS_SVCPARAM_KEY_LAST_KEY)
2269 ldns_buffer_write_string(output, svcparam_key_defs[key].str);
2270 else
2271 ldns_buffer_printf(output, "key%d", (int)key);
2272 return ldns_buffer_status(output);
2273 }
2274
2275 static ldns_status
parse_svcparam_key(const char ** s,ldns_svcparam_key * key)2276 parse_svcparam_key(const char **s, ldns_svcparam_key *key)
2277 {
2278 size_t i, len;
2279 const char *key_str = *s;
2280 char num_str[6];
2281 char *endptr;
2282 unsigned long int num;
2283
2284 /* parse key */
2285 while (islower((unsigned char)**s) || isdigit((unsigned char)**s)
2286 || **s == '-')
2287 *s += 1;
2288
2289 len = *s - key_str;
2290 for (i = 0; i < svcparam_key_defs_len; i++) {
2291 if (len == svcparam_key_defs[i].len
2292 && !strncmp(key_str, svcparam_key_defs[i].str, len)) {
2293 *key = i;
2294 return LDNS_STATUS_OK;
2295 }
2296 }
2297 /* Also allow "echconfig" from earlier draft versions. */
2298 if (len == 9 && !strncmp(key_str, "echconfig", 9)) {
2299 *key = LDNS_SVCPARAM_KEY_ECH;
2300 return LDNS_STATUS_OK;
2301 }
2302 if (len < 4 || len > 8 || strncmp(key_str, "key", 3))
2303 return LDNS_STATUS_SYNTAX_SVCPARAM_KEY_ERR;
2304
2305 memcpy(num_str, key_str + 3, len - 3);
2306 num_str[len - 3] = 0;
2307 num = strtoul(num_str, &endptr, 10);
2308 if (*endptr || num > 65535)
2309 return LDNS_STATUS_SYNTAX_SVCPARAM_KEY_ERR;
2310
2311 /* key65535 is Reserved to be an ("Invalid key"), though there is no
2312 * physiological reason to deny usage. We restrict ourselves to the
2313 * anatomical limitations only to maximize serviceability.
2314 * ```
2315 * if (num == 65535)
2316 * return LDNS_STATUS_RESERVED_SVCPARAM_KEY;
2317 * ```
2318 */
2319 *key = num;
2320 return LDNS_STATUS_OK;
2321 }
2322
2323 static ldns_status
parse_svcparam(const char ** s,uint8_t ** dp,uint8_t * eod)2324 parse_svcparam(const char **s, uint8_t **dp, uint8_t *eod)
2325 {
2326 ldns_svcparam_key key;
2327 ldns_status st;
2328 uint8_t *val;
2329
2330 if (*dp + 4 > eod)
2331 return LDNS_STATUS_RDATA_OVERFLOW;
2332
2333 if ((st = parse_svcparam_key(s, &key)))
2334 return st;
2335
2336 ldns_write_uint16(*dp, key);
2337 ldns_write_uint16(*dp + 2, 0);
2338 *dp += 4;
2339 if (isspace((unsigned char)**s) || !**s)
2340 return LDNS_STATUS_OK;
2341
2342 else if (**s != '=')
2343 return LDNS_STATUS_SYNTAX_ERR;
2344 *s += 1;
2345 val = *dp;
2346 switch(key) {
2347 case LDNS_SVCPARAM_KEY_MANDATORY:
2348 st = parse_svcparam_mandatory(s, dp, eod);
2349 break;
2350 case LDNS_SVCPARAM_KEY_ALPN:
2351 st = parse_svcparam_alpn(s, dp, eod);
2352 break;
2353 case LDNS_SVCPARAM_KEY_NO_DEFAULT_ALPN:
2354 return LDNS_STATUS_NO_SVCPARAM_VALUE_EXPECTED;
2355 case LDNS_SVCPARAM_KEY_PORT:
2356 st = parse_svcparam_port(s, dp, eod);
2357 break;
2358 case LDNS_SVCPARAM_KEY_IPV4HINT:
2359 st = parse_svcparam_ipv4hint(s, dp, eod);
2360 break;
2361 case LDNS_SVCPARAM_KEY_ECH:
2362 st = parse_svcparam_ech(s, dp, eod);
2363 break;
2364 case LDNS_SVCPARAM_KEY_IPV6HINT:
2365 st = parse_svcparam_ipv6hint(s, dp, eod);
2366 break;
2367 default:
2368 st = parse_svcparam_value(s, dp, eod);
2369 break;
2370 }
2371 if (st)
2372 return st;
2373 ldns_write_uint16(val - 2, *dp - val);
2374 return LDNS_STATUS_OK;
2375 }
2376
2377 static int
svcparam_ptr_cmp(const void * a,const void * b)2378 svcparam_ptr_cmp(const void *a, const void *b)
2379 {
2380 uint8_t *x = *(uint8_t **)a , *y = *(uint8_t **)b;
2381 uint16_t x_type = ldns_read_uint16(x), y_type = ldns_read_uint16(y);
2382 uint16_t x_len , y_len;
2383
2384 if (x_type != y_type)
2385 return x_type > y_type ? 1 : -1;
2386
2387 x_len = ldns_read_uint16(x + 2);
2388 y_len = ldns_read_uint16(y + 2);
2389
2390 return x_len != y_len
2391 ? (x_len > y_len ? 1 : -1)
2392 : (x_len == 0 ? 0 : memcmp(x + 4, y + 4, x_len));
2393 }
2394
2395 ldns_status
ldns_str2rdf_svcparams(ldns_rdf ** rd,const char * str)2396 ldns_str2rdf_svcparams(ldns_rdf **rd, const char *str)
2397 {
2398 uint8_t *data, *dp, *eod, *p, *new_data;
2399 ldns_status st = LDNS_STATUS_OK;
2400 size_t length, i;
2401 size_t nparams = 0;
2402 uint8_t **svcparams;
2403 int prev_key;
2404
2405 if (!rd || !str)
2406 return LDNS_STATUS_NULL;
2407
2408 length = strlen(str);
2409 /* Worst case space requirement. We'll realloc to actual size later. */
2410 if (!(dp = data = LDNS_XMALLOC(uint8_t, length * 4)))
2411 return LDNS_STATUS_MEM_ERR;
2412 eod = data + length * 4;
2413
2414 /* Fill data with parsed bytes */
2415 for (;;) {
2416 while (isspace((unsigned char)*str))
2417 str += 1;
2418 if(!*str)
2419 break;
2420 if ((st = parse_svcparam(&str, &dp, eod))) {
2421 LDNS_FREE(data);
2422 return st;
2423 }
2424 nparams += 1;
2425 }
2426
2427 /* draft-ietf-dnsop-svcb-https-02 in Section 2.2:
2428 *
2429 * SvcParamKeys SHALL appear in increasing numeric order
2430 *
2431 * A svcparams array (with pointers to the individual key, value pairs)
2432 * is created to qsort the pairs in increasing numeric order.
2433 */
2434 if (!(svcparams = LDNS_XMALLOC(uint8_t *, nparams))) {
2435 LDNS_FREE(data);
2436 return LDNS_STATUS_MEM_ERR;
2437 }
2438 for ( p = data, i = 0
2439 ; p < dp && i < nparams
2440 ; p += 4 + ldns_read_uint16(p + 2))
2441 svcparams[i++] = p;
2442
2443 qsort(svcparams, i, sizeof(uint8_t *), svcparam_ptr_cmp);
2444
2445 /* Write out the (key, value) pairs to a newly allocated data in
2446 * sorted order.
2447 */
2448 length = dp - data;
2449 if (!(new_data = LDNS_XMALLOC(uint8_t, length))) {
2450 LDNS_FREE(data);
2451 LDNS_FREE(svcparams);
2452 return LDNS_STATUS_MEM_ERR;
2453 }
2454 prev_key = -1;
2455 for ( p = new_data, i = 0
2456 ; p < new_data + length && i < nparams
2457 ; p += 4 + ldns_read_uint16(p + 2), i += 1) {
2458 uint16_t key = ldns_read_uint16(svcparams[i]);
2459
2460 /* In draft-ietf-dnsop-svcb-https-02 Section 2.1:
2461 *
2462 * SvcParams ...<snip>... keys MUST NOT be repeated.
2463 *
2464 * ldns will not impose this limitation on the library user,
2465 * but we can merge completely equal repetitions into one.
2466 * So, not doing
2467 * ```
2468 * if (key == prev_key)
2469 * return LDNS_STATUS_SVCPARAM_KEY_MORE_THAN_ONCE;
2470 * ```
2471 * but instead:
2472 */
2473 if (key == prev_key && ldns_read_uint16(svcparams[i] + 2)
2474 == ldns_read_uint16(svcparams[i - 1] + 2)
2475 && 0 == memcmp( svcparams[i ] + 4
2476 , svcparams[i - 1] + 4
2477 , ldns_read_uint16(svcparams[i] + 2))) {
2478 p -= 4 + ldns_read_uint16(svcparams[i] + 2);
2479 continue;
2480 }
2481 memcpy(p, svcparams[i], 4 + ldns_read_uint16(svcparams[i] + 2));
2482 prev_key = key;
2483 }
2484 LDNS_FREE(data);
2485 LDNS_FREE(svcparams);
2486
2487 /* Create rdf */
2488 *rd = ldns_rdf_new(LDNS_RDF_TYPE_SVCPARAMS, p - new_data, new_data);
2489 if (! *rd) {
2490 LDNS_FREE(new_data);
2491 return LDNS_STATUS_MEM_ERR;
2492 }
2493 return LDNS_STATUS_OK;
2494 }
2495 #else /* #ifdef RRTYPE_SVCB_HTTPS */
2496 ldns_status
ldns_str2rdf_svcparams(ldns_rdf ** rd,const char * str)2497 ldns_str2rdf_svcparams(ldns_rdf **rd, const char *str)
2498 {
2499 (void)rd; (void)str;
2500 return LDNS_STATUS_NOT_IMPL;
2501 }
2502 #endif /* #ifdef RRTYPE_SVCB_HTTPS */
2503