1 /*
2 * rdata.c
3 *
4 * rdata implementation
5 *
6 * a Net::DNS like library for C
7 *
8 * (c) NLnet Labs, 2004-2006
9 *
10 * See the file LICENSE for the license
11 */
12
13 #include <ldns/config.h>
14
15 #include <ldns/ldns.h>
16
17 /*
18 * Access functions
19 * do this as functions to get type checking
20 */
21
22 /* read */
23 size_t
ldns_rdf_size(const ldns_rdf * rd)24 ldns_rdf_size(const ldns_rdf *rd)
25 {
26 assert(rd != NULL);
27 return rd->_size;
28 }
29
30 ldns_rdf_type
ldns_rdf_get_type(const ldns_rdf * rd)31 ldns_rdf_get_type(const ldns_rdf *rd)
32 {
33 assert(rd != NULL);
34 return rd->_type;
35 }
36
37 uint8_t *
ldns_rdf_data(const ldns_rdf * rd)38 ldns_rdf_data(const ldns_rdf *rd)
39 {
40 assert(rd != NULL);
41 return rd->_data;
42 }
43
44 /* write */
45 void
ldns_rdf_set_size(ldns_rdf * rd,size_t size)46 ldns_rdf_set_size(ldns_rdf *rd, size_t size)
47 {
48 assert(rd != NULL);
49 rd->_size = size;
50 }
51
52 void
ldns_rdf_set_type(ldns_rdf * rd,ldns_rdf_type type)53 ldns_rdf_set_type(ldns_rdf *rd, ldns_rdf_type type)
54 {
55 assert(rd != NULL);
56 rd->_type = type;
57 }
58
59 void
ldns_rdf_set_data(ldns_rdf * rd,void * data)60 ldns_rdf_set_data(ldns_rdf *rd, void *data)
61 {
62 /* only copy the pointer */
63 assert(rd != NULL);
64 rd->_data = data;
65 }
66
67 /* for types that allow it, return
68 * the native/host order type */
69 uint8_t
ldns_rdf2native_int8(const ldns_rdf * rd)70 ldns_rdf2native_int8(const ldns_rdf *rd)
71 {
72 uint8_t data;
73
74 /* only allow 8 bit rdfs */
75 if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_BYTE) {
76 return 0;
77 }
78
79 memcpy(&data, ldns_rdf_data(rd), sizeof(data));
80 return data;
81 }
82
83 uint16_t
ldns_rdf2native_int16(const ldns_rdf * rd)84 ldns_rdf2native_int16(const ldns_rdf *rd)
85 {
86 uint16_t data;
87
88 /* only allow 16 bit rdfs */
89 if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_WORD) {
90 return 0;
91 }
92
93 memcpy(&data, ldns_rdf_data(rd), sizeof(data));
94 return ntohs(data);
95 }
96
97 uint32_t
ldns_rdf2native_int32(const ldns_rdf * rd)98 ldns_rdf2native_int32(const ldns_rdf *rd)
99 {
100 uint32_t data;
101
102 /* only allow 32 bit rdfs */
103 if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_DOUBLEWORD) {
104 return 0;
105 }
106
107 memcpy(&data, ldns_rdf_data(rd), sizeof(data));
108 return ntohl(data);
109 }
110
111 time_t
ldns_rdf2native_time_t(const ldns_rdf * rd)112 ldns_rdf2native_time_t(const ldns_rdf *rd)
113 {
114 uint32_t data;
115
116 /* only allow 32 bit rdfs */
117 if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_DOUBLEWORD ||
118 ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_TIME) {
119 return 0;
120 }
121 memcpy(&data, ldns_rdf_data(rd), sizeof(data));
122 return (time_t)ntohl(data);
123 }
124
125 ldns_rdf *
ldns_native2rdf_int8(ldns_rdf_type type,uint8_t value)126 ldns_native2rdf_int8(ldns_rdf_type type, uint8_t value)
127 {
128 return ldns_rdf_new_frm_data(type, LDNS_RDF_SIZE_BYTE, &value);
129 }
130
131 ldns_rdf *
ldns_native2rdf_int16(ldns_rdf_type type,uint16_t value)132 ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value)
133 {
134 uint16_t *rdf_data = LDNS_XMALLOC(uint16_t, 1);
135 ldns_rdf* rdf;
136 if (!rdf_data) {
137 return NULL;
138 }
139 ldns_write_uint16(rdf_data, value);
140 rdf = ldns_rdf_new(type, LDNS_RDF_SIZE_WORD, rdf_data);
141 if(!rdf)
142 LDNS_FREE(rdf_data);
143 return rdf;
144 }
145
146 ldns_rdf *
ldns_native2rdf_int32(ldns_rdf_type type,uint32_t value)147 ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value)
148 {
149 uint32_t *rdf_data = LDNS_XMALLOC(uint32_t, 1);
150 ldns_rdf* rdf;
151 if (!rdf_data) {
152 return NULL;
153 }
154 ldns_write_uint32(rdf_data, value);
155 rdf = ldns_rdf_new(type, LDNS_RDF_SIZE_DOUBLEWORD, rdf_data);
156 if(!rdf)
157 LDNS_FREE(rdf_data);
158 return rdf;
159 }
160
161 ldns_rdf *
ldns_native2rdf_int16_data(size_t size,uint8_t * data)162 ldns_native2rdf_int16_data(size_t size, uint8_t *data)
163 {
164 uint8_t *rdf_data = LDNS_XMALLOC(uint8_t, size + 2);
165 ldns_rdf* rdf;
166 if (!rdf_data) {
167 return NULL;
168 }
169 ldns_write_uint16(rdf_data, size);
170 memcpy(rdf_data + 2, data, size);
171 rdf = ldns_rdf_new(LDNS_RDF_TYPE_INT16_DATA, size + 2, rdf_data);
172 if(!rdf)
173 LDNS_FREE(rdf_data);
174 return rdf;
175 }
176
177 /* note: data must be allocated memory */
178 ldns_rdf *
ldns_rdf_new(ldns_rdf_type type,size_t size,void * data)179 ldns_rdf_new(ldns_rdf_type type, size_t size, void *data)
180 {
181 ldns_rdf *rd;
182 rd = LDNS_MALLOC(ldns_rdf);
183 if (!rd) {
184 return NULL;
185 }
186 ldns_rdf_set_size(rd, size);
187 ldns_rdf_set_type(rd, type);
188 ldns_rdf_set_data(rd, data);
189 return rd;
190 }
191
192 ldns_rdf *
ldns_rdf_new_frm_data(ldns_rdf_type type,size_t size,const void * data)193 ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data)
194 {
195 ldns_rdf *rdf;
196
197 /* if the size is too big, fail */
198 if (size > LDNS_MAX_RDFLEN) {
199 return NULL;
200 }
201
202 /* allocate space */
203 rdf = LDNS_MALLOC(ldns_rdf);
204 if (!rdf) {
205 return NULL;
206 }
207 rdf->_data = LDNS_XMALLOC(uint8_t, size);
208 if (!rdf->_data) {
209 LDNS_FREE(rdf);
210 return NULL;
211 }
212
213 /* set the values */
214 ldns_rdf_set_type(rdf, type);
215 ldns_rdf_set_size(rdf, size);
216 memcpy(rdf->_data, data, size);
217
218 return rdf;
219 }
220
221 ldns_rdf *
ldns_rdf_clone(const ldns_rdf * rd)222 ldns_rdf_clone(const ldns_rdf *rd)
223 {
224 assert(rd != NULL);
225 return (ldns_rdf_new_frm_data( ldns_rdf_get_type(rd),
226 ldns_rdf_size(rd), ldns_rdf_data(rd)));
227 }
228
229 void
ldns_rdf_deep_free(ldns_rdf * rd)230 ldns_rdf_deep_free(ldns_rdf *rd)
231 {
232 if (rd) {
233 if (rd->_data) {
234 LDNS_FREE(rd->_data);
235 }
236 LDNS_FREE(rd);
237 }
238 }
239
240 void
ldns_rdf_free(ldns_rdf * rd)241 ldns_rdf_free(ldns_rdf *rd)
242 {
243 if (rd) {
244 LDNS_FREE(rd);
245 }
246 }
247
248 ldns_rdf *
ldns_rdf_new_frm_str(ldns_rdf_type type,const char * str)249 ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str)
250 {
251 ldns_rdf *rdf = NULL;
252 ldns_status status;
253
254 switch (type) {
255 case LDNS_RDF_TYPE_DNAME:
256 status = ldns_str2rdf_dname(&rdf, str);
257 break;
258 case LDNS_RDF_TYPE_INT8:
259 status = ldns_str2rdf_int8(&rdf, str);
260 break;
261 case LDNS_RDF_TYPE_INT16:
262 status = ldns_str2rdf_int16(&rdf, str);
263 break;
264 case LDNS_RDF_TYPE_INT32:
265 status = ldns_str2rdf_int32(&rdf, str);
266 break;
267 case LDNS_RDF_TYPE_A:
268 status = ldns_str2rdf_a(&rdf, str);
269 break;
270 case LDNS_RDF_TYPE_AAAA:
271 status = ldns_str2rdf_aaaa(&rdf, str);
272 break;
273 case LDNS_RDF_TYPE_STR:
274 status = ldns_str2rdf_str(&rdf, str);
275 break;
276 case LDNS_RDF_TYPE_APL:
277 status = ldns_str2rdf_apl(&rdf, str);
278 break;
279 case LDNS_RDF_TYPE_B64:
280 status = ldns_str2rdf_b64(&rdf, str);
281 break;
282 case LDNS_RDF_TYPE_B32_EXT:
283 status = ldns_str2rdf_b32_ext(&rdf, str);
284 break;
285 case LDNS_RDF_TYPE_HEX:
286 status = ldns_str2rdf_hex(&rdf, str);
287 break;
288 case LDNS_RDF_TYPE_NSEC:
289 status = ldns_str2rdf_nsec(&rdf, str);
290 break;
291 case LDNS_RDF_TYPE_TYPE:
292 status = ldns_str2rdf_type(&rdf, str);
293 break;
294 case LDNS_RDF_TYPE_CLASS:
295 status = ldns_str2rdf_class(&rdf, str);
296 break;
297 case LDNS_RDF_TYPE_CERT_ALG:
298 status = ldns_str2rdf_cert_alg(&rdf, str);
299 break;
300 case LDNS_RDF_TYPE_ALG:
301 status = ldns_str2rdf_alg(&rdf, str);
302 break;
303 case LDNS_RDF_TYPE_UNKNOWN:
304 status = ldns_str2rdf_unknown(&rdf, str);
305 break;
306 case LDNS_RDF_TYPE_TIME:
307 status = ldns_str2rdf_time(&rdf, str);
308 break;
309 case LDNS_RDF_TYPE_PERIOD:
310 status = ldns_str2rdf_period(&rdf, str);
311 break;
312 case LDNS_RDF_TYPE_HIP:
313 status = ldns_str2rdf_hip(&rdf, str);
314 break;
315 case LDNS_RDF_TYPE_SERVICE:
316 status = ldns_str2rdf_service(&rdf, str);
317 break;
318 case LDNS_RDF_TYPE_LOC:
319 status = ldns_str2rdf_loc(&rdf, str);
320 break;
321 case LDNS_RDF_TYPE_WKS:
322 status = ldns_str2rdf_wks(&rdf, str);
323 break;
324 case LDNS_RDF_TYPE_NSAP:
325 status = ldns_str2rdf_nsap(&rdf, str);
326 break;
327 case LDNS_RDF_TYPE_ATMA:
328 status = ldns_str2rdf_atma(&rdf, str);
329 break;
330 case LDNS_RDF_TYPE_IPSECKEY:
331 status = ldns_str2rdf_ipseckey(&rdf, str);
332 break;
333 case LDNS_RDF_TYPE_NSEC3_SALT:
334 status = ldns_str2rdf_nsec3_salt(&rdf, str);
335 break;
336 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
337 status = ldns_str2rdf_b32_ext(&rdf, str);
338 break;
339 case LDNS_RDF_TYPE_ILNP64:
340 status = ldns_str2rdf_ilnp64(&rdf, str);
341 break;
342 case LDNS_RDF_TYPE_EUI48:
343 status = ldns_str2rdf_eui48(&rdf, str);
344 break;
345 case LDNS_RDF_TYPE_EUI64:
346 status = ldns_str2rdf_eui64(&rdf, str);
347 break;
348 case LDNS_RDF_TYPE_UNQUOTED:
349 status = ldns_str2rdf_str(&rdf, str);
350 break;
351 case LDNS_RDF_TYPE_TAG:
352 status = ldns_str2rdf_tag(&rdf, str);
353 break;
354 case LDNS_RDF_TYPE_LONG_STR:
355 status = ldns_str2rdf_long_str(&rdf, str);
356 break;
357 case LDNS_RDF_TYPE_CERTIFICATE_USAGE:
358 status = ldns_str2rdf_certificate_usage(&rdf, str);
359 break;
360 case LDNS_RDF_TYPE_SELECTOR:
361 status = ldns_str2rdf_selector(&rdf, str);
362 break;
363 case LDNS_RDF_TYPE_MATCHING_TYPE:
364 status = ldns_str2rdf_matching_type(&rdf, str);
365 break;
366 case LDNS_RDF_TYPE_AMTRELAY:
367 status = ldns_str2rdf_amtrelay(&rdf, str);
368 break;
369 case LDNS_RDF_TYPE_SVCPARAMS:
370 status = ldns_str2rdf_svcparams(&rdf, str);
371 break;
372 case LDNS_RDF_TYPE_IPN:
373 status = ldns_str2rdf_ipn(&rdf, str);
374 break;
375 case LDNS_RDF_TYPE_NONE:
376 default:
377 /* default default ??? */
378 status = LDNS_STATUS_ERR;
379 break;
380 }
381 if (LDNS_STATUS_OK == status) {
382 ldns_rdf_set_type(rdf, type);
383 return rdf;
384 }
385 if (rdf) {
386 LDNS_FREE(rdf);
387 }
388 return NULL;
389 }
390
391 ldns_status
ldns_rdf_new_frm_fp(ldns_rdf ** rdf,ldns_rdf_type type,FILE * fp)392 ldns_rdf_new_frm_fp(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp)
393 {
394 return ldns_rdf_new_frm_fp_l(rdf, type, fp, NULL);
395 }
396
397 ldns_status
ldns_rdf_new_frm_fp_l(ldns_rdf ** rdf,ldns_rdf_type type,FILE * fp,int * line_nr)398 ldns_rdf_new_frm_fp_l(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp, int *line_nr)
399 {
400 char *line;
401 ldns_rdf *r;
402 ssize_t t;
403
404 line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
405 if (!line) {
406 return LDNS_STATUS_MEM_ERR;
407 }
408
409 /* read an entire line in from the file */
410 if ((t = ldns_fget_token_l(fp, line, LDNS_PARSE_SKIP_SPACE, 0, line_nr)) == -1 || t == 0) {
411 LDNS_FREE(line);
412 return LDNS_STATUS_SYNTAX_RDATA_ERR;
413 }
414 r = ldns_rdf_new_frm_str(type, (const char*) line);
415 LDNS_FREE(line);
416 if (rdf) {
417 *rdf = r;
418 return LDNS_STATUS_OK;
419 } else {
420 return LDNS_STATUS_NULL;
421 }
422 }
423
424 ldns_rdf *
ldns_rdf_address_reverse(const ldns_rdf * rd)425 ldns_rdf_address_reverse(const ldns_rdf *rd)
426 {
427 uint8_t buf_4[LDNS_IP4ADDRLEN];
428 uint8_t buf_6[LDNS_IP6ADDRLEN * 2];
429 ldns_rdf *rev;
430 ldns_rdf *in_addr;
431 ldns_rdf *ret_dname;
432 uint8_t octet;
433 uint8_t nnibble;
434 uint8_t nibble;
435 uint8_t i, j;
436
437 char *char_dname;
438 int nbit;
439
440 if (ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_A &&
441 ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_AAAA) {
442 return NULL;
443 }
444
445 in_addr = NULL;
446 ret_dname = NULL;
447
448 switch(ldns_rdf_get_type(rd)) {
449 case LDNS_RDF_TYPE_A:
450 /* the length of the buffer is 4 */
451 buf_4[3] = ldns_rdf_data(rd)[0];
452 buf_4[2] = ldns_rdf_data(rd)[1];
453 buf_4[1] = ldns_rdf_data(rd)[2];
454 buf_4[0] = ldns_rdf_data(rd)[3];
455 in_addr = ldns_dname_new_frm_str("in-addr.arpa.");
456 if (!in_addr) {
457 return NULL;
458 }
459 /* make a new rdf and convert that back */
460 rev = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_A,
461 LDNS_IP4ADDRLEN, (void*)&buf_4);
462 if (!rev) {
463 LDNS_FREE(in_addr);
464 return NULL;
465 }
466
467 /* convert rev to a string */
468 char_dname = ldns_rdf2str(rev);
469 if (!char_dname) {
470 LDNS_FREE(in_addr);
471 ldns_rdf_deep_free(rev);
472 return NULL;
473 }
474 /* transform back to rdf with type dname */
475 ret_dname = ldns_dname_new_frm_str(char_dname);
476 if (!ret_dname) {
477 LDNS_FREE(in_addr);
478 ldns_rdf_deep_free(rev);
479 LDNS_FREE(char_dname);
480 return NULL;
481 }
482 /* not needed anymore */
483 ldns_rdf_deep_free(rev);
484 LDNS_FREE(char_dname);
485 break;
486 case LDNS_RDF_TYPE_AAAA:
487 /* some foo magic to reverse the nibbles ... */
488
489 for (nbit = 127; nbit >= 0; nbit = nbit - 4) {
490 /* calculate octet (8 bit) */
491 octet = ( ((unsigned int) nbit) & 0x78) >> 3;
492 /* calculate nibble */
493 nnibble = ( ((unsigned int) nbit) & 0x04) >> 2;
494 /* extract nibble */
495 nibble = (ldns_rdf_data(rd)[octet] & ( 0xf << (4 * (1 -
496 nnibble)) ) ) >> ( 4 * (1 -
497 nnibble));
498
499 buf_6[(LDNS_IP6ADDRLEN * 2 - 1) -
500 (octet * 2 + nnibble)] =
501 (uint8_t)ldns_int_to_hexdigit((int)nibble);
502 }
503
504 char_dname = LDNS_XMALLOC(char, (LDNS_IP6ADDRLEN * 4));
505 if (!char_dname) {
506 return NULL;
507 }
508 char_dname[LDNS_IP6ADDRLEN * 4 - 1] = '\0'; /* closure */
509
510 /* walk the string and add . 's */
511 for (i = 0, j = 0; i < LDNS_IP6ADDRLEN * 2; i++, j = j + 2) {
512 char_dname[j] = (char)buf_6[i];
513 if (i != LDNS_IP6ADDRLEN * 2 - 1) {
514 char_dname[j + 1] = '.';
515 }
516 }
517 in_addr = ldns_dname_new_frm_str("ip6.arpa.");
518 if (!in_addr) {
519 LDNS_FREE(char_dname);
520 return NULL;
521 }
522
523 /* convert rev to a string */
524 ret_dname = ldns_dname_new_frm_str(char_dname);
525 LDNS_FREE(char_dname);
526 if (!ret_dname) {
527 ldns_rdf_deep_free(in_addr);
528 return NULL;
529 }
530 break;
531 default:
532 break;
533 }
534 /* add the suffix */
535 rev = ldns_dname_cat_clone(ret_dname, in_addr);
536
537 ldns_rdf_deep_free(ret_dname);
538 ldns_rdf_deep_free(in_addr);
539 return rev;
540 }
541
542 ldns_status
ldns_rdf_hip_get_alg_hit_pk(ldns_rdf * rdf,uint8_t * alg,uint8_t * hit_size,uint8_t ** hit,uint16_t * pk_size,uint8_t ** pk)543 ldns_rdf_hip_get_alg_hit_pk(ldns_rdf *rdf, uint8_t* alg,
544 uint8_t *hit_size, uint8_t** hit,
545 uint16_t *pk_size, uint8_t** pk)
546 {
547 uint8_t *data;
548 size_t rdf_size;
549
550 if (! rdf || ! alg || ! hit || ! hit_size || ! pk || ! pk_size) {
551 return LDNS_STATUS_INVALID_POINTER;
552 } else if (ldns_rdf_get_type(rdf) != LDNS_RDF_TYPE_HIP) {
553 return LDNS_STATUS_INVALID_RDF_TYPE;
554 } else if ((rdf_size = ldns_rdf_size(rdf)) < 6) {
555 return LDNS_STATUS_WIRE_RDATA_ERR;
556 }
557 data = ldns_rdf_data(rdf);
558 *hit_size = data[0];
559 *alg = data[1];
560 *pk_size = ldns_read_uint16(data + 2);
561 *hit = data + 4;
562 *pk = data + 4 + *hit_size;
563 if (*hit_size == 0 || *pk_size == 0 ||
564 rdf_size < (size_t) *hit_size + *pk_size + 4) {
565 return LDNS_STATUS_WIRE_RDATA_ERR;
566 }
567 return LDNS_STATUS_OK;
568 }
569
570 ldns_status
ldns_rdf_hip_new_frm_alg_hit_pk(ldns_rdf ** rdf,uint8_t alg,uint8_t hit_size,uint8_t * hit,uint16_t pk_size,uint8_t * pk)571 ldns_rdf_hip_new_frm_alg_hit_pk(ldns_rdf** rdf, uint8_t alg,
572 uint8_t hit_size, uint8_t *hit,
573 uint16_t pk_size, uint8_t *pk)
574 {
575 uint8_t *data;
576
577 if (! rdf) {
578 return LDNS_STATUS_INVALID_POINTER;
579 }
580 if (4 + hit_size + pk_size > LDNS_MAX_RDFLEN) {
581 return LDNS_STATUS_RDATA_OVERFLOW;
582 }
583 data = LDNS_XMALLOC(uint8_t, 4 + hit_size + pk_size);
584 if (data == NULL) {
585 return LDNS_STATUS_MEM_ERR;
586 }
587 data[0] = hit_size;
588 data[1] = alg;
589 ldns_write_uint16(data + 2, pk_size);
590 memcpy(data + 4, hit, hit_size);
591 memcpy(data + 4 + hit_size, pk, pk_size);
592 *rdf = ldns_rdf_new(LDNS_RDF_TYPE_HIP, 4 + hit_size + pk_size, data);
593 if (! *rdf) {
594 LDNS_FREE(data);
595 return LDNS_STATUS_MEM_ERR;
596 }
597 return LDNS_STATUS_OK;
598 }
599
600 ldns_status
ldns_octet(char * word,size_t * length)601 ldns_octet(char *word, size_t *length)
602 {
603 char *s;
604 char *p;
605 *length = 0;
606
607 for (s = p = word; *s != '\0'; s++,p++) {
608 switch (*s) {
609 case '.':
610 if (s[1] == '.') {
611 return LDNS_STATUS_EMPTY_LABEL;
612 }
613 *p = *s;
614 (*length)++;
615 break;
616 case '\\':
617 if ('0' <= s[1] && s[1] <= '9' &&
618 '0' <= s[2] && s[2] <= '9' &&
619 '0' <= s[3] && s[3] <= '9') {
620 /* \DDD seen */
621 int val = ((s[1] - '0') * 100 +
622 (s[2] - '0') * 10 + (s[3] - '0'));
623
624 if (0 <= val && val <= 255) {
625 /* this also handles \0 */
626 s += 3;
627 *p = val;
628 (*length)++;
629 } else {
630 return LDNS_STATUS_DDD_OVERFLOW;
631 }
632 } else {
633 /* an escaped character, like \<space> ?
634 * remove the '\' keep the rest */
635 *p = *++s;
636 (*length)++;
637 }
638 break;
639 case '\"':
640 /* non quoted " Is either first or the last character in
641 * the string */
642
643 *p = *++s; /* skip it */
644 (*length)++;
645 /* I'm not sure if this is needed in libdns... MG */
646 if ( *s == '\0' ) {
647 /* ok, it was the last one */
648 *p = '\0';
649 return LDNS_STATUS_OK;
650 }
651 break;
652 default:
653 *p = *s;
654 (*length)++;
655 break;
656 }
657 }
658 *p = '\0';
659 return LDNS_STATUS_OK;
660 }
661
662 int
ldns_rdf_compare(const ldns_rdf * rd1,const ldns_rdf * rd2)663 ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2)
664 {
665 uint16_t i1, i2, i;
666 uint8_t *d1, *d2;
667
668 /* only when both are not NULL we can say anything about them */
669 if (!rd1 && !rd2) {
670 return 0;
671 }
672 if (!rd1 || !rd2) {
673 return -1;
674 }
675 i1 = ldns_rdf_size(rd1);
676 i2 = ldns_rdf_size(rd2);
677
678 if (i1 < i2) {
679 return -1;
680 } else if (i1 > i2) {
681 return +1;
682 } else {
683 d1 = (uint8_t*)ldns_rdf_data(rd1);
684 d2 = (uint8_t*)ldns_rdf_data(rd2);
685 for(i = 0; i < i1; i++) {
686 if (d1[i] < d2[i]) {
687 return -1;
688 } else if (d1[i] > d2[i]) {
689 return +1;
690 }
691 }
692 }
693 return 0;
694 }
695
696 uint32_t
ldns_str2period(const char * nptr,const char ** endptr)697 ldns_str2period(const char *nptr, const char **endptr)
698 {
699 int sign = 0;
700 uint32_t i = 0;
701 uint32_t seconds = 0;
702
703 for(*endptr = nptr; **endptr; (*endptr)++) {
704 switch (**endptr) {
705 case ' ':
706 case '\t':
707 break;
708 case '-':
709 if(sign == 0) {
710 sign = -1;
711 } else {
712 return seconds;
713 }
714 break;
715 case '+':
716 if(sign == 0) {
717 sign = 1;
718 } else {
719 return seconds;
720 }
721 break;
722 case 's':
723 case 'S':
724 seconds += i;
725 i = 0;
726 break;
727 case 'm':
728 case 'M':
729 seconds += i * 60;
730 i = 0;
731 break;
732 case 'h':
733 case 'H':
734 seconds += i * 60 * 60;
735 i = 0;
736 break;
737 case 'd':
738 case 'D':
739 seconds += i * 60 * 60 * 24;
740 i = 0;
741 break;
742 case 'w':
743 case 'W':
744 seconds += i * 60 * 60 * 24 * 7;
745 i = 0;
746 break;
747 case '0':
748 case '1':
749 case '2':
750 case '3':
751 case '4':
752 case '5':
753 case '6':
754 case '7':
755 case '8':
756 case '9':
757 i *= 10;
758 i += (**endptr - '0');
759 break;
760 default:
761 seconds += i;
762 /* disregard signedness */
763 return seconds;
764 }
765 }
766 seconds += i;
767 /* disregard signedness */
768 return seconds;
769 }
770