contrib/ldns/str2host.c

   1 /*
   2  * str2host.c
   3  *
   4  * conversion routines from the presentation format
   5  * to the host format
   6  *
   7  * a Net::DNS like library for C
   8  *
   9  * (c) NLnet Labs, 2004-2006
  10  *
  11  * See the file LICENSE for the license
  12  */
  13 #include <ldns/config.h>
  14
  15 #include <ldns/ldns.h>
  16
  17 #ifdef HAVE_SYS_SOCKET_H
  18 #include <sys/socket.h>
  19 #endif
  20 #ifdef HAVE_ARPA_INET_H
  21 #include <arpa/inet.h>
  22 #endif
  23 #include <time.h>
  24
  25 #include <errno.h>
  26 #ifdef HAVE_NETDB_H
  27 #include <netdb.h>
  28 #endif
  29
  30 #include <limits.h>
  31 #ifdef HAVE_SYS_PARAM_H
  32 #include <sys/param.h>
  33 #endif
  34
  35 ldns_status
  36 ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr)
  37 {
  38         char *end = NULL;
  39         uint16_t *r;
  40         r = LDNS_MALLOC(uint16_t);
  41
  42         *r = htons((uint16_t)strtol((char *)shortstr, &end, 10));
  43
  44         if(*end != 0) {
  45                 LDNS_FREE(r);
  46                 return LDNS_STATUS_INVALID_INT;
  47         } else {
  48                 *rd = ldns_rdf_new_frm_data(
  49                         LDNS_RDF_TYPE_INT16, sizeof(uint16_t), r);
  50                 LDNS_FREE(r);
  51                 return LDNS_STATUS_OK;
  52         }
  53 }
  54
  55 ldns_status
  56 ldns_str2rdf_time(ldns_rdf **rd, const char *time)
  57 {
  58         /* convert a time YYYYDDMMHHMMSS to wireformat */
  59         uint16_t *r = NULL;
  60         struct tm tm;
  61         uint32_t l;
  62         char *end;
  63
  64         /* Try to scan the time... */
  65         r = (uint16_t*)LDNS_MALLOC(uint32_t);
  66
  67         memset(&tm, 0, sizeof(tm));
  68
  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
  71            ) {
  72                 tm.tm_year -= 1900;
  73                 tm.tm_mon--;
  74                 /* Check values */
  75                 if (tm.tm_year < 70) {
  76                         goto bad_format;
  77                 }
  78                 if (tm.tm_mon < 0 || tm.tm_mon > 11) {
  79                         goto bad_format;
  80                 }
  81                 if (tm.tm_mday < 1 || tm.tm_mday > 31) {
  82                         goto bad_format;
  83                 }
  84
  85                 if (tm.tm_hour < 0 || tm.tm_hour > 23) {
  86                         goto bad_format;
  87                 }
  88
  89                 if (tm.tm_min < 0 || tm.tm_min > 59) {
  90                         goto bad_format;
  91                 }
  92
  93                 if (tm.tm_sec < 0 || tm.tm_sec > 59) {
  94                         goto bad_format;
  95                 }
  96
  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);
 101                 LDNS_FREE(r);
 102                 return LDNS_STATUS_OK;
 103         } else {
 104                 /* handle it as 32 bits timestamp */
 105                 l = htonl((uint32_t)strtol((char*)time, &end, 10));
 106                 if(*end != 0) {
 107                         LDNS_FREE(r);
 108                         return LDNS_STATUS_ERR;
 109                 } else {
 110                         memcpy(r, &l, sizeof(uint32_t));
 111                         *rd = ldns_rdf_new_frm_data(
 112                                 LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
 113                         LDNS_FREE(r);
 114                         return LDNS_STATUS_OK;
 115                 }
 116         }
 117
 118         bad_format:
 119         LDNS_FREE(r);
 120         return LDNS_STATUS_INVALID_TIME;
 121 }
 122
 123 ldns_status
 124 ldns_str2rdf_nsec3_salt(ldns_rdf **rd, const char *salt_str)
 125 {
 126         uint8_t salt_length;
 127         int c;
 128         int salt_length_str;
 129
 130         uint8_t *salt;
 131         uint8_t *data;
 132
 133         salt_length_str = strlen(salt_str);
 134         if (salt_length_str == 1 && salt_str[0] == '-') {
 135                 salt_length_str = 0;
 136         } else if (salt_length_str % 2 != 0) {
 137                 return LDNS_STATUS_INVALID_HEX;
 138         }
 139         if (salt_length_str > 512) {
 140                 return LDNS_STATUS_INVALID_HEX;
 141         }
 142
 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]);
 148                 } else {
 149                         LDNS_FREE(salt);
 150                         return LDNS_STATUS_INVALID_HEX;
 151                 }
 152         }
 153         salt_length = (uint8_t) (salt_length_str / 2);
 154
 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);
 159         LDNS_FREE(data);
 160         LDNS_FREE(salt);
 161
 162         return LDNS_STATUS_OK;
 163 }
 164
 165 ldns_status
 166 ldns_str2rdf_period(ldns_rdf **rd,const char *period)
 167 {
 168         uint32_t p;
 169         const char *end;
 170
 171         /* Allocate required space... */
 172         p = ldns_str2period(period, &end);
 173
 174         if (*end != 0) {
 175                 return LDNS_STATUS_ERR;
 176         } else {
 177                 p = (uint32_t) htonl(p);
 178                 *rd = ldns_rdf_new_frm_data(
 179                         LDNS_RDF_TYPE_PERIOD, sizeof(uint32_t), &p);
 180         }
 181         return LDNS_STATUS_OK;
 182 }
 183
 184 ldns_status
 185 ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr)
 186 {
 187         char *end;
 188         uint16_t *r = NULL;
 189         uint32_t l;
 190
 191         r = (uint16_t*)LDNS_MALLOC(uint32_t);
 192         errno = 0; /* must set to zero before call,
 193                         note race condition on errno */
 194         if(*longstr == '-')
 195                 l = htonl((uint32_t)strtol((char*)longstr, &end, 10));
 196         else    l = htonl((uint32_t)strtoul((char*)longstr, &end, 10));
 197
 198         if(*end != 0) {
 199                 LDNS_FREE(r);
 200                 return LDNS_STATUS_ERR;
 201      } else {
 202                 if (errno == ERANGE) {
 203                         LDNS_FREE(r);
 204                         return LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW;
 205                 }
 206                 memcpy(r, &l, sizeof(uint32_t));
 207                 *rd = ldns_rdf_new_frm_data(
 208                         LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
 209                 LDNS_FREE(r);
 210                 return LDNS_STATUS_OK;
 211         }
 212 }
 213
 214 ldns_status
 215 ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr)
 216 {
 217         char *end;
 218         uint8_t *r = NULL;
 219
 220         r = LDNS_MALLOC(uint8_t);
 221
 222         *r = (uint8_t)strtol((char*)bytestr, &end, 10);
 223
 224         if(*end != 0) {
 225                 LDNS_FREE(r);
 226                 return LDNS_STATUS_ERR;
 227         } else {
 228                 *rd = ldns_rdf_new_frm_data(
 229                         LDNS_RDF_TYPE_INT8, sizeof(uint8_t), r);
 230                 LDNS_FREE(r);
 231                 return LDNS_STATUS_OK;
 232         }
 233 }
 234
 235
 236 /*
 237  * Checks whether the escaped value at **s is an octal value or
 238  * a 'normally' escaped character (and not eos)
 239  *
 240  * The string pointer at *s is increased by either 0 (on error), 1 (on
 241  * normal escapes), or 3 (on octals)
 242  *
 243  * Returns the number of bytes read from the escaped string, or
 244  * 0 on error
 245  */
 246 static int
 247 parse_escape(uint8_t *s, uint8_t *q) {
 248         uint8_t val;
 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]);
 257                 *q = val;
 258                 return 3;
 259         } else {
 260                 s++;
 261                 if (*s == '\0' || isdigit((int) *s)) {
 262                         /* apparently the string terminator
 263                          * or a digit has been escaped...
 264                          */
 265                         return 0;
 266                 }
 267                 *q = *s;
 268                 return 1;
 269         }
 270 }
 271
 272 /*
 273  * No special care is taken, all dots are translated into
 274  * label seperators.
 275  * Could be made more efficient....we do 3 memcpy's in total...
 276  */
 277 ldns_status
 278 ldns_str2rdf_dname(ldns_rdf **d, const char *str)
 279 {
 280         size_t len;
 281
 282         int esc;
 283         uint8_t *s, *q, *pq, label_len;
 284         uint8_t buf[LDNS_MAX_DOMAINLEN + 1];
 285         *d = NULL;
 286
 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;
 291         }
 292         if (0 == len) {
 293                 return LDNS_STATUS_DOMAINNAME_UNDERFLOW;
 294         }
 295
 296         /* root label */
 297         if (1 == len && *str == '.') {
 298                 *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, 1, "\0");
 299                 return LDNS_STATUS_OK;
 300         }
 301
 302         /* get on with the rest */
 303
 304         /* s is on the current character in the string
 305          * pq points to where the labellength is going to go
 306          * label_len keeps track of the current label's length
 307          * q builds the dname inside the buf array
 308          */
 309         len = 0;
 310         q = buf+1;
 311         pq = buf;
 312         label_len = 0;
 313         for (s = (uint8_t *)str; *s; s++, q++) {
 314                 if (q > buf + LDNS_MAX_DOMAINLEN) {
 315                         return LDNS_STATUS_DOMAINNAME_OVERFLOW;
 316                 }
 317                 *q = 0;
 318                 switch (*s) {
 319                 case '.':
 320                         if (label_len > LDNS_MAX_LABELLEN) {
 321                                 return LDNS_STATUS_LABEL_OVERFLOW;
 322                         }
 323                         if (label_len == 0) {
 324                                 return LDNS_STATUS_EMPTY_LABEL;
 325                         }
 326                         len += label_len + 1;
 327                         *pq = label_len;
 328                         label_len = 0;
 329                         pq = q;
 330                         break;
 331                 case '\\':
 332                         /* octet value or literal char */
 333                         esc = parse_escape(s, q);
 334                         if (esc > 0) {
 335                                 s += esc;
 336                                 label_len++;
 337                         } else {
 338                                 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
 339                         }
 340                         break;
 341                 default:
 342                         *q = *s;
 343                         label_len++;
 344                 }
 345         }
 346
 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;
 351                 }
 352                 if (label_len > LDNS_MAX_LABELLEN) {
 353                         return LDNS_STATUS_LABEL_OVERFLOW;
 354                 }
 355                 if (label_len == 0) { /* label_len 0 but not . at end? */
 356                         return LDNS_STATUS_EMPTY_LABEL;
 357                 }
 358                 len += label_len + 1;
 359                 *pq = label_len;
 360                 *q = 0;
 361         }
 362         len++;
 363
 364         *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, len, buf);
 365         return LDNS_STATUS_OK;
 366 }
 367
 368 ldns_status
 369 ldns_str2rdf_a(ldns_rdf **rd, const char *str)
 370 {
 371         in_addr_t address;
 372         if (inet_pton(AF_INET, (char*)str, &address) != 1) {
 373                 return LDNS_STATUS_INVALID_IP4;
 374         } else {
 375                 *rd = ldns_rdf_new_frm_data(
 376                         LDNS_RDF_TYPE_A, sizeof(address), &address);
 377         }
 378         return LDNS_STATUS_OK;
 379 }
 380
 381 ldns_status
 382 ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str)
 383 {
 384         uint8_t address[LDNS_IP6ADDRLEN + 1];
 385
 386         if (inet_pton(AF_INET6, (char*)str, address) != 1) {
 387                 return LDNS_STATUS_INVALID_IP6;
 388         } else {
 389                 *rd = ldns_rdf_new_frm_data(
 390                         LDNS_RDF_TYPE_AAAA, sizeof(address) - 1, &address);
 391         }
 392         return LDNS_STATUS_OK;
 393 }
 394
 395 ldns_status
 396 ldns_str2rdf_str(ldns_rdf **rd, const char *str)
 397 {
 398         uint8_t *data;
 399         size_t i, str_i, esc_i;
 400
 401         if (strlen(str) > 255) {
 402                 return LDNS_STATUS_INVALID_STR;
 403         }
 404
 405         data = LDNS_XMALLOC(uint8_t, strlen(str) + 1);
 406         i = 1;
 407         for (str_i = 0; str_i < strlen(str); str_i++) {
 408                 if (str[str_i] == '\\') {
 409                         /* octet value or literal char */
 410                         esc_i = (size_t) parse_escape((uint8_t*) &str[str_i], (uint8_t*) &data[i]);
 411                         if (esc_i == 0) {
 412                                 LDNS_FREE(data);
 413                                 return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
 414                         }
 415                         str_i += esc_i;
 416                 } else {
 417                         data[i] = (uint8_t) str[str_i];
 418                 }
 419                 i++;
 420         }
 421         data[0] = i - 1;
 422         *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_STR, i, data);
 423         LDNS_FREE(data);
 424         return LDNS_STATUS_OK;
 425 }
 426
 427 ldns_status
 428 ldns_str2rdf_apl(ldns_rdf **rd, const char *str)
 429 {
 430         const char *my_str = str;
 431
 432         char *my_ip_str;
 433         size_t ip_str_len;
 434
 435         uint16_t family;
 436         bool negation;
 437         uint8_t afdlength = 0;
 438         uint8_t *afdpart;
 439         uint8_t prefix;
 440
 441         uint8_t *data;
 442
 443         size_t i = 0;
 444
 445         /* [!]afi:address/prefix */
 446         if (strlen(my_str) < 2) {
 447                 return LDNS_STATUS_INVALID_STR;
 448         }
 449
 450         if (my_str[0] == '!') {
 451                 negation = true;
 452                 my_str += 1;
 453         } else {
 454                 negation = false;
 455         }
 456
 457         family = (uint16_t) atoi(my_str);
 458
 459         my_str = strchr(my_str, ':') + 1;
 460
 461         /* need ip addr and only ip addr for inet_pton */
 462         ip_str_len = (size_t) (strchr(my_str, '/') - my_str);
 463         my_ip_str = LDNS_XMALLOC(char, ip_str_len + 1);
 464         strncpy(my_ip_str, my_str, ip_str_len + 1);
 465         my_ip_str[ip_str_len] = '\0';
 466
 467         if (family == 1) {
 468                 /* ipv4 */
 469                 afdpart = LDNS_XMALLOC(uint8_t, 4);
 470                 if (inet_pton(AF_INET, my_ip_str, afdpart) == 0) {
 471                         return LDNS_STATUS_INVALID_STR;
 472                 }
 473                 for (i = 0; i < 4; i++) {
 474                         if (afdpart[i] != 0) {
 475                                 afdlength = i + 1;
 476                         }
 477                 }
 478         } else if (family == 2) {
 479                 /* ipv6 */
 480                 afdpart = LDNS_XMALLOC(uint8_t, 16);
 481                 if (inet_pton(AF_INET6, my_ip_str, afdpart) == 0) {
 482                         return LDNS_STATUS_INVALID_STR;
 483                 }
 484                 for (i = 0; i < 16; i++) {
 485                         if (afdpart[i] != 0) {
 486                                 afdlength = i + 1;
 487                         }
 488                 }
 489         } else {
 490                 /* unknown family */
 491                 LDNS_FREE(my_ip_str);
 492                 return LDNS_STATUS_INVALID_STR;
 493         }
 494
 495         my_str = strchr(my_str, '/') + 1;
 496         prefix = (uint8_t) atoi(my_str);
 497
 498         data = LDNS_XMALLOC(uint8_t, 4 + afdlength);
 499         ldns_write_uint16(data, family);
 500         data[2] = prefix;
 501         data[3] = afdlength;
 502         if (negation) {
 503                 /* set bit 1 of byte 3 */
 504                 data[3] = data[3] | 0x80;
 505         }
 506
 507         memcpy(data + 4, afdpart, afdlength);
 508
 509         *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_APL, afdlength + 4, data);
 510         LDNS_FREE(afdpart);
 511         LDNS_FREE(data);
 512         LDNS_FREE(my_ip_str);
 513
 514         return LDNS_STATUS_OK;
 515 }
 516
 517 ldns_status
 518 ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
 519 {
 520         uint8_t *buffer;
 521         int16_t i;
 522
 523         buffer = LDNS_XMALLOC(uint8_t, ldns_b64_ntop_calculate_size(strlen(str)));
 524
 525         i = (uint16_t)ldns_b64_pton((const char*)str, buffer,
 526                                                    ldns_b64_ntop_calculate_size(strlen(str)));
 527         if (-1 == i) {
 528                 LDNS_FREE(buffer);
 529                 return LDNS_STATUS_INVALID_B64;
 530         } else {
 531                 *rd = ldns_rdf_new_frm_data(
 532                         LDNS_RDF_TYPE_B64, (uint16_t) i, buffer);
 533         }
 534         LDNS_FREE(buffer);
 535
 536         return LDNS_STATUS_OK;
 537 }
 538
 539 ldns_status
 540 ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str)
 541 {
 542         uint8_t *buffer;
 543         int i;
 544         /* first byte contains length of actual b32 data */
 545         uint8_t len = ldns_b32_pton_calculate_size(strlen(str));
 546         buffer = LDNS_XMALLOC(uint8_t, len + 1);
 547         buffer[0] = len;
 548
 549         i = ldns_b32_pton_extended_hex((const char*)str, strlen(str), buffer + 1,
 550                                                          ldns_b32_ntop_calculate_size(strlen(str)));
 551         if (i < 0) {
 552                 return LDNS_STATUS_INVALID_B32_EXT;
 553         } else {
 554                 *rd = ldns_rdf_new_frm_data(
 555                         LDNS_RDF_TYPE_B32_EXT, (uint16_t) i + 1, buffer);
 556         }
 557         LDNS_FREE(buffer);
 558
 559         return LDNS_STATUS_OK;
 560 }
 561
 562 ldns_status
 563 ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
 564 {
 565         uint8_t *t, *t_orig;
 566         int i;
 567         size_t len;
 568
 569         len = strlen(str);
 570
 571         if (len > LDNS_MAX_RDFLEN * 2) {
 572                 return LDNS_STATUS_LABEL_OVERFLOW;
 573         } else {
 574                 t = LDNS_XMALLOC(uint8_t, (len / 2) + 1);
 575                 t_orig = t;
 576                 /* Now process octet by octet... */
 577                 while (*str) {
 578                         *t = 0;
 579                         if (isspace((int) *str)) {
 580                                 str++;
 581                         } else {
 582                                 for (i = 16; i >= 1; i -= 15) {
 583                                         while (*str && isspace((int) *str)) { str++; }
 584                                         if (*str) {
 585                                                 if (isxdigit((int) *str)) {
 586                                                         *t += ldns_hexdigit_to_int(*str) * i;
 587                                                 } else {
 588                                                         return LDNS_STATUS_ERR;
 589                                                 }
 590                                                 ++str;
 591                                         }
 592                                 }
 593                                 ++t;
 594                         }
 595                 }
 596                 *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX,
 597                                             (size_t) (t - t_orig),
 598                                             t_orig);
 599                 LDNS_FREE(t_orig);
 600         }
 601         return LDNS_STATUS_OK;
 602 }
 603
 604 ldns_status
 605 ldns_str2rdf_nsec(ldns_rdf **rd, const char *str)
 606 {
 607         const char *delimiters = "\n\t ";
 608         char *token = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
 609         ldns_buffer *str_buf;
 610         ssize_t c;
 611         uint16_t cur_type;
 612         size_t type_count = 0;
 613         ldns_rr_type type_list[1024];
 614         if(!token) return LDNS_STATUS_MEM_ERR;
 615         if(rd == NULL) {
 616                 LDNS_FREE(token);
 617                 return LDNS_STATUS_NULL;
 618         }
 619
 620         str_buf = LDNS_MALLOC(ldns_buffer);
 621         if(!str_buf) {
 622                 LDNS_FREE(token);
 623                 return LDNS_STATUS_MEM_ERR;
 624         }
 625         ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
 626         if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
 627                 LDNS_FREE(str_buf);
 628                 LDNS_FREE(token);
 629                 return LDNS_STATUS_MEM_ERR;
 630         }
 631
 632         while ((c = ldns_bget_token(str_buf, token, delimiters, LDNS_MAX_RDFLEN)) != -1 && c != 0) {
 633                 cur_type = ldns_get_rr_type_by_name(token);
 634                 type_list[type_count] = cur_type;
 635                 type_count++;
 636         }
 637
 638         *rd = ldns_dnssec_create_nsec_bitmap(type_list,
 639                                              type_count,
 640                                              LDNS_RR_TYPE_NSEC);
 641
 642         LDNS_FREE(token);
 643         ldns_buffer_free(str_buf);
 644         return LDNS_STATUS_OK;
 645 }
 646
 647 ldns_status
 648 ldns_str2rdf_type(ldns_rdf **rd, const char *str)
 649 {
 650         uint16_t type;
 651         type = htons(ldns_get_rr_type_by_name(str));
 652         /* ldns_rr_type is a 16 bit value */
 653         *rd = ldns_rdf_new_frm_data(
 654                 LDNS_RDF_TYPE_TYPE, sizeof(uint16_t), &type);
 655         return LDNS_STATUS_OK;
 656 }
 657
 658 ldns_status
 659 ldns_str2rdf_class(ldns_rdf **rd, const char *str)
 660 {
 661         uint16_t klass;
 662         klass = htons(ldns_get_rr_class_by_name(str));
 663         /* class is 16 bit */
 664         *rd = ldns_rdf_new_frm_data(
 665                 LDNS_RDF_TYPE_CLASS, sizeof(uint16_t), &klass);
 666         return LDNS_STATUS_OK;
 667 }
 668
 669 /* An certificate alg field can either be specified as a 8 bits number
 670  * or by its symbolic name. Handle both
 671  */
 672 ldns_status
 673 ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str)
 674 {
 675         ldns_lookup_table *lt;
 676         ldns_status st;
 677         uint8_t idd[2];
 678         lt = ldns_lookup_by_name(ldns_cert_algorithms, str);
 679         st = LDNS_STATUS_OK;
 680
 681         if (lt) {
 682                 ldns_write_uint16(idd, (uint16_t) lt->id);
 683                 *rd = ldns_rdf_new_frm_data(
 684                         LDNS_RDF_TYPE_INT16, sizeof(uint16_t), idd);
 685                 if (!*rd) {
 686                         st = LDNS_STATUS_ERR;
 687                 }
 688         } else {
 689                 /* try as-is (a number) */
 690                 st = ldns_str2rdf_int16(rd, str);
 691                 if (st == LDNS_STATUS_OK &&
 692                     ldns_rdf2native_int16(*rd) == 0) {
 693                         st = LDNS_STATUS_CERT_BAD_ALGORITHM;
 694                 }
 695         }
 696
 697         return st;
 698 }
 699
 700 /* An alg field can either be specified as a 8 bits number
 701  * or by its symbolic name. Handle both
 702  */
 703 ldns_status
 704 ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
 705 {
 706         ldns_lookup_table *lt;
 707         ldns_status st;
 708
 709         lt = ldns_lookup_by_name(ldns_algorithms, str);
 710         st = LDNS_STATUS_OK;
 711
 712         if (lt) {
 713                 /* it was given as a integer */
 714                 *rd = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t) lt->id);
 715                 if (!*rd) {
 716                         st = LDNS_STATUS_ERR;
 717                 }
 718         } else {
 719                 /* try as-is (a number) */
 720                 st = ldns_str2rdf_int8(rd, str);
 721         }
 722         return st;
 723 }
 724
 725 ldns_status
 726 ldns_str2rdf_unknown(ldns_rdf **rd, const char *str)
 727 {
 728         /* this should be caught in an earlier time (general str2host for
 729            rr's */
 730         rd = rd;
 731         str = str;
 732         return LDNS_STATUS_NOT_IMPL;
 733 }
 734
 735 ldns_status
 736 ldns_str2rdf_tsig(ldns_rdf **rd, const char *str)
 737 {
 738         /* there is no strign representation for TSIG rrs */
 739         rd = rd;
 740         str = str;
 741         return LDNS_STATUS_NOT_IMPL;
 742 }
 743
 744 ldns_status
 745 ldns_str2rdf_service(ldns_rdf **rd, const char *str)
 746 {
 747         /* is this used? is this actually WKS? or SRV? */
 748         rd = rd;
 749         str = str;
 750         return LDNS_STATUS_NOT_IMPL;
 751 }
 752
 753 static int
 754 loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e)
 755 {
 756         /* read <digits>[.<digits>][mM] */
 757         /* into mantissa exponent format for LOC type */
 758         uint32_t meters = 0, cm = 0, val;
 759         while (isblank(*my_str)) {
 760                 my_str++;
 761         }
 762         meters = (uint32_t)strtol(my_str, &my_str, 10);
 763         if (*my_str == '.') {
 764                 my_str++;
 765                 cm = (uint32_t)strtol(my_str, &my_str, 10);
 766         }
 767         if (meters >= 1) {
 768                 *e = 2;
 769                 val = meters;
 770         } else  {
 771                 *e = 0;
 772                 val = cm;
 773         }
 774         while(val >= 10) {
 775                 (*e)++;
 776                 val /= 10;
 777         }
 778         *m = (uint8_t)val;
 779
 780         if (*e > 9)
 781                 return 0;
 782         if (*my_str == 'm' || *my_str == 'M') {
 783                 my_str++;
 784         }
 785         *endstr = my_str;
 786         return 1;
 787 }
 788
 789 ldns_status
 790 ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
 791 {
 792         uint32_t latitude = 0;
 793         uint32_t longitude = 0;
 794         uint32_t altitude = 0;
 795
 796         uint8_t *data;
 797         uint32_t equator = (uint32_t) ldns_power(2, 31);
 798
 799         uint32_t h = 0;
 800         uint32_t m = 0;
 801         uint8_t size_b = 1, size_e = 2;
 802         uint8_t horiz_pre_b = 1, horiz_pre_e = 6;
 803         uint8_t vert_pre_b = 1, vert_pre_e = 3;
 804
 805         double s = 0.0;
 806         bool northerness;
 807         bool easterness;
 808
 809         char *my_str = (char *) str;
 810
 811         /* only support version 0 */
 812         if (isdigit((int) *my_str)) {
 813                 h = (uint32_t) strtol(my_str, &my_str, 10);
 814         } else {
 815                 return LDNS_STATUS_INVALID_STR;
 816         }
 817
 818         while (isblank((int) *my_str)) {
 819                 my_str++;
 820         }
 821
 822         if (isdigit((int) *my_str)) {
 823                 m = (uint32_t) strtol(my_str, &my_str, 10);
 824         } else if (*my_str == 'N' || *my_str == 'S') {
 825                 goto north;
 826         } else {
 827                 return LDNS_STATUS_INVALID_STR;
 828         }
 829
 830         while (isblank((int) *my_str)) {
 831                 my_str++;
 832         }
 833
 834         if (isdigit((int) *my_str)) {
 835                 s = strtod(my_str, &my_str);
 836         }
 837 north:
 838         while (isblank((int) *my_str)) {
 839                 my_str++;
 840         }
 841
 842         if (*my_str == 'N') {
 843                 northerness = true;
 844         } else if (*my_str == 'S') {
 845                 northerness = false;
 846         } else {
 847                 return LDNS_STATUS_INVALID_STR;
 848         }
 849
 850         my_str++;
 851
 852         /* store number */
 853         s = 1000.0 * s;
 854         /* add a little to make floor in conversion a round */
 855         s += 0.0005;
 856         latitude = (uint32_t) s;
 857         latitude += 1000 * 60 * m;
 858         latitude += 1000 * 60 * 60 * h;
 859         if (northerness) {
 860                 latitude = equator + latitude;
 861         } else {
 862                 latitude = equator - latitude;
 863         }
 864         while (isblank(*my_str)) {
 865                 my_str++;
 866         }
 867
 868         if (isdigit((int) *my_str)) {
 869                 h = (uint32_t) strtol(my_str, &my_str, 10);
 870         } else {
 871                 return LDNS_STATUS_INVALID_STR;
 872         }
 873
 874         while (isblank((int) *my_str)) {
 875                 my_str++;
 876         }
 877
 878         if (isdigit((int) *my_str)) {
 879                 m = (uint32_t) strtol(my_str, &my_str, 10);
 880         } else if (*my_str == 'E' || *my_str == 'W') {
 881                 goto east;
 882         } else {
 883                 return LDNS_STATUS_INVALID_STR;
 884         }
 885
 886         while (isblank(*my_str)) {
 887                 my_str++;
 888         }
 889
 890         if (isdigit((int) *my_str)) {
 891                 s = strtod(my_str, &my_str);
 892         }
 893
 894 east:
 895         while (isblank(*my_str)) {
 896                 my_str++;
 897         }
 898
 899         if (*my_str == 'E') {
 900                 easterness = true;
 901         } else if (*my_str == 'W') {
 902                 easterness = false;
 903         } else {
 904                 return LDNS_STATUS_INVALID_STR;
 905         }
 906
 907         my_str++;
 908
 909         /* store number */
 910         s *= 1000.0;
 911         /* add a little to make floor in conversion a round */
 912         s += 0.0005;
 913         longitude = (uint32_t) s;
 914         longitude += 1000 * 60 * m;
 915         longitude += 1000 * 60 * 60 * h;
 916
 917         if (easterness) {
 918                 longitude += equator;
 919         } else {
 920                 longitude = equator - longitude;
 921         }
 922
 923         altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 +
 924                 10000000.0 + 0.5);
 925         if (*my_str == 'm' || *my_str == 'M') {
 926                 my_str++;
 927         }
 928
 929         if (strlen(my_str) > 0) {
 930                 if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e))
 931                         return LDNS_STATUS_INVALID_STR;
 932         }
 933
 934         if (strlen(my_str) > 0) {
 935                 if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e))
 936                         return LDNS_STATUS_INVALID_STR;
 937         }
 938
 939         if (strlen(my_str) > 0) {
 940                 if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e))
 941                         return LDNS_STATUS_INVALID_STR;
 942         }
 943
 944         data = LDNS_XMALLOC(uint8_t, 16);
 945         data[0] = 0;
 946         data[1] = 0;
 947         data[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f);
 948         data[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f);
 949         data[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f);
 950         ldns_write_uint32(data + 4, latitude);
 951         ldns_write_uint32(data + 8, longitude);
 952         ldns_write_uint32(data + 12, altitude);
 953
 954         *rd = ldns_rdf_new_frm_data(
 955                 LDNS_RDF_TYPE_LOC, 16, data);
 956
 957         LDNS_FREE(data);
 958         return LDNS_STATUS_OK;
 959 }
 960
 961 ldns_status
 962 ldns_str2rdf_wks(ldns_rdf **rd, const char *str)
 963 {
 964         uint8_t *bitmap = NULL;
 965         uint8_t *data;
 966         int bm_len = 0;
 967
 968         struct protoent *proto = NULL;
 969         struct servent *serv = NULL;
 970         int serv_port;
 971
 972         ldns_buffer *str_buf;
 973
 974         char *proto_str = NULL;
 975         char *token;
 976         if(strlen(str) == 0)
 977                 token = LDNS_XMALLOC(char, 50);
 978         else    token = LDNS_XMALLOC(char, strlen(str)+2);
 979         if(!token) return LDNS_STATUS_MEM_ERR;
 980
 981         str_buf = LDNS_MALLOC(ldns_buffer);
 982         if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
 983         ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
 984         if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
 985                 LDNS_FREE(str_buf);
 986                 LDNS_FREE(token);
 987                 return LDNS_STATUS_MEM_ERR;
 988         }
 989
 990         while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
 991                 if (!proto_str) {
 992                         proto_str = strdup(token);
 993                         if (!proto_str) {
 994                                 LDNS_FREE(bitmap);
 995                                 LDNS_FREE(token);
 996                                 ldns_buffer_free(str_buf);
 997                                 return LDNS_STATUS_INVALID_STR;
 998                         }
 999                 } else {
1000                         serv = getservbyname(token, proto_str);
1001                         if (serv) {
1002                                 serv_port = (int) ntohs((uint16_t) serv->s_port);
1003                         } else {
1004                                 serv_port = atoi(token);
1005                         }
1006                         if (serv_port / 8 >= bm_len) {
1007                                 uint8_t *b2 = LDNS_XREALLOC(bitmap, uint8_t, (serv_port / 8) + 1);
1008                                 if(!b2) {
1009                                         LDNS_FREE(bitmap);
1010                                         LDNS_FREE(token);
1011                                         ldns_buffer_free(str_buf);
1012                                         free(proto_str);
1013                                         return LDNS_STATUS_INVALID_STR;
1014                                 }
1015                                 bitmap = b2;
1016                                 /* set to zero to be sure */
1017                                 for (; bm_len <= serv_port / 8; bm_len++) {
1018                                         bitmap[bm_len] = 0;
1019                                 }
1020                         }
1021                         ldns_set_bit(bitmap + (serv_port / 8), 7 - (serv_port % 8), true);
1022                 }
1023         }
1024
1025         if (!proto_str || !bitmap) {
1026                 LDNS_FREE(bitmap);
1027                 LDNS_FREE(token);
1028                 ldns_buffer_free(str_buf);
1029                 free(proto_str);
1030                 return LDNS_STATUS_INVALID_STR;
1031         }
1032
1033         data = LDNS_XMALLOC(uint8_t, bm_len + 1);
1034         if(!data) {
1035                 LDNS_FREE(token);
1036                 ldns_buffer_free(str_buf);
1037                 LDNS_FREE(bitmap);
1038                 free(proto_str);
1039                 return LDNS_STATUS_INVALID_STR;
1040         }
1041     if (proto_str)
1042                 proto = getprotobyname(proto_str);
1043         if (proto) {
1044                 data[0] = (uint8_t) proto->p_proto;
1045         } else if (proto_str) {
1046                 data[0] = (uint8_t) atoi(proto_str);
1047         } else {
1048                 data[0] = 0;
1049         }
1050         memcpy(data + 1, bitmap, (size_t) bm_len);
1051
1052         *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_WKS, (uint16_t) (bm_len + 1), data);
1053
1054         LDNS_FREE(data);
1055         LDNS_FREE(token);
1056         ldns_buffer_free(str_buf);
1057         LDNS_FREE(bitmap);
1058         free(proto_str);
1059 #ifdef HAVE_ENDSERVENT
1060         endservent();
1061 #endif
1062 #ifdef HAVE_ENDPROTOENT
1063         endprotoent();
1064 #endif
1065
1066         if(!*rd) return LDNS_STATUS_MEM_ERR;
1067
1068         return LDNS_STATUS_OK;
1069 }
1070
1071 ldns_status
1072 ldns_str2rdf_nsap(ldns_rdf **rd, const char *str)
1073 {
1074     size_t len, i;
1075     char* nsap_str = (char*) str;
1076
1077         /* just a hex string with optional dots? */
1078         if (str[0] != '0' || str[1] != 'x') {
1079                 return LDNS_STATUS_INVALID_STR;
1080         } else {
1081                 len = strlen(str);
1082                 for (i=0; i < len; i++) {
1083                         if (nsap_str[i] == '.')
1084                                 nsap_str[i] = ' ';
1085         }
1086                 return ldns_str2rdf_hex(rd, str+2);
1087         }
1088 }
1089
1090 ldns_status
1091 ldns_str2rdf_atma(ldns_rdf **rd, const char *str)
1092 {
1093     size_t len, i;
1094     char* atma_str = (char*) str;
1095         ldns_status status;
1096
1097         /* just a hex string with optional dots? */
1098         len = strlen(str);
1099         for (i=0; i < len; i++) {
1100                 if (atma_str[i] == '.')
1101                         atma_str[i] = ' ';
1102         }
1103         status = ldns_str2rdf_hex(rd, str);
1104     if (status != LDNS_STATUS_OK) {
1105                 ; /* probably in e.164 format than */
1106         }
1107         return status;
1108 }
1109
1110 ldns_status
1111 ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
1112 {
1113         uint8_t precedence = 0;
1114         uint8_t gateway_type = 0;
1115         uint8_t algorithm = 0;
1116         char* gateway = NULL;
1117         char* publickey = NULL;
1118         uint8_t *data;
1119         ldns_buffer *str_buf;
1120         char *token;
1121         int token_count = 0;
1122         int ipseckey_len = 0;
1123         ldns_rdf* gateway_rdf = NULL;
1124         ldns_rdf* publickey_rdf = NULL;
1125         ldns_status status = LDNS_STATUS_OK;
1126
1127         if(strlen(str) == 0)
1128                 token = LDNS_XMALLOC(char, 256);
1129         else    token = LDNS_XMALLOC(char, strlen(str)+2);
1130         if(!token) return LDNS_STATUS_MEM_ERR;
1131
1132         str_buf = LDNS_MALLOC(ldns_buffer);
1133         if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1134         ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1135         if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1136                 LDNS_FREE(str_buf);
1137                 LDNS_FREE(token);
1138                 return LDNS_STATUS_MEM_ERR;
1139         }
1140         while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1141                 switch (token_count) {
1142                                 case 0:
1143                                         precedence = atoi(token);
1144                                         break;
1145                                 case 1:
1146                                         gateway_type = atoi(token);
1147                                         break;
1148                                 case 2:
1149                                         algorithm = atoi(token);
1150                                         break;
1151                                 case 3:
1152                                         gateway = strdup(token);
1153                                         if (!gateway || (gateway_type == 0 &&
1154                                                         (token[0] != '.' || token[1] != '\0'))) {
1155                                                 LDNS_FREE(gateway);
1156                                                 LDNS_FREE(token);
1157                                                 ldns_buffer_free(str_buf);
1158                                                 return LDNS_STATUS_INVALID_STR;
1159                                         }
1160                                         break;
1161                                 case 4:
1162                                         publickey = strdup(token);
1163                                         break;
1164                                 default:
1165                                         LDNS_FREE(token);
1166                                         ldns_buffer_free(str_buf);
1167                                         return LDNS_STATUS_INVALID_STR;
1168                                         break;
1169                 }
1170                 token_count++;
1171         }
1172
1173         if (!gateway || !publickey) {
1174                 if (gateway)
1175                         LDNS_FREE(gateway);
1176                 if (publickey)
1177                         LDNS_FREE(publickey);
1178                 LDNS_FREE(token);
1179                 ldns_buffer_free(str_buf);
1180                 return LDNS_STATUS_INVALID_STR;
1181         }
1182
1183         if (gateway_type == 1) {
1184                 status = ldns_str2rdf_a(&gateway_rdf, gateway);
1185         } else if (gateway_type == 2) {
1186                 status = ldns_str2rdf_aaaa(&gateway_rdf, gateway);
1187         } else if (gateway_type == 3) {
1188                 status = ldns_str2rdf_dname(&gateway_rdf, gateway);
1189         }
1190
1191         if (status != LDNS_STATUS_OK) {
1192                 if (gateway)
1193                         LDNS_FREE(gateway);
1194                 if (publickey)
1195                         LDNS_FREE(publickey);
1196                 LDNS_FREE(token);
1197                 ldns_buffer_free(str_buf);
1198                 return LDNS_STATUS_INVALID_STR;
1199         }
1200
1201         status = ldns_str2rdf_b64(&publickey_rdf, publickey);
1202
1203         if (status != LDNS_STATUS_OK) {
1204                 if (gateway)
1205                         LDNS_FREE(gateway);
1206                 if (publickey)
1207                         LDNS_FREE(publickey);
1208                 LDNS_FREE(token);
1209                 ldns_buffer_free(str_buf);
1210                 if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1211                 return LDNS_STATUS_INVALID_STR;
1212         }
1213
1214         /* now copy all into one ipseckey rdf */
1215         if (gateway_type)
1216                 ipseckey_len = 3 + ldns_rdf_size(gateway_rdf) + ldns_rdf_size(publickey_rdf);
1217         else
1218                 ipseckey_len = 3 + ldns_rdf_size(publickey_rdf);
1219
1220         data = LDNS_XMALLOC(uint8_t, ipseckey_len);
1221         if(!data) {
1222                 if (gateway)
1223                         LDNS_FREE(gateway);
1224                 if (publickey)
1225                         LDNS_FREE(publickey);
1226                 LDNS_FREE(token);
1227                 ldns_buffer_free(str_buf);
1228                 if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1229                 if (publickey_rdf) ldns_rdf_free(publickey_rdf);
1230                 return LDNS_STATUS_MEM_ERR;
1231         }
1232
1233         data[0] = precedence;
1234         data[1] = gateway_type;
1235         data[2] = algorithm;
1236
1237         if (gateway_type) {
1238                 memcpy(data + 3,
1239                         ldns_rdf_data(gateway_rdf), ldns_rdf_size(gateway_rdf));
1240                 memcpy(data + 3 + ldns_rdf_size(gateway_rdf),
1241                         ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1242         } else {
1243                 memcpy(data + 3,
1244                         ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1245         }
1246
1247         *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_IPSECKEY, (uint16_t) ipseckey_len, data);
1248
1249         if (gateway)
1250                 LDNS_FREE(gateway);
1251         if (publickey)
1252                 LDNS_FREE(publickey);
1253         LDNS_FREE(token);
1254         ldns_buffer_free(str_buf);
1255         ldns_rdf_free(gateway_rdf);
1256         ldns_rdf_free(publickey_rdf);
1257         LDNS_FREE(data);
1258         if(!*rd) return LDNS_STATUS_MEM_ERR;
1259         return LDNS_STATUS_OK;
1260 }