str2host.c
Go to the documentation of this file.
00001 /*
00002  * str2host.c
00003  *
00004  * conversion routines from the presentation format
00005  * to the host format
00006  *
00007  * a Net::DNS like library for C
00008  *
00009  * (c) NLnet Labs, 2004-2006
00010  *
00011  * See the file LICENSE for the license
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         /* convert a time YYYYDDMMHHMMSS to wireformat */
00060         uint16_t *r = NULL;
00061         struct tm tm;
00062         uint32_t l;
00063         char *end;
00064 
00065         /* Try to scan the time... */
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                 /* Check values */
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                 /* handle it as 32 bits timestamp */
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         /* Allocate required space... */
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; /* must set to zero before call,
00206                         note race condition on errno */
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  * Checks whether the escaped value at **s is an octal value or
00252  * a 'normally' escaped character (and not eos)
00253  *
00254  * The string pointer at *s is increased by either 0 (on error), 1 (on
00255  * normal escapes), or 3 (on octals)
00256  *
00257  * Returns the number of bytes read from the escaped string, or
00258  * 0 on error
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; /* LDNS_STATUS_SYNTAX_BAD_ESCAPE */
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  * No special care is taken, all dots are translated into
00307  * label seperators.
00308  * Could be made more efficient....we do 3 memcpy's in total...
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         /* octet representation can make strings a lot longer than actual length */
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         /* root label */
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         /* get on with the rest */
00336 
00337         /* s is on the current character in the string
00338          * pq points to where the labellength is going to go
00339          * label_len keeps track of the current label's length
00340          * q builds the dname inside the buf array
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                         /* octet value or literal char */
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         /* add root label if last char was not '.' */
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) { /* label_len 0 but not . at end? */
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         /* Worst case space requirement. We'll realloc to actual size later. */
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         /* Fill data (up to 255 characters) */
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         /* Fix last length byte */
00452         data[0] = (uint8_t)length;
00453 
00454         /* Lose the overmeasure */
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         /* Create rdf */
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         /* [!]afi:address/prefix */
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         /* need ip addr and only ip addr for inet_pton */
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                 /* ipv4 */
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                 /* ipv6 */
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                 /* unknown family */
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                 /* set bit 1 of byte 3 */
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         /* first byte contains length of actual b32 data */
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                 /* Now process octet by octet... */
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         /* ldns_rr_type is a 16 bit value */
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         /* class is 16 bit */
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 /* An certificate alg field can either be specified as a 8 bits number
00750  * or by its symbolic name. Handle both
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                 /* try as-is (a number) */
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 /* An alg field can either be specified as a 8 bits number
00781  * or by its symbolic name. Handle both
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                 /* it was given as a integer */
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                 /* try as-is (a number) */
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         /* this should be caught in an earlier time (general str2host for
00811            rr's */
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         /* is this used? is this actually WKS? or SRV? */
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         /* read <digits>[.<digits>][mM] */
00828         /* into mantissa exponent format for LOC type */
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         /* only support version 0 */
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         /* store number */
00924         s = 1000.0 * s;
00925         /* add a little to make floor in conversion a round */
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         /* store number */
00981         s *= 1000.0;
00982         /* add a little to make floor in conversion a round */
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                                 /* set to zero to be sure */
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         /* just a hex string with optional dots? */
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         /* just a hex string with optional dots? */
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                 ; /* probably in e.164 format than */
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         /* now copy all into one ipseckey rdf */
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) || /* more data to read */
01343                         strpbrk(str, "+-")       /* signed hexes */
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) || /* more data to read */
01367                         strpbrk(str, "+-")       /* signed hexes */
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) || /* more data to read */
01392                         strpbrk(str, "+-")       /* signed hexes */
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         /* Worst case space requirement. We'll realloc to actual size later. */
01445         dp = data = LDNS_XMALLOC(uint8_t, strlen(str));
01446         if (! data) {
01447                 return LDNS_STATUS_MEM_ERR;
01448         }
01449 
01450         /* Fill data with parsed bytes */
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         /* Lose the overmeasure */
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         /* Create rdf */
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; /* utility var for strtol usage */
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) /* out of range */
01501                         || endptr == str                  /* no digits    */) {
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         /* From RFC 5205 section 5. HIP RR Storage Format:
01510          *************************************************
01511 
01512         0                   1                   2                   3
01513         0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
01514         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
01515         |  HIT length   | PK algorithm  |          PK length            |
01516         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
01517         |                                                               |
01518         ~                           HIT                                 ~
01519         |                                                               |
01520         +                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
01521         |                     |                                         |
01522         +-+-+-+-+-+-+-+-+-+-+-+                                         +
01523         |                           Public Key                          |
01524         ~                                                               ~
01525         |                                                               |
01526         +                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
01527         |                               |                               |
01528         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                               +
01529         |                                                               |
01530         ~                       Rendezvous Servers                      ~
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         /* Because ldns_b64_pton_calculate_size isn't always correct:
01556          * (we have to fix it at some point)
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         /* Create rdf */
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 }