Coverage Report

Created: 2025-07-11 06:08

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