4 * conversion routines from the presentation format
7 * a Net::DNS like library for C
9 * (c) NLnet Labs, 2004-2006
11 * See the file LICENSE for the license
13 #include <ldns/config.h>
15 #include <ldns/ldns.h>
17 #ifdef HAVE_SYS_SOCKET_H
18 #include <sys/socket.h>
20 #ifdef HAVE_ARPA_INET_H
21 #include <arpa/inet.h>
31 #ifdef HAVE_SYS_PARAM_H
32 #include <sys/param.h>
36 ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr)
40 r = LDNS_MALLOC(uint16_t);
41 if(!r) return LDNS_STATUS_MEM_ERR;
43 *r = htons((uint16_t)strtol((char *)shortstr, &end, 10));
47 return LDNS_STATUS_INVALID_INT;
49 *rd = ldns_rdf_new_frm_data(
50 LDNS_RDF_TYPE_INT16, sizeof(uint16_t), r);
52 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
57 ldns_str2rdf_time(ldns_rdf **rd, const char *time)
59 /* convert a time YYYYDDMMHHMMSS to wireformat */
65 /* Try to scan the time... */
66 r = (uint16_t*)LDNS_MALLOC(uint32_t);
67 if(!r) return LDNS_STATUS_MEM_ERR;
69 memset(&tm, 0, sizeof(tm));
71 if (strlen(time) == 14 &&
72 sscanf(time, "%4d%2d%2d%2d%2d%2d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec) == 6
77 if (tm.tm_year < 70) {
80 if (tm.tm_mon < 0 || tm.tm_mon > 11) {
83 if (tm.tm_mday < 1 || tm.tm_mday > 31) {
87 if (tm.tm_hour < 0 || tm.tm_hour > 23) {
91 if (tm.tm_min < 0 || tm.tm_min > 59) {
95 if (tm.tm_sec < 0 || tm.tm_sec > 59) {
99 l = htonl(mktime_from_utc(&tm));
100 memcpy(r, &l, sizeof(uint32_t));
101 *rd = ldns_rdf_new_frm_data(
102 LDNS_RDF_TYPE_TIME, sizeof(uint32_t), r);
104 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
106 /* handle it as 32 bits timestamp */
107 l = htonl((uint32_t)strtol((char*)time, &end, 10));
110 return LDNS_STATUS_ERR;
112 memcpy(r, &l, sizeof(uint32_t));
113 *rd = ldns_rdf_new_frm_data(
114 LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
116 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
122 return LDNS_STATUS_INVALID_TIME;
126 ldns_str2rdf_nsec3_salt(ldns_rdf **rd, const char *salt_str)
135 return LDNS_STATUS_NULL;
138 salt_length_str = (int)strlen(salt_str);
139 if (salt_length_str == 1 && salt_str[0] == '-') {
141 } else if (salt_length_str % 2 != 0) {
142 return LDNS_STATUS_INVALID_HEX;
144 if (salt_length_str > 512) {
145 return LDNS_STATUS_INVALID_HEX;
148 salt = LDNS_XMALLOC(uint8_t, salt_length_str / 2);
150 return LDNS_STATUS_MEM_ERR;
152 for (c = 0; c < salt_length_str; c += 2) {
153 if (isxdigit((int) salt_str[c]) && isxdigit((int) salt_str[c+1])) {
154 salt[c/2] = (uint8_t) ldns_hexdigit_to_int(salt_str[c]) * 16 +
155 ldns_hexdigit_to_int(salt_str[c+1]);
158 return LDNS_STATUS_INVALID_HEX;
161 salt_length = (uint8_t) (salt_length_str / 2);
163 data = LDNS_XMALLOC(uint8_t, 1 + salt_length);
166 return LDNS_STATUS_MEM_ERR;
168 data[0] = salt_length;
169 memcpy(&data[1], salt, salt_length);
170 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_NSEC3_SALT, 1 + salt_length, data);
174 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
178 ldns_str2rdf_period(ldns_rdf **rd,const char *period)
183 /* Allocate required space... */
184 p = ldns_str2period(period, &end);
187 return LDNS_STATUS_ERR;
189 p = (uint32_t) htonl(p);
190 *rd = ldns_rdf_new_frm_data(
191 LDNS_RDF_TYPE_PERIOD, sizeof(uint32_t), &p);
193 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
197 ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr)
203 r = (uint16_t*)LDNS_MALLOC(uint32_t);
204 if(!r) return LDNS_STATUS_MEM_ERR;
205 errno = 0; /* must set to zero before call,
206 note race condition on errno */
208 l = htonl((uint32_t)strtol((char*)longstr, &end, 10));
209 else l = htonl((uint32_t)strtoul((char*)longstr, &end, 10));
213 return LDNS_STATUS_ERR;
215 if (errno == ERANGE) {
217 return LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW;
219 memcpy(r, &l, sizeof(uint32_t));
220 *rd = ldns_rdf_new_frm_data(
221 LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
223 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
228 ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr)
233 r = LDNS_MALLOC(uint8_t);
234 if(!r) return LDNS_STATUS_MEM_ERR;
236 *r = (uint8_t)strtol((char*)bytestr, &end, 10);
240 return LDNS_STATUS_ERR;
242 *rd = ldns_rdf_new_frm_data(
243 LDNS_RDF_TYPE_INT8, sizeof(uint8_t), r);
245 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
251 * Checks whether the escaped value at **s is an octal value or
252 * a 'normally' escaped character (and not eos)
254 * The string pointer at *s is increased by either 0 (on error), 1 (on
255 * normal escapes), or 3 (on octals)
257 * Returns the number of bytes read from the escaped string, or
261 parse_escape(uint8_t *s, uint8_t *q) {
263 if (strlen((char *)s) > 3 &&
264 isdigit((int) s[1]) &&
265 isdigit((int) s[2]) &&
266 isdigit((int) s[3])) {
267 /* cast this so it fits */
268 val = (uint8_t) ldns_hexdigit_to_int((char) s[1]) * 100 +
269 ldns_hexdigit_to_int((char) s[2]) * 10 +
270 ldns_hexdigit_to_int((char) s[3]);
275 if (*s == '\0' || isdigit((int) *s)) {
276 /* apparently the string terminator
277 * or a digit has been escaped...
287 * No special care is taken, all dots are translated into
289 * Could be made more efficient....we do 3 memcpy's in total...
292 ldns_str2rdf_dname(ldns_rdf **d, const char *str)
297 uint8_t *s, *q, *pq, label_len;
298 uint8_t buf[LDNS_MAX_DOMAINLEN + 1];
301 len = strlen((char*)str);
302 /* octet representation can make strings a lot longer than actual length */
303 if (len > LDNS_MAX_DOMAINLEN * 4) {
304 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
307 return LDNS_STATUS_DOMAINNAME_UNDERFLOW;
311 if (1 == len && *str == '.') {
312 *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, 1, "\0");
313 return LDNS_STATUS_OK;
316 /* get on with the rest */
318 /* s is on the current character in the string
319 * pq points to where the labellength is going to go
320 * label_len keeps track of the current label's length
321 * q builds the dname inside the buf array
327 for (s = (uint8_t *)str; *s; s++, q++) {
328 if (q > buf + LDNS_MAX_DOMAINLEN) {
329 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
334 if (label_len > LDNS_MAX_LABELLEN) {
335 return LDNS_STATUS_LABEL_OVERFLOW;
337 if (label_len == 0) {
338 return LDNS_STATUS_EMPTY_LABEL;
340 len += label_len + 1;
346 /* octet value or literal char */
347 esc = parse_escape(s, q);
352 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
361 /* add root label if last char was not '.' */
362 if (!ldns_dname_str_absolute(str)) {
363 if (q > buf + LDNS_MAX_DOMAINLEN) {
364 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
366 if (label_len > LDNS_MAX_LABELLEN) {
367 return LDNS_STATUS_LABEL_OVERFLOW;
369 if (label_len == 0) { /* label_len 0 but not . at end? */
370 return LDNS_STATUS_EMPTY_LABEL;
372 len += label_len + 1;
378 *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, len, buf);
379 return LDNS_STATUS_OK;
383 ldns_str2rdf_a(ldns_rdf **rd, const char *str)
386 if (inet_pton(AF_INET, (char*)str, &address) != 1) {
387 return LDNS_STATUS_INVALID_IP4;
389 *rd = ldns_rdf_new_frm_data(
390 LDNS_RDF_TYPE_A, sizeof(address), &address);
392 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
396 ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str)
398 uint8_t address[LDNS_IP6ADDRLEN + 1];
400 if (inet_pton(AF_INET6, (char*)str, address) != 1) {
401 return LDNS_STATUS_INVALID_IP6;
403 *rd = ldns_rdf_new_frm_data(
404 LDNS_RDF_TYPE_AAAA, sizeof(address) - 1, &address);
406 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
410 ldns_str2rdf_str(ldns_rdf **rd, const char *str)
413 size_t i, str_i, esc_i;
415 if (strlen(str) > 255) {
416 return LDNS_STATUS_INVALID_STR;
419 data = LDNS_XMALLOC(uint8_t, strlen(str) + 1);
420 if(!data) return LDNS_STATUS_MEM_ERR;
423 for (str_i = 0; str_i < strlen(str); str_i++) {
424 if (str[str_i] == '\\') {
425 /* octet value or literal char */
426 esc_i = (size_t) parse_escape((uint8_t*) &str[str_i], (uint8_t*) &data[i]);
429 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
433 data[i] = (uint8_t) str[str_i];
438 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_STR, i, data);
441 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
445 ldns_str2rdf_apl(ldns_rdf **rd, const char *str)
447 const char *my_str = str;
454 uint8_t afdlength = 0;
462 /* [!]afi:address/prefix */
463 if (strlen(my_str) < 2
464 || strchr(my_str, ':') == NULL
465 || strchr(my_str, '/') == NULL
466 || strchr(my_str, ':') > strchr(my_str, '/')) {
467 return LDNS_STATUS_INVALID_STR;
470 if (my_str[0] == '!') {
477 family = (uint16_t) atoi(my_str);
479 my_str = strchr(my_str, ':') + 1;
481 /* need ip addr and only ip addr for inet_pton */
482 ip_str_len = (size_t) (strchr(my_str, '/') - my_str);
483 my_ip_str = LDNS_XMALLOC(char, ip_str_len + 1);
484 if(!my_ip_str) return LDNS_STATUS_MEM_ERR;
485 strncpy(my_ip_str, my_str, ip_str_len + 1);
486 my_ip_str[ip_str_len] = '\0';
490 afdpart = LDNS_XMALLOC(uint8_t, 4);
492 LDNS_FREE(my_ip_str);
493 return LDNS_STATUS_MEM_ERR;
495 if (inet_pton(AF_INET, my_ip_str, afdpart) == 0) {
496 LDNS_FREE(my_ip_str);
498 return LDNS_STATUS_INVALID_STR;
500 for (i = 0; i < 4; i++) {
501 if (afdpart[i] != 0) {
505 } else if (family == 2) {
507 afdpart = LDNS_XMALLOC(uint8_t, 16);
509 LDNS_FREE(my_ip_str);
510 return LDNS_STATUS_MEM_ERR;
512 if (inet_pton(AF_INET6, my_ip_str, afdpart) == 0) {
513 LDNS_FREE(my_ip_str);
515 return LDNS_STATUS_INVALID_STR;
517 for (i = 0; i < 16; i++) {
518 if (afdpart[i] != 0) {
524 LDNS_FREE(my_ip_str);
525 return LDNS_STATUS_INVALID_STR;
528 my_str = strchr(my_str, '/') + 1;
529 prefix = (uint8_t) atoi(my_str);
531 data = LDNS_XMALLOC(uint8_t, 4 + afdlength);
533 LDNS_FREE(my_ip_str);
534 return LDNS_STATUS_INVALID_STR;
536 ldns_write_uint16(data, family);
540 /* set bit 1 of byte 3 */
541 data[3] = data[3] | 0x80;
544 memcpy(data + 4, afdpart, afdlength);
546 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_APL, afdlength + 4, data);
549 LDNS_FREE(my_ip_str);
551 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
555 ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
560 buffer = LDNS_XMALLOC(uint8_t, ldns_b64_ntop_calculate_size(strlen(str)));
562 return LDNS_STATUS_MEM_ERR;
565 i = (uint16_t)ldns_b64_pton((const char*)str, buffer,
566 ldns_b64_ntop_calculate_size(strlen(str)));
569 return LDNS_STATUS_INVALID_B64;
571 *rd = ldns_rdf_new_frm_data(
572 LDNS_RDF_TYPE_B64, (uint16_t) i, buffer);
576 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
580 ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str)
584 /* first byte contains length of actual b32 data */
585 uint8_t len = ldns_b32_pton_calculate_size(strlen(str));
586 buffer = LDNS_XMALLOC(uint8_t, len + 1);
588 return LDNS_STATUS_MEM_ERR;
592 i = ldns_b32_pton_extended_hex((const char*)str, strlen(str), buffer + 1,
593 ldns_b32_ntop_calculate_size(strlen(str)));
596 return LDNS_STATUS_INVALID_B32_EXT;
598 *rd = ldns_rdf_new_frm_data(
599 LDNS_RDF_TYPE_B32_EXT, (uint16_t) i + 1, buffer);
603 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
607 ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
615 if (len > LDNS_MAX_RDFLEN * 2) {
616 return LDNS_STATUS_LABEL_OVERFLOW;
618 t = LDNS_XMALLOC(uint8_t, (len / 2) + 1);
620 return LDNS_STATUS_MEM_ERR;
623 /* Now process octet by octet... */
626 if (isspace((int) *str)) {
629 for (i = 16; i >= 1; i -= 15) {
630 while (*str && isspace((int) *str)) { str++; }
632 if (isxdigit((int) *str)) {
633 *t += ldns_hexdigit_to_int(*str) * i;
636 return LDNS_STATUS_ERR;
644 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX,
645 (size_t) (t - t_orig),
649 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
653 ldns_str2rdf_nsec(ldns_rdf **rd, const char *str)
655 const char *delimiters = "\n\t ";
656 char *token = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
657 ldns_buffer *str_buf;
660 size_t type_count = 0;
661 ldns_rr_type type_list[65536];
662 if(!token) return LDNS_STATUS_MEM_ERR;
665 return LDNS_STATUS_NULL;
668 str_buf = LDNS_MALLOC(ldns_buffer);
671 return LDNS_STATUS_MEM_ERR;
673 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
674 if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
677 return LDNS_STATUS_MEM_ERR;
680 while ((c = ldns_bget_token(str_buf, token, delimiters, LDNS_MAX_RDFLEN)) != -1 && c != 0) {
681 if(type_count >= sizeof(type_list)) {
684 return LDNS_STATUS_ERR;
686 cur_type = ldns_get_rr_type_by_name(token);
687 type_list[type_count] = cur_type;
691 *rd = ldns_dnssec_create_nsec_bitmap(type_list,
696 ldns_buffer_free(str_buf);
697 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
701 ldns_str2rdf_type(ldns_rdf **rd, const char *str)
704 type = htons(ldns_get_rr_type_by_name(str));
705 /* ldns_rr_type is a 16 bit value */
706 *rd = ldns_rdf_new_frm_data(
707 LDNS_RDF_TYPE_TYPE, sizeof(uint16_t), &type);
708 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
712 ldns_str2rdf_class(ldns_rdf **rd, const char *str)
715 klass = htons(ldns_get_rr_class_by_name(str));
716 /* class is 16 bit */
717 *rd = ldns_rdf_new_frm_data(
718 LDNS_RDF_TYPE_CLASS, sizeof(uint16_t), &klass);
719 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
722 /* An certificate alg field can either be specified as a 8 bits number
723 * or by its symbolic name. Handle both
726 ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str)
728 ldns_lookup_table *lt;
731 lt = ldns_lookup_by_name(ldns_cert_algorithms, str);
735 ldns_write_uint16(idd, (uint16_t) lt->id);
736 *rd = ldns_rdf_new_frm_data(
737 LDNS_RDF_TYPE_INT16, sizeof(uint16_t), idd);
739 st = LDNS_STATUS_ERR;
742 /* try as-is (a number) */
743 st = ldns_str2rdf_int16(rd, str);
744 if (st == LDNS_STATUS_OK &&
745 ldns_rdf2native_int16(*rd) == 0) {
746 st = LDNS_STATUS_CERT_BAD_ALGORITHM;
753 /* An alg field can either be specified as a 8 bits number
754 * or by its symbolic name. Handle both
757 ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
759 ldns_lookup_table *lt;
762 lt = ldns_lookup_by_name(ldns_algorithms, str);
766 /* it was given as a integer */
767 *rd = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t) lt->id);
769 st = LDNS_STATUS_ERR;
772 /* try as-is (a number) */
773 st = ldns_str2rdf_int8(rd, str);
779 ldns_str2rdf_unknown(ldns_rdf **rd, const char *str)
781 /* this should be caught in an earlier time (general str2host for
785 return LDNS_STATUS_NOT_IMPL;
789 ldns_str2rdf_tsig(ldns_rdf **rd, const char *str)
791 /* there is no strign representation for TSIG rrs */
794 return LDNS_STATUS_NOT_IMPL;
798 ldns_str2rdf_service(ldns_rdf **rd, const char *str)
800 /* is this used? is this actually WKS? or SRV? */
803 return LDNS_STATUS_NOT_IMPL;
807 loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e)
809 /* read <digits>[.<digits>][mM] */
810 /* into mantissa exponent format for LOC type */
811 uint32_t meters = 0, cm = 0, val;
812 while (isblank(*my_str)) {
815 meters = (uint32_t)strtol(my_str, &my_str, 10);
816 if (*my_str == '.') {
818 cm = (uint32_t)strtol(my_str, &my_str, 10);
835 if (*my_str == 'm' || *my_str == 'M') {
843 ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
845 uint32_t latitude = 0;
846 uint32_t longitude = 0;
847 uint32_t altitude = 0;
850 uint32_t equator = (uint32_t) ldns_power(2, 31);
854 uint8_t size_b = 1, size_e = 2;
855 uint8_t horiz_pre_b = 1, horiz_pre_e = 6;
856 uint8_t vert_pre_b = 1, vert_pre_e = 3;
862 char *my_str = (char *) str;
864 /* only support version 0 */
865 if (isdigit((int) *my_str)) {
866 h = (uint32_t) strtol(my_str, &my_str, 10);
868 return LDNS_STATUS_INVALID_STR;
871 while (isblank((int) *my_str)) {
875 if (isdigit((int) *my_str)) {
876 m = (uint32_t) strtol(my_str, &my_str, 10);
877 } else if (*my_str == 'N' || *my_str == 'S') {
880 return LDNS_STATUS_INVALID_STR;
883 while (isblank((int) *my_str)) {
887 if (isdigit((int) *my_str)) {
888 s = strtod(my_str, &my_str);
891 while (isblank((int) *my_str)) {
895 if (*my_str == 'N') {
897 } else if (*my_str == 'S') {
900 return LDNS_STATUS_INVALID_STR;
907 /* add a little to make floor in conversion a round */
909 latitude = (uint32_t) s;
910 latitude += 1000 * 60 * m;
911 latitude += 1000 * 60 * 60 * h;
913 latitude = equator + latitude;
915 latitude = equator - latitude;
917 while (isblank(*my_str)) {
921 if (isdigit((int) *my_str)) {
922 h = (uint32_t) strtol(my_str, &my_str, 10);
924 return LDNS_STATUS_INVALID_STR;
927 while (isblank((int) *my_str)) {
931 if (isdigit((int) *my_str)) {
932 m = (uint32_t) strtol(my_str, &my_str, 10);
933 } else if (*my_str == 'E' || *my_str == 'W') {
936 return LDNS_STATUS_INVALID_STR;
939 while (isblank(*my_str)) {
943 if (isdigit((int) *my_str)) {
944 s = strtod(my_str, &my_str);
948 while (isblank(*my_str)) {
952 if (*my_str == 'E') {
954 } else if (*my_str == 'W') {
957 return LDNS_STATUS_INVALID_STR;
964 /* add a little to make floor in conversion a round */
966 longitude = (uint32_t) s;
967 longitude += 1000 * 60 * m;
968 longitude += 1000 * 60 * 60 * h;
971 longitude += equator;
973 longitude = equator - longitude;
976 altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 +
978 if (*my_str == 'm' || *my_str == 'M') {
982 if (strlen(my_str) > 0) {
983 if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e))
984 return LDNS_STATUS_INVALID_STR;
987 if (strlen(my_str) > 0) {
988 if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e))
989 return LDNS_STATUS_INVALID_STR;
992 if (strlen(my_str) > 0) {
993 if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e))
994 return LDNS_STATUS_INVALID_STR;
997 data = LDNS_XMALLOC(uint8_t, 16);
999 return LDNS_STATUS_MEM_ERR;
1003 data[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f);
1004 data[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f);
1005 data[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f);
1006 ldns_write_uint32(data + 4, latitude);
1007 ldns_write_uint32(data + 8, longitude);
1008 ldns_write_uint32(data + 12, altitude);
1010 *rd = ldns_rdf_new_frm_data(
1011 LDNS_RDF_TYPE_LOC, 16, data);
1014 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
1018 ldns_str2rdf_wks(ldns_rdf **rd, const char *str)
1020 uint8_t *bitmap = NULL;
1024 struct protoent *proto = NULL;
1025 struct servent *serv = NULL;
1028 ldns_buffer *str_buf;
1030 char *proto_str = NULL;
1032 if(strlen(str) == 0)
1033 token = LDNS_XMALLOC(char, 50);
1034 else token = LDNS_XMALLOC(char, strlen(str)+2);
1035 if(!token) return LDNS_STATUS_MEM_ERR;
1037 str_buf = LDNS_MALLOC(ldns_buffer);
1038 if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1039 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1040 if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1043 return LDNS_STATUS_MEM_ERR;
1046 while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1048 proto_str = strdup(token);
1052 ldns_buffer_free(str_buf);
1053 return LDNS_STATUS_INVALID_STR;
1056 serv = getservbyname(token, proto_str);
1058 serv_port = (int) ntohs((uint16_t) serv->s_port);
1060 serv_port = atoi(token);
1062 if (serv_port / 8 >= bm_len) {
1063 uint8_t *b2 = LDNS_XREALLOC(bitmap, uint8_t, (serv_port / 8) + 1);
1067 ldns_buffer_free(str_buf);
1069 return LDNS_STATUS_INVALID_STR;
1072 /* set to zero to be sure */
1073 for (; bm_len <= serv_port / 8; bm_len++) {
1077 ldns_set_bit(bitmap + (serv_port / 8), 7 - (serv_port % 8), true);
1081 if (!proto_str || !bitmap) {
1084 ldns_buffer_free(str_buf);
1086 return LDNS_STATUS_INVALID_STR;
1089 data = LDNS_XMALLOC(uint8_t, bm_len + 1);
1092 ldns_buffer_free(str_buf);
1095 return LDNS_STATUS_INVALID_STR;
1098 proto = getprotobyname(proto_str);
1100 data[0] = (uint8_t) proto->p_proto;
1101 } else if (proto_str) {
1102 data[0] = (uint8_t) atoi(proto_str);
1106 memcpy(data + 1, bitmap, (size_t) bm_len);
1108 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_WKS, (uint16_t) (bm_len + 1), data);
1112 ldns_buffer_free(str_buf);
1115 #ifdef HAVE_ENDSERVENT
1118 #ifdef HAVE_ENDPROTOENT
1122 if(!*rd) return LDNS_STATUS_MEM_ERR;
1124 return LDNS_STATUS_OK;
1128 ldns_str2rdf_nsap(ldns_rdf **rd, const char *str)
1131 char* nsap_str = (char*) str;
1133 /* just a hex string with optional dots? */
1134 if (str[0] != '0' || str[1] != 'x') {
1135 return LDNS_STATUS_INVALID_STR;
1138 for (i=0; i < len; i++) {
1139 if (nsap_str[i] == '.')
1142 return ldns_str2rdf_hex(rd, str+2);
1147 ldns_str2rdf_atma(ldns_rdf **rd, const char *str)
1150 char* atma_str = (char*) str;
1153 /* just a hex string with optional dots? */
1155 for (i=0; i < len; i++) {
1156 if (atma_str[i] == '.')
1159 status = ldns_str2rdf_hex(rd, str);
1160 if (status != LDNS_STATUS_OK) {
1161 ; /* probably in e.164 format than */
1167 ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
1169 uint8_t precedence = 0;
1170 uint8_t gateway_type = 0;
1171 uint8_t algorithm = 0;
1172 char* gateway = NULL;
1173 char* publickey = NULL;
1175 ldns_buffer *str_buf;
1177 int token_count = 0;
1178 int ipseckey_len = 0;
1179 ldns_rdf* gateway_rdf = NULL;
1180 ldns_rdf* publickey_rdf = NULL;
1181 ldns_status status = LDNS_STATUS_OK;
1183 if(strlen(str) == 0)
1184 token = LDNS_XMALLOC(char, 256);
1185 else token = LDNS_XMALLOC(char, strlen(str)+2);
1186 if(!token) return LDNS_STATUS_MEM_ERR;
1188 str_buf = LDNS_MALLOC(ldns_buffer);
1189 if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1190 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1191 if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1194 return LDNS_STATUS_MEM_ERR;
1196 while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1197 switch (token_count) {
1199 precedence = (uint8_t)atoi(token);
1202 gateway_type = (uint8_t)atoi(token);
1205 algorithm = (uint8_t)atoi(token);
1208 gateway = strdup(token);
1209 if (!gateway || (gateway_type == 0 &&
1210 (token[0] != '.' || token[1] != '\0'))) {
1213 ldns_buffer_free(str_buf);
1214 return LDNS_STATUS_INVALID_STR;
1218 publickey = strdup(token);
1222 ldns_buffer_free(str_buf);
1223 return LDNS_STATUS_INVALID_STR;
1229 if (!gateway || !publickey) {
1233 LDNS_FREE(publickey);
1235 ldns_buffer_free(str_buf);
1236 return LDNS_STATUS_INVALID_STR;
1239 if (gateway_type == 1) {
1240 status = ldns_str2rdf_a(&gateway_rdf, gateway);
1241 } else if (gateway_type == 2) {
1242 status = ldns_str2rdf_aaaa(&gateway_rdf, gateway);
1243 } else if (gateway_type == 3) {
1244 status = ldns_str2rdf_dname(&gateway_rdf, gateway);
1247 if (status != LDNS_STATUS_OK) {
1251 LDNS_FREE(publickey);
1253 ldns_buffer_free(str_buf);
1254 return LDNS_STATUS_INVALID_STR;
1257 status = ldns_str2rdf_b64(&publickey_rdf, publickey);
1259 if (status != LDNS_STATUS_OK) {
1263 LDNS_FREE(publickey);
1265 ldns_buffer_free(str_buf);
1266 if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1267 return LDNS_STATUS_INVALID_STR;
1270 /* now copy all into one ipseckey rdf */
1272 ipseckey_len = 3 + (int)ldns_rdf_size(gateway_rdf) + (int)ldns_rdf_size(publickey_rdf);
1274 ipseckey_len = 3 + (int)ldns_rdf_size(publickey_rdf);
1276 data = LDNS_XMALLOC(uint8_t, ipseckey_len);
1281 LDNS_FREE(publickey);
1283 ldns_buffer_free(str_buf);
1284 if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1285 if (publickey_rdf) ldns_rdf_free(publickey_rdf);
1286 return LDNS_STATUS_MEM_ERR;
1289 data[0] = precedence;
1290 data[1] = gateway_type;
1291 data[2] = algorithm;
1295 ldns_rdf_data(gateway_rdf), ldns_rdf_size(gateway_rdf));
1296 memcpy(data + 3 + ldns_rdf_size(gateway_rdf),
1297 ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1300 ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1303 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_IPSECKEY, (uint16_t) ipseckey_len, data);
1308 LDNS_FREE(publickey);
1310 ldns_buffer_free(str_buf);
1311 ldns_rdf_free(gateway_rdf);
1312 ldns_rdf_free(publickey_rdf);
1314 if(!*rd) return LDNS_STATUS_MEM_ERR;
1315 return LDNS_STATUS_OK;