00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #include <ldns/config.h>
00014
00015 #include <ldns/ldns.h>
00016
00017 #ifdef HAVE_SYS_SOCKET_H
00018 #include <sys/socket.h>
00019 #endif
00020 #ifdef HAVE_ARPA_INET_H
00021 #include <arpa/inet.h>
00022 #endif
00023 #include <time.h>
00024
00025 #include <errno.h>
00026 #ifdef HAVE_NETDB_H
00027 #include <netdb.h>
00028 #endif
00029
00030 #include <limits.h>
00031 #ifdef HAVE_SYS_PARAM_H
00032 #include <sys/param.h>
00033 #endif
00034
00035 ldns_status
00036 ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr)
00037 {
00038 char *end = NULL;
00039 uint16_t *r;
00040 r = LDNS_MALLOC(uint16_t);
00041 if(!r) return LDNS_STATUS_MEM_ERR;
00042
00043 *r = htons((uint16_t)strtol((char *)shortstr, &end, 10));
00044
00045 if(*end != 0) {
00046 LDNS_FREE(r);
00047 return LDNS_STATUS_INVALID_INT;
00048 } else {
00049 *rd = ldns_rdf_new_frm_data(
00050 LDNS_RDF_TYPE_INT16, sizeof(uint16_t), r);
00051 LDNS_FREE(r);
00052 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00053 }
00054 }
00055
00056 ldns_status
00057 ldns_str2rdf_time(ldns_rdf **rd, const char *time)
00058 {
00059
00060 uint16_t *r = NULL;
00061 struct tm tm;
00062 uint32_t l;
00063 char *end;
00064
00065
00066 r = (uint16_t*)LDNS_MALLOC(uint32_t);
00067 if(!r) return LDNS_STATUS_MEM_ERR;
00068
00069 memset(&tm, 0, sizeof(tm));
00070
00071 if (strlen(time) == 14 &&
00072 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
00073 ) {
00074 tm.tm_year -= 1900;
00075 tm.tm_mon--;
00076
00077 if (tm.tm_year < 70) {
00078 goto bad_format;
00079 }
00080 if (tm.tm_mon < 0 || tm.tm_mon > 11) {
00081 goto bad_format;
00082 }
00083 if (tm.tm_mday < 1 || tm.tm_mday > 31) {
00084 goto bad_format;
00085 }
00086
00087 if (tm.tm_hour < 0 || tm.tm_hour > 23) {
00088 goto bad_format;
00089 }
00090
00091 if (tm.tm_min < 0 || tm.tm_min > 59) {
00092 goto bad_format;
00093 }
00094
00095 if (tm.tm_sec < 0 || tm.tm_sec > 59) {
00096 goto bad_format;
00097 }
00098
00099 l = htonl(ldns_mktime_from_utc(&tm));
00100 memcpy(r, &l, sizeof(uint32_t));
00101 *rd = ldns_rdf_new_frm_data(
00102 LDNS_RDF_TYPE_TIME, sizeof(uint32_t), r);
00103 LDNS_FREE(r);
00104 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00105 } else {
00106
00107 l = htonl((uint32_t)strtol((char*)time, &end, 10));
00108 if(*end != 0) {
00109 LDNS_FREE(r);
00110 return LDNS_STATUS_ERR;
00111 } else {
00112 memcpy(r, &l, sizeof(uint32_t));
00113 *rd = ldns_rdf_new_frm_data(
00114 LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
00115 LDNS_FREE(r);
00116 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00117 }
00118 }
00119
00120 bad_format:
00121 LDNS_FREE(r);
00122 return LDNS_STATUS_INVALID_TIME;
00123 }
00124
00125 ldns_status
00126 ldns_str2rdf_nsec3_salt(ldns_rdf **rd, const char *salt_str)
00127 {
00128 uint8_t salt_length;
00129 int c;
00130 int salt_length_str;
00131
00132 uint8_t *salt;
00133 uint8_t *data;
00134 if(rd == NULL) {
00135 return LDNS_STATUS_NULL;
00136 }
00137
00138 salt_length_str = (int)strlen(salt_str);
00139 if (salt_length_str == 1 && salt_str[0] == '-') {
00140 salt_length_str = 0;
00141 } else if (salt_length_str % 2 != 0) {
00142 return LDNS_STATUS_INVALID_HEX;
00143 }
00144 if (salt_length_str > 512) {
00145 return LDNS_STATUS_INVALID_HEX;
00146 }
00147
00148 salt = LDNS_XMALLOC(uint8_t, salt_length_str / 2);
00149 if(!salt) {
00150 return LDNS_STATUS_MEM_ERR;
00151 }
00152 for (c = 0; c < salt_length_str; c += 2) {
00153 if (isxdigit((int) salt_str[c]) && isxdigit((int) salt_str[c+1])) {
00154 salt[c/2] = (uint8_t) ldns_hexdigit_to_int(salt_str[c]) * 16 +
00155 ldns_hexdigit_to_int(salt_str[c+1]);
00156 } else {
00157 LDNS_FREE(salt);
00158 return LDNS_STATUS_INVALID_HEX;
00159 }
00160 }
00161 salt_length = (uint8_t) (salt_length_str / 2);
00162
00163 data = LDNS_XMALLOC(uint8_t, 1 + salt_length);
00164 if(!data) {
00165 LDNS_FREE(salt);
00166 return LDNS_STATUS_MEM_ERR;
00167 }
00168 data[0] = salt_length;
00169 memcpy(&data[1], salt, salt_length);
00170 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_NSEC3_SALT, 1 + salt_length, data);
00171 LDNS_FREE(data);
00172 LDNS_FREE(salt);
00173
00174 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00175 }
00176
00177 ldns_status
00178 ldns_str2rdf_period(ldns_rdf **rd,const char *period)
00179 {
00180 uint32_t p;
00181 const char *end;
00182
00183
00184 p = ldns_str2period(period, &end);
00185
00186 if (*end != 0) {
00187 return LDNS_STATUS_ERR;
00188 } else {
00189 p = (uint32_t) htonl(p);
00190 *rd = ldns_rdf_new_frm_data(
00191 LDNS_RDF_TYPE_PERIOD, sizeof(uint32_t), &p);
00192 }
00193 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00194 }
00195
00196 ldns_status
00197 ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr)
00198 {
00199 char *end;
00200 uint16_t *r = NULL;
00201 uint32_t l;
00202
00203 r = (uint16_t*)LDNS_MALLOC(uint32_t);
00204 if(!r) return LDNS_STATUS_MEM_ERR;
00205 errno = 0;
00206
00207 if(*longstr == '-')
00208 l = htonl((uint32_t)strtol((char*)longstr, &end, 10));
00209 else l = htonl((uint32_t)strtoul((char*)longstr, &end, 10));
00210
00211 if(*end != 0) {
00212 LDNS_FREE(r);
00213 return LDNS_STATUS_ERR;
00214 } else {
00215 if (errno == ERANGE) {
00216 LDNS_FREE(r);
00217 return LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW;
00218 }
00219 memcpy(r, &l, sizeof(uint32_t));
00220 *rd = ldns_rdf_new_frm_data(
00221 LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
00222 LDNS_FREE(r);
00223 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00224 }
00225 }
00226
00227 ldns_status
00228 ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr)
00229 {
00230 char *end;
00231 uint8_t *r = NULL;
00232
00233 r = LDNS_MALLOC(uint8_t);
00234 if(!r) return LDNS_STATUS_MEM_ERR;
00235
00236 *r = (uint8_t)strtol((char*)bytestr, &end, 10);
00237
00238 if(*end != 0) {
00239 LDNS_FREE(r);
00240 return LDNS_STATUS_ERR;
00241 } else {
00242 *rd = ldns_rdf_new_frm_data(
00243 LDNS_RDF_TYPE_INT8, sizeof(uint8_t), r);
00244 LDNS_FREE(r);
00245 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00246 }
00247 }
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260 INLINE bool
00261 parse_escape(uint8_t *ch_p, const char** str_p)
00262 {
00263 uint16_t val;
00264
00265 if ((*str_p)[0] && isdigit((*str_p)[0]) &&
00266 (*str_p)[1] && isdigit((*str_p)[1]) &&
00267 (*str_p)[2] && isdigit((*str_p)[2])) {
00268
00269 val = (uint16_t)(((*str_p)[0] - '0') * 100 +
00270 ((*str_p)[1] - '0') * 10 +
00271 ((*str_p)[2] - '0'));
00272
00273 if (val > 255) {
00274 goto error;
00275 }
00276 *ch_p = (uint8_t)val;
00277 *str_p += 3;
00278 return true;
00279
00280 } else if ((*str_p)[0] && !isdigit((*str_p)[0])) {
00281
00282 *ch_p = (uint8_t)*(*str_p)++;
00283 return true;
00284 }
00285 error:
00286 *str_p = NULL;
00287 return false;
00288 }
00289
00290 INLINE bool
00291 parse_char(uint8_t *ch_p, const char** str_p)
00292 {
00293 switch (**str_p) {
00294
00295 case '\0': return false;
00296
00297 case '\\': *str_p += 1;
00298 return parse_escape(ch_p, str_p);
00299
00300 default: *ch_p = (uint8_t)*(*str_p)++;
00301 return true;
00302 }
00303 }
00304
00305
00306
00307
00308
00309
00310 ldns_status
00311 ldns_str2rdf_dname(ldns_rdf **d, const char *str)
00312 {
00313 size_t len;
00314
00315 const char *s;
00316 uint8_t *q, *pq, label_len;
00317 uint8_t buf[LDNS_MAX_DOMAINLEN + 1];
00318 *d = NULL;
00319
00320 len = strlen((char*)str);
00321
00322 if (len > LDNS_MAX_DOMAINLEN * 4) {
00323 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
00324 }
00325 if (0 == len) {
00326 return LDNS_STATUS_DOMAINNAME_UNDERFLOW;
00327 }
00328
00329
00330 if (1 == len && *str == '.') {
00331 *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, 1, "\0");
00332 return LDNS_STATUS_OK;
00333 }
00334
00335
00336
00337
00338
00339
00340
00341
00342 len = 0;
00343 q = buf+1;
00344 pq = buf;
00345 label_len = 0;
00346 for (s = str; *s; s++, q++) {
00347 if (q > buf + LDNS_MAX_DOMAINLEN) {
00348 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
00349 }
00350 *q = 0;
00351 switch (*s) {
00352 case '.':
00353 if (label_len > LDNS_MAX_LABELLEN) {
00354 return LDNS_STATUS_LABEL_OVERFLOW;
00355 }
00356 if (label_len == 0) {
00357 return LDNS_STATUS_EMPTY_LABEL;
00358 }
00359 len += label_len + 1;
00360 *pq = label_len;
00361 label_len = 0;
00362 pq = q;
00363 break;
00364 case '\\':
00365
00366 s += 1;
00367 if (! parse_escape(q, &s)) {
00368 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
00369 }
00370 s -= 1;
00371 label_len++;
00372 break;
00373 default:
00374 *q = (uint8_t)*s;
00375 label_len++;
00376 }
00377 }
00378
00379
00380 if (!ldns_dname_str_absolute(str)) {
00381 if (q > buf + LDNS_MAX_DOMAINLEN) {
00382 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
00383 }
00384 if (label_len > LDNS_MAX_LABELLEN) {
00385 return LDNS_STATUS_LABEL_OVERFLOW;
00386 }
00387 if (label_len == 0) {
00388 return LDNS_STATUS_EMPTY_LABEL;
00389 }
00390 len += label_len + 1;
00391 *pq = label_len;
00392 *q = 0;
00393 }
00394 len++;
00395
00396 *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, len, buf);
00397 return LDNS_STATUS_OK;
00398 }
00399
00400 ldns_status
00401 ldns_str2rdf_a(ldns_rdf **rd, const char *str)
00402 {
00403 in_addr_t address;
00404 if (inet_pton(AF_INET, (char*)str, &address) != 1) {
00405 return LDNS_STATUS_INVALID_IP4;
00406 } else {
00407 *rd = ldns_rdf_new_frm_data(
00408 LDNS_RDF_TYPE_A, sizeof(address), &address);
00409 }
00410 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00411 }
00412
00413 ldns_status
00414 ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str)
00415 {
00416 uint8_t address[LDNS_IP6ADDRLEN + 1];
00417
00418 if (inet_pton(AF_INET6, (char*)str, address) != 1) {
00419 return LDNS_STATUS_INVALID_IP6;
00420 } else {
00421 *rd = ldns_rdf_new_frm_data(
00422 LDNS_RDF_TYPE_AAAA, sizeof(address) - 1, &address);
00423 }
00424 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00425 }
00426
00427 ldns_status
00428 ldns_str2rdf_str(ldns_rdf **rd, const char *str)
00429 {
00430 uint8_t *data, *dp, ch = 0;
00431 size_t length;
00432
00433
00434 dp = data = LDNS_XMALLOC(uint8_t, strlen(str) > 255 ? 256 : (strlen(str) + 1));
00435 if (! data) {
00436 return LDNS_STATUS_MEM_ERR;
00437 }
00438
00439
00440 while (parse_char(&ch, &str)) {
00441 if (dp - data >= 255) {
00442 LDNS_FREE(data);
00443 return LDNS_STATUS_INVALID_STR;
00444 }
00445 *++dp = ch;
00446 }
00447 if (! str) {
00448 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
00449 }
00450 length = (size_t)(dp - data);
00451
00452 data[0] = (uint8_t)length;
00453
00454
00455 data = LDNS_XREALLOC(dp = data, uint8_t, length + 1);
00456 if (! data) {
00457 LDNS_FREE(dp);
00458 return LDNS_STATUS_MEM_ERR;
00459 }
00460
00461
00462 *rd = ldns_rdf_new(LDNS_RDF_TYPE_STR, length + 1, data);
00463 if (! *rd) {
00464 LDNS_FREE(data);
00465 return LDNS_STATUS_MEM_ERR;
00466 }
00467 return LDNS_STATUS_OK;
00468 }
00469
00470 ldns_status
00471 ldns_str2rdf_apl(ldns_rdf **rd, const char *str)
00472 {
00473 const char *my_str = str;
00474
00475 char *my_ip_str;
00476 size_t ip_str_len;
00477
00478 uint16_t family;
00479 bool negation;
00480 uint8_t afdlength = 0;
00481 uint8_t *afdpart;
00482 uint8_t prefix;
00483
00484 uint8_t *data;
00485
00486 size_t i = 0;
00487
00488
00489 if (strlen(my_str) < 2
00490 || strchr(my_str, ':') == NULL
00491 || strchr(my_str, '/') == NULL
00492 || strchr(my_str, ':') > strchr(my_str, '/')) {
00493 return LDNS_STATUS_INVALID_STR;
00494 }
00495
00496 if (my_str[0] == '!') {
00497 negation = true;
00498 my_str += 1;
00499 } else {
00500 negation = false;
00501 }
00502
00503 family = (uint16_t) atoi(my_str);
00504
00505 my_str = strchr(my_str, ':') + 1;
00506
00507
00508 ip_str_len = (size_t) (strchr(my_str, '/') - my_str);
00509 my_ip_str = LDNS_XMALLOC(char, ip_str_len + 1);
00510 if(!my_ip_str) return LDNS_STATUS_MEM_ERR;
00511 strncpy(my_ip_str, my_str, ip_str_len + 1);
00512 my_ip_str[ip_str_len] = '\0';
00513
00514 if (family == 1) {
00515
00516 afdpart = LDNS_XMALLOC(uint8_t, 4);
00517 if(!afdpart) {
00518 LDNS_FREE(my_ip_str);
00519 return LDNS_STATUS_MEM_ERR;
00520 }
00521 if (inet_pton(AF_INET, my_ip_str, afdpart) == 0) {
00522 LDNS_FREE(my_ip_str);
00523 LDNS_FREE(afdpart);
00524 return LDNS_STATUS_INVALID_STR;
00525 }
00526 for (i = 0; i < 4; i++) {
00527 if (afdpart[i] != 0) {
00528 afdlength = i + 1;
00529 }
00530 }
00531 } else if (family == 2) {
00532
00533 afdpart = LDNS_XMALLOC(uint8_t, 16);
00534 if(!afdpart) {
00535 LDNS_FREE(my_ip_str);
00536 return LDNS_STATUS_MEM_ERR;
00537 }
00538 if (inet_pton(AF_INET6, my_ip_str, afdpart) == 0) {
00539 LDNS_FREE(my_ip_str);
00540 LDNS_FREE(afdpart);
00541 return LDNS_STATUS_INVALID_STR;
00542 }
00543 for (i = 0; i < 16; i++) {
00544 if (afdpart[i] != 0) {
00545 afdlength = i + 1;
00546 }
00547 }
00548 } else {
00549
00550 LDNS_FREE(my_ip_str);
00551 return LDNS_STATUS_INVALID_STR;
00552 }
00553
00554 my_str = strchr(my_str, '/') + 1;
00555 prefix = (uint8_t) atoi(my_str);
00556
00557 data = LDNS_XMALLOC(uint8_t, 4 + afdlength);
00558 if(!data) {
00559 LDNS_FREE(afdpart);
00560 LDNS_FREE(my_ip_str);
00561 return LDNS_STATUS_INVALID_STR;
00562 }
00563 ldns_write_uint16(data, family);
00564 data[2] = prefix;
00565 data[3] = afdlength;
00566 if (negation) {
00567
00568 data[3] = data[3] | 0x80;
00569 }
00570
00571 memcpy(data + 4, afdpart, afdlength);
00572
00573 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_APL, afdlength + 4, data);
00574 LDNS_FREE(afdpart);
00575 LDNS_FREE(data);
00576 LDNS_FREE(my_ip_str);
00577
00578 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00579 }
00580
00581 ldns_status
00582 ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
00583 {
00584 uint8_t *buffer;
00585 int16_t i;
00586
00587 buffer = LDNS_XMALLOC(uint8_t, ldns_b64_ntop_calculate_size(strlen(str)));
00588 if(!buffer) {
00589 return LDNS_STATUS_MEM_ERR;
00590 }
00591
00592 i = (uint16_t)ldns_b64_pton((const char*)str, buffer,
00593 ldns_b64_ntop_calculate_size(strlen(str)));
00594 if (-1 == i) {
00595 LDNS_FREE(buffer);
00596 return LDNS_STATUS_INVALID_B64;
00597 } else {
00598 *rd = ldns_rdf_new_frm_data(
00599 LDNS_RDF_TYPE_B64, (uint16_t) i, buffer);
00600 }
00601 LDNS_FREE(buffer);
00602
00603 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00604 }
00605
00606 ldns_status
00607 ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str)
00608 {
00609 uint8_t *buffer;
00610 int i;
00611
00612 uint8_t len = ldns_b32_pton_calculate_size(strlen(str));
00613 buffer = LDNS_XMALLOC(uint8_t, len + 1);
00614 if(!buffer) {
00615 return LDNS_STATUS_MEM_ERR;
00616 }
00617 buffer[0] = len;
00618
00619 i = ldns_b32_pton_extended_hex((const char*)str, strlen(str), buffer + 1,
00620 ldns_b32_ntop_calculate_size(strlen(str)));
00621 if (i < 0) {
00622 LDNS_FREE(buffer);
00623 return LDNS_STATUS_INVALID_B32_EXT;
00624 } else {
00625 *rd = ldns_rdf_new_frm_data(
00626 LDNS_RDF_TYPE_B32_EXT, (uint16_t) i + 1, buffer);
00627 }
00628 LDNS_FREE(buffer);
00629
00630 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00631 }
00632
00633 ldns_status
00634 ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
00635 {
00636 uint8_t *t, *t_orig;
00637 int i;
00638 size_t len;
00639
00640 len = strlen(str);
00641
00642 if (len > LDNS_MAX_RDFLEN * 2) {
00643 return LDNS_STATUS_LABEL_OVERFLOW;
00644 } else {
00645 t = LDNS_XMALLOC(uint8_t, (len / 2) + 1);
00646 if(!t) {
00647 return LDNS_STATUS_MEM_ERR;
00648 }
00649 t_orig = t;
00650
00651 while (*str) {
00652 *t = 0;
00653 if (isspace((int) *str)) {
00654 str++;
00655 } else {
00656 for (i = 16; i >= 1; i -= 15) {
00657 while (*str && isspace((int) *str)) { str++; }
00658 if (*str) {
00659 if (isxdigit((int) *str)) {
00660 *t += ldns_hexdigit_to_int(*str) * i;
00661 } else {
00662 LDNS_FREE(t_orig);
00663 return LDNS_STATUS_ERR;
00664 }
00665 ++str;
00666 }
00667 }
00668 ++t;
00669 }
00670 }
00671 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX,
00672 (size_t) (t - t_orig),
00673 t_orig);
00674 LDNS_FREE(t_orig);
00675 }
00676 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00677 }
00678
00679 ldns_status
00680 ldns_str2rdf_nsec(ldns_rdf **rd, const char *str)
00681 {
00682 const char *delimiters = "\n\t ";
00683 char *token = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
00684 ldns_buffer *str_buf;
00685 ssize_t c;
00686 uint16_t cur_type;
00687 size_t type_count = 0;
00688 ldns_rr_type type_list[65536];
00689 if(!token) return LDNS_STATUS_MEM_ERR;
00690 if(rd == NULL) {
00691 LDNS_FREE(token);
00692 return LDNS_STATUS_NULL;
00693 }
00694
00695 str_buf = LDNS_MALLOC(ldns_buffer);
00696 if(!str_buf) {
00697 LDNS_FREE(token);
00698 return LDNS_STATUS_MEM_ERR;
00699 }
00700 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
00701 if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
00702 LDNS_FREE(str_buf);
00703 LDNS_FREE(token);
00704 return LDNS_STATUS_MEM_ERR;
00705 }
00706
00707 while ((c = ldns_bget_token(str_buf, token, delimiters, LDNS_MAX_RDFLEN)) != -1 && c != 0) {
00708 if(type_count >= sizeof(type_list)) {
00709 LDNS_FREE(str_buf);
00710 LDNS_FREE(token);
00711 return LDNS_STATUS_ERR;
00712 }
00713 cur_type = ldns_get_rr_type_by_name(token);
00714 type_list[type_count] = cur_type;
00715 type_count++;
00716 }
00717
00718 *rd = ldns_dnssec_create_nsec_bitmap(type_list,
00719 type_count,
00720 LDNS_RR_TYPE_NSEC);
00721
00722 LDNS_FREE(token);
00723 ldns_buffer_free(str_buf);
00724 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00725 }
00726
00727 ldns_status
00728 ldns_str2rdf_type(ldns_rdf **rd, const char *str)
00729 {
00730 uint16_t type;
00731 type = htons(ldns_get_rr_type_by_name(str));
00732
00733 *rd = ldns_rdf_new_frm_data(
00734 LDNS_RDF_TYPE_TYPE, sizeof(uint16_t), &type);
00735 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00736 }
00737
00738 ldns_status
00739 ldns_str2rdf_class(ldns_rdf **rd, const char *str)
00740 {
00741 uint16_t klass;
00742 klass = htons(ldns_get_rr_class_by_name(str));
00743
00744 *rd = ldns_rdf_new_frm_data(
00745 LDNS_RDF_TYPE_CLASS, sizeof(uint16_t), &klass);
00746 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
00747 }
00748
00749
00750
00751
00752 ldns_status
00753 ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str)
00754 {
00755 ldns_lookup_table *lt;
00756 ldns_status st;
00757 uint8_t idd[2];
00758 lt = ldns_lookup_by_name(ldns_cert_algorithms, str);
00759 st = LDNS_STATUS_OK;
00760
00761 if (lt) {
00762 ldns_write_uint16(idd, (uint16_t) lt->id);
00763 *rd = ldns_rdf_new_frm_data(
00764 LDNS_RDF_TYPE_INT16, sizeof(uint16_t), idd);
00765 if (!*rd) {
00766 st = LDNS_STATUS_ERR;
00767 }
00768 } else {
00769
00770 st = ldns_str2rdf_int16(rd, str);
00771 if (st == LDNS_STATUS_OK &&
00772 ldns_rdf2native_int16(*rd) == 0) {
00773 st = LDNS_STATUS_CERT_BAD_ALGORITHM;
00774 }
00775 }
00776
00777 return st;
00778 }
00779
00780
00781
00782
00783 ldns_status
00784 ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
00785 {
00786 ldns_lookup_table *lt;
00787 ldns_status st;
00788
00789 lt = ldns_lookup_by_name(ldns_algorithms, str);
00790 st = LDNS_STATUS_OK;
00791
00792 if (lt) {
00793
00794 *rd = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t) lt->id);
00795 if (!*rd) {
00796 st = LDNS_STATUS_ERR;
00797 }
00798 } else {
00799
00800 st = ldns_str2rdf_int8(rd, str);
00801 }
00802 return st;
00803 }
00804
00805 ldns_status
00806 ldns_str2rdf_unknown( ATTR_UNUSED(ldns_rdf **rd)
00807 , ATTR_UNUSED(const char *str)
00808 )
00809 {
00810
00811
00812 return LDNS_STATUS_NOT_IMPL;
00813 }
00814
00815 ldns_status
00816 ldns_str2rdf_service( ATTR_UNUSED(ldns_rdf **rd)
00817 , ATTR_UNUSED(const char *str)
00818 )
00819 {
00820
00821 return LDNS_STATUS_NOT_IMPL;
00822 }
00823
00824 static int
00825 loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e)
00826 {
00827
00828
00829 uint32_t meters = 0, cm = 0, val;
00830 while (isblank(*my_str)) {
00831 my_str++;
00832 }
00833 meters = (uint32_t)strtol(my_str, &my_str, 10);
00834 if (*my_str == '.') {
00835 my_str++;
00836 cm = (uint32_t)strtol(my_str, &my_str, 10);
00837 }
00838 if (meters >= 1) {
00839 *e = 2;
00840 val = meters;
00841 } else {
00842 *e = 0;
00843 val = cm;
00844 }
00845 while(val >= 10) {
00846 (*e)++;
00847 val /= 10;
00848 }
00849 *m = (uint8_t)val;
00850
00851 if (*e > 9)
00852 return 0;
00853 if (*my_str == 'm' || *my_str == 'M') {
00854 my_str++;
00855 }
00856 *endstr = my_str;
00857 return 1;
00858 }
00859
00860 ldns_status
00861 ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
00862 {
00863 uint32_t latitude = 0;
00864 uint32_t longitude = 0;
00865 uint32_t altitude = 0;
00866
00867 uint8_t *data;
00868 uint32_t equator = (uint32_t) ldns_power(2, 31);
00869
00870 uint32_t h = 0;
00871 uint32_t m = 0;
00872 uint8_t size_b = 1, size_e = 2;
00873 uint8_t horiz_pre_b = 1, horiz_pre_e = 6;
00874 uint8_t vert_pre_b = 1, vert_pre_e = 3;
00875
00876 double s = 0.0;
00877 bool northerness;
00878 bool easterness;
00879
00880 char *my_str = (char *) str;
00881
00882
00883 if (isdigit((int) *my_str)) {
00884 h = (uint32_t) strtol(my_str, &my_str, 10);
00885 } else {
00886 return LDNS_STATUS_INVALID_STR;
00887 }
00888
00889 while (isblank((int) *my_str)) {
00890 my_str++;
00891 }
00892
00893 if (isdigit((int) *my_str)) {
00894 m = (uint32_t) strtol(my_str, &my_str, 10);
00895 } else if (*my_str == 'N' || *my_str == 'S') {
00896 goto north;
00897 } else {
00898 return LDNS_STATUS_INVALID_STR;
00899 }
00900
00901 while (isblank((int) *my_str)) {
00902 my_str++;
00903 }
00904
00905 if (isdigit((int) *my_str)) {
00906 s = strtod(my_str, &my_str);
00907 }
00908 north:
00909 while (isblank((int) *my_str)) {
00910 my_str++;
00911 }
00912
00913 if (*my_str == 'N') {
00914 northerness = true;
00915 } else if (*my_str == 'S') {
00916 northerness = false;
00917 } else {
00918 return LDNS_STATUS_INVALID_STR;
00919 }
00920
00921 my_str++;
00922
00923
00924 s = 1000.0 * s;
00925
00926 s += 0.0005;
00927 latitude = (uint32_t) s;
00928 latitude += 1000 * 60 * m;
00929 latitude += 1000 * 60 * 60 * h;
00930 if (northerness) {
00931 latitude = equator + latitude;
00932 } else {
00933 latitude = equator - latitude;
00934 }
00935 while (isblank(*my_str)) {
00936 my_str++;
00937 }
00938
00939 if (isdigit((int) *my_str)) {
00940 h = (uint32_t) strtol(my_str, &my_str, 10);
00941 } else {
00942 return LDNS_STATUS_INVALID_STR;
00943 }
00944
00945 while (isblank((int) *my_str)) {
00946 my_str++;
00947 }
00948
00949 if (isdigit((int) *my_str)) {
00950 m = (uint32_t) strtol(my_str, &my_str, 10);
00951 } else if (*my_str == 'E' || *my_str == 'W') {
00952 goto east;
00953 } else {
00954 return LDNS_STATUS_INVALID_STR;
00955 }
00956
00957 while (isblank(*my_str)) {
00958 my_str++;
00959 }
00960
00961 if (isdigit((int) *my_str)) {
00962 s = strtod(my_str, &my_str);
00963 }
00964
00965 east:
00966 while (isblank(*my_str)) {
00967 my_str++;
00968 }
00969
00970 if (*my_str == 'E') {
00971 easterness = true;
00972 } else if (*my_str == 'W') {
00973 easterness = false;
00974 } else {
00975 return LDNS_STATUS_INVALID_STR;
00976 }
00977
00978 my_str++;
00979
00980
00981 s *= 1000.0;
00982
00983 s += 0.0005;
00984 longitude = (uint32_t) s;
00985 longitude += 1000 * 60 * m;
00986 longitude += 1000 * 60 * 60 * h;
00987
00988 if (easterness) {
00989 longitude += equator;
00990 } else {
00991 longitude = equator - longitude;
00992 }
00993
00994 altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 +
00995 10000000.0 + 0.5);
00996 if (*my_str == 'm' || *my_str == 'M') {
00997 my_str++;
00998 }
00999
01000 if (strlen(my_str) > 0) {
01001 if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e))
01002 return LDNS_STATUS_INVALID_STR;
01003 }
01004
01005 if (strlen(my_str) > 0) {
01006 if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e))
01007 return LDNS_STATUS_INVALID_STR;
01008 }
01009
01010 if (strlen(my_str) > 0) {
01011 if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e))
01012 return LDNS_STATUS_INVALID_STR;
01013 }
01014
01015 data = LDNS_XMALLOC(uint8_t, 16);
01016 if(!data) {
01017 return LDNS_STATUS_MEM_ERR;
01018 }
01019 data[0] = 0;
01020 data[1] = 0;
01021 data[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f);
01022 data[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f);
01023 data[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f);
01024 ldns_write_uint32(data + 4, latitude);
01025 ldns_write_uint32(data + 8, longitude);
01026 ldns_write_uint32(data + 12, altitude);
01027
01028 *rd = ldns_rdf_new_frm_data(
01029 LDNS_RDF_TYPE_LOC, 16, data);
01030
01031 LDNS_FREE(data);
01032 return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
01033 }
01034
01035 ldns_status
01036 ldns_str2rdf_wks(ldns_rdf **rd, const char *str)
01037 {
01038 uint8_t *bitmap = NULL;
01039 uint8_t *data;
01040 int bm_len = 0;
01041
01042 struct protoent *proto = NULL;
01043 struct servent *serv = NULL;
01044 int serv_port;
01045
01046 ldns_buffer *str_buf;
01047
01048 char *proto_str = NULL;
01049 char *token;
01050 if(strlen(str) == 0)
01051 token = LDNS_XMALLOC(char, 50);
01052 else token = LDNS_XMALLOC(char, strlen(str)+2);
01053 if(!token) return LDNS_STATUS_MEM_ERR;
01054
01055 str_buf = LDNS_MALLOC(ldns_buffer);
01056 if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
01057 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
01058 if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
01059 LDNS_FREE(str_buf);
01060 LDNS_FREE(token);
01061 return LDNS_STATUS_MEM_ERR;
01062 }
01063
01064 while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
01065 if (!proto_str) {
01066 proto_str = strdup(token);
01067 if (!proto_str) {
01068 LDNS_FREE(bitmap);
01069 LDNS_FREE(token);
01070 ldns_buffer_free(str_buf);
01071 return LDNS_STATUS_INVALID_STR;
01072 }
01073 } else {
01074 serv = getservbyname(token, proto_str);
01075 if (serv) {
01076 serv_port = (int) ntohs((uint16_t) serv->s_port);
01077 } else {
01078 serv_port = atoi(token);
01079 }
01080 if (serv_port / 8 >= bm_len) {
01081 uint8_t *b2 = LDNS_XREALLOC(bitmap, uint8_t, (serv_port / 8) + 1);
01082 if(!b2) {
01083 LDNS_FREE(bitmap);
01084 LDNS_FREE(token);
01085 ldns_buffer_free(str_buf);
01086 free(proto_str);
01087 return LDNS_STATUS_INVALID_STR;
01088 }
01089 bitmap = b2;
01090
01091 for (; bm_len <= serv_port / 8; bm_len++) {
01092 bitmap[bm_len] = 0;
01093 }
01094 }
01095 ldns_set_bit(bitmap + (serv_port / 8), 7 - (serv_port % 8), true);
01096 }
01097 }
01098
01099 if (!proto_str || !bitmap) {
01100 LDNS_FREE(bitmap);
01101 LDNS_FREE(token);
01102 ldns_buffer_free(str_buf);
01103 free(proto_str);
01104 return LDNS_STATUS_INVALID_STR;
01105 }
01106
01107 data = LDNS_XMALLOC(uint8_t, bm_len + 1);
01108 if(!data) {
01109 LDNS_FREE(token);
01110 ldns_buffer_free(str_buf);
01111 LDNS_FREE(bitmap);
01112 free(proto_str);
01113 return LDNS_STATUS_INVALID_STR;
01114 }
01115 if (proto_str)
01116 proto = getprotobyname(proto_str);
01117 if (proto) {
01118 data[0] = (uint8_t) proto->p_proto;
01119 } else if (proto_str) {
01120 data[0] = (uint8_t) atoi(proto_str);
01121 }
01122 memcpy(data + 1, bitmap, (size_t) bm_len);
01123
01124 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_WKS, (uint16_t) (bm_len + 1), data);
01125
01126 LDNS_FREE(data);
01127 LDNS_FREE(token);
01128 ldns_buffer_free(str_buf);
01129 LDNS_FREE(bitmap);
01130 free(proto_str);
01131 #ifdef HAVE_ENDSERVENT
01132 endservent();
01133 #endif
01134 #ifdef HAVE_ENDPROTOENT
01135 endprotoent();
01136 #endif
01137
01138 if(!*rd) return LDNS_STATUS_MEM_ERR;
01139
01140 return LDNS_STATUS_OK;
01141 }
01142
01143 ldns_status
01144 ldns_str2rdf_nsap(ldns_rdf **rd, const char *str)
01145 {
01146 size_t len, i;
01147 char* nsap_str = (char*) str;
01148
01149
01150 if (str[0] != '0' || str[1] != 'x') {
01151 return LDNS_STATUS_INVALID_STR;
01152 } else {
01153 len = strlen(str);
01154 for (i=0; i < len; i++) {
01155 if (nsap_str[i] == '.')
01156 nsap_str[i] = ' ';
01157 }
01158 return ldns_str2rdf_hex(rd, str+2);
01159 }
01160 }
01161
01162 ldns_status
01163 ldns_str2rdf_atma(ldns_rdf **rd, const char *str)
01164 {
01165 size_t len, i;
01166 char* atma_str = (char*) str;
01167 ldns_status status;
01168
01169
01170 len = strlen(str);
01171 for (i=0; i < len; i++) {
01172 if (atma_str[i] == '.')
01173 atma_str[i] = ' ';
01174 }
01175 status = ldns_str2rdf_hex(rd, str);
01176 if (status != LDNS_STATUS_OK) {
01177 ;
01178 }
01179 return status;
01180 }
01181
01182 ldns_status
01183 ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
01184 {
01185 uint8_t precedence = 0;
01186 uint8_t gateway_type = 0;
01187 uint8_t algorithm = 0;
01188 char* gateway = NULL;
01189 char* publickey = NULL;
01190 uint8_t *data;
01191 ldns_buffer *str_buf;
01192 char *token;
01193 int token_count = 0;
01194 int ipseckey_len = 0;
01195 ldns_rdf* gateway_rdf = NULL;
01196 ldns_rdf* publickey_rdf = NULL;
01197 ldns_status status = LDNS_STATUS_OK;
01198
01199 if(strlen(str) == 0)
01200 token = LDNS_XMALLOC(char, 256);
01201 else token = LDNS_XMALLOC(char, strlen(str)+2);
01202 if(!token) return LDNS_STATUS_MEM_ERR;
01203
01204 str_buf = LDNS_MALLOC(ldns_buffer);
01205 if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
01206 ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
01207 if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
01208 LDNS_FREE(str_buf);
01209 LDNS_FREE(token);
01210 return LDNS_STATUS_MEM_ERR;
01211 }
01212 while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
01213 switch (token_count) {
01214 case 0:
01215 precedence = (uint8_t)atoi(token);
01216 break;
01217 case 1:
01218 gateway_type = (uint8_t)atoi(token);
01219 break;
01220 case 2:
01221 algorithm = (uint8_t)atoi(token);
01222 break;
01223 case 3:
01224 gateway = strdup(token);
01225 if (!gateway || (gateway_type == 0 &&
01226 (token[0] != '.' || token[1] != '\0'))) {
01227 LDNS_FREE(gateway);
01228 LDNS_FREE(token);
01229 ldns_buffer_free(str_buf);
01230 return LDNS_STATUS_INVALID_STR;
01231 }
01232 break;
01233 case 4:
01234 publickey = strdup(token);
01235 break;
01236 default:
01237 LDNS_FREE(token);
01238 ldns_buffer_free(str_buf);
01239 return LDNS_STATUS_INVALID_STR;
01240 break;
01241 }
01242 token_count++;
01243 }
01244
01245 if (!gateway || !publickey) {
01246 if (gateway)
01247 LDNS_FREE(gateway);
01248 if (publickey)
01249 LDNS_FREE(publickey);
01250 LDNS_FREE(token);
01251 ldns_buffer_free(str_buf);
01252 return LDNS_STATUS_INVALID_STR;
01253 }
01254
01255 if (gateway_type == 1) {
01256 status = ldns_str2rdf_a(&gateway_rdf, gateway);
01257 } else if (gateway_type == 2) {
01258 status = ldns_str2rdf_aaaa(&gateway_rdf, gateway);
01259 } else if (gateway_type == 3) {
01260 status = ldns_str2rdf_dname(&gateway_rdf, gateway);
01261 }
01262
01263 if (status != LDNS_STATUS_OK) {
01264 if (gateway)
01265 LDNS_FREE(gateway);
01266 if (publickey)
01267 LDNS_FREE(publickey);
01268 LDNS_FREE(token);
01269 ldns_buffer_free(str_buf);
01270 return LDNS_STATUS_INVALID_STR;
01271 }
01272
01273 status = ldns_str2rdf_b64(&publickey_rdf, publickey);
01274
01275 if (status != LDNS_STATUS_OK) {
01276 if (gateway)
01277 LDNS_FREE(gateway);
01278 if (publickey)
01279 LDNS_FREE(publickey);
01280 LDNS_FREE(token);
01281 ldns_buffer_free(str_buf);
01282 if (gateway_rdf) ldns_rdf_free(gateway_rdf);
01283 return LDNS_STATUS_INVALID_STR;
01284 }
01285
01286
01287 if (gateway_type)
01288 ipseckey_len = 3 + (int)ldns_rdf_size(gateway_rdf) + (int)ldns_rdf_size(publickey_rdf);
01289 else
01290 ipseckey_len = 3 + (int)ldns_rdf_size(publickey_rdf);
01291
01292 data = LDNS_XMALLOC(uint8_t, ipseckey_len);
01293 if(!data) {
01294 if (gateway)
01295 LDNS_FREE(gateway);
01296 if (publickey)
01297 LDNS_FREE(publickey);
01298 LDNS_FREE(token);
01299 ldns_buffer_free(str_buf);
01300 if (gateway_rdf) ldns_rdf_free(gateway_rdf);
01301 if (publickey_rdf) ldns_rdf_free(publickey_rdf);
01302 return LDNS_STATUS_MEM_ERR;
01303 }
01304
01305 data[0] = precedence;
01306 data[1] = gateway_type;
01307 data[2] = algorithm;
01308
01309 if (gateway_type) {
01310 memcpy(data + 3,
01311 ldns_rdf_data(gateway_rdf), ldns_rdf_size(gateway_rdf));
01312 memcpy(data + 3 + ldns_rdf_size(gateway_rdf),
01313 ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
01314 } else {
01315 memcpy(data + 3,
01316 ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
01317 }
01318
01319 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_IPSECKEY, (uint16_t) ipseckey_len, data);
01320
01321 if (gateway)
01322 LDNS_FREE(gateway);
01323 if (publickey)
01324 LDNS_FREE(publickey);
01325 LDNS_FREE(token);
01326 ldns_buffer_free(str_buf);
01327 ldns_rdf_free(gateway_rdf);
01328 ldns_rdf_free(publickey_rdf);
01329 LDNS_FREE(data);
01330 if(!*rd) return LDNS_STATUS_MEM_ERR;
01331 return LDNS_STATUS_OK;
01332 }
01333
01334 ldns_status
01335 ldns_str2rdf_ilnp64(ldns_rdf **rd, const char *str)
01336 {
01337 unsigned int a, b, c, d;
01338 uint16_t shorts[4];
01339 int l;
01340
01341 if (sscanf(str, "%4x:%4x:%4x:%4x%n", &a, &b, &c, &d, &l) != 4 ||
01342 l != (int)strlen(str) ||
01343 strpbrk(str, "+-")
01344 ) {
01345 return LDNS_STATUS_INVALID_ILNP64;
01346 } else {
01347 shorts[0] = htons(a);
01348 shorts[1] = htons(b);
01349 shorts[2] = htons(c);
01350 shorts[3] = htons(d);
01351 *rd = ldns_rdf_new_frm_data(
01352 LDNS_RDF_TYPE_ILNP64, 4 * sizeof(uint16_t), &shorts);
01353 }
01354 return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
01355 }
01356
01357 ldns_status
01358 ldns_str2rdf_eui48(ldns_rdf **rd, const char *str)
01359 {
01360 unsigned int a, b, c, d, e, f;
01361 uint8_t bytes[6];
01362 int l;
01363
01364 if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x%n",
01365 &a, &b, &c, &d, &e, &f, &l) != 6 ||
01366 l != (int)strlen(str) ||
01367 strpbrk(str, "+-")
01368 ) {
01369 return LDNS_STATUS_INVALID_EUI48;
01370 } else {
01371 bytes[0] = a;
01372 bytes[1] = b;
01373 bytes[2] = c;
01374 bytes[3] = d;
01375 bytes[4] = e;
01376 bytes[5] = f;
01377 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI48, 6, &bytes);
01378 }
01379 return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
01380 }
01381
01382 ldns_status
01383 ldns_str2rdf_eui64(ldns_rdf **rd, const char *str)
01384 {
01385 unsigned int a, b, c, d, e, f, g, h;
01386 uint8_t bytes[8];
01387 int l;
01388
01389 if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x-%2x-%2x%n",
01390 &a, &b, &c, &d, &e, &f, &g, &h, &l) != 8 ||
01391 l != (int)strlen(str) ||
01392 strpbrk(str, "+-")
01393 ) {
01394 return LDNS_STATUS_INVALID_EUI64;
01395 } else {
01396 bytes[0] = a;
01397 bytes[1] = b;
01398 bytes[2] = c;
01399 bytes[3] = d;
01400 bytes[4] = e;
01401 bytes[5] = f;
01402 bytes[6] = g;
01403 bytes[7] = h;
01404 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI64, 8, &bytes);
01405 }
01406 return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
01407 }
01408
01409 ldns_status
01410 ldns_str2rdf_tag(ldns_rdf **rd, const char *str)
01411 {
01412 uint8_t *data;
01413 const char* ptr;
01414
01415 if (strlen(str) > 255) {
01416 return LDNS_STATUS_INVALID_TAG;
01417 }
01418 for (ptr = str; *ptr; ptr++) {
01419 if (! isalnum(*ptr)) {
01420 return LDNS_STATUS_INVALID_TAG;
01421 }
01422 }
01423 data = LDNS_XMALLOC(uint8_t, strlen(str) + 1);
01424 if (!data) {
01425 return LDNS_STATUS_MEM_ERR;
01426 }
01427 data[0] = strlen(str);
01428 memcpy(data + 1, str, strlen(str));
01429
01430 *rd = ldns_rdf_new(LDNS_RDF_TYPE_TAG, strlen(str) + 1, data);
01431 if (!*rd) {
01432 LDNS_FREE(data);
01433 return LDNS_STATUS_MEM_ERR;
01434 }
01435 return LDNS_STATUS_OK;
01436 }
01437
01438 ldns_status
01439 ldns_str2rdf_long_str(ldns_rdf **rd, const char *str)
01440 {
01441 uint8_t *data, *dp, ch = 0;
01442 size_t length;
01443
01444
01445 dp = data = LDNS_XMALLOC(uint8_t, strlen(str));
01446 if (! data) {
01447 return LDNS_STATUS_MEM_ERR;
01448 }
01449
01450
01451 while (parse_char(&ch, &str)) {
01452 *dp++ = ch;
01453 if (dp - data > LDNS_MAX_RDFLEN) {
01454 LDNS_FREE(data);
01455 return LDNS_STATUS_INVALID_STR;
01456 }
01457 }
01458 if (! str) {
01459 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
01460 }
01461 length = (size_t)(dp - data);
01462
01463
01464 data = LDNS_XREALLOC(dp = data, uint8_t, length);
01465 if (! data) {
01466 LDNS_FREE(dp);
01467 return LDNS_STATUS_MEM_ERR;
01468 }
01469
01470
01471 *rd = ldns_rdf_new(LDNS_RDF_TYPE_LONG_STR, length, data);
01472 if (! *rd) {
01473 LDNS_FREE(data);
01474 return LDNS_STATUS_MEM_ERR;
01475 }
01476 return LDNS_STATUS_OK;
01477 }
01478
01479 ldns_status
01480 ldns_str2rdf_hip(ldns_rdf **rd, const char *str)
01481 {
01482 const char *hit = strchr(str, ' ') + 1;
01483 const char *pk = hit == NULL ? NULL : strchr(hit, ' ') + 1;
01484 size_t hit_size = hit == NULL ? 0
01485 : pk == NULL ? strlen(hit) : (size_t) (pk - hit) - 1;
01486 size_t pk_size = pk == NULL ? 0 : strlen(pk);
01487 size_t hit_wire_size = (hit_size + 1) / 2;
01488 size_t pk_wire_size = ldns_b64_pton_calculate_size(pk_size);
01489 size_t rdf_size = 4 + hit_wire_size + pk_wire_size;
01490
01491 char *endptr;
01492 int algorithm = strtol(str, &endptr, 10);
01493
01494 uint8_t *data, *dp;
01495 int hi, lo, written;
01496
01497 if (hit_size == 0 || pk_size == 0 || (hit_size + 1) / 2 > 255
01498 || rdf_size > LDNS_MAX_RDFLEN
01499 || algorithm < 0 || algorithm > 255
01500 || (errno != 0 && algorithm == 0)
01501 || endptr == str ) {
01502
01503 return LDNS_STATUS_SYNTAX_ERR;
01504 }
01505 if ((data = LDNS_XMALLOC(uint8_t, rdf_size)) == NULL) {
01506
01507 return LDNS_STATUS_MEM_ERR;
01508 }
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525
01526
01527
01528
01529
01530
01531
01532
01533
01534
01535
01536 data[0] = (uint8_t) hit_wire_size;
01537 data[1] = (uint8_t) algorithm;
01538
01539 for (dp = data + 4; *hit && *hit != ' '; dp++) {
01540
01541 if ((hi = ldns_hexdigit_to_int(*hit++)) == -1 ||
01542 (lo = ldns_hexdigit_to_int(*hit++)) == -1) {
01543
01544 LDNS_FREE(data);
01545 return LDNS_STATUS_INVALID_HEX;
01546 }
01547 *dp = (uint8_t) hi << 4 | lo;
01548 }
01549 if ((written = ldns_b64_pton(pk, dp, pk_wire_size)) <= 0) {
01550
01551 LDNS_FREE(data);
01552 return LDNS_STATUS_INVALID_B64;
01553 }
01554
01555
01556
01557
01558 pk_wire_size = (uint16_t) written;
01559 ldns_write_uint16(data + 2, pk_wire_size);
01560 rdf_size = 4 + hit_wire_size + pk_wire_size;
01561
01562
01563 if (! (*rd = ldns_rdf_new(LDNS_RDF_TYPE_HIP, rdf_size, data))) {
01564
01565 LDNS_FREE(data);
01566 return LDNS_STATUS_MEM_ERR;
01567 }
01568 return LDNS_STATUS_OK;
01569 }