1 /**
2 * str2wire.c - read txt presentation of RRs
3 *
4 * (c) NLnet Labs, 2005-2006
5 *
6 * See the file LICENSE for the license
7 */
8
9 /**
10 * \file
11 *
12 * Parses text to wireformat.
13 */
14 #include "config.h"
15 #include "sldns/str2wire.h"
16 #include "sldns/wire2str.h"
17 #include "sldns/sbuffer.h"
18 #include "sldns/parse.h"
19 #include "sldns/parseutil.h"
20 #include <ctype.h>
21 #ifdef HAVE_TIME_H
22 #include <time.h>
23 #endif
24 #ifdef HAVE_NETDB_H
25 #include <netdb.h>
26 #endif
27
28 /** bits for the offset */
29 #define RET_OFFSET_MASK (((unsigned)(~LDNS_WIREPARSE_MASK))>>LDNS_WIREPARSE_SHIFT)
30 /** return an error */
31 #define RET_ERR(e, off) ((int)(((e)&LDNS_WIREPARSE_MASK)|(((off)&RET_OFFSET_MASK)<<LDNS_WIREPARSE_SHIFT)))
32 /** Move parse error but keep its ID */
33 #define RET_ERR_SHIFT(e, move) RET_ERR(LDNS_WIREPARSE_ERROR(e), LDNS_WIREPARSE_OFFSET(e)+(move));
34
35 /*
36 * No special care is taken, all dots are translated into
37 * label separators.
38 * @param rel: true if the domain is not absolute (not terminated in .).
39 * The output is then still terminated with a '0' rootlabel.
40 */
sldns_str2wire_dname_buf_rel(const char * str,uint8_t * buf,size_t * olen,int * rel)41 static int sldns_str2wire_dname_buf_rel(const char* str, uint8_t* buf,
42 size_t* olen, int* rel)
43 {
44 size_t len;
45
46 const char *s;
47 uint8_t *q, *pq, label_len;
48
49 if(rel) *rel = 0;
50 len = strlen((char*)str);
51 /* octet representation can make strings a lot longer than actual length */
52 if (len > LDNS_MAX_DOMAINLEN * 4) {
53 return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, 0);
54 }
55 if (0 == len) {
56 return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_UNDERFLOW, 0);
57 }
58
59 /* root label */
60 if (1 == len && *str == '.') {
61 if(*olen < 1)
62 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 0);
63 buf[0] = 0;
64 *olen = 1;
65 return LDNS_WIREPARSE_ERR_OK;
66 }
67
68 /* get on with the rest */
69
70 /* s is on the current character in the string
71 * pq points to where the labellength is going to go
72 * label_len keeps track of the current label's length
73 * q builds the dname inside the buf array
74 */
75 len = 0;
76 if(*olen < 1)
77 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 0);
78 q = buf+1;
79 pq = buf;
80 label_len = 0;
81 for (s = str; *s; s++, q++) {
82 if (q >= buf + *olen)
83 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, q-buf);
84 if (q >= buf + LDNS_MAX_DOMAINLEN)
85 return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, q-buf);
86 switch (*s) {
87 case '.':
88 if (label_len > LDNS_MAX_LABELLEN) {
89 return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, q-buf);
90 }
91 if (label_len == 0) {
92 return RET_ERR(LDNS_WIREPARSE_ERR_EMPTY_LABEL, q-buf);
93 }
94 len += label_len + 1;
95 *q = 0;
96 *pq = label_len;
97 label_len = 0;
98 pq = q;
99 break;
100 case '\\':
101 /* octet value or literal char */
102 s += 1;
103 if (!sldns_parse_escape(q, &s)) {
104 *q = 0;
105 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_BAD_ESCAPE, q-buf);
106 }
107 s -= 1;
108 label_len++;
109 break;
110 default:
111 *q = (uint8_t)*s;
112 label_len++;
113 }
114 }
115
116 /* add root label if last char was not '.' */
117 if(label_len != 0) {
118 if(rel) *rel = 1;
119 if (q >= buf + *olen)
120 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, q-buf);
121 if (q >= buf + LDNS_MAX_DOMAINLEN) {
122 return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, q-buf);
123 }
124 if (label_len > LDNS_MAX_LABELLEN) {
125 return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, q-buf);
126 }
127 if (label_len == 0) { /* label_len 0 but not . at end? */
128 return RET_ERR(LDNS_WIREPARSE_ERR_EMPTY_LABEL, q-buf);
129 }
130 len += label_len + 1;
131 *pq = label_len;
132 *q = 0;
133 }
134 len++;
135 *olen = len;
136
137 return LDNS_WIREPARSE_ERR_OK;
138 }
139
sldns_str2wire_dname_buf(const char * str,uint8_t * buf,size_t * len)140 int sldns_str2wire_dname_buf(const char* str, uint8_t* buf, size_t* len)
141 {
142 return sldns_str2wire_dname_buf_rel(str, buf, len, NULL);
143 }
144
sldns_str2wire_dname_buf_origin(const char * str,uint8_t * buf,size_t * len,uint8_t * origin,size_t origin_len)145 int sldns_str2wire_dname_buf_origin(const char* str, uint8_t* buf, size_t* len,
146 uint8_t* origin, size_t origin_len)
147 {
148 size_t dlen = *len;
149 int rel = 0;
150 int s = sldns_str2wire_dname_buf_rel(str, buf, &dlen, &rel);
151 if(s) return s;
152
153 if(rel && origin && dlen > 0) {
154 if((unsigned)dlen >= 0x00ffffffU ||
155 (unsigned)origin_len >= 0x00ffffffU)
156 /* guard against integer overflow in addition */
157 return RET_ERR(LDNS_WIREPARSE_ERR_GENERAL, *len);
158 if(dlen + origin_len - 1 > LDNS_MAX_DOMAINLEN)
159 return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW,
160 LDNS_MAX_DOMAINLEN);
161 if(dlen + origin_len - 1 > *len)
162 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
163 *len);
164 memmove(buf+dlen-1, origin, origin_len);
165 *len = dlen + origin_len - 1;
166 } else
167 *len = dlen;
168 return LDNS_WIREPARSE_ERR_OK;
169 }
170
sldns_str2wire_dname(const char * str,size_t * len)171 uint8_t* sldns_str2wire_dname(const char* str, size_t* len)
172 {
173 uint8_t dname[LDNS_MAX_DOMAINLEN+1];
174 *len = sizeof(dname);
175 if(sldns_str2wire_dname_buf(str, dname, len) == 0) {
176 uint8_t* r;
177 if(*len > sizeof(dname)) return NULL;
178 r = (uint8_t*)malloc(*len);
179 if(r) return memcpy(r, dname, *len);
180 }
181 *len = 0;
182 return NULL;
183 }
184
185 /** read owner name */
186 static int
rrinternal_get_owner(sldns_buffer * strbuf,uint8_t * rr,size_t * len,size_t * dname_len,uint8_t * origin,size_t origin_len,uint8_t * prev,size_t prev_len,char * token,size_t token_len)187 rrinternal_get_owner(sldns_buffer* strbuf, uint8_t* rr, size_t* len,
188 size_t* dname_len, uint8_t* origin, size_t origin_len, uint8_t* prev,
189 size_t prev_len, char* token, size_t token_len)
190 {
191 /* split the rr in its parts -1 signals trouble */
192 if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
193 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX,
194 sldns_buffer_position(strbuf));
195 }
196
197 if(token_len < 2) /* make sure there is space to read "@" or "" */
198 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
199 sldns_buffer_position(strbuf));
200 if(token[0]=='@' && token[1]=='\0') {
201 uint8_t* tocopy;
202 if (origin) {
203 *dname_len = origin_len;
204 tocopy = origin;
205 } else if (prev) {
206 *dname_len = prev_len;
207 tocopy = prev;
208 } else {
209 /* default to root */
210 *dname_len = 1;
211 tocopy = (uint8_t*)"\0";
212 }
213 if(*len < *dname_len)
214 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
215 sldns_buffer_position(strbuf));
216 memmove(rr, tocopy, *dname_len);
217 } else if(*token == '\0') {
218 /* no ownername was given, try prev, if that fails
219 * origin, else default to root */
220 uint8_t* tocopy;
221 if(prev) {
222 *dname_len = prev_len;
223 tocopy = prev;
224 } else if(origin) {
225 *dname_len = origin_len;
226 tocopy = origin;
227 } else {
228 *dname_len = 1;
229 tocopy = (uint8_t*)"\0";
230 }
231 if(*len < *dname_len)
232 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
233 sldns_buffer_position(strbuf));
234 memmove(rr, tocopy, *dname_len);
235 } else {
236 size_t dlen = *len;
237 int s = sldns_str2wire_dname_buf_origin(token, rr, &dlen,
238 origin, origin_len);
239 if(s) return RET_ERR_SHIFT(s,
240 sldns_buffer_position(strbuf)-strlen(token));
241 *dname_len = dlen;
242 }
243 return LDNS_WIREPARSE_ERR_OK;
244 }
245
246 /** read ttl */
247 static int
rrinternal_get_ttl(sldns_buffer * strbuf,char * token,size_t token_len,int * not_there,uint32_t * ttl,uint32_t default_ttl)248 rrinternal_get_ttl(sldns_buffer* strbuf, char* token, size_t token_len,
249 int* not_there, uint32_t* ttl, uint32_t default_ttl)
250 {
251 const char* endptr;
252 int overflow;
253 if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
254 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TTL,
255 sldns_buffer_position(strbuf));
256 }
257 *ttl = (uint32_t) sldns_str2period(token, &endptr, &overflow);
258 if(overflow) {
259 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INTEGER_OVERFLOW,
260 sldns_buffer_position(strbuf));
261 }
262
263 if (strlen(token) > 0 && !isdigit((unsigned char)token[0])) {
264 *not_there = 1;
265 /* ah, it's not there or something */
266 if (default_ttl == 0) {
267 *ttl = LDNS_DEFAULT_TTL;
268 } else {
269 *ttl = default_ttl;
270 }
271 }
272 return LDNS_WIREPARSE_ERR_OK;
273 }
274
275 /** read class */
276 static int
rrinternal_get_class(sldns_buffer * strbuf,char * token,size_t token_len,int * not_there,uint16_t * cl)277 rrinternal_get_class(sldns_buffer* strbuf, char* token, size_t token_len,
278 int* not_there, uint16_t* cl)
279 {
280 /* if 'not_there' then we got token from previous parse routine */
281 if(!*not_there) {
282 /* parse new token for class */
283 if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
284 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_CLASS,
285 sldns_buffer_position(strbuf));
286 }
287 } else *not_there = 0;
288 *cl = sldns_get_rr_class_by_name(token);
289 /* class can be left out too, assume IN, current token must be type */
290 if(*cl == 0 && strcmp(token, "CLASS0") != 0) {
291 *not_there = 1;
292 *cl = LDNS_RR_CLASS_IN;
293 }
294 return LDNS_WIREPARSE_ERR_OK;
295 }
296
297 /** read type */
298 static int
rrinternal_get_type(sldns_buffer * strbuf,char * token,size_t token_len,int * not_there,uint16_t * tp)299 rrinternal_get_type(sldns_buffer* strbuf, char* token, size_t token_len,
300 int* not_there, uint16_t* tp)
301 {
302 /* if 'not_there' then we got token from previous parse routine */
303 if(!*not_there) {
304 /* parse new token for type */
305 if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
306 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE,
307 sldns_buffer_position(strbuf));
308 }
309 }
310 *tp = sldns_get_rr_type_by_name(token);
311 if(*tp == 0 && strcmp(token, "TYPE0") != 0) {
312 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE,
313 sldns_buffer_position(strbuf));
314 }
315 return LDNS_WIREPARSE_ERR_OK;
316 }
317
318 /** put type, class, ttl into rr buffer */
319 static int
rrinternal_write_typeclassttl(sldns_buffer * strbuf,uint8_t * rr,size_t len,size_t dname_len,uint16_t tp,uint16_t cl,uint32_t ttl,int question)320 rrinternal_write_typeclassttl(sldns_buffer* strbuf, uint8_t* rr, size_t len,
321 size_t dname_len, uint16_t tp, uint16_t cl, uint32_t ttl, int question)
322 {
323 if(question) {
324 /* question is : name, type, class */
325 if(dname_len + 4 > len)
326 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
327 sldns_buffer_position(strbuf));
328 sldns_write_uint16(rr+dname_len, tp);
329 sldns_write_uint16(rr+dname_len+2, cl);
330 return LDNS_WIREPARSE_ERR_OK;
331 }
332
333 /* type(2), class(2), ttl(4), rdatalen(2 (later)) = 10 */
334 if(dname_len + 10 > len)
335 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
336 sldns_buffer_position(strbuf));
337 sldns_write_uint16(rr+dname_len, tp);
338 sldns_write_uint16(rr+dname_len+2, cl);
339 sldns_write_uint32(rr+dname_len+4, ttl);
340 sldns_write_uint16(rr+dname_len+8, 0); /* rdatalen placeholder */
341 return LDNS_WIREPARSE_ERR_OK;
342 }
343
344 /** find delimiters for type */
345 static const char*
rrinternal_get_delims(sldns_rdf_type rdftype,size_t r_cnt,size_t r_max)346 rrinternal_get_delims(sldns_rdf_type rdftype, size_t r_cnt, size_t r_max)
347 {
348 switch(rdftype) {
349 case LDNS_RDF_TYPE_B64 :
350 case LDNS_RDF_TYPE_HEX : /* These rdf types may con- */
351 case LDNS_RDF_TYPE_LOC : /* tain whitespace, only if */
352 case LDNS_RDF_TYPE_WKS : /* it is the last rd field. */
353 case LDNS_RDF_TYPE_IPSECKEY :
354 case LDNS_RDF_TYPE_NSEC : if (r_cnt == r_max - 1) {
355 return "\n";
356 }
357 break;
358 default : break;
359 }
360 return "\n\t ";
361 }
362
363 /* Syntactic sugar for sldns_rr_new_frm_str_internal */
364 static int
sldns_rdf_type_maybe_quoted(sldns_rdf_type rdf_type)365 sldns_rdf_type_maybe_quoted(sldns_rdf_type rdf_type)
366 {
367 return rdf_type == LDNS_RDF_TYPE_STR ||
368 rdf_type == LDNS_RDF_TYPE_LONG_STR ||
369 rdf_type == LDNS_RDF_TYPE_UNQUOTED;
370 }
371
372 /** see if rdata is quoted */
373 static int
rrinternal_get_quoted(sldns_buffer * strbuf,const char ** delimiters,sldns_rdf_type rdftype)374 rrinternal_get_quoted(sldns_buffer* strbuf, const char** delimiters,
375 sldns_rdf_type rdftype)
376 {
377 if(sldns_rdf_type_maybe_quoted(rdftype) &&
378 sldns_buffer_remaining(strbuf) > 0) {
379
380 /* skip spaces */
381 while(sldns_buffer_remaining(strbuf) > 0 &&
382 (*(sldns_buffer_current(strbuf)) == ' ' ||
383 *(sldns_buffer_current(strbuf)) == '\t')) {
384 sldns_buffer_skip(strbuf, 1);
385 }
386
387 if(sldns_buffer_remaining(strbuf) > 0 &&
388 *(sldns_buffer_current(strbuf)) == '\"') {
389 *delimiters = "\"\0";
390 sldns_buffer_skip(strbuf, 1);
391 return 1;
392 }
393 }
394 return 0;
395 }
396
397 /** spool hex data into rdata */
398 static int
rrinternal_spool_hex(char * token,uint8_t * rr,size_t rr_len,size_t rr_cur_len,size_t * cur_hex_data_size,size_t hex_data_size)399 rrinternal_spool_hex(char* token, uint8_t* rr, size_t rr_len,
400 size_t rr_cur_len, size_t* cur_hex_data_size, size_t hex_data_size)
401 {
402 char* p = token;
403 while(*p) {
404 if(isspace((unsigned char)*p)) {
405 p++;
406 continue;
407 }
408 if(!isxdigit((unsigned char)*p))
409 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_RDATA,
410 p-token);
411 if(*cur_hex_data_size >= hex_data_size)
412 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_RDATA,
413 p-token);
414 /* extra robust check */
415 if(rr_cur_len+(*cur_hex_data_size)/2 >= rr_len)
416 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
417 p-token);
418 /* see if 16s or 1s */
419 if( ((*cur_hex_data_size)&1) == 0) {
420 rr[rr_cur_len+(*cur_hex_data_size)/2] =
421 (uint8_t)sldns_hexdigit_to_int(*p)*16;
422 } else {
423 rr[rr_cur_len+(*cur_hex_data_size)/2] +=
424 (uint8_t)sldns_hexdigit_to_int(*p);
425 }
426 p++;
427 (*cur_hex_data_size)++;
428 }
429 return LDNS_WIREPARSE_ERR_OK;
430 }
431
432 /** read unknown rr type format */
433 static int
rrinternal_parse_unknown(sldns_buffer * strbuf,char * token,size_t token_len,uint8_t * rr,size_t * rr_len,size_t * rr_cur_len,size_t pre_data_pos)434 rrinternal_parse_unknown(sldns_buffer* strbuf, char* token, size_t token_len,
435 uint8_t* rr, size_t* rr_len, size_t* rr_cur_len, size_t pre_data_pos)
436 {
437 const char* delim = "\n\t ";
438 size_t hex_data_size, cur_hex_data_size;
439 /* go back to before \#
440 * and skip it while setting delimiters better
441 */
442 sldns_buffer_set_position(strbuf, pre_data_pos);
443 if(sldns_bget_token(strbuf, token, delim, token_len) == -1)
444 return LDNS_WIREPARSE_ERR_GENERAL; /* should not fail */
445 /* read rdata octet length */
446 if(sldns_bget_token(strbuf, token, delim, token_len) == -1) {
447 /* something goes very wrong here */
448 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_RDATA,
449 sldns_buffer_position(strbuf));
450 }
451 hex_data_size = (size_t)atoi(token);
452 if(hex_data_size > LDNS_MAX_RDFLEN ||
453 *rr_cur_len + hex_data_size > *rr_len) {
454 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
455 sldns_buffer_position(strbuf));
456 }
457 /* copy hex chars into hex str (2 chars per byte) */
458 hex_data_size *= 2;
459 cur_hex_data_size = 0;
460 while(cur_hex_data_size < hex_data_size) {
461 int status;
462 ssize_t c = sldns_bget_token(strbuf, token, delim, token_len);
463 if((status = rrinternal_spool_hex(token, rr, *rr_len,
464 *rr_cur_len, &cur_hex_data_size, hex_data_size)) != 0)
465 return RET_ERR_SHIFT(status,
466 sldns_buffer_position(strbuf)-strlen(token));
467 if(c == -1) {
468 if(cur_hex_data_size != hex_data_size)
469 return RET_ERR(
470 LDNS_WIREPARSE_ERR_SYNTAX_RDATA,
471 sldns_buffer_position(strbuf));
472 break;
473 }
474 }
475 *rr_cur_len += hex_data_size/2;
476 return LDNS_WIREPARSE_ERR_OK;
477 }
478
479 /** parse normal RR rdata element */
480 static int
rrinternal_parse_rdf(sldns_buffer * strbuf,char * token,size_t token_len,uint8_t * rr,size_t rr_len,size_t * rr_cur_len,sldns_rdf_type rdftype,uint16_t rr_type,size_t r_cnt,size_t r_max,size_t dname_len,uint8_t * origin,size_t origin_len)481 rrinternal_parse_rdf(sldns_buffer* strbuf, char* token, size_t token_len,
482 uint8_t* rr, size_t rr_len, size_t* rr_cur_len, sldns_rdf_type rdftype,
483 uint16_t rr_type, size_t r_cnt, size_t r_max, size_t dname_len,
484 uint8_t* origin, size_t origin_len)
485 {
486 size_t len;
487 int status;
488
489 switch(rdftype) {
490 case LDNS_RDF_TYPE_DNAME:
491 /* check if the origin should be used or concatenated */
492 if(strcmp(token, "@") == 0) {
493 uint8_t* tocopy;
494 size_t copylen;
495 if(origin) {
496 copylen = origin_len;
497 tocopy = origin;
498 } else if(rr_type == LDNS_RR_TYPE_SOA) {
499 copylen = dname_len;
500 tocopy = rr; /* copy rr owner name */
501 } else {
502 copylen = 1;
503 tocopy = (uint8_t*)"\0";
504 }
505 if((*rr_cur_len) + copylen > rr_len)
506 return RET_ERR(
507 LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
508 sldns_buffer_position(strbuf));
509 memmove(rr+*rr_cur_len, tocopy, copylen);
510 (*rr_cur_len) += copylen;
511 } else {
512 size_t dlen = rr_len - (*rr_cur_len);
513 int s = sldns_str2wire_dname_buf_origin(token,
514 rr+*rr_cur_len, &dlen, origin, origin_len);
515 if(s) return RET_ERR_SHIFT(s,
516 sldns_buffer_position(strbuf)-strlen(token));
517 (*rr_cur_len) += dlen;
518 }
519 return LDNS_WIREPARSE_ERR_OK;
520
521 case LDNS_RDF_TYPE_HEX:
522 case LDNS_RDF_TYPE_B64:
523 /* When this is the last rdata field, then the
524 * rest should be read in (cause then these
525 * rdf types may contain spaces). */
526 if(r_cnt == r_max - 1) {
527 size_t tlen = strlen(token);
528 (void)sldns_bget_token(strbuf, token+tlen, "\n",
529 token_len - tlen);
530 }
531 break;
532 default:
533 break;
534 }
535
536 len = rr_len - (*rr_cur_len);
537 if((status=sldns_str2wire_rdf_buf(token, rr+(*rr_cur_len), &len,
538 rdftype)) != 0)
539 return RET_ERR_SHIFT(status,
540 sldns_buffer_position(strbuf)-strlen(token));
541 *rr_cur_len += len;
542 return LDNS_WIREPARSE_ERR_OK;
543 }
544
545 /**
546 * Parse one rdf token. Takes care of quotes and parenthesis.
547 */
548 static int
sldns_parse_rdf_token(sldns_buffer * strbuf,char * token,size_t token_len,int * quoted,int * parens,size_t * pre_data_pos,const char * delimiters,sldns_rdf_type rdftype,size_t * token_strlen)549 sldns_parse_rdf_token(sldns_buffer* strbuf, char* token, size_t token_len,
550 int* quoted, int* parens, size_t* pre_data_pos,
551 const char* delimiters, sldns_rdf_type rdftype, size_t* token_strlen)
552 {
553 size_t slen;
554
555 /* skip spaces and tabs */
556 while(sldns_buffer_remaining(strbuf) > 0 && !*quoted &&
557 (*(sldns_buffer_current(strbuf)) == ' ' ||
558 *(sldns_buffer_current(strbuf)) == '\t')) {
559 sldns_buffer_skip(strbuf, 1);
560 }
561
562 *pre_data_pos = sldns_buffer_position(strbuf);
563 if(sldns_bget_token_par(strbuf, token, (*quoted)?"\"":delimiters,
564 token_len, parens, (*quoted)?NULL:" \t") == -1) {
565 return 0;
566 }
567 slen = strlen(token);
568 /* check if not quoted yet, and we have encountered quotes */
569 if(!*quoted && sldns_rdf_type_maybe_quoted(rdftype) &&
570 slen >= 2 &&
571 (token[0] == '"' || token[0] == '\'') &&
572 (token[slen-1] == '"' || token[slen-1] == '\'')) {
573 /* move token two smaller (quotes) with endnull */
574 memmove(token, token+1, slen-2);
575 token[slen-2] = 0;
576 slen -= 2;
577 *quoted = 1;
578 } else if(!*quoted && sldns_rdf_type_maybe_quoted(rdftype) &&
579 slen >= 2 &&
580 (token[0] == '"' || token[0] == '\'')) {
581 /* got the start quote (remove it) but read remainder
582 * of quoted string as well into remainder of token */
583 memmove(token, token+1, slen-1);
584 token[slen-1] = 0;
585 slen -= 1;
586 *quoted = 1;
587 /* rewind buffer over skipped whitespace */
588 while(sldns_buffer_position(strbuf) > 0 &&
589 (sldns_buffer_current(strbuf)[-1] == ' ' ||
590 sldns_buffer_current(strbuf)[-1] == '\t')) {
591 sldns_buffer_skip(strbuf, -1);
592 }
593 if(sldns_bget_token_par(strbuf, token+slen,
594 "\"", token_len-slen,
595 parens, NULL) == -1) {
596 return 0;
597 }
598 slen = strlen(token);
599 }
600 *token_strlen = slen;
601 return 1;
602 }
603
604 /** Add space and one more rdf token onto the existing token string. */
605 static int
sldns_affix_token(sldns_buffer * strbuf,char * token,size_t * token_len,int * quoted,int * parens,size_t * pre_data_pos,const char * delimiters,sldns_rdf_type rdftype,size_t * token_strlen)606 sldns_affix_token(sldns_buffer* strbuf, char* token, size_t* token_len,
607 int* quoted, int* parens, size_t* pre_data_pos,
608 const char* delimiters, sldns_rdf_type rdftype, size_t* token_strlen)
609 {
610 size_t addlen = *token_len - *token_strlen;
611 size_t addstrlen = 0;
612
613 /* add space */
614 /* when addlen < 2, the token buffer is full considering the NULL byte
615 * from strlen and will lead to buffer overflow with the second
616 * assignment below. */
617 if(addlen < 2) return 0;
618 token[*token_strlen] = ' ';
619 token[++(*token_strlen)] = 0;
620
621 /* read another token */
622 addlen = *token_len - *token_strlen;
623 if(!sldns_parse_rdf_token(strbuf, token+*token_strlen, addlen, quoted,
624 parens, pre_data_pos, delimiters, rdftype, &addstrlen))
625 return 0;
626 (*token_strlen) += addstrlen;
627 return 1;
628 }
629
sldns_str2wire_svcparam_key_cmp(const void * a,const void * b)630 static int sldns_str2wire_svcparam_key_cmp(const void *a, const void *b)
631 {
632 return sldns_read_uint16(*(uint8_t**) a)
633 - sldns_read_uint16(*(uint8_t**) b);
634 }
635
636 /**
637 * Add constraints to the SVCB RRs which involve the whole set
638 */
sldns_str2wire_check_svcbparams(uint8_t * rdata,uint16_t rdata_len)639 static int sldns_str2wire_check_svcbparams(uint8_t* rdata, uint16_t rdata_len)
640 {
641 size_t nparams = 0, i;
642 uint8_t new_rdata[LDNS_MAX_RDFLEN];
643 uint8_t* new_rdata_ptr = new_rdata;
644 uint8_t* svcparams[MAX_NUMBER_OF_SVCPARAMS];
645 uint8_t* rdata_ptr = rdata;
646 uint16_t rdata_remaining = rdata_len;
647
648 /* find the SvcParams */
649 while (rdata_remaining) {
650 uint16_t svcbparam_len;
651
652 svcparams[nparams] = rdata_ptr;
653 if (rdata_remaining < 4)
654 return LDNS_WIREPARSE_ERR_SVCPARAM_BROKEN_RDATA;
655 svcbparam_len = sldns_read_uint16(rdata_ptr + 2);
656 rdata_remaining -= 4;
657 rdata_ptr += 4;
658
659 if (rdata_remaining < svcbparam_len)
660 return LDNS_WIREPARSE_ERR_SVCPARAM_BROKEN_RDATA;
661 rdata_remaining -= svcbparam_len;
662 rdata_ptr += svcbparam_len;
663
664 nparams += 1;
665 if (nparams >= MAX_NUMBER_OF_SVCPARAMS)
666 return LDNS_WIREPARSE_ERR_SVCB_TOO_MANY_PARAMS;
667 }
668
669 /* In draft-ietf-dnsop-svcb-https-06 Section 7:
670 *
671 * In wire format, the keys are represented by their numeric
672 * values in network byte order, concatenated in ascending order.
673 */
674 qsort((void *)svcparams
675 ,nparams
676 ,sizeof(uint8_t*)
677 ,sldns_str2wire_svcparam_key_cmp);
678
679
680 /* The code below revolves around semantic errors in the SVCParam set.
681 * So long as we do not distinguish between running Unbound as a primary
682 * or as a secondary, we default to secondary behavior and we ignore the
683 * semantic errors. */
684
685 #ifdef SVCB_SEMANTIC_ERRORS
686 {
687 uint8_t* mandatory = NULL;
688 /* In draft-ietf-dnsop-svcb-https-06 Section 7:
689 *
690 * Keys (...) MUST NOT appear more than once.
691 *
692 * If they key has already been seen, we have a duplicate
693 */
694 for(i=0; i < nparams; i++) {
695 uint16_t key = sldns_read_uint16(svcparams[i]);
696 if(i + 1 < nparams && key == sldns_read_uint16(svcparams[i+1]))
697 return LDNS_WIREPARSE_ERR_SVCB_DUPLICATE_KEYS;
698 if(key == SVCB_KEY_MANDATORY)
699 mandatory = svcparams[i];
700 }
701
702 /* Verify that all the SvcParamKeys in mandatory are present */
703 if(mandatory) {
704 /* Divide by sizeof(uint16_t)*/
705 uint16_t mandatory_nkeys = sldns_read_uint16(mandatory + 2) / sizeof(uint16_t);
706
707 /* Guaranteed by sldns_str2wire_svcparam_key_value */
708 assert(mandatory_nkeys > 0);
709
710 for(i=0; i < mandatory_nkeys; i++) {
711 uint16_t mandatory_key = sldns_read_uint16(
712 mandatory
713 + 2 * sizeof(uint16_t)
714 + i * sizeof(uint16_t));
715 uint8_t found = 0;
716 size_t j;
717
718 for(j=0; j < nparams; j++) {
719 if(mandatory_key == sldns_read_uint16(svcparams[j])) {
720 found = 1;
721 break;
722 }
723 }
724
725 if(!found)
726 return LDNS_WIREPARSE_ERR_SVCB_MANDATORY_MISSING_PARAM;
727 }
728 }
729 }
730 #endif
731 /* Write rdata in correct order */
732 for (i = 0; i < nparams; i++) {
733 uint16_t svcparam_len = sldns_read_uint16(svcparams[i] + 2)
734 + 2 * sizeof(uint16_t);
735
736 if ((unsigned)(new_rdata_ptr - new_rdata) + svcparam_len > sizeof(new_rdata))
737 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
738
739 memcpy(new_rdata_ptr, svcparams[i], svcparam_len);
740 new_rdata_ptr += svcparam_len;
741 }
742 memcpy(rdata, new_rdata, rdata_len);
743 return LDNS_WIREPARSE_ERR_OK;
744 }
745
746 /** parse rdata from string into rr buffer(-remainder after dname). */
747 static int
rrinternal_parse_rdata(sldns_buffer * strbuf,char * token,size_t token_len,uint8_t * rr,size_t * rr_len,size_t dname_len,uint16_t rr_type,uint8_t * origin,size_t origin_len)748 rrinternal_parse_rdata(sldns_buffer* strbuf, char* token, size_t token_len,
749 uint8_t* rr, size_t* rr_len, size_t dname_len, uint16_t rr_type,
750 uint8_t* origin, size_t origin_len)
751 {
752 const sldns_rr_descriptor *desc = sldns_rr_descript((uint16_t)rr_type);
753 size_t r_cnt, r_min, r_max;
754 size_t rr_cur_len = dname_len + 10, pre_data_pos, token_strlen;
755 int was_unknown_rr_format = 0, parens = 0, status, quoted;
756 const char* delimiters;
757 sldns_rdf_type rdftype;
758 /* a desc is always returned */
759 if(!desc) return LDNS_WIREPARSE_ERR_GENERAL;
760 r_max = sldns_rr_descriptor_maximum(desc);
761 r_min = sldns_rr_descriptor_minimum(desc);
762 /* robust check */
763 if(rr_cur_len > *rr_len)
764 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
765 sldns_buffer_position(strbuf));
766
767 /* because number of fields can be variable, we can't rely on
768 * _maximum() only */
769 for(r_cnt=0; r_cnt < r_max; r_cnt++) {
770 rdftype = sldns_rr_descriptor_field_type(desc, r_cnt);
771 delimiters = rrinternal_get_delims(rdftype, r_cnt, r_max);
772 quoted = rrinternal_get_quoted(strbuf, &delimiters, rdftype);
773
774 if(!sldns_parse_rdf_token(strbuf, token, token_len, "ed,
775 &parens, &pre_data_pos, delimiters, rdftype,
776 &token_strlen))
777 break;
778
779 /* rfc3597 specifies that any type can be represented
780 * with \# method, which can contain spaces...
781 * it does specify size though... */
782
783 /* unknown RR data */
784 if(token_strlen>=2 && strncmp(token, "\\#", 2) == 0 &&
785 !quoted && (token_strlen == 2 || token[2]==' ' ||
786 token[2]=='\t')) {
787 was_unknown_rr_format = 1;
788 if((status=rrinternal_parse_unknown(strbuf, token,
789 token_len, rr, rr_len, &rr_cur_len,
790 pre_data_pos)) != 0)
791 return status;
792 } else if(token_strlen > 0 || quoted) {
793 if(rdftype == LDNS_RDF_TYPE_HIP) {
794 /* affix the HIT and PK fields, with a space */
795 if(!sldns_affix_token(strbuf, token,
796 &token_len, "ed, &parens,
797 &pre_data_pos, delimiters,
798 rdftype, &token_strlen))
799 break;
800 if(!sldns_affix_token(strbuf, token,
801 &token_len, "ed, &parens,
802 &pre_data_pos, delimiters,
803 rdftype, &token_strlen))
804 break;
805 } else if(rdftype == LDNS_RDF_TYPE_INT16_DATA &&
806 strcmp(token, "0")!=0) {
807 /* affix len and b64 fields */
808 if(!sldns_affix_token(strbuf, token,
809 &token_len, "ed, &parens,
810 &pre_data_pos, delimiters,
811 rdftype, &token_strlen))
812 break;
813 }
814
815 /* normal RR */
816 if((status=rrinternal_parse_rdf(strbuf, token,
817 token_len, rr, *rr_len, &rr_cur_len, rdftype,
818 rr_type, r_cnt, r_max, dname_len, origin,
819 origin_len)) != 0) {
820 return status;
821 }
822 }
823 }
824 if(!was_unknown_rr_format && r_cnt+1 < r_min) {
825 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_MISSING_VALUE,
826 sldns_buffer_position(strbuf));
827 }
828 while(parens != 0) {
829 /* read remainder, must be "" */
830 if(sldns_bget_token_par(strbuf, token, "\n", token_len,
831 &parens, " \t") == -1) {
832 if(parens != 0)
833 return RET_ERR(LDNS_WIREPARSE_ERR_PARENTHESIS,
834 sldns_buffer_position(strbuf));
835 break;
836 }
837 if(strcmp(token, "") != 0)
838 return RET_ERR(LDNS_WIREPARSE_ERR_PARENTHESIS,
839 sldns_buffer_position(strbuf));
840 }
841 /* write rdata length */
842 sldns_write_uint16(rr+dname_len+8, (uint16_t)(rr_cur_len-dname_len-10));
843 *rr_len = rr_cur_len;
844 /* SVCB/HTTPS handling */
845 if ((rr_type == LDNS_RR_TYPE_SVCB || rr_type == LDNS_RR_TYPE_HTTPS)
846 && !was_unknown_rr_format) {
847 size_t rdata_len = rr_cur_len - dname_len - 10;
848 uint8_t *rdata = rr+dname_len + 10;
849
850 /* skip 1st rdata field SvcPriority (uint16_t) */
851 if (rdata_len < sizeof(uint16_t))
852 return LDNS_WIREPARSE_ERR_OK;
853
854 rdata_len -= sizeof(uint16_t);
855 rdata += sizeof(uint16_t);
856
857 /* skip 2nd rdata field dname */
858 while (rdata_len && *rdata != 0) {
859 uint8_t label_len;
860
861 if ((*rdata & 0xC0))
862 return LDNS_WIREPARSE_ERR_OK;
863
864 label_len = *rdata + 1;
865 if (rdata_len < label_len)
866 return LDNS_WIREPARSE_ERR_OK;
867
868 rdata_len -= label_len;
869 rdata += label_len;
870 }
871 /* The root label is one more character, so smaller
872 * than 1 + 1 means no Svcparam Keys */
873 if (rdata_len < 2 || *rdata != 0)
874 return LDNS_WIREPARSE_ERR_OK;
875
876 rdata_len -= 1;
877 rdata += 1;
878 return sldns_str2wire_check_svcbparams(rdata, rdata_len);
879
880 }
881 return LDNS_WIREPARSE_ERR_OK;
882 }
883
884 /*
885 * trailing spaces are allowed
886 * leading spaces are not allowed
887 * allow ttl to be optional
888 * class is optional too
889 * if ttl is missing, and default_ttl is 0, use DEF_TTL
890 * allow ttl to be written as 1d3h
891 * So the RR should look like. e.g.
892 * miek.nl. 3600 IN MX 10 elektron.atoom.net
893 * or
894 * miek.nl. 1h IN MX 10 elektron.atoom.net
895 * or
896 * miek.nl. IN MX 10 elektron.atoom.net
897 */
898 static int
sldns_str2wire_rr_buf_internal(const char * str,uint8_t * rr,size_t * len,size_t * dname_len,uint32_t default_ttl,uint8_t * origin,size_t origin_len,uint8_t * prev,size_t prev_len,int question)899 sldns_str2wire_rr_buf_internal(const char* str, uint8_t* rr, size_t* len,
900 size_t* dname_len, uint32_t default_ttl, uint8_t* origin,
901 size_t origin_len, uint8_t* prev, size_t prev_len, int question)
902 {
903 int status;
904 int not_there = 0;
905 char token[LDNS_MAX_RDFLEN+1];
906 uint32_t ttl = 0;
907 uint16_t tp = 0, cl = 0;
908 size_t ddlen = 0;
909
910 /* string in buffer */
911 sldns_buffer strbuf;
912 sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
913 if(!dname_len) dname_len = &ddlen;
914
915 /* parse the owner */
916 if((status=rrinternal_get_owner(&strbuf, rr, len, dname_len, origin,
917 origin_len, prev, prev_len, token, sizeof(token))) != 0)
918 return status;
919
920 /* parse the [ttl] [class] <type> */
921 if((status=rrinternal_get_ttl(&strbuf, token, sizeof(token),
922 ¬_there, &ttl, default_ttl)) != 0)
923 return status;
924 if((status=rrinternal_get_class(&strbuf, token, sizeof(token),
925 ¬_there, &cl)) != 0)
926 return status;
927 if((status=rrinternal_get_type(&strbuf, token, sizeof(token),
928 ¬_there, &tp)) != 0)
929 return status;
930 /* put ttl, class, type into the rr result */
931 if((status=rrinternal_write_typeclassttl(&strbuf, rr, *len, *dname_len, tp, cl,
932 ttl, question)) != 0)
933 return status;
934 /* for a question-RR we are done, no rdata */
935 if(question) {
936 *len = *dname_len + 4;
937 return LDNS_WIREPARSE_ERR_OK;
938 }
939
940 /* rdata */
941 if((status=rrinternal_parse_rdata(&strbuf, token, sizeof(token),
942 rr, len, *dname_len, tp, origin, origin_len)) != 0)
943 return status;
944
945 return LDNS_WIREPARSE_ERR_OK;
946 }
947
sldns_str2wire_rr_buf(const char * str,uint8_t * rr,size_t * len,size_t * dname_len,uint32_t default_ttl,uint8_t * origin,size_t origin_len,uint8_t * prev,size_t prev_len)948 int sldns_str2wire_rr_buf(const char* str, uint8_t* rr, size_t* len,
949 size_t* dname_len, uint32_t default_ttl, uint8_t* origin,
950 size_t origin_len, uint8_t* prev, size_t prev_len)
951 {
952 return sldns_str2wire_rr_buf_internal(str, rr, len, dname_len,
953 default_ttl, origin, origin_len, prev, prev_len, 0);
954 }
955
sldns_str2wire_rr_question_buf(const char * str,uint8_t * rr,size_t * len,size_t * dname_len,uint8_t * origin,size_t origin_len,uint8_t * prev,size_t prev_len)956 int sldns_str2wire_rr_question_buf(const char* str, uint8_t* rr, size_t* len,
957 size_t* dname_len, uint8_t* origin, size_t origin_len, uint8_t* prev,
958 size_t prev_len)
959 {
960 return sldns_str2wire_rr_buf_internal(str, rr, len, dname_len,
961 0, origin, origin_len, prev, prev_len, 1);
962 }
963
sldns_wirerr_get_type(uint8_t * rr,size_t len,size_t dname_len)964 uint16_t sldns_wirerr_get_type(uint8_t* rr, size_t len, size_t dname_len)
965 {
966 if(len < dname_len+2)
967 return 0;
968 return sldns_read_uint16(rr+dname_len);
969 }
970
sldns_wirerr_get_class(uint8_t * rr,size_t len,size_t dname_len)971 uint16_t sldns_wirerr_get_class(uint8_t* rr, size_t len, size_t dname_len)
972 {
973 if(len < dname_len+4)
974 return 0;
975 return sldns_read_uint16(rr+dname_len+2);
976 }
977
sldns_wirerr_get_ttl(uint8_t * rr,size_t len,size_t dname_len)978 uint32_t sldns_wirerr_get_ttl(uint8_t* rr, size_t len, size_t dname_len)
979 {
980 if(len < dname_len+8)
981 return 0;
982 return sldns_read_uint32(rr+dname_len+4);
983 }
984
sldns_wirerr_get_rdatalen(uint8_t * rr,size_t len,size_t dname_len)985 uint16_t sldns_wirerr_get_rdatalen(uint8_t* rr, size_t len, size_t dname_len)
986 {
987 if(len < dname_len+10)
988 return 0;
989 return sldns_read_uint16(rr+dname_len+8);
990 }
991
sldns_wirerr_get_rdata(uint8_t * rr,size_t len,size_t dname_len)992 uint8_t* sldns_wirerr_get_rdata(uint8_t* rr, size_t len, size_t dname_len)
993 {
994 if(len < dname_len+10)
995 return NULL;
996 return rr+dname_len+10;
997 }
998
sldns_wirerr_get_rdatawl(uint8_t * rr,size_t len,size_t dname_len)999 uint8_t* sldns_wirerr_get_rdatawl(uint8_t* rr, size_t len, size_t dname_len)
1000 {
1001 if(len < dname_len+10)
1002 return NULL;
1003 return rr+dname_len+8;
1004 }
1005
sldns_get_errorstr_parse(int e)1006 const char* sldns_get_errorstr_parse(int e)
1007 {
1008 sldns_lookup_table *lt;
1009 lt = sldns_lookup_by_id(sldns_wireparse_errors, LDNS_WIREPARSE_ERROR(e));
1010 return lt?lt->name:"unknown error";
1011 }
1012
1013 /* Strip whitespace from the start and the end of <line>. */
1014 char *
sldns_strip_ws(char * line)1015 sldns_strip_ws(char *line)
1016 {
1017 char *s = line, *e;
1018
1019 for (s = line; *s && isspace((unsigned char)*s); s++)
1020 ;
1021 for (e = strchr(s, 0); e > s+2 && isspace((unsigned char)e[-1]) && e[-2] != '\\'; e--)
1022 ;
1023 *e = 0;
1024 return s;
1025 }
1026
sldns_fp2wire_rr_buf(FILE * in,uint8_t * rr,size_t * len,size_t * dname_len,struct sldns_file_parse_state * parse_state)1027 int sldns_fp2wire_rr_buf(FILE* in, uint8_t* rr, size_t* len, size_t* dname_len,
1028 struct sldns_file_parse_state* parse_state)
1029 {
1030 char line[LDNS_RR_BUF_SIZE+1];
1031 ssize_t size;
1032
1033 /* read an entire line in from the file */
1034 if((size = sldns_fget_token_l(in, line, LDNS_PARSE_SKIP_SPACE,
1035 LDNS_RR_BUF_SIZE, parse_state?&parse_state->lineno:NULL))
1036 == -1) {
1037 /* if last line was empty, we are now at feof, which is not
1038 * always a parse error (happens when for instance last line
1039 * was a comment)
1040 */
1041 return LDNS_WIREPARSE_ERR_SYNTAX;
1042 }
1043
1044 /* we can have the situation, where we've read ok, but still got
1045 * no bytes to play with, in this case size is 0 */
1046 if(size == 0) {
1047 if(*len > 0)
1048 rr[0] = 0;
1049 *len = 0;
1050 *dname_len = 0;
1051 return LDNS_WIREPARSE_ERR_OK;
1052 }
1053
1054 if(strncmp(line, "$ORIGIN", 7) == 0 && isspace((unsigned char)line[7])) {
1055 int s;
1056 strlcpy((char*)rr, line, *len);
1057 *len = 0;
1058 *dname_len = 0;
1059 if(!parse_state) return LDNS_WIREPARSE_ERR_OK;
1060 parse_state->origin_len = sizeof(parse_state->origin);
1061 s = sldns_str2wire_dname_buf(sldns_strip_ws(line+8),
1062 parse_state->origin, &parse_state->origin_len);
1063 if(s) parse_state->origin_len = 0;
1064 return s;
1065 } else if(strncmp(line, "$TTL", 4) == 0 && isspace((unsigned char)line[4])) {
1066 const char* end = NULL;
1067 int overflow = 0;
1068 strlcpy((char*)rr, line, *len);
1069 *len = 0;
1070 *dname_len = 0;
1071 if(!parse_state) return LDNS_WIREPARSE_ERR_OK;
1072 parse_state->default_ttl = sldns_str2period(
1073 sldns_strip_ws(line+5), &end, &overflow);
1074 if(overflow)
1075 return LDNS_WIREPARSE_ERR_SYNTAX_INTEGER_OVERFLOW;
1076 } else if (strncmp(line, "$INCLUDE", 8) == 0) {
1077 strlcpy((char*)rr, line, *len);
1078 *len = 0;
1079 *dname_len = 0;
1080 return LDNS_WIREPARSE_ERR_INCLUDE;
1081 } else if (strncmp(line, "$", 1) == 0) {
1082 strlcpy((char*)rr, line, *len);
1083 *len = 0;
1084 *dname_len = 0;
1085 return LDNS_WIREPARSE_ERR_INCLUDE;
1086 } else {
1087 int r = sldns_str2wire_rr_buf(line, rr, len, dname_len,
1088 parse_state?parse_state->default_ttl:0,
1089 (parse_state&&parse_state->origin_len)?
1090 parse_state->origin:NULL,
1091 parse_state?parse_state->origin_len:0,
1092 (parse_state&&parse_state->prev_rr_len)?
1093 parse_state->prev_rr:NULL,
1094 parse_state?parse_state->prev_rr_len:0);
1095 if(r == LDNS_WIREPARSE_ERR_OK && (*dname_len) != 0 &&
1096 parse_state &&
1097 (*dname_len) <= sizeof(parse_state->prev_rr)) {
1098 memmove(parse_state->prev_rr, rr, *dname_len);
1099 parse_state->prev_rr_len = (*dname_len);
1100 }
1101 if(r == LDNS_WIREPARSE_ERR_OK && parse_state) {
1102 parse_state->default_ttl = sldns_wirerr_get_ttl(
1103 rr, *len, *dname_len);
1104 }
1105 return r;
1106 }
1107 return LDNS_WIREPARSE_ERR_OK;
1108 }
1109
1110 static int
sldns_str2wire_svcparam_key_lookup(const char * key,size_t key_len)1111 sldns_str2wire_svcparam_key_lookup(const char *key, size_t key_len)
1112 {
1113 char buf[64];
1114 char *endptr;
1115 unsigned long int key_value;
1116
1117 if (key_len >= 4 && key_len <= 8 && !strncmp(key, "key", 3)) {
1118 memcpy(buf, key + 3, key_len - 3);
1119 buf[key_len - 3] = 0;
1120 key_value = strtoul(buf, &endptr, 10);
1121
1122 if (endptr > buf /* digits seen */
1123 && *endptr == 0 /* no non-digit chars after digits */
1124 && key_value <= 65535) /* no overflow */
1125 return key_value;
1126
1127 } else switch (key_len) {
1128 case 3:
1129 if (!strncmp(key, "ech", key_len))
1130 return SVCB_KEY_ECH;
1131 break;
1132
1133 case 4:
1134 if (!strncmp(key, "alpn", key_len))
1135 return SVCB_KEY_ALPN;
1136 if (!strncmp(key, "port", key_len))
1137 return SVCB_KEY_PORT;
1138 break;
1139
1140 case 7:
1141 if (!strncmp(key, "dohpath", key_len))
1142 return SVCB_KEY_DOHPATH;
1143 break;
1144
1145 case 8:
1146 if (!strncmp(key, "ipv4hint", key_len))
1147 return SVCB_KEY_IPV4HINT;
1148 if (!strncmp(key, "ipv6hint", key_len))
1149 return SVCB_KEY_IPV6HINT;
1150 break;
1151
1152 case 9:
1153 if (!strncmp(key, "mandatory", key_len))
1154 return SVCB_KEY_MANDATORY;
1155 if (!strncmp(key, "echconfig", key_len))
1156 return SVCB_KEY_ECH; /* allow "echconfig" as well as "ech" */
1157 break;
1158
1159 case 15:
1160 if (!strncmp(key, "no-default-alpn", key_len))
1161 return SVCB_KEY_NO_DEFAULT_ALPN;
1162 break;
1163
1164 default:
1165 break;
1166 }
1167
1168 /* Although the returned value might be used by the caller,
1169 * the parser has erred, so the zone will not be loaded.
1170 */
1171 return -1;
1172 }
1173
1174 static int
sldns_str2wire_svcparam_port(const char * val,uint8_t * rd,size_t * rd_len)1175 sldns_str2wire_svcparam_port(const char* val, uint8_t* rd, size_t* rd_len)
1176 {
1177 unsigned long int port;
1178 char *endptr;
1179
1180 if (*rd_len < 6)
1181 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1182
1183 port = strtoul(val, &endptr, 10);
1184
1185 if (endptr > val /* digits seen */
1186 && *endptr == 0 /* no non-digit chars after digits */
1187 && port <= 65535) { /* no overflow */
1188
1189 sldns_write_uint16(rd, SVCB_KEY_PORT);
1190 sldns_write_uint16(rd + 2, sizeof(uint16_t));
1191 sldns_write_uint16(rd + 4, port);
1192 *rd_len = 6;
1193
1194 return LDNS_WIREPARSE_ERR_OK;
1195 }
1196
1197 return LDNS_WIREPARSE_ERR_SVCB_PORT_VALUE_SYNTAX;
1198 }
1199
1200 static int
sldns_str2wire_svcbparam_ipv4hint(const char * val,uint8_t * rd,size_t * rd_len)1201 sldns_str2wire_svcbparam_ipv4hint(const char* val, uint8_t* rd, size_t* rd_len)
1202 {
1203 size_t count;
1204 char ip_str[INET_ADDRSTRLEN+1];
1205 const char *next_ip_str;
1206 size_t i;
1207
1208 for (i = 0, count = 1; val[i]; i++) {
1209 if (val[i] == ',')
1210 count += 1;
1211 if (count > SVCB_MAX_COMMA_SEPARATED_VALUES) {
1212 return LDNS_WIREPARSE_ERR_SVCB_IPV4_TOO_MANY_ADDRESSES;
1213 }
1214 }
1215
1216 if (*rd_len < (LDNS_IP4ADDRLEN * count) + 4)
1217 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1218
1219 /* count is number of comma's in val + 1; so the actual number of IPv4
1220 * addresses in val
1221 */
1222 sldns_write_uint16(rd, SVCB_KEY_IPV4HINT);
1223 sldns_write_uint16(rd + 2, LDNS_IP4ADDRLEN * count);
1224 *rd_len = 4;
1225
1226 while (count) {
1227 if (!(next_ip_str = strchr(val, ','))) {
1228 if (inet_pton(AF_INET, val, rd + *rd_len) != 1)
1229 break;
1230 *rd_len += LDNS_IP4ADDRLEN;
1231
1232 assert(count == 1);
1233
1234 } else if (next_ip_str - val >= (int)sizeof(ip_str))
1235 break;
1236
1237 else {
1238 memcpy(ip_str, val, next_ip_str - val);
1239 ip_str[next_ip_str - val] = 0;
1240 if (inet_pton(AF_INET, ip_str, rd + *rd_len) != 1) {
1241 break;
1242 }
1243 *rd_len += LDNS_IP4ADDRLEN;
1244
1245 val = next_ip_str + 1;
1246 }
1247 count--;
1248 }
1249 if (count) /* verify that we parsed all values */
1250 return LDNS_WIREPARSE_ERR_SYNTAX_IP4;
1251
1252 return LDNS_WIREPARSE_ERR_OK;
1253 }
1254
1255 static int
sldns_str2wire_svcbparam_ipv6hint(const char * val,uint8_t * rd,size_t * rd_len)1256 sldns_str2wire_svcbparam_ipv6hint(const char* val, uint8_t* rd, size_t* rd_len)
1257 {
1258 size_t count;
1259 char ip_str[INET6_ADDRSTRLEN+1];
1260 const char *next_ip_str;
1261 size_t i;
1262
1263 for (i = 0, count = 1; val[i]; i++) {
1264 if (val[i] == ',')
1265 count += 1;
1266 if (count > SVCB_MAX_COMMA_SEPARATED_VALUES) {
1267 return LDNS_WIREPARSE_ERR_SVCB_IPV6_TOO_MANY_ADDRESSES;
1268 }
1269 }
1270
1271 if (*rd_len < (LDNS_IP6ADDRLEN * count) + 4)
1272 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1273
1274 /* count is number of comma's in val + 1; so the actual number of IPv6
1275 * addresses in val
1276 */
1277 sldns_write_uint16(rd, SVCB_KEY_IPV6HINT);
1278 sldns_write_uint16(rd + 2, LDNS_IP6ADDRLEN * count);
1279 *rd_len = 4;
1280
1281 while (count) {
1282 if (!(next_ip_str = strchr(val, ','))) {
1283 if (inet_pton(AF_INET6, val, rd + *rd_len) != 1)
1284 break;
1285 *rd_len += LDNS_IP6ADDRLEN;
1286
1287 assert(count == 1);
1288
1289 } else if (next_ip_str - val >= (int)sizeof(ip_str))
1290 break;
1291
1292 else {
1293 memcpy(ip_str, val, next_ip_str - val);
1294 ip_str[next_ip_str - val] = 0;
1295 if (inet_pton(AF_INET6, ip_str, rd + *rd_len) != 1) {
1296 break;
1297 }
1298 *rd_len += LDNS_IP6ADDRLEN;
1299
1300 val = next_ip_str + 1;
1301 }
1302 count--;
1303 }
1304 if (count) /* verify that we parsed all values */
1305 return LDNS_WIREPARSE_ERR_SYNTAX_IP6;
1306
1307 return LDNS_WIREPARSE_ERR_OK;
1308 }
1309
1310 /* compare function used for sorting uint16_t's */
1311 static int
sldns_network_uint16_cmp(const void * a,const void * b)1312 sldns_network_uint16_cmp(const void *a, const void *b)
1313 {
1314 return ((int)sldns_read_uint16(a)) - ((int)sldns_read_uint16(b));
1315 }
1316
1317 static int
sldns_str2wire_svcbparam_mandatory(const char * val,uint8_t * rd,size_t * rd_len)1318 sldns_str2wire_svcbparam_mandatory(const char* val, uint8_t* rd, size_t* rd_len)
1319 {
1320 size_t i, count, val_len;
1321 const char* next_key;
1322
1323 val_len = strlen(val);
1324
1325 for (i = 0, count = 1; val[i]; i++) {
1326 if (val[i] == ',')
1327 count += 1;
1328 if (count > SVCB_MAX_COMMA_SEPARATED_VALUES) {
1329 return LDNS_WIREPARSE_ERR_SVCB_MANDATORY_TOO_MANY_KEYS;
1330 }
1331 }
1332 if (sizeof(uint16_t) * (count + 2) > *rd_len)
1333 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1334
1335 sldns_write_uint16(rd, SVCB_KEY_MANDATORY);
1336 sldns_write_uint16(rd + 2, sizeof(uint16_t) * count);
1337 *rd_len = 4;
1338
1339 while (1) {
1340 int svcparamkey;
1341
1342 if (!(next_key = strchr(val, ','))) {
1343 svcparamkey = sldns_str2wire_svcparam_key_lookup(val, val_len);
1344
1345 if (svcparamkey < 0) {
1346 return LDNS_WIREPARSE_ERR_SVCB_UNKNOWN_KEY;
1347 }
1348
1349 sldns_write_uint16(rd + *rd_len, svcparamkey);
1350 *rd_len += 2;
1351 break;
1352 } else {
1353 svcparamkey = sldns_str2wire_svcparam_key_lookup(val, next_key - val);
1354
1355 if (svcparamkey < 0) {
1356 return LDNS_WIREPARSE_ERR_SVCB_UNKNOWN_KEY;
1357 }
1358
1359 sldns_write_uint16(rd + *rd_len,
1360 svcparamkey);
1361 *rd_len += 2;
1362 }
1363
1364 val_len -= next_key - val + 1;
1365 val = next_key + 1; /* skip the comma */
1366 }
1367
1368 /* In draft-ietf-dnsop-svcb-https-06 Section 7:
1369 *
1370 * "In wire format, the keys are represented by their numeric
1371 * values in network byte order, concatenated in ascending order."
1372 */
1373 qsort((void *)(rd + 4), count, sizeof(uint16_t), sldns_network_uint16_cmp);
1374
1375 /* The code below revolves around semantic errors in the SVCParam set.
1376 * So long as we do not distinguish between running Unbound as a primary
1377 * or as a secondary, we default to secondary behavior and we ignore the
1378 * semantic errors. */
1379 #ifdef SVCB_SEMANTIC_ERRORS
1380 /* In draft-ietf-dnsop-svcb-https-06 Section 8
1381 * automatically mandatory MUST NOT appear in its own value-list
1382 */
1383 if (sldns_read_uint16(rd + 4) == SVCB_KEY_MANDATORY)
1384 return LDNS_WIREPARSE_ERR_SVCB_MANDATORY_IN_MANDATORY;
1385
1386 /* Guarantee key uniqueness. After the sort we only need to
1387 * compare neighbouring keys */
1388 if (count > 1) {
1389 for (i = 0; i < count - 1; i++) {
1390 uint8_t* current_pos = (rd + 4 + (sizeof(uint16_t) * i));
1391 uint16_t key = sldns_read_uint16(current_pos);
1392
1393 if (key == sldns_read_uint16(current_pos + 2)) {
1394 return LDNS_WIREPARSE_ERR_SVCB_MANDATORY_DUPLICATE_KEY;
1395 }
1396 }
1397 }
1398 #endif
1399 return LDNS_WIREPARSE_ERR_OK;
1400 }
1401
1402 static int
sldns_str2wire_svcbparam_ech_value(const char * val,uint8_t * rd,size_t * rd_len)1403 sldns_str2wire_svcbparam_ech_value(const char* val, uint8_t* rd, size_t* rd_len)
1404 {
1405 uint8_t buffer[LDNS_MAX_RDFLEN];
1406 int wire_len;
1407
1408 /* single 0 represents empty buffer */
1409 if(strcmp(val, "0") == 0) {
1410 if (*rd_len < 4)
1411 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1412 sldns_write_uint16(rd, SVCB_KEY_ECH);
1413 sldns_write_uint16(rd + 2, 0);
1414 *rd_len = 4;
1415
1416 return LDNS_WIREPARSE_ERR_OK;
1417 }
1418
1419 wire_len = sldns_b64_pton(val, buffer, LDNS_MAX_RDFLEN);
1420
1421 if (wire_len <= 0) {
1422 return LDNS_WIREPARSE_ERR_SYNTAX_B64;
1423 } else if ((unsigned)wire_len + 4 > *rd_len) {
1424 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1425 } else {
1426 sldns_write_uint16(rd, SVCB_KEY_ECH);
1427 sldns_write_uint16(rd + 2, wire_len);
1428 memcpy(rd + 4, buffer, wire_len);
1429 *rd_len = 4 + wire_len;
1430
1431 return LDNS_WIREPARSE_ERR_OK;
1432 }
1433 }
1434
1435 static const char*
sldns_str2wire_svcbparam_parse_next_unescaped_comma(const char * val)1436 sldns_str2wire_svcbparam_parse_next_unescaped_comma(const char *val)
1437 {
1438 while (*val) {
1439 /* Only return when the comma is not escaped*/
1440 if (*val == '\\'){
1441 ++val;
1442 if (!*val)
1443 break;
1444 } else if (*val == ',')
1445 return val;
1446
1447 val++;
1448 }
1449 return NULL;
1450 }
1451
1452 /* The source is already properly unescaped, this double unescaping is purely to allow for
1453 * comma's in comma separated alpn lists.
1454 *
1455 * In draft-ietf-dnsop-svcb-https-06 Section 7:
1456 * To enable simpler parsing, this SvcParamValue MUST NOT contain escape sequences.
1457 */
1458 static size_t
sldns_str2wire_svcbparam_parse_copy_unescaped(uint8_t * dst,const char * src,size_t len)1459 sldns_str2wire_svcbparam_parse_copy_unescaped(uint8_t *dst,
1460 const char *src, size_t len)
1461 {
1462 uint8_t *orig_dst = dst;
1463
1464 while (len) {
1465 if (*src == '\\') {
1466 src++;
1467 len--;
1468 if (!len)
1469 break;
1470 }
1471 *dst++ = *src++;
1472 len--;
1473 }
1474 return (size_t)(dst - orig_dst);
1475 }
1476
1477 static int
sldns_str2wire_svcbparam_alpn_value(const char * val,uint8_t * rd,size_t * rd_len)1478 sldns_str2wire_svcbparam_alpn_value(const char* val,
1479 uint8_t* rd, size_t* rd_len)
1480 {
1481 uint8_t unescaped_dst[LDNS_MAX_RDFLEN];
1482 uint8_t *dst = unescaped_dst;
1483 const char *next_str;
1484 size_t str_len;
1485 size_t dst_len;
1486 size_t val_len;
1487
1488 val_len = strlen(val);
1489
1490 if (val_len > sizeof(unescaped_dst)) {
1491 return LDNS_WIREPARSE_ERR_SVCB_ALPN_KEY_TOO_LARGE;
1492 }
1493 while (val_len) {
1494 size_t key_len;
1495
1496 str_len = (next_str = sldns_str2wire_svcbparam_parse_next_unescaped_comma(val))
1497 ? (size_t)(next_str - val) : val_len;
1498
1499 if (str_len > 255) {
1500 return LDNS_WIREPARSE_ERR_SVCB_ALPN_KEY_TOO_LARGE;
1501 }
1502
1503 key_len = sldns_str2wire_svcbparam_parse_copy_unescaped(dst + 1, val, str_len);
1504 *dst++ = key_len;
1505 dst += key_len;
1506
1507 if (!next_str)
1508 break;
1509
1510 /* skip the comma in the next iteration */
1511 val_len -= next_str - val + 1;
1512 val = next_str + 1;
1513 }
1514 dst_len = dst - unescaped_dst;
1515 if (*rd_len < 4 + dst_len)
1516 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1517 sldns_write_uint16(rd, SVCB_KEY_ALPN);
1518 sldns_write_uint16(rd + 2, dst_len);
1519 memcpy(rd + 4, unescaped_dst, dst_len);
1520 *rd_len = 4 + dst_len;
1521
1522 return LDNS_WIREPARSE_ERR_OK;
1523 }
1524
1525 static int
sldns_str2wire_svcbparam_dohpath_value(const char * val,uint8_t * rd,size_t * rd_len)1526 sldns_str2wire_svcbparam_dohpath_value(const char* val,
1527 uint8_t* rd, size_t* rd_len)
1528 {
1529 size_t val_len;
1530
1531 /* RFC6570#section-2.1
1532 * "The characters outside of expressions in a URI Template string are
1533 * intended to be copied literally"
1534 * Practically this means we do not have to look for "double escapes"
1535 * like in the alpn value list.
1536 */
1537
1538 val_len = strlen(val);
1539
1540 if (*rd_len < 4 + val_len) {
1541 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1542 }
1543
1544 sldns_write_uint16(rd, SVCB_KEY_DOHPATH);
1545 sldns_write_uint16(rd + 2, val_len);
1546 memcpy(rd + 4, val, val_len);
1547 *rd_len = 4 + val_len;
1548
1549 return LDNS_WIREPARSE_ERR_OK;
1550 }
1551
1552 static int
sldns_str2wire_svcparam_value(const char * key,size_t key_len,const char * val,uint8_t * rd,size_t * rd_len)1553 sldns_str2wire_svcparam_value(const char *key, size_t key_len,
1554 const char *val, uint8_t* rd, size_t* rd_len)
1555 {
1556 size_t str_len;
1557 int svcparamkey = sldns_str2wire_svcparam_key_lookup(key, key_len);
1558
1559 if (svcparamkey < 0) {
1560 return LDNS_WIREPARSE_ERR_SVCB_UNKNOWN_KEY;
1561 }
1562
1563 /* key without value */
1564 if (val == NULL) {
1565 switch (svcparamkey) {
1566 #ifdef SVCB_SEMANTIC_ERRORS
1567 case SVCB_KEY_MANDATORY:
1568 case SVCB_KEY_ALPN:
1569 case SVCB_KEY_PORT:
1570 case SVCB_KEY_IPV4HINT:
1571 case SVCB_KEY_IPV6HINT:
1572 case SVCB_KEY_DOHPATH:
1573 return LDNS_WIREPARSE_ERR_SVCB_MISSING_PARAM;
1574 #endif
1575 default:
1576 if (*rd_len < 4)
1577 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1578 sldns_write_uint16(rd, svcparamkey);
1579 sldns_write_uint16(rd + 2, 0);
1580 *rd_len = 4;
1581
1582 return LDNS_WIREPARSE_ERR_OK;
1583 }
1584 }
1585
1586 /* value is non-empty */
1587 switch (svcparamkey) {
1588 case SVCB_KEY_PORT:
1589 return sldns_str2wire_svcparam_port(val, rd, rd_len);
1590 case SVCB_KEY_IPV4HINT:
1591 return sldns_str2wire_svcbparam_ipv4hint(val, rd, rd_len);
1592 case SVCB_KEY_IPV6HINT:
1593 return sldns_str2wire_svcbparam_ipv6hint(val, rd, rd_len);
1594 case SVCB_KEY_MANDATORY:
1595 return sldns_str2wire_svcbparam_mandatory(val, rd, rd_len);
1596 #ifdef SVCB_SEMANTIC_ERRORS
1597 case SVCB_KEY_NO_DEFAULT_ALPN:
1598 return LDNS_WIREPARSE_ERR_SVCB_NO_DEFAULT_ALPN_VALUE;
1599 #endif
1600 case SVCB_KEY_ECH:
1601 return sldns_str2wire_svcbparam_ech_value(val, rd, rd_len);
1602 case SVCB_KEY_ALPN:
1603 return sldns_str2wire_svcbparam_alpn_value(val, rd, rd_len);
1604 case SVCB_KEY_DOHPATH:
1605 return sldns_str2wire_svcbparam_dohpath_value(val, rd, rd_len);
1606 default:
1607 str_len = strlen(val);
1608 if (*rd_len < 4 + str_len)
1609 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1610 sldns_write_uint16(rd, svcparamkey);
1611 sldns_write_uint16(rd + 2, str_len);
1612 memcpy(rd + 4, val, str_len);
1613 *rd_len = 4 + str_len;
1614
1615 return LDNS_WIREPARSE_ERR_OK;
1616 }
1617
1618 return LDNS_WIREPARSE_ERR_GENERAL;
1619 }
1620
sldns_str2wire_svcparam_buf(const char * str,uint8_t * rd,size_t * rd_len)1621 static int sldns_str2wire_svcparam_buf(const char* str, uint8_t* rd, size_t* rd_len)
1622 {
1623 const char* eq_pos;
1624 char unescaped_val[LDNS_MAX_RDFLEN];
1625 char* val_out = unescaped_val;
1626 const char* val_in;
1627
1628 eq_pos = strchr(str, '=');
1629
1630 /* case: key=value */
1631 if (eq_pos != NULL && eq_pos[1]) {
1632 val_in = eq_pos + 1;
1633
1634 /* unescape characters and "" blocks */
1635 if (*val_in == '"') {
1636 val_in++;
1637 while (*val_in != '"'
1638 && (size_t)(val_out - unescaped_val + 1) < sizeof(unescaped_val)
1639 && sldns_parse_char( (uint8_t*) val_out, &val_in)) {
1640 val_out++;
1641 }
1642 } else {
1643 while ((size_t)(val_out - unescaped_val + 1) < sizeof(unescaped_val)
1644 && sldns_parse_char( (uint8_t*) val_out, &val_in)) {
1645 val_out++;
1646 }
1647 }
1648 *val_out = 0;
1649
1650 return sldns_str2wire_svcparam_value(str, eq_pos - str,
1651 unescaped_val[0] ? unescaped_val : NULL, rd, rd_len);
1652 }
1653 /* case: key= */
1654 else if (eq_pos != NULL && !(eq_pos[1])) {
1655 return sldns_str2wire_svcparam_value(str, eq_pos - str, NULL, rd, rd_len);
1656 }
1657 /* case: key */
1658 else {
1659 return sldns_str2wire_svcparam_value(str, strlen(str), NULL, rd, rd_len);
1660 }
1661 }
1662
sldns_str2wire_rdf_buf(const char * str,uint8_t * rd,size_t * len,sldns_rdf_type rdftype)1663 int sldns_str2wire_rdf_buf(const char* str, uint8_t* rd, size_t* len,
1664 sldns_rdf_type rdftype)
1665 {
1666 switch (rdftype) {
1667 case LDNS_RDF_TYPE_DNAME:
1668 return sldns_str2wire_dname_buf(str, rd, len);
1669 case LDNS_RDF_TYPE_INT8:
1670 return sldns_str2wire_int8_buf(str, rd, len);
1671 case LDNS_RDF_TYPE_INT16:
1672 return sldns_str2wire_int16_buf(str, rd, len);
1673 case LDNS_RDF_TYPE_INT32:
1674 return sldns_str2wire_int32_buf(str, rd, len);
1675 case LDNS_RDF_TYPE_A:
1676 return sldns_str2wire_a_buf(str, rd, len);
1677 case LDNS_RDF_TYPE_AAAA:
1678 return sldns_str2wire_aaaa_buf(str, rd, len);
1679 case LDNS_RDF_TYPE_STR:
1680 return sldns_str2wire_str_buf(str, rd, len);
1681 case LDNS_RDF_TYPE_APL:
1682 return sldns_str2wire_apl_buf(str, rd, len);
1683 case LDNS_RDF_TYPE_B64:
1684 return sldns_str2wire_b64_buf(str, rd, len);
1685 case LDNS_RDF_TYPE_B32_EXT:
1686 return sldns_str2wire_b32_ext_buf(str, rd, len);
1687 case LDNS_RDF_TYPE_HEX:
1688 return sldns_str2wire_hex_buf(str, rd, len);
1689 case LDNS_RDF_TYPE_NSEC:
1690 return sldns_str2wire_nsec_buf(str, rd, len);
1691 case LDNS_RDF_TYPE_TYPE:
1692 return sldns_str2wire_type_buf(str, rd, len);
1693 case LDNS_RDF_TYPE_CLASS:
1694 return sldns_str2wire_class_buf(str, rd, len);
1695 case LDNS_RDF_TYPE_CERT_ALG:
1696 return sldns_str2wire_cert_alg_buf(str, rd, len);
1697 case LDNS_RDF_TYPE_ALG:
1698 return sldns_str2wire_alg_buf(str, rd, len);
1699 case LDNS_RDF_TYPE_TIME:
1700 return sldns_str2wire_time_buf(str, rd, len);
1701 case LDNS_RDF_TYPE_PERIOD:
1702 return sldns_str2wire_period_buf(str, rd, len);
1703 case LDNS_RDF_TYPE_TSIGTIME:
1704 return sldns_str2wire_tsigtime_buf(str, rd, len);
1705 case LDNS_RDF_TYPE_LOC:
1706 return sldns_str2wire_loc_buf(str, rd, len);
1707 case LDNS_RDF_TYPE_WKS:
1708 return sldns_str2wire_wks_buf(str, rd, len);
1709 case LDNS_RDF_TYPE_NSAP:
1710 return sldns_str2wire_nsap_buf(str, rd, len);
1711 case LDNS_RDF_TYPE_ATMA:
1712 return sldns_str2wire_atma_buf(str, rd, len);
1713 case LDNS_RDF_TYPE_IPSECKEY:
1714 return sldns_str2wire_ipseckey_buf(str, rd, len);
1715 case LDNS_RDF_TYPE_NSEC3_SALT:
1716 return sldns_str2wire_nsec3_salt_buf(str, rd, len);
1717 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
1718 return sldns_str2wire_b32_ext_buf(str, rd, len);
1719 case LDNS_RDF_TYPE_ILNP64:
1720 return sldns_str2wire_ilnp64_buf(str, rd, len);
1721 case LDNS_RDF_TYPE_EUI48:
1722 return sldns_str2wire_eui48_buf(str, rd, len);
1723 case LDNS_RDF_TYPE_EUI64:
1724 return sldns_str2wire_eui64_buf(str, rd, len);
1725 case LDNS_RDF_TYPE_UNQUOTED:
1726 return sldns_str2wire_unquoted_buf(str, rd, len);
1727 case LDNS_RDF_TYPE_TAG:
1728 return sldns_str2wire_tag_buf(str, rd, len);
1729 case LDNS_RDF_TYPE_LONG_STR:
1730 return sldns_str2wire_long_str_buf(str, rd, len);
1731 case LDNS_RDF_TYPE_TSIGERROR:
1732 return sldns_str2wire_tsigerror_buf(str, rd, len);
1733 case LDNS_RDF_TYPE_HIP:
1734 return sldns_str2wire_hip_buf(str, rd, len);
1735 case LDNS_RDF_TYPE_INT16_DATA:
1736 return sldns_str2wire_int16_data_buf(str, rd, len);
1737 case LDNS_RDF_TYPE_SVCPARAM:
1738 return sldns_str2wire_svcparam_buf(str, rd, len);
1739 case LDNS_RDF_TYPE_UNKNOWN:
1740 case LDNS_RDF_TYPE_SERVICE:
1741 return LDNS_WIREPARSE_ERR_NOT_IMPL;
1742 case LDNS_RDF_TYPE_NONE:
1743 default:
1744 break;
1745 }
1746 return LDNS_WIREPARSE_ERR_GENERAL;
1747 }
1748
sldns_str2wire_int8_buf(const char * str,uint8_t * rd,size_t * len)1749 int sldns_str2wire_int8_buf(const char* str, uint8_t* rd, size_t* len)
1750 {
1751 char* end;
1752 uint8_t r = (uint8_t)strtol((char*)str, &end, 10);
1753 if(*end != 0)
1754 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, end-(char*)str);
1755 if(*len < 1)
1756 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1757 rd[0] = r;
1758 *len = 1;
1759 return LDNS_WIREPARSE_ERR_OK;
1760 }
1761
sldns_str2wire_int16_buf(const char * str,uint8_t * rd,size_t * len)1762 int sldns_str2wire_int16_buf(const char* str, uint8_t* rd, size_t* len)
1763 {
1764 char* end;
1765 uint16_t r = (uint16_t)strtol((char*)str, &end, 10);
1766 if(*end != 0)
1767 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, end-(char*)str);
1768 if(*len < 2)
1769 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1770 sldns_write_uint16(rd, r);
1771 *len = 2;
1772 return LDNS_WIREPARSE_ERR_OK;
1773 }
1774
sldns_str2wire_int32_buf(const char * str,uint8_t * rd,size_t * len)1775 int sldns_str2wire_int32_buf(const char* str, uint8_t* rd, size_t* len)
1776 {
1777 char* end;
1778 uint32_t r;
1779 errno = 0; /* must set to zero before call,
1780 note race condition on errno */
1781 if(*str == '-')
1782 r = (uint32_t)strtol((char*)str, &end, 10);
1783 else r = (uint32_t)strtoul((char*)str, &end, 10);
1784 if(*end != 0)
1785 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, end-(char*)str);
1786 if(errno == ERANGE)
1787 return LDNS_WIREPARSE_ERR_SYNTAX_INTEGER_OVERFLOW;
1788 if(*len < 4)
1789 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1790 sldns_write_uint32(rd, r);
1791 *len = 4;
1792 return LDNS_WIREPARSE_ERR_OK;
1793 }
1794
sldns_str2wire_a_buf(const char * str,uint8_t * rd,size_t * len)1795 int sldns_str2wire_a_buf(const char* str, uint8_t* rd, size_t* len)
1796 {
1797 struct in_addr address;
1798 if(inet_pton(AF_INET, (char*)str, &address) != 1)
1799 return LDNS_WIREPARSE_ERR_SYNTAX_IP4;
1800 if(*len < sizeof(address))
1801 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1802 memmove(rd, &address, sizeof(address));
1803 *len = sizeof(address);
1804 return LDNS_WIREPARSE_ERR_OK;
1805 }
1806
sldns_str2wire_aaaa_buf(const char * str,uint8_t * rd,size_t * len)1807 int sldns_str2wire_aaaa_buf(const char* str, uint8_t* rd, size_t* len)
1808 {
1809 #ifdef AF_INET6
1810 uint8_t address[LDNS_IP6ADDRLEN + 1];
1811 if(inet_pton(AF_INET6, (char*)str, address) != 1)
1812 return LDNS_WIREPARSE_ERR_SYNTAX_IP6;
1813 if(*len < LDNS_IP6ADDRLEN)
1814 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1815 memmove(rd, address, LDNS_IP6ADDRLEN);
1816 *len = LDNS_IP6ADDRLEN;
1817 return LDNS_WIREPARSE_ERR_OK;
1818 #else
1819 return LDNS_WIREPARSE_ERR_NOT_IMPL;
1820 #endif
1821 }
1822
sldns_str2wire_str_buf(const char * str,uint8_t * rd,size_t * len)1823 int sldns_str2wire_str_buf(const char* str, uint8_t* rd, size_t* len)
1824 {
1825 uint8_t ch = 0;
1826 size_t sl = 0;
1827 const char* s = str;
1828 /* skip length byte */
1829 if(*len < 1)
1830 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1831
1832 /* read characters */
1833 while(sldns_parse_char(&ch, &s)) {
1834 if(sl >= 255)
1835 return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, s-str);
1836 if(*len < sl+2)
1837 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
1838 s-str);
1839 rd[++sl] = ch;
1840 }
1841 if(!s)
1842 return LDNS_WIREPARSE_ERR_SYNTAX_BAD_ESCAPE;
1843 rd[0] = (uint8_t)sl;
1844 *len = sl+1;
1845 return LDNS_WIREPARSE_ERR_OK;
1846 }
1847
sldns_str2wire_apl_buf(const char * str,uint8_t * rd,size_t * len)1848 int sldns_str2wire_apl_buf(const char* str, uint8_t* rd, size_t* len)
1849 {
1850 const char *my_str = str;
1851
1852 char my_ip_str[64];
1853 size_t ip_str_len;
1854
1855 uint16_t family;
1856 int negation;
1857 size_t adflength = 0;
1858 uint8_t data[16+4];
1859 uint8_t prefix;
1860 size_t i;
1861
1862 if(*my_str == '\0') {
1863 /* empty APL element, no data, no string */
1864 *len = 0;
1865 return LDNS_WIREPARSE_ERR_OK;
1866 }
1867
1868 /* [!]afi:address/prefix */
1869 if (strlen(my_str) < 2
1870 || strchr(my_str, ':') == NULL
1871 || strchr(my_str, '/') == NULL
1872 || strchr(my_str, ':') > strchr(my_str, '/')) {
1873 return LDNS_WIREPARSE_ERR_INVALID_STR;
1874 }
1875
1876 if (my_str[0] == '!') {
1877 negation = 1;
1878 my_str += 1;
1879 } else {
1880 negation = 0;
1881 }
1882
1883 family = (uint16_t) atoi(my_str);
1884
1885 my_str = strchr(my_str, ':') + 1;
1886
1887 /* need ip addr and only ip addr for inet_pton */
1888 ip_str_len = (size_t) (strchr(my_str, '/') - my_str);
1889 if(ip_str_len+1 > sizeof(my_ip_str))
1890 return LDNS_WIREPARSE_ERR_INVALID_STR;
1891 (void)strlcpy(my_ip_str, my_str, sizeof(my_ip_str));
1892 my_ip_str[ip_str_len] = 0;
1893
1894 if (family == 1) {
1895 /* ipv4 */
1896 if(inet_pton(AF_INET, my_ip_str, data+4) == 0)
1897 return LDNS_WIREPARSE_ERR_INVALID_STR;
1898 for (i = 0; i < 4; i++) {
1899 if (data[i+4] != 0) {
1900 adflength = i + 1;
1901 }
1902 }
1903 } else if (family == 2) {
1904 /* ipv6 */
1905 if (inet_pton(AF_INET6, my_ip_str, data+4) == 0)
1906 return LDNS_WIREPARSE_ERR_INVALID_STR;
1907 for (i = 0; i < 16; i++) {
1908 if (data[i+4] != 0) {
1909 adflength = i + 1;
1910 }
1911 }
1912 } else {
1913 /* unknown family */
1914 return LDNS_WIREPARSE_ERR_INVALID_STR;
1915 }
1916
1917 my_str = strchr(my_str, '/') + 1;
1918 prefix = (uint8_t) atoi(my_str);
1919
1920 sldns_write_uint16(data, family);
1921 data[2] = prefix;
1922 data[3] = (uint8_t)adflength;
1923 if (negation) {
1924 /* set bit 1 of byte 3 */
1925 data[3] = data[3] | 0x80;
1926 }
1927
1928 if(*len < 4+adflength)
1929 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1930 memmove(rd, data, 4+adflength);
1931 *len = 4+adflength;
1932 return LDNS_WIREPARSE_ERR_OK;
1933 }
1934
sldns_str2wire_b64_buf(const char * str,uint8_t * rd,size_t * len)1935 int sldns_str2wire_b64_buf(const char* str, uint8_t* rd, size_t* len)
1936 {
1937 size_t sz = sldns_b64_pton_calculate_size(strlen(str));
1938 int n;
1939 if(strcmp(str, "0") == 0) {
1940 *len = 0;
1941 return LDNS_WIREPARSE_ERR_OK;
1942 }
1943 if(*len < sz)
1944 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1945 n = sldns_b64_pton(str, rd, *len);
1946 if(n < 0)
1947 return LDNS_WIREPARSE_ERR_SYNTAX_B64;
1948 *len = (size_t)n;
1949 return LDNS_WIREPARSE_ERR_OK;
1950 }
1951
sldns_str2wire_b32_ext_buf(const char * str,uint8_t * rd,size_t * len)1952 int sldns_str2wire_b32_ext_buf(const char* str, uint8_t* rd, size_t* len)
1953 {
1954 size_t slen = strlen(str);
1955 size_t sz = sldns_b32_pton_calculate_size(slen);
1956 int n;
1957 if(*len < 1+sz)
1958 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
1959 rd[0] = (uint8_t)sz;
1960 n = sldns_b32_pton_extended_hex(str, slen, rd+1, *len-1);
1961 if(n < 0)
1962 return LDNS_WIREPARSE_ERR_SYNTAX_B32_EXT;
1963 *len = (size_t)n+1;
1964 return LDNS_WIREPARSE_ERR_OK;
1965 }
1966
1967 /** see if the string ends, or ends in whitespace */
1968 static int
sldns_is_last_of_string(const char * str)1969 sldns_is_last_of_string(const char* str)
1970 {
1971 if(*str == 0) return 1;
1972 while(isspace((unsigned char)*str))
1973 str++;
1974 if(*str == 0) return 1;
1975 return 0;
1976 }
1977
sldns_str2wire_hex_buf(const char * str,uint8_t * rd,size_t * len)1978 int sldns_str2wire_hex_buf(const char* str, uint8_t* rd, size_t* len)
1979 {
1980 const char* s = str;
1981 size_t dlen = 0; /* number of hexdigits parsed */
1982 while(*s) {
1983 if(isspace((unsigned char)*s)) {
1984 s++;
1985 continue;
1986 }
1987 if(dlen == 0 && *s == '0' && sldns_is_last_of_string(s+1)) {
1988 *len = 0;
1989 return LDNS_WIREPARSE_ERR_OK;
1990 }
1991 if(!isxdigit((unsigned char)*s))
1992 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str);
1993 if(*len < dlen/2 + 1)
1994 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
1995 s-str);
1996 if((dlen&1)==0)
1997 rd[dlen/2] = (uint8_t)sldns_hexdigit_to_int(*s++) * 16;
1998 else rd[dlen/2] += (uint8_t)sldns_hexdigit_to_int(*s++);
1999 dlen++;
2000 }
2001 if((dlen&1)!=0)
2002 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str);
2003 *len = dlen/2;
2004 return LDNS_WIREPARSE_ERR_OK;
2005 }
2006
sldns_str2wire_nsec_buf(const char * str,uint8_t * rd,size_t * len)2007 int sldns_str2wire_nsec_buf(const char* str, uint8_t* rd, size_t* len)
2008 {
2009 const char *delim = "\n\t ";
2010 char token[64]; /* for a type name */
2011 size_t type_count = 0;
2012 int block;
2013 size_t used = 0;
2014 uint16_t maxtype = 0;
2015 uint8_t typebits[8192]; /* 65536 bits */
2016 uint8_t window_in_use[256];
2017
2018 /* string in buffer */
2019 sldns_buffer strbuf;
2020 sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
2021
2022 /* parse the types */
2023 memset(typebits, 0, sizeof(typebits));
2024 memset(window_in_use, 0, sizeof(window_in_use));
2025 while(sldns_buffer_remaining(&strbuf) > 0 &&
2026 sldns_bget_token(&strbuf, token, delim, sizeof(token)) != -1) {
2027 uint16_t t = sldns_get_rr_type_by_name(token);
2028 if(token[0] == 0)
2029 continue;
2030 if(t == 0 && strcmp(token, "TYPE0") != 0)
2031 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE,
2032 sldns_buffer_position(&strbuf));
2033 typebits[t/8] |= (0x80>>(t%8));
2034 window_in_use[t/256] = 1;
2035 type_count++;
2036 if(t > maxtype) maxtype = t;
2037 }
2038
2039 /* empty NSEC bitmap */
2040 if(type_count == 0) {
2041 *len = 0;
2042 return LDNS_WIREPARSE_ERR_OK;
2043 }
2044
2045 /* encode windows {u8 windowblock, u8 bitmaplength, 0-32u8 bitmap},
2046 * block is 0-255 upper octet of types, length if 0-32. */
2047 for(block = 0; block <= (int)maxtype/256; block++) {
2048 int i, blocklen = 0;
2049 if(!window_in_use[block])
2050 continue;
2051 for(i=0; i<32; i++) {
2052 if(typebits[block*32+i] != 0)
2053 blocklen = i+1;
2054 }
2055 if(blocklen == 0)
2056 continue; /* empty window should have been !in_use */
2057 if(used+blocklen+2 > *len)
2058 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2059 rd[used+0] = (uint8_t)block;
2060 rd[used+1] = (uint8_t)blocklen;
2061 for(i=0; i<blocklen; i++) {
2062 rd[used+2+i] = typebits[block*32+i];
2063 }
2064 used += blocklen+2;
2065 }
2066 *len = used;
2067 return LDNS_WIREPARSE_ERR_OK;
2068 }
2069
sldns_str2wire_type_buf(const char * str,uint8_t * rd,size_t * len)2070 int sldns_str2wire_type_buf(const char* str, uint8_t* rd, size_t* len)
2071 {
2072 uint16_t t = sldns_get_rr_type_by_name(str);
2073 if(t == 0 && strcmp(str, "TYPE0") != 0)
2074 return LDNS_WIREPARSE_ERR_SYNTAX_TYPE;
2075 if(*len < 2)
2076 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2077 sldns_write_uint16(rd, t);
2078 *len = 2;
2079 return LDNS_WIREPARSE_ERR_OK;
2080 }
2081
sldns_str2wire_class_buf(const char * str,uint8_t * rd,size_t * len)2082 int sldns_str2wire_class_buf(const char* str, uint8_t* rd, size_t* len)
2083 {
2084 uint16_t c = sldns_get_rr_class_by_name(str);
2085 if(c == 0 && strcmp(str, "CLASS0") != 0)
2086 return LDNS_WIREPARSE_ERR_SYNTAX_CLASS;
2087 if(*len < 2)
2088 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2089 sldns_write_uint16(rd, c);
2090 *len = 2;
2091 return LDNS_WIREPARSE_ERR_OK;
2092 }
2093
2094 /* An certificate alg field can either be specified as a 8 bits number
2095 * or by its symbolic name. Handle both */
sldns_str2wire_cert_alg_buf(const char * str,uint8_t * rd,size_t * len)2096 int sldns_str2wire_cert_alg_buf(const char* str, uint8_t* rd, size_t* len)
2097 {
2098 sldns_lookup_table *lt = sldns_lookup_by_name(sldns_cert_algorithms,
2099 str);
2100 if(*len < 2)
2101 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2102 if(lt) {
2103 sldns_write_uint16(rd, (uint16_t)lt->id);
2104 } else {
2105 int s = sldns_str2wire_int16_buf(str, rd, len);
2106 if(s) return s;
2107 if(sldns_read_uint16(rd) == 0)
2108 return LDNS_WIREPARSE_ERR_CERT_BAD_ALGORITHM;
2109 }
2110 *len = 2;
2111 return LDNS_WIREPARSE_ERR_OK;
2112 }
2113
2114 /* An alg field can either be specified as a 8 bits number
2115 * or by its symbolic name. Handle both */
sldns_str2wire_alg_buf(const char * str,uint8_t * rd,size_t * len)2116 int sldns_str2wire_alg_buf(const char* str, uint8_t* rd, size_t* len)
2117 {
2118 sldns_lookup_table *lt = sldns_lookup_by_name(sldns_algorithms, str);
2119 if(*len < 1)
2120 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2121 if(lt) {
2122 rd[0] = (uint8_t)lt->id;
2123 *len = 1;
2124 } else {
2125 /* try as-is (a number) */
2126 return sldns_str2wire_int8_buf(str, rd, len);
2127 }
2128 return LDNS_WIREPARSE_ERR_OK;
2129 }
2130
sldns_str2wire_tsigerror_buf(const char * str,uint8_t * rd,size_t * len)2131 int sldns_str2wire_tsigerror_buf(const char* str, uint8_t* rd, size_t* len)
2132 {
2133 sldns_lookup_table *lt = sldns_lookup_by_name(sldns_tsig_errors, str);
2134 if(*len < 2)
2135 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2136 if(lt) {
2137 sldns_write_uint16(rd, (uint16_t)lt->id);
2138 *len = 2;
2139 } else {
2140 /* try as-is (a number) */
2141 return sldns_str2wire_int16_buf(str, rd, len);
2142 }
2143 return LDNS_WIREPARSE_ERR_OK;
2144 }
2145
sldns_str2wire_time_buf(const char * str,uint8_t * rd,size_t * len)2146 int sldns_str2wire_time_buf(const char* str, uint8_t* rd, size_t* len)
2147 {
2148 /* convert a time YYYYDDMMHHMMSS to wireformat */
2149 struct tm tm;
2150 if(*len < 4)
2151 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2152
2153 /* Try to scan the time... */
2154 memset(&tm, 0, sizeof(tm));
2155 if (strlen(str) == 14 && sscanf(str, "%4d%2d%2d%2d%2d%2d",
2156 &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour,
2157 &tm.tm_min, &tm.tm_sec) == 6) {
2158 tm.tm_year -= 1900;
2159 tm.tm_mon--;
2160 /* Check values */
2161 if (tm.tm_year < 70)
2162 return LDNS_WIREPARSE_ERR_SYNTAX_TIME;
2163 if (tm.tm_mon < 0 || tm.tm_mon > 11)
2164 return LDNS_WIREPARSE_ERR_SYNTAX_TIME;
2165 if (tm.tm_mday < 1 || tm.tm_mday > 31)
2166 return LDNS_WIREPARSE_ERR_SYNTAX_TIME;
2167 if (tm.tm_hour < 0 || tm.tm_hour > 23)
2168 return LDNS_WIREPARSE_ERR_SYNTAX_TIME;
2169 if (tm.tm_min < 0 || tm.tm_min > 59)
2170 return LDNS_WIREPARSE_ERR_SYNTAX_TIME;
2171 if (tm.tm_sec < 0 || tm.tm_sec > 59)
2172 return LDNS_WIREPARSE_ERR_SYNTAX_TIME;
2173
2174 sldns_write_uint32(rd, (uint32_t)sldns_mktime_from_utc(&tm));
2175 } else {
2176 /* handle it as 32 bits timestamp */
2177 char *end;
2178 uint32_t l = (uint32_t)strtol((char*)str, &end, 10);
2179 if(*end != 0)
2180 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TIME,
2181 end-(char*)str);
2182 sldns_write_uint32(rd, l);
2183 }
2184 *len = 4;
2185 return LDNS_WIREPARSE_ERR_OK;
2186 }
2187
sldns_str2wire_tsigtime_buf(const char * str,uint8_t * rd,size_t * len)2188 int sldns_str2wire_tsigtime_buf(const char* str, uint8_t* rd, size_t* len)
2189 {
2190 char* end;
2191 uint64_t t = (uint64_t)strtol((char*)str, &end, 10);
2192 uint16_t high;
2193 uint32_t low;
2194 if(*end != 0)
2195 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TIME, end-str);
2196 if(*len < 6)
2197 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2198 high = (uint16_t)(t>>32);
2199 low = (uint32_t)(t);
2200 sldns_write_uint16(rd, high);
2201 sldns_write_uint32(rd+2, low);
2202 *len = 6;
2203 return LDNS_WIREPARSE_ERR_OK;
2204 }
2205
sldns_str2wire_period_buf(const char * str,uint8_t * rd,size_t * len)2206 int sldns_str2wire_period_buf(const char* str, uint8_t* rd, size_t* len)
2207 {
2208 const char* end;
2209 int overflow;
2210 uint32_t p = sldns_str2period(str, &end, &overflow);
2211 if(*end != 0)
2212 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_PERIOD, end-str);
2213 if(overflow)
2214 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INTEGER_OVERFLOW,
2215 end-str);
2216 if(*len < 4)
2217 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2218 sldns_write_uint32(rd, p);
2219 *len = 4;
2220 return LDNS_WIREPARSE_ERR_OK;
2221 }
2222
2223 /** read "<digits>[.<digits>][mM]" into mantissa exponent format for LOC type */
2224 static int
loc_parse_cm(char * my_str,char ** endstr,uint8_t * m,uint8_t * e)2225 loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e)
2226 {
2227 uint32_t meters = 0, cm = 0, val;
2228 char* cm_endstr;
2229 while (isblank((unsigned char)*my_str)) {
2230 my_str++;
2231 }
2232 meters = (uint32_t)strtol(my_str, &my_str, 10);
2233 if (*my_str == '.') {
2234 my_str++;
2235 cm = (uint32_t)strtol(my_str, &cm_endstr, 10);
2236 if(cm_endstr == my_str + 1)
2237 cm *= 10;
2238 my_str = cm_endstr;
2239 }
2240 if (meters >= 1) {
2241 *e = 2;
2242 val = meters;
2243 } else {
2244 *e = 0;
2245 val = cm;
2246 }
2247 while(val >= 10) {
2248 (*e)++;
2249 val /= 10;
2250 }
2251 *m = (uint8_t)val;
2252
2253 if (*e > 9)
2254 return 0;
2255 if (*my_str == 'm' || *my_str == 'M') {
2256 my_str++;
2257 }
2258 *endstr = my_str;
2259 return 1;
2260 }
2261
sldns_str2wire_loc_buf(const char * str,uint8_t * rd,size_t * len)2262 int sldns_str2wire_loc_buf(const char* str, uint8_t* rd, size_t* len)
2263 {
2264 uint32_t latitude = 0;
2265 uint32_t longitude = 0;
2266 uint32_t altitude = 0;
2267
2268 uint32_t equator = (uint32_t)1<<31; /* 2**31 */
2269
2270 /* only support version 0 */
2271 uint32_t h = 0;
2272 uint32_t m = 0;
2273 uint8_t size_b = 1, size_e = 2;
2274 uint8_t horiz_pre_b = 1, horiz_pre_e = 6;
2275 uint8_t vert_pre_b = 1, vert_pre_e = 3;
2276
2277 double s = 0.0;
2278 int northerness;
2279 int easterness;
2280
2281 char *my_str = (char *) str;
2282
2283 if (isdigit((unsigned char) *my_str)) {
2284 h = (uint32_t) strtol(my_str, &my_str, 10);
2285 } else {
2286 return LDNS_WIREPARSE_ERR_INVALID_STR;
2287 }
2288
2289 while (isblank((unsigned char) *my_str)) {
2290 my_str++;
2291 }
2292
2293 if (isdigit((unsigned char) *my_str)) {
2294 m = (uint32_t) strtol(my_str, &my_str, 10);
2295 } else if (*my_str == 'N' || *my_str == 'S') {
2296 goto north;
2297 } else {
2298 return LDNS_WIREPARSE_ERR_INVALID_STR;
2299 }
2300
2301 while (isblank((unsigned char) *my_str)) {
2302 my_str++;
2303 }
2304
2305 if (isdigit((unsigned char) *my_str)) {
2306 s = strtod(my_str, &my_str);
2307 }
2308
2309 /* skip blanks before northerness */
2310 while (isblank((unsigned char) *my_str)) {
2311 my_str++;
2312 }
2313
2314 north:
2315 if (*my_str == 'N') {
2316 northerness = 1;
2317 } else if (*my_str == 'S') {
2318 northerness = 0;
2319 } else {
2320 return LDNS_WIREPARSE_ERR_INVALID_STR;
2321 }
2322
2323 my_str++;
2324
2325 /* store number */
2326 s = 1000.0 * s;
2327 /* add a little to make floor in conversion a round */
2328 s += 0.0005;
2329 latitude = (uint32_t) s;
2330 latitude += 1000 * 60 * m;
2331 latitude += 1000 * 60 * 60 * h;
2332 if (northerness) {
2333 latitude = equator + latitude;
2334 } else {
2335 latitude = equator - latitude;
2336 }
2337 while (isblank((unsigned char)*my_str)) {
2338 my_str++;
2339 }
2340
2341 if (isdigit((unsigned char) *my_str)) {
2342 h = (uint32_t) strtol(my_str, &my_str, 10);
2343 } else {
2344 return LDNS_WIREPARSE_ERR_INVALID_STR;
2345 }
2346
2347 while (isblank((unsigned char) *my_str)) {
2348 my_str++;
2349 }
2350
2351 if (isdigit((unsigned char) *my_str)) {
2352 m = (uint32_t) strtol(my_str, &my_str, 10);
2353 } else if (*my_str == 'E' || *my_str == 'W') {
2354 goto east;
2355 } else {
2356 return LDNS_WIREPARSE_ERR_INVALID_STR;
2357 }
2358
2359 while (isblank((unsigned char)*my_str)) {
2360 my_str++;
2361 }
2362
2363 if (isdigit((unsigned char) *my_str)) {
2364 s = strtod(my_str, &my_str);
2365 }
2366
2367 /* skip blanks before easterness */
2368 while (isblank((unsigned char)*my_str)) {
2369 my_str++;
2370 }
2371
2372 east:
2373 if (*my_str == 'E') {
2374 easterness = 1;
2375 } else if (*my_str == 'W') {
2376 easterness = 0;
2377 } else {
2378 return LDNS_WIREPARSE_ERR_INVALID_STR;
2379 }
2380
2381 my_str++;
2382
2383 /* store number */
2384 s *= 1000.0;
2385 /* add a little to make floor in conversion a round */
2386 s += 0.0005;
2387 longitude = (uint32_t) s;
2388 longitude += 1000 * 60 * m;
2389 longitude += 1000 * 60 * 60 * h;
2390
2391 if (easterness) {
2392 longitude += equator;
2393 } else {
2394 longitude = equator - longitude;
2395 }
2396
2397 altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 +
2398 10000000.0 + 0.5);
2399 if (*my_str == 'm' || *my_str == 'M') {
2400 my_str++;
2401 }
2402
2403 if (strlen(my_str) > 0) {
2404 if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e))
2405 return LDNS_WIREPARSE_ERR_INVALID_STR;
2406 }
2407
2408 if (strlen(my_str) > 0) {
2409 if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e))
2410 return LDNS_WIREPARSE_ERR_INVALID_STR;
2411 }
2412
2413 if (strlen(my_str) > 0) {
2414 if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e))
2415 return LDNS_WIREPARSE_ERR_INVALID_STR;
2416 }
2417
2418 if(*len < 16)
2419 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2420 rd[0] = 0;
2421 rd[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f);
2422 rd[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f);
2423 rd[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f);
2424 sldns_write_uint32(rd + 4, latitude);
2425 sldns_write_uint32(rd + 8, longitude);
2426 sldns_write_uint32(rd + 12, altitude);
2427 *len = 16;
2428 return LDNS_WIREPARSE_ERR_OK;
2429 }
2430
2431 static void
ldns_tolower_str(char * s)2432 ldns_tolower_str(char* s)
2433 {
2434 if(s) {
2435 while(*s) {
2436 *s = (char)tolower((unsigned char)*s);
2437 s++;
2438 }
2439 }
2440 }
2441
sldns_str2wire_wks_buf(const char * str,uint8_t * rd,size_t * len)2442 int sldns_str2wire_wks_buf(const char* str, uint8_t* rd, size_t* len)
2443 {
2444 int rd_len = 1;
2445 int have_proto = 0;
2446 char token[50], proto_str[50];
2447 sldns_buffer strbuf;
2448 sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
2449 proto_str[0]=0;
2450
2451 /* check we have one byte for proto */
2452 if(*len < 1)
2453 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2454
2455 while(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) > 0) {
2456 ldns_tolower_str(token);
2457 if(!have_proto) {
2458 struct protoent *p = getprotobyname(token);
2459 have_proto = 1;
2460 if(p) rd[0] = (uint8_t)p->p_proto;
2461 else if(strcasecmp(token, "tcp")==0) rd[0]=6;
2462 else if(strcasecmp(token, "udp")==0) rd[0]=17;
2463 else rd[0] = (uint8_t)atoi(token);
2464 (void)strlcpy(proto_str, token, sizeof(proto_str));
2465 } else {
2466 int serv_port;
2467 if(atoi(token) != 0) serv_port=atoi(token);
2468 else if(strcmp(token, "0") == 0) serv_port=0;
2469 else if(strcasecmp(token, "domain")==0) serv_port=53;
2470 else {
2471 struct servent *serv = getservbyname(token, proto_str);
2472 if(serv) serv_port=(int)ntohs((uint16_t)serv->s_port);
2473 else {
2474 #ifdef HAVE_ENDSERVENT
2475 endservent();
2476 #endif
2477 #ifdef HAVE_ENDPROTOENT
2478 endprotoent();
2479 #endif
2480 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX,
2481 sldns_buffer_position(&strbuf));
2482 }
2483 }
2484 if(serv_port < 0 || serv_port > 65535) {
2485 #ifdef HAVE_ENDSERVENT
2486 endservent();
2487 #endif
2488 #ifdef HAVE_ENDPROTOENT
2489 endprotoent();
2490 #endif
2491 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX,
2492 sldns_buffer_position(&strbuf));
2493 }
2494 if(rd_len < 1+serv_port/8+1) {
2495 /* bitmap is larger, init new bytes at 0 */
2496 if(*len < 1+(size_t)serv_port/8+1) {
2497 #ifdef HAVE_ENDSERVENT
2498 endservent();
2499 #endif
2500 #ifdef HAVE_ENDPROTOENT
2501 endprotoent();
2502 #endif
2503 return RET_ERR(
2504 LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
2505 sldns_buffer_position(&strbuf));
2506 }
2507 memset(rd+rd_len, 0, 1+(size_t)serv_port/8+1-rd_len);
2508 rd_len = 1+serv_port/8+1;
2509 }
2510 rd[1+ serv_port/8] |= (1 << (7 - serv_port % 8));
2511 }
2512 }
2513 *len = (size_t)rd_len;
2514
2515 #ifdef HAVE_ENDSERVENT
2516 endservent();
2517 #endif
2518 #ifdef HAVE_ENDPROTOENT
2519 endprotoent();
2520 #endif
2521 return LDNS_WIREPARSE_ERR_OK;
2522 }
2523
sldns_str2wire_nsap_buf(const char * str,uint8_t * rd,size_t * len)2524 int sldns_str2wire_nsap_buf(const char* str, uint8_t* rd, size_t* len)
2525 {
2526 const char* s = str;
2527 size_t slen;
2528 size_t dlen = 0; /* number of hexdigits parsed */
2529
2530 /* just a hex string with optional dots? */
2531 if (s[0] != '0' || s[1] != 'x')
2532 return LDNS_WIREPARSE_ERR_INVALID_STR;
2533 s += 2;
2534 slen = strlen(s);
2535 if(slen > LDNS_MAX_RDFLEN*2)
2536 return LDNS_WIREPARSE_ERR_LABEL_OVERFLOW;
2537 while(*s) {
2538 if(isspace((unsigned char)*s) || *s == '.') {
2539 s++;
2540 continue;
2541 }
2542 if(!isxdigit((unsigned char)*s))
2543 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str);
2544 if(*len < dlen/2 + 1)
2545 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
2546 s-str);
2547 if((dlen&1)==0)
2548 rd[dlen/2] = (uint8_t)sldns_hexdigit_to_int(*s++) * 16;
2549 else rd[dlen/2] += sldns_hexdigit_to_int(*s++);
2550 dlen++;
2551 }
2552 if((dlen&1)!=0)
2553 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str);
2554 *len = dlen/2;
2555 return LDNS_WIREPARSE_ERR_OK;
2556 }
2557
sldns_str2wire_atma_buf(const char * str,uint8_t * rd,size_t * len)2558 int sldns_str2wire_atma_buf(const char* str, uint8_t* rd, size_t* len)
2559 {
2560 const char* s = str;
2561 size_t slen = strlen(str);
2562 size_t dlen = 0; /* number of hexdigits parsed for hex,
2563 digits for E.164 */
2564
2565 if(slen > LDNS_MAX_RDFLEN*2)
2566 return LDNS_WIREPARSE_ERR_LABEL_OVERFLOW;
2567 if(*len < 1)
2568 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2569 if(*s == 0) {
2570 /* empty string */
2571 rd[0] = 0;
2572 *len = 1;
2573 return LDNS_WIREPARSE_ERR_OK;
2574 }
2575 if(s[0] == '+') {
2576 rd[0] = 1; /* E.164 format */
2577 /* digits '0'..'9', with skipped dots. */
2578 s++;
2579 while(*s) {
2580 if(isspace((unsigned char)*s) || *s == '.') {
2581 s++;
2582 continue;
2583 }
2584 if(*s < '0' || *s > '9')
2585 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX, s-str);
2586 if(*len < dlen + 2)
2587 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
2588 s-str);
2589 rd[dlen+1] = *s++;
2590 dlen++;
2591 }
2592 *len = dlen+1;
2593 return LDNS_WIREPARSE_ERR_OK;
2594 }
2595
2596 rd[0] = 0; /* AESA format */
2597 /* hex, with skipped dots. */
2598 while(*s) {
2599 if(isspace((unsigned char)*s) || *s == '.') {
2600 s++;
2601 continue;
2602 }
2603 if(!isxdigit((unsigned char)*s))
2604 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str);
2605 if(*len < dlen/2 + 2)
2606 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
2607 s-str);
2608 if((dlen&1)==0)
2609 rd[dlen/2 + 1] = (uint8_t)sldns_hexdigit_to_int(*s++) * 16;
2610 else rd[dlen/2 + 1] += sldns_hexdigit_to_int(*s++);
2611 dlen++;
2612 }
2613 if((dlen&1)!=0)
2614 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str);
2615 *len = dlen/2 + 1;
2616 return LDNS_WIREPARSE_ERR_OK;
2617 }
2618
sldns_str2wire_ipseckey_buf(const char * str,uint8_t * rd,size_t * len)2619 int sldns_str2wire_ipseckey_buf(const char* str, uint8_t* rd, size_t* len)
2620 {
2621 size_t gwlen = 0, keylen = 0;
2622 int s;
2623 uint8_t gwtype;
2624 char token[512];
2625 sldns_buffer strbuf;
2626 sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
2627
2628 if(*len < 3)
2629 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2630 /* precedence */
2631 if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
2632 return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
2633 sldns_buffer_position(&strbuf));
2634 rd[0] = (uint8_t)atoi(token);
2635 /* gateway_type */
2636 if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
2637 return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
2638 sldns_buffer_position(&strbuf));
2639 rd[1] = (uint8_t)atoi(token);
2640 gwtype = rd[1];
2641 /* algorithm */
2642 if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
2643 return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
2644 sldns_buffer_position(&strbuf));
2645 rd[2] = (uint8_t)atoi(token);
2646
2647 /* gateway */
2648 if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
2649 return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
2650 sldns_buffer_position(&strbuf));
2651 if(gwtype == 0) {
2652 /* NOGATEWAY */
2653 if(strcmp(token, ".") != 0)
2654 return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
2655 sldns_buffer_position(&strbuf));
2656 gwlen = 0;
2657 } else if(gwtype == 1) {
2658 /* IP4 */
2659 gwlen = *len - 3;
2660 s = sldns_str2wire_a_buf(token, rd+3, &gwlen);
2661 if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
2662 } else if(gwtype == 2) {
2663 /* IP6 */
2664 gwlen = *len - 3;
2665 s = sldns_str2wire_aaaa_buf(token, rd+3, &gwlen);
2666 if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
2667 } else if(gwtype == 3) {
2668 /* DNAME */
2669 gwlen = *len - 3;
2670 s = sldns_str2wire_dname_buf(token, rd+3, &gwlen);
2671 if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
2672 } else {
2673 /* unknown gateway type */
2674 return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
2675 sldns_buffer_position(&strbuf));
2676 }
2677 /* double check for size */
2678 if(*len < 3 + gwlen)
2679 return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
2680 sldns_buffer_position(&strbuf));
2681
2682 /* publickey in remainder of strbuf */
2683 keylen = *len - 3 - gwlen;
2684 s = sldns_str2wire_b64_buf((const char*)sldns_buffer_current(&strbuf),
2685 rd+3+gwlen, &keylen);
2686 if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
2687
2688 *len = 3 + gwlen + keylen;
2689 return LDNS_WIREPARSE_ERR_OK;
2690 }
2691
sldns_str2wire_nsec3_salt_buf(const char * str,uint8_t * rd,size_t * len)2692 int sldns_str2wire_nsec3_salt_buf(const char* str, uint8_t* rd, size_t* len)
2693 {
2694 int i, salt_length_str = (int)strlen(str);
2695 if (salt_length_str == 1 && str[0] == '-') {
2696 salt_length_str = 0;
2697 } else if (salt_length_str % 2 != 0) {
2698 return LDNS_WIREPARSE_ERR_SYNTAX_HEX;
2699 }
2700 if (salt_length_str > 512)
2701 return LDNS_WIREPARSE_ERR_SYNTAX_HEX;
2702 if(*len < 1+(size_t)salt_length_str / 2)
2703 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2704 rd[0] = (uint8_t) (salt_length_str / 2);
2705 for (i = 0; i < salt_length_str; i += 2) {
2706 if (isxdigit((unsigned char)str[i]) &&
2707 isxdigit((unsigned char)str[i+1])) {
2708 rd[1+i/2] = (uint8_t)(sldns_hexdigit_to_int(str[i])*16
2709 + sldns_hexdigit_to_int(str[i+1]));
2710 } else {
2711 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, i);
2712 }
2713 }
2714 *len = 1 + (size_t)rd[0];
2715 return LDNS_WIREPARSE_ERR_OK;
2716 }
2717
sldns_str2wire_ilnp64_buf(const char * str,uint8_t * rd,size_t * len)2718 int sldns_str2wire_ilnp64_buf(const char* str, uint8_t* rd, size_t* len)
2719 {
2720 unsigned int a, b, c, d;
2721 uint16_t shorts[4];
2722 int l;
2723 if(*len < sizeof(shorts))
2724 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2725
2726 if (sscanf(str, "%4x:%4x:%4x:%4x%n", &a, &b, &c, &d, &l) != 4 ||
2727 l != (int)strlen(str) || /* more data to read */
2728 strpbrk(str, "+-") /* signed hexes */
2729 )
2730 return LDNS_WIREPARSE_ERR_SYNTAX_ILNP64;
2731 shorts[0] = htons(a);
2732 shorts[1] = htons(b);
2733 shorts[2] = htons(c);
2734 shorts[3] = htons(d);
2735 memmove(rd, &shorts, sizeof(shorts));
2736 *len = sizeof(shorts);
2737 return LDNS_WIREPARSE_ERR_OK;
2738 }
2739
sldns_str2wire_eui48_buf(const char * str,uint8_t * rd,size_t * len)2740 int sldns_str2wire_eui48_buf(const char* str, uint8_t* rd, size_t* len)
2741 {
2742 unsigned int a, b, c, d, e, f;
2743 int l;
2744
2745 if(*len < 6)
2746 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2747 if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x%n",
2748 &a, &b, &c, &d, &e, &f, &l) != 6 ||
2749 l != (int)strlen(str))
2750 return LDNS_WIREPARSE_ERR_SYNTAX_EUI48;
2751 rd[0] = a;
2752 rd[1] = b;
2753 rd[2] = c;
2754 rd[3] = d;
2755 rd[4] = e;
2756 rd[5] = f;
2757 *len = 6;
2758 return LDNS_WIREPARSE_ERR_OK;
2759 }
2760
sldns_str2wire_eui64_buf(const char * str,uint8_t * rd,size_t * len)2761 int sldns_str2wire_eui64_buf(const char* str, uint8_t* rd, size_t* len)
2762 {
2763 unsigned int a, b, c, d, e, f, g, h;
2764 int l;
2765
2766 if(*len < 8)
2767 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2768 if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x-%2x-%2x%n",
2769 &a, &b, &c, &d, &e, &f, &g, &h, &l) != 8 ||
2770 l != (int)strlen(str))
2771 return LDNS_WIREPARSE_ERR_SYNTAX_EUI64;
2772 rd[0] = a;
2773 rd[1] = b;
2774 rd[2] = c;
2775 rd[3] = d;
2776 rd[4] = e;
2777 rd[5] = f;
2778 rd[6] = g;
2779 rd[7] = h;
2780 *len = 8;
2781 return LDNS_WIREPARSE_ERR_OK;
2782 }
2783
sldns_str2wire_unquoted_buf(const char * str,uint8_t * rd,size_t * len)2784 int sldns_str2wire_unquoted_buf(const char* str, uint8_t* rd, size_t* len)
2785 {
2786 return sldns_str2wire_str_buf(str, rd, len);
2787 }
2788
sldns_str2wire_tag_buf(const char * str,uint8_t * rd,size_t * len)2789 int sldns_str2wire_tag_buf(const char* str, uint8_t* rd, size_t* len)
2790 {
2791 size_t slen = strlen(str);
2792 const char* ptr;
2793
2794 if (slen > 255)
2795 return LDNS_WIREPARSE_ERR_SYNTAX_TAG;
2796 if(*len < slen+1)
2797 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2798 for (ptr = str; *ptr; ptr++) {
2799 if(!isalnum((unsigned char)*ptr))
2800 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TAG, ptr-str);
2801 }
2802 rd[0] = (uint8_t)slen;
2803 memmove(rd+1, str, slen);
2804 *len = slen+1;
2805 return LDNS_WIREPARSE_ERR_OK;
2806 }
2807
sldns_str2wire_long_str_buf(const char * str,uint8_t * rd,size_t * len)2808 int sldns_str2wire_long_str_buf(const char* str, uint8_t* rd, size_t* len)
2809 {
2810 uint8_t ch = 0;
2811 const char* pstr = str;
2812 size_t length = 0;
2813
2814 /* Fill data with parsed bytes */
2815 while (sldns_parse_char(&ch, &pstr)) {
2816 if(*len < length+1)
2817 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2818 rd[length++] = ch;
2819 }
2820 if(!pstr)
2821 return LDNS_WIREPARSE_ERR_SYNTAX_BAD_ESCAPE;
2822 *len = length;
2823 return LDNS_WIREPARSE_ERR_OK;
2824 }
2825
sldns_str2wire_hip_buf(const char * str,uint8_t * rd,size_t * len)2826 int sldns_str2wire_hip_buf(const char* str, uint8_t* rd, size_t* len)
2827 {
2828 char* s, *end;
2829 int e;
2830 size_t hitlen, pklen = 0;
2831 /* presentation format:
2832 * pk-algo HIThex pubkeybase64
2833 * wireformat:
2834 * hitlen[1byte] pkalgo[1byte] pubkeylen[2byte] [hit] [pubkey] */
2835 if(*len < 4)
2836 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2837
2838 /* read PK algorithm */
2839 rd[1] = (uint8_t)strtol((char*)str, &s, 10);
2840 if(*s != ' ')
2841 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, s-(char*)str);
2842 s++;
2843 while(*s == ' ')
2844 s++;
2845
2846 /* read HIT hex tag */
2847 /* zero terminate the tag (replace later) */
2848 end = strchr(s, ' ');
2849 if(!end) return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX, s-(char*)str);
2850 *end = 0;
2851 hitlen = *len - 4;
2852 if((e = sldns_str2wire_hex_buf(s, rd+4, &hitlen)) != 0) {
2853 *end = ' ';
2854 return RET_ERR_SHIFT(e, s-(char*)str);
2855 }
2856 if(hitlen > 255) {
2857 *end = ' ';
2858 return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, s-(char*)str+255*2);
2859 }
2860 rd[0] = (uint8_t)hitlen;
2861 *end = ' ';
2862 s = end+1;
2863
2864 /* read pubkey base64 sequence */
2865 pklen = *len - 4 - hitlen;
2866 if((e = sldns_str2wire_b64_buf(s, rd+4+hitlen, &pklen)) != 0)
2867 return RET_ERR_SHIFT(e, s-(char*)str);
2868 if(pklen > 65535)
2869 return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, s-(char*)str+65535);
2870 sldns_write_uint16(rd+2, (uint16_t)pklen);
2871
2872 *len = 4 + hitlen + pklen;
2873 return LDNS_WIREPARSE_ERR_OK;
2874 }
2875
sldns_str2wire_int16_data_buf(const char * str,uint8_t * rd,size_t * len)2876 int sldns_str2wire_int16_data_buf(const char* str, uint8_t* rd, size_t* len)
2877 {
2878 char* s;
2879 int n;
2880 n = strtol(str, &s, 10);
2881 if(n < 0) /* negative number not allowed */
2882 return LDNS_WIREPARSE_ERR_SYNTAX;
2883 if(*len < ((size_t)n)+2)
2884 return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
2885 if(n > 65535)
2886 return LDNS_WIREPARSE_ERR_LABEL_OVERFLOW;
2887
2888 if(n == 0) {
2889 sldns_write_uint16(rd, 0);
2890 *len = 2;
2891 return LDNS_WIREPARSE_ERR_OK;
2892 }
2893 if(*s != ' ')
2894 return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, s-(char*)str);
2895 s++;
2896 while(*s == ' ')
2897 s++;
2898
2899 n = sldns_b64_pton(s, rd+2, (*len)-2);
2900 if(n < 0)
2901 return LDNS_WIREPARSE_ERR_SYNTAX_B64;
2902 sldns_write_uint16(rd, (uint16_t)n);
2903 *len = ((size_t)n)+2;
2904 return LDNS_WIREPARSE_ERR_OK;
2905 }
2906