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);
42 *r = htons((uint16_t)strtol((char *)shortstr, &end, 10));
46 return LDNS_STATUS_INVALID_INT;
48 *rd = ldns_rdf_new_frm_data(
49 LDNS_RDF_TYPE_INT16, sizeof(uint16_t), r);
51 return LDNS_STATUS_OK;
56 ldns_str2rdf_time(ldns_rdf **rd, const char *time)
58 /* convert a time YYYYDDMMHHMMSS to wireformat */
64 /* Try to scan the time... */
65 r = (uint16_t*)LDNS_MALLOC(uint32_t);
67 memset(&tm, 0, sizeof(tm));
69 if (strlen(time) == 14 &&
70 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
75 if (tm.tm_year < 70) {
78 if (tm.tm_mon < 0 || tm.tm_mon > 11) {
81 if (tm.tm_mday < 1 || tm.tm_mday > 31) {
85 if (tm.tm_hour < 0 || tm.tm_hour > 23) {
89 if (tm.tm_min < 0 || tm.tm_min > 59) {
93 if (tm.tm_sec < 0 || tm.tm_sec > 59) {
97 l = htonl(mktime_from_utc(&tm));
98 memcpy(r, &l, sizeof(uint32_t));
99 *rd = ldns_rdf_new_frm_data(
100 LDNS_RDF_TYPE_TIME, sizeof(uint32_t), r);
102 return LDNS_STATUS_OK;
104 /* handle it as 32 bits timestamp */
105 l = htonl((uint32_t)strtol((char*)time, &end, 10));
108 return LDNS_STATUS_ERR;
110 memcpy(r, &l, sizeof(uint32_t));
111 *rd = ldns_rdf_new_frm_data(
112 LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
114 return LDNS_STATUS_OK;
120 return LDNS_STATUS_INVALID_TIME;
124 ldns_str2rdf_nsec3_salt(ldns_rdf **rd, const char *salt_str)
133 salt_length_str = strlen(salt_str);
134 if (salt_length_str == 1 && salt_str[0] == '-') {
136 } else if (salt_length_str % 2 != 0) {
137 return LDNS_STATUS_INVALID_HEX;
139 if (salt_length_str > 512) {
140 return LDNS_STATUS_INVALID_HEX;
143 salt = LDNS_XMALLOC(uint8_t, salt_length_str / 2);
144 for (c = 0; c < salt_length_str; c += 2) {
145 if (isxdigit((int) salt_str[c]) && isxdigit((int) salt_str[c+1])) {
146 salt[c/2] = (uint8_t) ldns_hexdigit_to_int(salt_str[c]) * 16 +
147 ldns_hexdigit_to_int(salt_str[c+1]);
150 return LDNS_STATUS_INVALID_HEX;
153 salt_length = (uint8_t) (salt_length_str / 2);
155 data = LDNS_XMALLOC(uint8_t, 1 + salt_length);
156 data[0] = salt_length;
157 memcpy(&data[1], salt, salt_length);
158 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_NSEC3_SALT, 1 + salt_length, data);
162 return LDNS_STATUS_OK;
166 ldns_str2rdf_period(ldns_rdf **rd,const char *period)
171 /* Allocate required space... */
172 p = ldns_str2period(period, &end);
175 return LDNS_STATUS_ERR;
177 p = (uint32_t) htonl(p);
178 *rd = ldns_rdf_new_frm_data(
179 LDNS_RDF_TYPE_PERIOD, sizeof(uint32_t), &p);
181 return LDNS_STATUS_OK;
185 ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr)
191 r = (uint16_t*)LDNS_MALLOC(uint32_t);
192 errno = 0; /* must set to zero before call,
193 note race condition on errno */
195 l = htonl((uint32_t)strtol((char*)longstr, &end, 10));
196 else l = htonl((uint32_t)strtoul((char*)longstr, &end, 10));
200 return LDNS_STATUS_ERR;
202 if (errno == ERANGE) {
204 return LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW;
206 memcpy(r, &l, sizeof(uint32_t));
207 *rd = ldns_rdf_new_frm_data(
208 LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
210 return LDNS_STATUS_OK;
215 ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr)
220 r = LDNS_MALLOC(uint8_t);
222 *r = (uint8_t)strtol((char*)bytestr, &end, 10);
226 return LDNS_STATUS_ERR;
228 *rd = ldns_rdf_new_frm_data(
229 LDNS_RDF_TYPE_INT8, sizeof(uint8_t), r);
231 return LDNS_STATUS_OK;
237 * Checks whether the escaped value at **s is an octal value or
238 * a 'normally' escaped character (and not eos)
240 * The string pointer at *s is increased by either 0 (on error), 1 (on
241 * normal escapes), or 3 (on octals)
243 * Returns the number of bytes read from the escaped string, or
247 parse_escape(uint8_t *s, uint8_t *q) {
249 if (strlen((char *)s) > 3 &&
250 isdigit((int) s[1]) &&
251 isdigit((int) s[2]) &&
252 isdigit((int) s[3])) {
253 /* cast this so it fits */
254 val = (uint8_t) ldns_hexdigit_to_int((char) s[1]) * 100 +
255 ldns_hexdigit_to_int((char) s[2]) * 10 +
256 ldns_hexdigit_to_int((char) s[3]);
262 /* apparently the string terminator
263 * has been escaped...
273 * No special care is taken, all dots are translated into
275 * Could be made more efficient....we do 3 memcpy's in total...
278 ldns_str2rdf_dname(ldns_rdf **d, const char *str)
283 uint8_t *s,*p,*q, *pq, label_len;
284 uint8_t buf[LDNS_MAX_DOMAINLEN + 1];
287 len = strlen((char*)str);
288 /* octet representation can make strings a lot longer than actual length */
289 if (len > LDNS_MAX_DOMAINLEN * 4) {
290 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
293 return LDNS_STATUS_DOMAINNAME_UNDERFLOW;
297 if (1 == len && *str == '.') {
298 *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, 1, "\0");
299 return LDNS_STATUS_OK;
302 /* get on with the rest */
304 /* s is on the current dot
305 * p on the previous one
312 for (s = p = (uint8_t *) str; *s; s++, q++) {
313 if (q > buf + LDNS_MAX_DOMAINLEN) {
314 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
319 if (label_len > LDNS_MAX_LABELLEN) {
320 return LDNS_STATUS_LABEL_OVERFLOW;
322 if (label_len == 0) {
323 return LDNS_STATUS_EMPTY_LABEL;
325 len += label_len + 1;
332 /* octet value or literal char */
333 esc = parse_escape(s, q);
338 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
347 /* add root label if last char was not '.' */
348 if (!ldns_dname_str_absolute(str)) {
349 if (q > buf + LDNS_MAX_DOMAINLEN) {
350 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
352 len += label_len + 1;
358 *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, len, buf);
359 return LDNS_STATUS_OK;
363 ldns_str2rdf_a(ldns_rdf **rd, const char *str)
366 if (inet_pton(AF_INET, (char*)str, &address) != 1) {
367 return LDNS_STATUS_INVALID_IP4;
369 *rd = ldns_rdf_new_frm_data(
370 LDNS_RDF_TYPE_A, sizeof(address), &address);
372 return LDNS_STATUS_OK;
376 ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str)
378 uint8_t address[LDNS_IP6ADDRLEN + 1];
380 if (inet_pton(AF_INET6, (char*)str, address) != 1) {
381 return LDNS_STATUS_INVALID_IP6;
383 *rd = ldns_rdf_new_frm_data(
384 LDNS_RDF_TYPE_AAAA, sizeof(address) - 1, &address);
386 return LDNS_STATUS_OK;
390 ldns_str2rdf_str(ldns_rdf **rd, const char *str)
395 if (strlen(str) > 255) {
396 return LDNS_STATUS_INVALID_STR;
399 data = LDNS_XMALLOC(uint8_t, strlen(str) + 1);
401 for (str_i = 0; str_i < strlen(str); str_i++) {
402 if (str[str_i] == '\\') {
403 /* octet value or literal char */
404 str_i += (size_t) parse_escape((uint8_t*) &str[str_i], (uint8_t*) &data[i]);
406 data[i] = (uint8_t) str[str_i];
411 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_STR, i, data);
413 return LDNS_STATUS_OK;
417 ldns_str2rdf_apl(ldns_rdf **rd, const char *str)
419 const char *my_str = str;
426 uint8_t afdlength = 0;
434 /* [!]afi:address/prefix */
435 if (strlen(my_str) < 2) {
436 return LDNS_STATUS_INVALID_STR;
439 if (my_str[0] == '!') {
446 family = (uint16_t) atoi(my_str);
448 my_str = strchr(my_str, ':') + 1;
450 /* need ip addr and only ip addr for inet_pton */
451 ip_str_len = (size_t) (strchr(my_str, '/') - my_str);
452 my_ip_str = LDNS_XMALLOC(char, ip_str_len + 1);
453 strncpy(my_ip_str, my_str, ip_str_len + 1);
454 my_ip_str[ip_str_len] = '\0';
458 afdpart = LDNS_XMALLOC(uint8_t, 4);
459 if (inet_pton(AF_INET, my_ip_str, afdpart) == 0) {
460 return LDNS_STATUS_INVALID_STR;
462 for (i = 0; i < 4; i++) {
463 if (afdpart[i] != 0) {
467 } else if (family == 2) {
469 afdpart = LDNS_XMALLOC(uint8_t, 16);
470 if (inet_pton(AF_INET6, my_ip_str, afdpart) == 0) {
471 return LDNS_STATUS_INVALID_STR;
473 for (i = 0; i < 16; i++) {
474 if (afdpart[i] != 0) {
480 LDNS_FREE(my_ip_str);
481 return LDNS_STATUS_INVALID_STR;
484 my_str = strchr(my_str, '/') + 1;
485 prefix = (uint8_t) atoi(my_str);
487 data = LDNS_XMALLOC(uint8_t, 4 + afdlength);
488 ldns_write_uint16(data, family);
492 /* set bit 1 of byte 3 */
493 data[3] = data[3] | 0x80;
496 memcpy(data + 4, afdpart, afdlength);
498 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_APL, afdlength + 4, data);
501 LDNS_FREE(my_ip_str);
503 return LDNS_STATUS_OK;
507 ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
512 buffer = LDNS_XMALLOC(uint8_t, ldns_b64_ntop_calculate_size(strlen(str)));
514 i = (uint16_t)ldns_b64_pton((const char*)str, buffer,
515 ldns_b64_ntop_calculate_size(strlen(str)));
518 return LDNS_STATUS_INVALID_B64;
520 *rd = ldns_rdf_new_frm_data(
521 LDNS_RDF_TYPE_B64, (uint16_t) i, buffer);
525 return LDNS_STATUS_OK;
529 ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str)
533 /* first byte contains length of actual b32 data */
534 uint8_t len = ldns_b32_pton_calculate_size(strlen(str));
535 buffer = LDNS_XMALLOC(uint8_t, len + 1);
538 i = ldns_b32_pton_extended_hex((const char*)str, strlen(str), buffer + 1,
539 ldns_b32_ntop_calculate_size(strlen(str)));
541 return LDNS_STATUS_INVALID_B32_EXT;
543 *rd = ldns_rdf_new_frm_data(
544 LDNS_RDF_TYPE_B32_EXT, (uint16_t) i + 1, buffer);
548 return LDNS_STATUS_OK;
552 ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
560 if (len > LDNS_MAX_RDFLEN * 2) {
561 return LDNS_STATUS_LABEL_OVERFLOW;
563 t = LDNS_XMALLOC(uint8_t, (len / 2) + 1);
565 /* Now process octet by octet... */
568 if (isspace((int) *str)) {
571 for (i = 16; i >= 1; i -= 15) {
572 while (*str && isspace((int) *str)) { str++; }
574 if (isxdigit((int) *str)) {
575 *t += ldns_hexdigit_to_int(*str) * i;
577 return LDNS_STATUS_ERR;
585 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX,
586 (size_t) (t - t_orig),
590 return LDNS_STATUS_OK;
594 ldns_str2rdf_nsec(ldns_rdf **rd, const char *str)
596 const char *delimiters = "\n\t ";
597 char *token = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
598 ldns_buffer *str_buf;
601 size_t type_count = 0;
602 ldns_rr_type type_list[1024];
604 str_buf = LDNS_MALLOC(ldns_buffer);
605 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
607 while ((c = ldns_bget_token(str_buf, token, delimiters, LDNS_MAX_RDFLEN)) != -1) {
608 cur_type = ldns_get_rr_type_by_name(token);
609 type_list[type_count] = cur_type;
613 *rd = ldns_dnssec_create_nsec_bitmap(type_list,
619 ldns_buffer_free(str_buf);
620 return LDNS_STATUS_OK;
624 ldns_str2rdf_type(ldns_rdf **rd, const char *str)
627 type = htons(ldns_get_rr_type_by_name(str));
628 /* ldns_rr_type is a 16 bit value */
629 *rd = ldns_rdf_new_frm_data(
630 LDNS_RDF_TYPE_TYPE, sizeof(uint16_t), &type);
631 return LDNS_STATUS_OK;
635 ldns_str2rdf_class(ldns_rdf **rd, const char *str)
638 klass = htons(ldns_get_rr_class_by_name(str));
639 /* class is 16 bit */
640 *rd = ldns_rdf_new_frm_data(
641 LDNS_RDF_TYPE_CLASS, sizeof(uint16_t), &klass);
642 return LDNS_STATUS_OK;
645 /* An certificate alg field can either be specified as a 8 bits number
646 * or by its symbolic name. Handle both
649 ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str)
651 ldns_lookup_table *lt;
654 lt = ldns_lookup_by_name(ldns_cert_algorithms, str);
658 ldns_write_uint16(idd, (uint16_t) lt->id);
659 *rd = ldns_rdf_new_frm_data(
660 LDNS_RDF_TYPE_INT16, sizeof(uint16_t), idd);
662 st = LDNS_STATUS_ERR;
665 /* try as-is (a number) */
666 st = ldns_str2rdf_int16(rd, str);
667 if (st == LDNS_STATUS_OK &&
668 ldns_rdf2native_int16(*rd) == 0) {
669 st = LDNS_STATUS_CERT_BAD_ALGORITHM;
676 /* An alg field can either be specified as a 8 bits number
677 * or by its symbolic name. Handle both
680 ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
682 ldns_lookup_table *lt;
685 lt = ldns_lookup_by_name(ldns_algorithms, str);
689 /* it was given as a integer */
690 *rd = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t) lt->id);
692 st = LDNS_STATUS_ERR;
695 /* try as-is (a number) */
696 st = ldns_str2rdf_int8(rd, str);
702 ldns_str2rdf_unknown(ldns_rdf **rd, const char *str)
704 /* this should be caught in an earlier time (general str2host for
708 return LDNS_STATUS_NOT_IMPL;
712 ldns_str2rdf_tsig(ldns_rdf **rd, const char *str)
714 /* there is no strign representation for TSIG rrs */
717 return LDNS_STATUS_NOT_IMPL;
721 ldns_str2rdf_service(ldns_rdf **rd, const char *str)
723 /* is this used? is this actually WKS? or SRV? */
726 return LDNS_STATUS_NOT_IMPL;
730 loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e)
732 /* read <digits>[.<digits>][mM] */
733 /* into mantissa exponent format for LOC type */
734 uint32_t meters = 0, cm = 0, val;
735 while (isblank(*my_str)) {
738 meters = (uint32_t)strtol(my_str, &my_str, 10);
739 if (*my_str == '.') {
741 cm = (uint32_t)strtol(my_str, &my_str, 10);
758 if (*my_str == 'm' || *my_str == 'M') {
766 ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
768 uint32_t latitude = 0;
769 uint32_t longitude = 0;
770 uint32_t altitude = 0;
773 uint32_t equator = (uint32_t) ldns_power(2, 31);
777 uint8_t size_b = 1, size_e = 2;
778 uint8_t horiz_pre_b = 1, horiz_pre_e = 6;
779 uint8_t vert_pre_b = 1, vert_pre_e = 3;
785 char *my_str = (char *) str;
787 /* only support version 0 */
788 if (isdigit((int) *my_str)) {
789 h = (uint32_t) strtol(my_str, &my_str, 10);
791 return LDNS_STATUS_INVALID_STR;
794 while (isblank((int) *my_str)) {
798 if (isdigit((int) *my_str)) {
799 m = (uint32_t) strtol(my_str, &my_str, 10);
800 } else if (*my_str == 'N' || *my_str == 'S') {
803 return LDNS_STATUS_INVALID_STR;
806 while (isblank((int) *my_str)) {
810 if (isdigit((int) *my_str)) {
811 s = strtod(my_str, &my_str);
814 while (isblank((int) *my_str)) {
818 if (*my_str == 'N') {
820 } else if (*my_str == 'S') {
823 return LDNS_STATUS_INVALID_STR;
830 /* add a little to make floor in conversion a round */
832 latitude = (uint32_t) s;
833 latitude += 1000 * 60 * m;
834 latitude += 1000 * 60 * 60 * h;
836 latitude = equator + latitude;
838 latitude = equator - latitude;
840 while (isblank(*my_str)) {
844 if (isdigit((int) *my_str)) {
845 h = (uint32_t) strtol(my_str, &my_str, 10);
847 return LDNS_STATUS_INVALID_STR;
850 while (isblank((int) *my_str)) {
854 if (isdigit((int) *my_str)) {
855 m = (uint32_t) strtol(my_str, &my_str, 10);
856 } else if (*my_str == 'E' || *my_str == 'W') {
859 return LDNS_STATUS_INVALID_STR;
862 while (isblank(*my_str)) {
866 if (isdigit((int) *my_str)) {
867 s = strtod(my_str, &my_str);
871 while (isblank(*my_str)) {
875 if (*my_str == 'E') {
877 } else if (*my_str == 'W') {
880 return LDNS_STATUS_INVALID_STR;
887 /* add a little to make floor in conversion a round */
889 longitude = (uint32_t) s;
890 longitude += 1000 * 60 * m;
891 longitude += 1000 * 60 * 60 * h;
894 longitude += equator;
896 longitude = equator - longitude;
899 altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 +
901 if (*my_str == 'm' || *my_str == 'M') {
905 if (strlen(my_str) > 0) {
906 if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e))
907 return LDNS_STATUS_INVALID_STR;
910 if (strlen(my_str) > 0) {
911 if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e))
912 return LDNS_STATUS_INVALID_STR;
915 if (strlen(my_str) > 0) {
916 if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e))
917 return LDNS_STATUS_INVALID_STR;
920 data = LDNS_XMALLOC(uint8_t, 16);
923 data[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f);
924 data[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f);
925 data[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f);
926 ldns_write_uint32(data + 4, latitude);
927 ldns_write_uint32(data + 8, longitude);
928 ldns_write_uint32(data + 12, altitude);
930 *rd = ldns_rdf_new_frm_data(
931 LDNS_RDF_TYPE_LOC, 16, data);
934 return LDNS_STATUS_OK;
938 ldns_str2rdf_wks(ldns_rdf **rd, const char *str)
940 uint8_t *bitmap = NULL;
944 struct protoent *proto = NULL;
945 struct servent *serv = NULL;
948 ldns_buffer *str_buf;
950 char *proto_str = NULL;
951 char *token = LDNS_XMALLOC(char, 50);
953 str_buf = LDNS_MALLOC(ldns_buffer);
954 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
956 while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
958 proto_str = strdup(token);
962 return LDNS_STATUS_INVALID_STR;
965 serv = getservbyname(token, proto_str);
967 serv_port = (int) ntohs((uint16_t) serv->s_port);
969 serv_port = atoi(token);
971 if (serv_port / 8 >= bm_len) {
972 bitmap = LDNS_XREALLOC(bitmap, uint8_t, (serv_port / 8) + 1);
973 /* set to zero to be sure */
974 for (; bm_len <= serv_port / 8; bm_len++) {
978 ldns_set_bit(bitmap + (serv_port / 8), 7 - (serv_port % 8), true);
985 return LDNS_STATUS_INVALID_STR;
988 data = LDNS_XMALLOC(uint8_t, bm_len + 1);
990 proto = getprotobyname(proto_str);
992 data[0] = (uint8_t) proto->p_proto;
993 } else if (proto_str) {
994 data[0] = (uint8_t) atoi(proto_str);
998 memcpy(data + 1, bitmap, (size_t) bm_len);
1000 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_WKS, (uint16_t) (bm_len + 1), data);
1004 ldns_buffer_free(str_buf);
1007 #ifdef HAVE_ENDSERVENT
1010 #ifdef HAVE_ENDPROTOENT
1014 return LDNS_STATUS_OK;
1018 ldns_str2rdf_nsap(ldns_rdf **rd, const char *str)
1021 char* nsap_str = (char*) str;
1023 /* just a hex string with optional dots? */
1024 if (str[0] != '0' || str[1] != 'x') {
1025 return LDNS_STATUS_INVALID_STR;
1028 for (i=0; i < len; i++) {
1029 if (nsap_str[i] == '.')
1032 return ldns_str2rdf_hex(rd, str+2);
1037 ldns_str2rdf_atma(ldns_rdf **rd, const char *str)
1040 char* atma_str = (char*) str;
1043 /* just a hex string with optional dots? */
1045 for (i=0; i < len; i++) {
1046 if (atma_str[i] == '.')
1049 status = ldns_str2rdf_hex(rd, str);
1050 if (status != LDNS_STATUS_OK) {
1051 ; /* probably in e.164 format than */
1057 ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
1059 uint8_t precedence = 0;
1060 uint8_t gateway_type = 0;
1061 uint8_t algorithm = 0;
1062 char* gateway = NULL;
1063 char* publickey = NULL;
1065 ldns_buffer *str_buf;
1066 char *token = LDNS_XMALLOC(char, 256);
1067 int token_count = 0;
1068 int ipseckey_len = 0;
1069 ldns_rdf* gateway_rdf = NULL;
1070 ldns_rdf* publickey_rdf = NULL;
1071 ldns_status status = LDNS_STATUS_OK;
1073 str_buf = LDNS_MALLOC(ldns_buffer);
1074 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1075 while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1076 switch (token_count) {
1078 precedence = atoi(token);
1081 gateway_type = atoi(token);
1084 algorithm = atoi(token);
1087 gateway = strdup(token);
1088 if (!gateway || (gateway_type == 0 &&
1089 (token[0] != '.' || token[1] != '\0'))) {
1093 return LDNS_STATUS_INVALID_STR;
1097 publickey = strdup(token);
1102 return LDNS_STATUS_INVALID_STR;
1108 if (!gateway || !publickey) {
1112 LDNS_FREE(publickey);
1115 return LDNS_STATUS_INVALID_STR;
1118 if (gateway_type == 1) {
1119 status = ldns_str2rdf_a(&gateway_rdf, gateway);
1120 } else if (gateway_type == 2) {
1121 status = ldns_str2rdf_aaaa(&gateway_rdf, gateway);
1122 } else if (gateway_type == 3) {
1123 status = ldns_str2rdf_dname(&gateway_rdf, gateway);
1126 if (status != LDNS_STATUS_OK) {
1130 LDNS_FREE(publickey);
1133 return LDNS_STATUS_INVALID_STR;
1136 status = ldns_str2rdf_b64(&publickey_rdf, publickey);
1138 if (status != LDNS_STATUS_OK) {
1142 LDNS_FREE(publickey);
1145 return LDNS_STATUS_INVALID_STR;
1148 /* now copy all into one ipseckey rdf */
1150 ipseckey_len = 3 + ldns_rdf_size(gateway_rdf) + ldns_rdf_size(publickey_rdf);
1152 ipseckey_len = 3 + ldns_rdf_size(publickey_rdf);
1154 data = LDNS_XMALLOC(uint8_t, ipseckey_len);
1156 data[0] = precedence;
1157 data[1] = gateway_type;
1158 data[2] = algorithm;
1162 ldns_rdf_data(gateway_rdf), ldns_rdf_size(gateway_rdf));
1163 memcpy(data + 3 + ldns_rdf_size(gateway_rdf),
1164 ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1167 ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1170 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_IPSECKEY, (uint16_t) ipseckey_len, data);
1175 LDNS_FREE(publickey);
1177 ldns_buffer_free(str_buf);
1178 ldns_rdf_free(gateway_rdf);
1179 ldns_rdf_free(publickey_rdf);
1181 return LDNS_STATUS_OK;