ldns documentation

- Main Page
- Related Pages
- Data Structures
- Files

- File List
- Globals

rdata.c
Go to the documentation of this file.
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
24 ldns_rdf_size(const ldns_rdf *rd)
25 {
26 assert(rd != NULL);
27 return rd->_size;
28 }
29
30 ldns_rdf_type
31 ldns_rdf_get_type(const ldns_rdf *rd)
32 {
33 assert(rd != NULL);
34 return rd->_type;
35 }
36
37 uint8_t *
38 ldns_rdf_data(const ldns_rdf *rd)
39 {
40 assert(rd != NULL);
41 return rd->_data;
42 }
43
44 /* write */
45 void
46 ldns_rdf_set_size(ldns_rdf *rd, size_t size)
47 {
48 assert(rd != NULL);
49 rd->_size = size;
50 }
51
52 void
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
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
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
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
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
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 *
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 *
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 *
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 *
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 *
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 *
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 *
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
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
241 ldns_rdf_free(ldns_rdf *rd)
242 {
243 if (rd) {
244 LDNS_FREE(rd);
245 }
246 }
247
248 ldns_rdf *
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_TAG:
349 status = ldns_str2rdf_tag(&rdf, str);
350 break;
351 case LDNS_RDF_TYPE_LONG_STR:
352 status = ldns_str2rdf_long_str(&rdf, str);
353 break;
354 case LDNS_RDF_TYPE_NONE:
355 default:
356 /* default default ??? */
357 status = LDNS_STATUS_ERR;
358 break;
359 }
360 if (LDNS_STATUS_OK == status) {
361 ldns_rdf_set_type(rdf, type);
362 return rdf;
363 }
364 if (rdf) {
365 LDNS_FREE(rdf);
366 }
367 return NULL;
368 }
369
370 ldns_status
371 ldns_rdf_new_frm_fp(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp)
372 {
373 return ldns_rdf_new_frm_fp_l(rdf, type, fp, NULL);
374 }
375
376 ldns_status
377 ldns_rdf_new_frm_fp_l(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp, int *line_nr)
378 {
379 char *line;
380 ldns_rdf *r;
381 ssize_t t;
382
383 line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
384 if (!line) {
385 return LDNS_STATUS_MEM_ERR;
386 }
387
388 /* read an entire line in from the file */
389 if ((t = ldns_fget_token_l(fp, line, LDNS_PARSE_SKIP_SPACE, 0, line_nr)) == -1 || t == 0) {
390 LDNS_FREE(line);
391 return LDNS_STATUS_SYNTAX_RDATA_ERR;
392 }
393 r = ldns_rdf_new_frm_str(type, (const char*) line);
394 LDNS_FREE(line);
395 if (rdf) {
396 *rdf = r;
397 return LDNS_STATUS_OK;
398 } else {
399 return LDNS_STATUS_NULL;
400 }
401 }
402
403 ldns_rdf *
404 ldns_rdf_address_reverse(ldns_rdf *rd)
405 {
406 uint8_t buf_4[LDNS_IP4ADDRLEN];
407 uint8_t buf_6[LDNS_IP6ADDRLEN * 2];
408 ldns_rdf *rev;
409 ldns_rdf *in_addr;
410 ldns_rdf *ret_dname;
411 uint8_t octet;
412 uint8_t nnibble;
413 uint8_t nibble;
414 uint8_t i, j;
415
416 char *char_dname;
417 int nbit;
418
419 if (ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_A &&
420 ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_AAAA) {
421 return NULL;
422 }
423
424 in_addr = NULL;
425 ret_dname = NULL;
426
427 switch(ldns_rdf_get_type(rd)) {
428 case LDNS_RDF_TYPE_A:
429 /* the length of the buffer is 4 */
430 buf_4[3] = ldns_rdf_data(rd)[0];
431 buf_4[2] = ldns_rdf_data(rd)[1];
432 buf_4[1] = ldns_rdf_data(rd)[2];
433 buf_4[0] = ldns_rdf_data(rd)[3];
434 in_addr = ldns_dname_new_frm_str("in-addr.arpa.");
435 if (!in_addr) {
436 return NULL;
437 }
438 /* make a new rdf and convert that back */
439 rev = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_A,
440 LDNS_IP4ADDRLEN, (void*)&buf_4);
441 if (!rev) {
442 LDNS_FREE(in_addr);
443 return NULL;
444 }
445
446 /* convert rev to a string */
447 char_dname = ldns_rdf2str(rev);
448 if (!char_dname) {
449 LDNS_FREE(in_addr);
450 ldns_rdf_deep_free(rev);
451 return NULL;
452 }
453 /* transform back to rdf with type dname */
454 ret_dname = ldns_dname_new_frm_str(char_dname);
455 if (!ret_dname) {
456 LDNS_FREE(in_addr);
457 ldns_rdf_deep_free(rev);
458 LDNS_FREE(char_dname);
459 return NULL;
460 }
461 /* not needed anymore */
462 ldns_rdf_deep_free(rev);
463 LDNS_FREE(char_dname);
464 break;
465 case LDNS_RDF_TYPE_AAAA:
466 /* some foo magic to reverse the nibbles ... */
467
468 for (nbit = 127; nbit >= 0; nbit = nbit - 4) {
469 /* calculate octett (8 bit) */
470 octet = ( ((unsigned int) nbit) & 0x78) >> 3;
471 /* calculate nibble */
472 nnibble = ( ((unsigned int) nbit) & 0x04) >> 2;
473 /* extract nibble */
474 nibble = (ldns_rdf_data(rd)[octet] & ( 0xf << (4 * (1 -
475 nnibble)) ) ) >> ( 4 * (1 -
476 nnibble));
477
478 buf_6[(LDNS_IP6ADDRLEN * 2 - 1) -
479 (octet * 2 + nnibble)] =
480 (uint8_t)ldns_int_to_hexdigit((int)nibble);
481 }
482
483 char_dname = LDNS_XMALLOC(char, (LDNS_IP6ADDRLEN * 4));
484 if (!char_dname) {
485 return NULL;
486 }
487 char_dname[LDNS_IP6ADDRLEN * 4 - 1] = '\0'; /* closure */
488
489 /* walk the string and add . 's */
490 for (i = 0, j = 0; i < LDNS_IP6ADDRLEN * 2; i++, j = j + 2) {
491 char_dname[j] = (char)buf_6[i];
492 if (i != LDNS_IP6ADDRLEN * 2 - 1) {
493 char_dname[j + 1] = '.';
494 }
495 }
496 in_addr = ldns_dname_new_frm_str("ip6.arpa.");
497 if (!in_addr) {
498 LDNS_FREE(char_dname);
499 return NULL;
500 }
501
502 /* convert rev to a string */
503 ret_dname = ldns_dname_new_frm_str(char_dname);
504 LDNS_FREE(char_dname);
505 if (!ret_dname) {
506 ldns_rdf_deep_free(in_addr);
507 return NULL;
508 }
509 break;
510 default:
511 break;
512 }
513 /* add the suffix */
514 rev = ldns_dname_cat_clone(ret_dname, in_addr);
515
516 ldns_rdf_deep_free(ret_dname);
517 ldns_rdf_deep_free(in_addr);
518 return rev;
519 }
520
521 ldns_status
522 ldns_rdf_hip_get_alg_hit_pk(ldns_rdf *rdf, uint8_t* alg,
523 uint8_t *hit_size, uint8_t** hit,
524 uint16_t *pk_size, uint8_t** pk)
525 {
526 uint8_t *data;
527 size_t rdf_size;
528
529 if (! rdf || ! alg || ! hit || ! hit_size || ! pk || ! pk_size) {
530 return LDNS_STATUS_INVALID_POINTER;
531 } else if (ldns_rdf_get_type(rdf) != LDNS_RDF_TYPE_HIP) {
532 return LDNS_STATUS_INVALID_RDF_TYPE;
533 } else if ((rdf_size = ldns_rdf_size(rdf)) < 6) {
534 return LDNS_STATUS_WIRE_RDATA_ERR;
535 }
536 data = ldns_rdf_data(rdf);
537 *hit_size = data[0];
538 *alg = data[1];
539 *pk_size = ldns_read_uint16(data + 2);
540 *hit = data + 4;
541 *pk = data + 4 + *hit_size;
542 if (*hit_size == 0 || *pk_size == 0 ||
543 rdf_size < (size_t) *hit_size + *pk_size + 4) {
544 return LDNS_STATUS_WIRE_RDATA_ERR;
545 }
546 return LDNS_STATUS_OK;
547 }
548
549 ldns_status
550 ldns_rdf_hip_new_frm_alg_hit_pk(ldns_rdf** rdf, uint8_t alg,
551 uint8_t hit_size, uint8_t *hit,
552 uint16_t pk_size, uint8_t *pk)
553 {
554 uint8_t *data;
555
556 if (! rdf) {
557 return LDNS_STATUS_INVALID_POINTER;
558 }
559 if (4 + hit_size + pk_size > LDNS_MAX_RDFLEN) {
560 return LDNS_STATUS_RDATA_OVERFLOW;
561 }
562 data = LDNS_XMALLOC(uint8_t, 4 + hit_size + pk_size);
563 if (data == NULL) {
564 return LDNS_STATUS_MEM_ERR;
565 }
566 data[0] = hit_size;
567 data[1] = alg;
568 ldns_write_uint16(data + 2, pk_size);
569 memcpy(data + 4, hit, hit_size);
570 memcpy(data + 4 + hit_size, pk, pk_size);
571 *rdf = ldns_rdf_new(LDNS_RDF_TYPE_HIP, 4 + hit_size + pk_size, data);
572 if (! *rdf) {
573 LDNS_FREE(data);
574 return LDNS_STATUS_MEM_ERR;
575 }
576 return LDNS_STATUS_OK;
577 }
578
579 ldns_status
580 ldns_octet(char *word, size_t *length)
581 {
582 char *s;
583 char *p;
584 *length = 0;
585
586 for (s = p = word; *s != '\0'; s++,p++) {
587 switch (*s) {
588 case '.':
589 if (s[1] == '.') {
590 return LDNS_STATUS_EMPTY_LABEL;
591 }
592 *p = *s;
593 (*length)++;
594 break;
595 case '\\':
596 if ('0' <= s[1] && s[1] <= '9' &&
597 '0' <= s[2] && s[2] <= '9' &&
598 '0' <= s[3] && s[3] <= '9') {
599 /* \DDD seen */
600 int val = ((s[1] - '0') * 100 +
601 (s[2] - '0') * 10 + (s[3] - '0'));
602
603 if (0 <= val && val <= 255) {
604 /* this also handles \0 */
605 s += 3;
606 *p = val;
607 (*length)++;
608 } else {
609 return LDNS_STATUS_DDD_OVERFLOW;
610 }
611 } else {
612 /* an espaced character, like <space> ?
613 * remove the '\' keep the rest */
614 *p = *++s;
615 (*length)++;
616 }
617 break;
618 case '\"':
619 /* non quoted " Is either first or the last character in
620 * the string */
621
622 *p = *++s; /* skip it */
623 (*length)++;
624 /* I'm not sure if this is needed in libdns... MG */
625 if ( *s == '\0' ) {
626 /* ok, it was the last one */
627 *p = '\0';
628 return LDNS_STATUS_OK;
629 }
630 break;
631 default:
632 *p = *s;
633 (*length)++;
634 break;
635 }
636 }
637 *p = '\0';
638 return LDNS_STATUS_OK;
639 }
640
641 int
642 ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2)
643 {
644 uint16_t i1, i2, i;
645 uint8_t *d1, *d2;
646
647 /* only when both are not NULL we can say anything about them */
648 if (!rd1 && !rd2) {
649 return 0;
650 }
651 if (!rd1 || !rd2) {
652 return -1;
653 }
654 i1 = ldns_rdf_size(rd1);
655 i2 = ldns_rdf_size(rd2);
656
657 if (i1 < i2) {
658 return -1;
659 } else if (i1 > i2) {
660 return +1;
661 } else {
662 d1 = (uint8_t*)ldns_rdf_data(rd1);
663 d2 = (uint8_t*)ldns_rdf_data(rd2);
664 for(i = 0; i < i1; i++) {
665 if (d1[i] < d2[i]) {
666 return -1;
667 } else if (d1[i] > d2[i]) {
668 return +1;
669 }
670 }
671 }
672 return 0;
673 }
674
675 uint32_t
676 ldns_str2period(const char *nptr, const char **endptr)
677 {
678 int sign = 0;
679 uint32_t i = 0;
680 uint32_t seconds = 0;
681
682 for(*endptr = nptr; **endptr; (*endptr)++) {
683 switch (**endptr) {
684 case ' ':
685 case '\t':
686 break;
687 case '-':
688 if(sign == 0) {
689 sign = -1;
690 } else {
691 return seconds;
692 }
693 break;
694 case '+':
695 if(sign == 0) {
696 sign = 1;
697 } else {
698 return seconds;
699 }
700 break;
701 case 's':
702 case 'S':
703 seconds += i;
704 i = 0;
705 break;
706 case 'm':
707 case 'M':
708 seconds += i * 60;
709 i = 0;
710 break;
711 case 'h':
712 case 'H':
713 seconds += i * 60 * 60;
714 i = 0;
715 break;
716 case 'd':
717 case 'D':
718 seconds += i * 60 * 60 * 24;
719 i = 0;
720 break;
721 case 'w':
722 case 'W':
723 seconds += i * 60 * 60 * 24 * 7;
724 i = 0;
725 break;
726 case '0':
727 case '1':
728 case '2':
729 case '3':
730 case '4':
731 case '5':
732 case '6':
733 case '7':
734 case '8':
735 case '9':
736 i *= 10;
737 i += (**endptr - '0');
738 break;
739 default:
740 seconds += i;
741 /* disregard signedness */
742 return seconds;
743 }
744 }
745 seconds += i;
746 /* disregard signedness */
747 return seconds;
748 }
LDNS_RDF_TYPE_TIME
time (32 bits)
Definition: rdata.h:84
ldns_str2rdf_atma
ldns_status ldns_str2rdf_atma(ldns_rdf **rd, const char *str)
convert a str with a ATMA RR into wireformat
Definition: str2host.c:1163
LDNS_STATUS_NULL
Definition: error.h:51
ldns_str2rdf_str
ldns_status ldns_str2rdf_str(ldns_rdf **rd, const char *str)
convert a string into wireformat (think txt record)
Definition: str2host.c:428
ldns_str2rdf_nsec3_salt
ldns_status ldns_str2rdf_nsec3_salt(ldns_rdf **rd, const char *salt_str)
Definition: str2host.c:126
ldns_rdf_deep_free
void ldns_rdf_deep_free(ldns_rdf *rd)
frees a rdf structure and frees the data.
Definition: rdata.c:230
LDNS_RDF_TYPE_B64
b64 string
Definition: rdata.h:68
ldns_native2rdf_int16
ldns_rdf * ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value)
returns the rdf containing the native uint16_t representation.
Definition: rdata.c:132
ldns_str2rdf_loc
ldns_status ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
convert a string with a LOC RR into wireformat
Definition: str2host.c:861
ldns_rdf_hip_get_alg_hit_pk
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)
Gets the algorithm value, the HIT and Public Key data from the rdf with type LDNS_RDF_TYPE_HIP.
Definition: rdata.c:522
ldns_str2rdf_dname
ldns_status ldns_str2rdf_dname(ldns_rdf **d, const char *str)
convert a dname string into wireformat
Definition: str2host.c:311
ldns_int_to_hexdigit
char ldns_int_to_hexdigit(int i)
Returns the char (hex) representation of the given int.
Definition: util.c:113
ldns_rdf2native_int8
uint8_t ldns_rdf2native_int8(const ldns_rdf *rd)
returns the native uint8_t representation from the rdf.
Definition: rdata.c:70
LDNS_RDF_TYPE_UNKNOWN
unknown types
Definition: rdata.h:82
LDNS_STATUS_OK
Definition: error.h:26
ldns_rdf_hip_new_frm_alg_hit_pk
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)
Creates a new LDNS_RDF_TYPE_HIP rdf from given data.
Definition: rdata.c:550
ldns_rdf_address_reverse
ldns_rdf * ldns_rdf_address_reverse(ldns_rdf *rd)
reverses an rdf, only actually useful for AAAA and A records.
Definition: rdata.c:404
LDNS_STATUS_SYNTAX_RDATA_ERR
Definition: error.h:83
LDNS_RDF_TYPE_TYPE
a RR type
Definition: rdata.h:74
LDNS_RDF_TYPE_NONE
none
Definition: rdata.h:48
ldns_str2rdf_alg
ldns_status ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
convert and algorithm value into wireformat
Definition: str2host.c:784
LDNS_XMALLOC
#define LDNS_XMALLOC(type, count)
Definition: util.h:51
ldns_rdf_size
size_t ldns_rdf_size(const ldns_rdf *rd)
returns the size of the rdf.
Definition: rdata.c:24
ldns_str2rdf_aaaa
ldns_status ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str)
convert the str with an AAAA record into wireformat
Definition: str2host.c:414
ldns_str2rdf_b32_ext
ldns_status ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str)
convert the string with the b32 ext hex data into wireformat
Definition: str2host.c:607
LDNS_RDF_SIZE_DOUBLEWORD
#define LDNS_RDF_SIZE_DOUBLEWORD
Definition: rdata.h:35
ldns_str2rdf_nsec
ldns_status ldns_str2rdf_nsec(ldns_rdf **rd, const char *str)
convert string with nsec into wireformat
Definition: str2host.c:680
ldns_str2rdf_eui48
ldns_status ldns_str2rdf_eui48(ldns_rdf **rd, const char *str)
convert 6 hex bytes separated by dashes into wireformat
Definition: str2host.c:1358
ldns_str2rdf_hip
ldns_status ldns_str2rdf_hip(ldns_rdf **rd, const char *str)
Convert a "<algorithm> <hit> <pk>" encoding of the value field as specified in Section 6...
Definition: str2host.c:1480
ldns_rdf_clone
ldns_rdf * ldns_rdf_clone(const ldns_rdf *rd)
clones a rdf structure.
Definition: rdata.c:222
LDNS_RDF_TYPE_CLASS
a class
Definition: rdata.h:76
ldns_rdf_set_size
void ldns_rdf_set_size(ldns_rdf *rd, size_t size)
sets the size of the rdf.
Definition: rdata.c:46
LDNS_RDF_TYPE_IPSECKEY
IPSECKEY.
Definition: rdata.h:107
LDNS_STATUS_INVALID_RDF_TYPE
Definition: error.h:128
ldns_str2rdf_time
ldns_status ldns_str2rdf_time(ldns_rdf **rd, const char *time)
convert a time string to a time value in wireformat
Definition: str2host.c:57
LDNS_RDF_SIZE_BYTE
#define LDNS_RDF_SIZE_BYTE
Definition: rdata.h:33
LDNS_STATUS_INVALID_POINTER
Definition: error.h:33
ldns_rdf_set_data
void ldns_rdf_set_data(ldns_rdf *rd, void *data)
sets the size of the rdf.
Definition: rdata.c:60
LDNS_RDF_TYPE_SERVICE
protocol and port bitmaps
Definition: rdata.h:97
LDNS_RDF_TYPE_TAG
A non-zero sequence of US-ASCII letters and numbers in lower case.
Definition: rdata.h:126
LDNS_RDF_TYPE_LONG_STR
A <character-string> encoding of the value field as specified [RFC1035], Section 5.1., encoded as remaining rdata.
Definition: rdata.h:132
LDNS_RDF_TYPE_APL
apl data
Definition: rdata.h:64
ldns_rdf_free
void ldns_rdf_free(ldns_rdf *rd)
frees a rdf structure, leaving the data pointer intact.
Definition: rdata.c:241
ldns.h
Including this file will include all ldns files, and define some lookup tables.
ldns_dname_new_frm_str
ldns_rdf * ldns_dname_new_frm_str(const char *str)
creates a new dname rdf from a string.
Definition: dname.c:265
ldns_native2rdf_int8
ldns_rdf * ldns_native2rdf_int8(ldns_rdf_type type, uint8_t value)
returns the rdf containing the native uint8_t repr.
Definition: rdata.c:126
LDNS_RDF_TYPE_CERT_ALG
certificate algorithm
Definition: rdata.h:78
ldns_native2rdf_int32
ldns_rdf * ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value)
returns an rdf that contains the given int32 value.
Definition: rdata.c:147
ldns_rdf_data
uint8_t * ldns_rdf_data(const ldns_rdf *rd)
returns the data of the rdf.
Definition: rdata.c:38
ldns_str2rdf_apl
ldns_status ldns_str2rdf_apl(ldns_rdf **rd, const char *str)
convert str with the apl record into wireformat
Definition: str2host.c:471
ldns_rdf_type
enum ldns_enum_rdf_type ldns_rdf_type
Definition: rdata.h:137
ldns_rdf_set_type
void ldns_rdf_set_type(ldns_rdf *rd, ldns_rdf_type type)
sets the size of the rdf.
Definition: rdata.c:53
LDNS_RDF_TYPE_INT16
16 bits
Definition: rdata.h:54
ldns_str2rdf_service
ldns_status ldns_str2rdf_service(ldns_rdf **rd __attribute__((unused)), const char *str __attribute__((unused)))
Definition: str2host.c:816
ldns_rdf_new_frm_fp
ldns_status ldns_rdf_new_frm_fp(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp)
creates a new rdf from a file containing a string.
Definition: rdata.c:371
LDNS_IP4ADDRLEN
#define LDNS_IP4ADDRLEN
Definition: ldns.h:131
ldns_struct_rdf::_data
void * _data
Pointer to the data (raw octets)
Definition: rdata.h:173
LDNS_RDF_TYPE_NSAP
NSAP.
Definition: rdata.h:103
ldns_str2rdf_hex
ldns_status ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
convert a hex value into wireformat
Definition: str2host.c:634
LDNS_RDF_TYPE_INT16_DATA
variable length any type rdata where the length is specified by the first 2 bytes ...
Definition: rdata.h:95
LDNS_RDF_TYPE_ALG
a key algorithm
Definition: rdata.h:80
LDNS_STATUS_WIRE_RDATA_ERR
Definition: error.h:125
ldns_rdf2native_int16
uint16_t ldns_rdf2native_int16(const ldns_rdf *rd)
returns the native uint16_t representation from the rdf.
Definition: rdata.c:84
ldns_rdf2native_time_t
time_t ldns_rdf2native_time_t(const ldns_rdf *rd)
returns the native time_t representation from the rdf.
Definition: rdata.c:112
LDNS_RDF_TYPE_B32_EXT
b32 string
Definition: rdata.h:66
LDNS_RDF_TYPE_A
A record.
Definition: rdata.h:58
LDNS_RDF_TYPE_NSEC
nsec type codes
Definition: rdata.h:72
LDNS_IP6ADDRLEN
#define LDNS_IP6ADDRLEN
Definition: ldns.h:132
ldns_str2rdf_long_str
ldns_status ldns_str2rdf_long_str(ldns_rdf **rd, const char *str)
Convert a <character-string> encoding of the value field as specified [RFC1035], Section 5...
Definition: str2host.c:1439
LDNS_RDF_TYPE_AAAA
AAAA record.
Definition: rdata.h:60
LDNS_RDF_TYPE_INT32
32 bits
Definition: rdata.h:56
ldns_rdf_new_frm_str
ldns_rdf * ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str)
creates a new rdf from a string.
Definition: rdata.c:249
ldns_dname_cat_clone
ldns_rdf * ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2)
concatenates two dnames together
Definition: dname.c:52
ldns_str2rdf_tag
ldns_status ldns_str2rdf_tag(ldns_rdf **rd, const char *str)
Convert a non-zero sequence of US-ASCII letters and numbers into wireformat.
Definition: str2host.c:1410
ldns_native2rdf_int16_data
ldns_rdf * ldns_native2rdf_int16_data(size_t size, uint8_t *data)
returns an int16_data rdf that contains the data in the given array, preceded by an int16 specifying ...
Definition: rdata.c:162
ldns_str2rdf_cert_alg
ldns_status ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str)
convert an certificate algorithm value into wireformat
Definition: str2host.c:753
ldns_str2rdf_int16
ldns_status ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr)
convert a string to a int16 in wireformat
Definition: str2host.c:36
ldns_str2rdf_nsap
ldns_status ldns_str2rdf_nsap(ldns_rdf **rd, const char *str)
convert a str with a NSAP RR into wireformat
Definition: str2host.c:1144
ldns_fget_token_l
ssize_t ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr)
returns a token/char from the stream F.
Definition: parse.c:31
LDNS_RDF_TYPE_HEX
hex string
Definition: rdata.h:70
ldns_rdf_get_type
ldns_rdf_type ldns_rdf_get_type(const ldns_rdf *rd)
returns the type of the rdf.
Definition: rdata.c:31
LDNS_RDF_TYPE_PERIOD
period
Definition: rdata.h:86
LDNS_RDF_TYPE_STR
txt string
Definition: rdata.h:62
ldns_rdf2native_int32
uint32_t ldns_rdf2native_int32(const ldns_rdf *rd)
returns the native uint32_t representation from the rdf.
Definition: rdata.c:98
ldns_str2rdf_wks
ldns_status ldns_str2rdf_wks(ldns_rdf **rd, const char *str)
convert string with a WKS RR into wireformat
Definition: str2host.c:1036
ldns_octet
ldns_status ldns_octet(char *word, size_t *length)
removes \DDD, \[space] and other escapes from the input.
Definition: rdata.c:580
ldns_str2rdf_ipseckey
ldns_status ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
convert a str with a IPSECKEY RR into wireformat
Definition: str2host.c:1183
ldns_str2period
uint32_t ldns_str2period(const char *nptr, const char **endptr)
converts a ttl value (like 5d2h) to a long.
Definition: rdata.c:676
LDNS_STATUS_MEM_ERR
Definition: error.h:34
LDNS_RDF_TYPE_NSEC3_NEXT_OWNER
nsec3 base32 string (with length byte on wire
Definition: rdata.h:111
ldns_status
enum ldns_enum_status ldns_status
Definition: error.h:131
ldns_rdf_new_frm_data
ldns_rdf * ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data)
allocates a new rdf structure and fills it.
Definition: rdata.c:193
LDNS_MALLOC
#define LDNS_MALLOC(type)
Memory management macros.
Definition: util.h:49
LDNS_STATUS_DDD_OVERFLOW
Definition: error.h:31
ldns_rdf_new
ldns_rdf * ldns_rdf_new(ldns_rdf_type type, size_t size, void *data)
allocates a new rdf structure and fills it.
Definition: rdata.c:179
LDNS_RDF_SIZE_WORD
#define LDNS_RDF_SIZE_WORD
Definition: rdata.h:34
LDNS_PARSE_SKIP_SPACE
#define LDNS_PARSE_SKIP_SPACE
Definition: parse.h:20
LDNS_STATUS_RDATA_OVERFLOW
Definition: error.h:129
ldns_str2rdf_unknown
ldns_status ldns_str2rdf_unknown(ldns_rdf **rd __attribute__((unused)), const char *str __attribute__((unused)))
Definition: str2host.c:806
ldns_str2rdf_ilnp64
ldns_status ldns_str2rdf_ilnp64(ldns_rdf **rd, const char *str)
convert 4 * 16bit hex separated by colons into wireformat
Definition: str2host.c:1335
ldns_struct_rdf::_size
size_t _size
The size of the data (in octets)
Definition: rdata.h:169
LDNS_STATUS_EMPTY_LABEL
Definition: error.h:27
LDNS_RDF_TYPE_ILNP64
4 shorts represented as 4 * 16 bit hex numbers separated by colons.
Definition: rdata.h:116
ldns_rdf2str
char * ldns_rdf2str(const ldns_rdf *rdf)
Converts the data in the rdata field to presentation format and returns that as a char *...
Definition: host2str.c:2371
ldns_str2rdf_b64
ldns_status ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
convert the string with the b64 data into wireformat
Definition: str2host.c:582
LDNS_MAX_LINELEN
#define LDNS_MAX_LINELEN
Definition: parse.h:23
ldns_struct_rdf
Resource record data field.
Definition: rdata.h:166
ldns_str2rdf_eui64
ldns_status ldns_str2rdf_eui64(ldns_rdf **rd, const char *str)
convert 8 hex bytes separated by dashes into wireformat
Definition: str2host.c:1383
LDNS_RDF_TYPE_HIP
Represents the Public Key Algorithm, HIT and Public Key fields for the HIP RR types.
Definition: rdata.h:92
ldns_rdf_new_frm_fp_l
ldns_status ldns_rdf_new_frm_fp_l(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp, int *line_nr)
creates a new rdf from a file containing a string.
Definition: rdata.c:377
LDNS_RDF_TYPE_NSEC3_SALT
nsec3 hash salt
Definition: rdata.h:109
ldns_str2rdf_a
ldns_status ldns_str2rdf_a(ldns_rdf **rd, const char *str)
convert str with an A record into wireformat
Definition: str2host.c:401
LDNS_RDF_TYPE_INT8
8 bits
Definition: rdata.h:52
ldns_str2rdf_period
ldns_status ldns_str2rdf_period(ldns_rdf **rd, const char *period)
Definition: str2host.c:178
ldns_struct_rdf::_type
ldns_rdf_type _type
The type of the data.
Definition: rdata.h:171
LDNS_FREE
#define LDNS_FREE(ptr)
Definition: util.h:60
ldns_str2rdf_int8
ldns_status ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr)
convert a byte into wireformat
Definition: str2host.c:228
ldns_str2rdf_class
ldns_status ldns_str2rdf_class(ldns_rdf **rd, const char *str)
convert string with a classname into wireformat
Definition: str2host.c:739
LDNS_RDF_TYPE_DNAME
domain name
Definition: rdata.h:50
LDNS_RDF_TYPE_LOC
location data
Definition: rdata.h:99
LDNS_RDF_TYPE_EUI64
8 * 8 bit hex numbers separated by dashes.
Definition: rdata.h:121
LDNS_MAX_RDFLEN
#define LDNS_MAX_RDFLEN
Definition: rdata.h:31
LDNS_RDF_TYPE_EUI48
6 * 8 bit hex numbers separated by dashes.
Definition: rdata.h:119
LDNS_RDF_TYPE_WKS
well known services
Definition: rdata.h:101
LDNS_RDF_TYPE_ATMA
ATMA.
Definition: rdata.h:105
ldns_rdf_compare
int ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2)
compares two rdf&#39;s on their wire formats.
Definition: rdata.c:642
ldns_str2rdf_int32
ldns_status ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr)
convert a strings into a 4 byte int in wireformat
Definition: str2host.c:197
LDNS_STATUS_ERR
Definition: error.h:37
config.h
ldns_str2rdf_type
ldns_status ldns_str2rdf_type(ldns_rdf **rd, const char *str)
convert a rrtype into wireformat
Definition: str2host.c:728