00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #include <ldns/config.h>
00014
00015 #include <ldns/ldns.h>
00016
00017
00018
00019
00020
00021
00022
00023 size_t
00024 ldns_rdf_size(const ldns_rdf *rd)
00025 {
00026 assert(rd != NULL);
00027 return rd->_size;
00028 }
00029
00030 ldns_rdf_type
00031 ldns_rdf_get_type(const ldns_rdf *rd)
00032 {
00033 assert(rd != NULL);
00034 return rd->_type;
00035 }
00036
00037 uint8_t *
00038 ldns_rdf_data(const ldns_rdf *rd)
00039 {
00040 assert(rd != NULL);
00041 return rd->_data;
00042 }
00043
00044
00045 void
00046 ldns_rdf_set_size(ldns_rdf *rd, size_t size)
00047 {
00048 assert(rd != NULL);
00049 rd->_size = size;
00050 }
00051
00052 void
00053 ldns_rdf_set_type(ldns_rdf *rd, ldns_rdf_type type)
00054 {
00055 assert(rd != NULL);
00056 rd->_type = type;
00057 }
00058
00059 void
00060 ldns_rdf_set_data(ldns_rdf *rd, void *data)
00061 {
00062
00063 assert(rd != NULL);
00064 rd->_data = data;
00065 }
00066
00067
00068
00069 uint8_t
00070 ldns_rdf2native_int8(const ldns_rdf *rd)
00071 {
00072 uint8_t data;
00073
00074
00075 if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_BYTE) {
00076 return 0;
00077 }
00078
00079 memcpy(&data, ldns_rdf_data(rd), sizeof(data));
00080 return data;
00081 }
00082
00083 uint16_t
00084 ldns_rdf2native_int16(const ldns_rdf *rd)
00085 {
00086 uint16_t data;
00087
00088
00089 if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_WORD) {
00090 return 0;
00091 }
00092
00093 memcpy(&data, ldns_rdf_data(rd), sizeof(data));
00094 return ntohs(data);
00095 }
00096
00097 uint32_t
00098 ldns_rdf2native_int32(const ldns_rdf *rd)
00099 {
00100 uint32_t data;
00101
00102
00103 if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_DOUBLEWORD) {
00104 return 0;
00105 }
00106
00107 memcpy(&data, ldns_rdf_data(rd), sizeof(data));
00108 return ntohl(data);
00109 }
00110
00111 time_t
00112 ldns_rdf2native_time_t(const ldns_rdf *rd)
00113 {
00114 uint32_t data;
00115
00116 switch(ldns_rdf_get_type(rd)) {
00117 case LDNS_RDF_TYPE_TIME:
00118 memcpy(&data, ldns_rdf_data(rd), sizeof(data));
00119 return (time_t)ntohl(data);
00120 default:
00121 return 0;
00122 }
00123 }
00124
00125 ldns_rdf *
00126 ldns_native2rdf_int8(ldns_rdf_type type, uint8_t value)
00127 {
00128 return ldns_rdf_new_frm_data(type, LDNS_RDF_SIZE_BYTE, &value);
00129 }
00130
00131 ldns_rdf *
00132 ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value)
00133 {
00134 uint16_t *rdf_data = LDNS_XMALLOC(uint16_t, 1);
00135 ldns_write_uint16(rdf_data, value);
00136 return ldns_rdf_new(type, LDNS_RDF_SIZE_WORD, rdf_data);
00137 }
00138
00139 ldns_rdf *
00140 ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value)
00141 {
00142 uint32_t *rdf_data = LDNS_XMALLOC(uint32_t, 1);
00143 ldns_write_uint32(rdf_data, value);
00144 return ldns_rdf_new(type, LDNS_RDF_SIZE_DOUBLEWORD, rdf_data);
00145 }
00146
00147 ldns_rdf *
00148 ldns_native2rdf_int16_data(size_t size, uint8_t *data)
00149 {
00150 uint8_t *rdf_data = LDNS_XMALLOC(uint8_t, size + 2);
00151 ldns_write_uint16(rdf_data, size);
00152 memcpy(rdf_data + 2, data, size);
00153 return ldns_rdf_new(LDNS_RDF_TYPE_INT16_DATA, size + 2, rdf_data);
00154 }
00155
00156 ldns_rdf *
00157 ldns_rdf_new(ldns_rdf_type type, size_t size, void *data)
00158 {
00159 ldns_rdf *rd;
00160 rd = LDNS_MALLOC(ldns_rdf);
00161 if (!rd) {
00162 return NULL;
00163 }
00164 ldns_rdf_set_size(rd, size);
00165 ldns_rdf_set_type(rd, type);
00166 ldns_rdf_set_data(rd, data);
00167 return rd;
00168 }
00169
00170 ldns_rdf *
00171 ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data)
00172 {
00173 ldns_rdf *rdf;
00174
00175 rdf = LDNS_MALLOC(ldns_rdf);
00176 if (!rdf) {
00177 return NULL;
00178 }
00179 if (size > LDNS_MAX_RDFLEN) {
00180 return NULL;
00181 }
00182 rdf->_data = LDNS_XMALLOC(uint8_t, size);
00183 if (!rdf->_data) {
00184 return NULL;
00185 }
00186
00187 ldns_rdf_set_type(rdf, type);
00188 ldns_rdf_set_size(rdf, size);
00189 memcpy(rdf->_data, data, size);
00190
00191 return rdf;
00192 }
00193
00194 ldns_rdf *
00195 ldns_rdf_clone(const ldns_rdf *rd)
00196 {
00197 assert(rd != NULL);
00198 return (ldns_rdf_new_frm_data( ldns_rdf_get_type(rd),
00199 ldns_rdf_size(rd), ldns_rdf_data(rd)));
00200 }
00201
00202 void
00203 ldns_rdf_deep_free(ldns_rdf *rd)
00204 {
00205 if (rd) {
00206 if (rd->_data) {
00207 LDNS_FREE(rd->_data);
00208 }
00209 LDNS_FREE(rd);
00210 }
00211 }
00212
00213 void
00214 ldns_rdf_free(ldns_rdf *rd)
00215 {
00216 if (rd) {
00217 LDNS_FREE(rd);
00218 }
00219 }
00220
00221 ldns_rdf *
00222 ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str)
00223 {
00224 ldns_rdf *rdf = NULL;
00225 ldns_status status;
00226
00227 switch (type) {
00228 case LDNS_RDF_TYPE_DNAME:
00229 status = ldns_str2rdf_dname(&rdf, str);
00230 break;
00231 case LDNS_RDF_TYPE_INT8:
00232 status = ldns_str2rdf_int8(&rdf, str);
00233 break;
00234 case LDNS_RDF_TYPE_INT16:
00235 status = ldns_str2rdf_int16(&rdf, str);
00236 break;
00237 case LDNS_RDF_TYPE_INT32:
00238 status = ldns_str2rdf_int32(&rdf, str);
00239 break;
00240 case LDNS_RDF_TYPE_A:
00241 status = ldns_str2rdf_a(&rdf, str);
00242 break;
00243 case LDNS_RDF_TYPE_AAAA:
00244 status = ldns_str2rdf_aaaa(&rdf, str);
00245 break;
00246 case LDNS_RDF_TYPE_STR:
00247 status = ldns_str2rdf_str(&rdf, str);
00248 break;
00249 case LDNS_RDF_TYPE_APL:
00250 status = ldns_str2rdf_apl(&rdf, str);
00251 break;
00252 case LDNS_RDF_TYPE_B64:
00253 status = ldns_str2rdf_b64(&rdf, str);
00254 break;
00255 case LDNS_RDF_TYPE_B32_EXT:
00256 status = ldns_str2rdf_b32_ext(&rdf, str);
00257 break;
00258 case LDNS_RDF_TYPE_HEX:
00259 status = ldns_str2rdf_hex(&rdf, str);
00260 break;
00261 case LDNS_RDF_TYPE_NSEC:
00262 status = ldns_str2rdf_nsec(&rdf, str);
00263 break;
00264 case LDNS_RDF_TYPE_TYPE:
00265 status = ldns_str2rdf_type(&rdf, str);
00266 break;
00267 case LDNS_RDF_TYPE_CLASS:
00268 status = ldns_str2rdf_class(&rdf, str);
00269 break;
00270 case LDNS_RDF_TYPE_CERT_ALG:
00271 status = ldns_str2rdf_cert_alg(&rdf, str);
00272 break;
00273 case LDNS_RDF_TYPE_ALG:
00274 status = ldns_str2rdf_alg(&rdf, str);
00275 break;
00276 case LDNS_RDF_TYPE_UNKNOWN:
00277 status = ldns_str2rdf_unknown(&rdf, str);
00278 break;
00279 case LDNS_RDF_TYPE_TIME:
00280 status = ldns_str2rdf_time(&rdf, str);
00281 break;
00282 case LDNS_RDF_TYPE_PERIOD:
00283 status = ldns_str2rdf_period(&rdf, str);
00284 break;
00285 case LDNS_RDF_TYPE_TSIG:
00286 status = ldns_str2rdf_tsig(&rdf, str);
00287 break;
00288 case LDNS_RDF_TYPE_SERVICE:
00289 status = ldns_str2rdf_service(&rdf, str);
00290 break;
00291 case LDNS_RDF_TYPE_LOC:
00292 status = ldns_str2rdf_loc(&rdf, str);
00293 break;
00294 case LDNS_RDF_TYPE_WKS:
00295 status = ldns_str2rdf_wks(&rdf, str);
00296 break;
00297 case LDNS_RDF_TYPE_NSAP:
00298 status = ldns_str2rdf_nsap(&rdf, str);
00299 break;
00300 case LDNS_RDF_TYPE_NSEC3_SALT:
00301 status = ldns_str2rdf_nsec3_salt(&rdf, str);
00302 break;
00303 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
00304 status = ldns_str2rdf_b32_ext(&rdf, str);
00305 break;
00306 case LDNS_RDF_TYPE_NONE:
00307 default:
00308
00309 printf("unknown\n");
00310 status = LDNS_STATUS_ERR;
00311 break;
00312 }
00313 if (LDNS_STATUS_OK != status || !rdf) {
00314 return NULL;
00315 } else {
00316 ldns_rdf_set_type(rdf, type);
00317 return rdf;
00318 }
00319 }
00320
00321 ldns_status
00322 ldns_rdf_new_frm_fp(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp)
00323 {
00324 return ldns_rdf_new_frm_fp_l(rdf, type, fp, NULL);
00325 }
00326
00327 ldns_status
00328 ldns_rdf_new_frm_fp_l(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp, int *line_nr)
00329 {
00330 char *line;
00331 ldns_rdf *r;
00332 ssize_t t;
00333
00334 line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
00335 if (!line) {
00336 return LDNS_STATUS_MEM_ERR;
00337 }
00338
00339
00340 if ((t = ldns_fget_token_l(fp, line, LDNS_PARSE_SKIP_SPACE, 0, line_nr)) == -1) {
00341 LDNS_FREE(line);
00342 return LDNS_STATUS_SYNTAX_RDATA_ERR;
00343 }
00344 r = ldns_rdf_new_frm_str(type, (const char*) line);
00345 LDNS_FREE(line);
00346 if (rdf) {
00347 *rdf = r;
00348 return LDNS_STATUS_OK;
00349 } else {
00350 return LDNS_STATUS_NULL;
00351 }
00352 }
00353
00354 ldns_rdf *
00355 ldns_rdf_address_reverse(ldns_rdf *rd)
00356 {
00357 uint8_t buf_4[LDNS_IP4ADDRLEN];
00358 uint8_t buf_6[LDNS_IP6ADDRLEN * 2];
00359 ldns_rdf *rev;
00360 ldns_rdf *in_addr;
00361 ldns_rdf *ret_dname;
00362 uint8_t octet;
00363 uint8_t nnibble;
00364 uint8_t nibble;
00365 uint8_t i, j;
00366
00367 char *char_dname;
00368 int nbit;
00369
00370 if (ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_A &&
00371 ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_AAAA) {
00372 return NULL;
00373 }
00374
00375 in_addr = NULL;
00376 ret_dname = NULL;
00377
00378 switch(ldns_rdf_get_type(rd)) {
00379 case LDNS_RDF_TYPE_A:
00380
00381 buf_4[3] = ldns_rdf_data(rd)[0];
00382 buf_4[2] = ldns_rdf_data(rd)[1];
00383 buf_4[1] = ldns_rdf_data(rd)[2];
00384 buf_4[0] = ldns_rdf_data(rd)[3];
00385 in_addr = ldns_dname_new_frm_str("in-addr.arpa.");
00386 if (!in_addr) {
00387 return NULL;
00388 }
00389
00390 rev = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_A,
00391 LDNS_IP4ADDRLEN, (void*)&buf_4);
00392
00393
00394 char_dname = ldns_rdf2str(rev);
00395 if (!char_dname) {
00396 return NULL;
00397 }
00398
00399 ret_dname = ldns_dname_new_frm_str(char_dname);
00400 if (!ret_dname) {
00401 return NULL;
00402 }
00403
00404 ldns_rdf_deep_free(rev);
00405 LDNS_FREE(char_dname);
00406 break;
00407 case LDNS_RDF_TYPE_AAAA:
00408
00409
00410 for (nbit = 127; nbit >= 0; nbit = nbit - 4) {
00411
00412 octet = ( ((unsigned int) nbit) & 0x78) >> 3;
00413
00414 nnibble = ( ((unsigned int) nbit) & 0x04) >> 2;
00415
00416 nibble = (ldns_rdf_data(rd)[octet] & ( 0xf << (4 * (1 -
00417 nnibble)) ) ) >> ( 4 * (1 -
00418 nnibble));
00419
00420 buf_6[(LDNS_IP6ADDRLEN * 2 - 1) -
00421 (octet * 2 + nnibble)] =
00422 (uint8_t)ldns_int_to_hexdigit((int)nibble);
00423 }
00424
00425 char_dname = LDNS_XMALLOC(char, (LDNS_IP6ADDRLEN * 4));
00426 if (!char_dname) {
00427 return NULL;
00428 }
00429 char_dname[LDNS_IP6ADDRLEN * 4 - 1] = '\0';
00430
00431
00432 for (i = 0, j = 0; i < LDNS_IP6ADDRLEN * 2; i++, j = j + 2) {
00433 char_dname[j] = (char)buf_6[i];
00434 if (i != LDNS_IP6ADDRLEN * 2 - 1) {
00435 char_dname[j + 1] = '.';
00436 }
00437 }
00438 in_addr = ldns_dname_new_frm_str("ip6.arpa.");
00439 if (!in_addr) {
00440 return NULL;
00441 }
00442
00443
00444 ret_dname = ldns_dname_new_frm_str(char_dname);
00445 if (!ret_dname) {
00446 return NULL;
00447 }
00448 LDNS_FREE(char_dname);
00449 break;
00450 default:
00451 break;
00452 }
00453
00454 rev = ldns_dname_cat_clone(ret_dname, in_addr);
00455
00456 ldns_rdf_deep_free(ret_dname);
00457 ldns_rdf_deep_free(in_addr);
00458 return rev;
00459 }
00460
00461 ldns_status
00462 ldns_octet(char *word, size_t *length)
00463 {
00464 char *s;
00465 char *p;
00466 *length = 0;
00467
00468 for (s = p = word; *s != '\0'; s++,p++) {
00469 switch (*s) {
00470 case '.':
00471 if (s[1] == '.') {
00472 return LDNS_STATUS_EMPTY_LABEL;
00473 }
00474 *p = *s;
00475 (*length)++;
00476 break;
00477 case '\\':
00478 if ('0' <= s[1] && s[1] <= '9' &&
00479 '0' <= s[2] && s[2] <= '9' &&
00480 '0' <= s[3] && s[3] <= '9') {
00481
00482 int val = ((s[1] - '0') * 100 +
00483 (s[2] - '0') * 10 + (s[3] - '0'));
00484
00485 if (0 <= val && val <= 255) {
00486
00487 s += 3;
00488 *p = val;
00489 (*length)++;
00490 } else {
00491 return LDNS_STATUS_DDD_OVERFLOW;
00492 }
00493 } else {
00494
00495
00496 *p = *++s;
00497 (*length)++;
00498 }
00499 break;
00500 case '\"':
00501
00502
00503
00504 *p = *++s;
00505 (*length)++;
00506
00507 if ( *s == '\0' ) {
00508
00509 *p = '\0';
00510 return LDNS_STATUS_OK;
00511 }
00512 break;
00513 default:
00514 *p = *s;
00515 (*length)++;
00516 break;
00517 }
00518 }
00519 *p = '\0';
00520 return LDNS_STATUS_OK;
00521 }
00522
00523 int
00524 ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2)
00525 {
00526 uint16_t i1, i2, i;
00527 uint8_t *d1, *d2;
00528
00529
00530 if (!rd1 && !rd2) {
00531 return 0;
00532 }
00533 if (!rd1 || !rd2) {
00534 return -1;
00535 }
00536 i1 = ldns_rdf_size(rd1);
00537 i2 = ldns_rdf_size(rd1);
00538
00539 if (i1 < i2) {
00540 return -1;
00541 } else if (i1 > i2) {
00542 return +1;
00543 } else {
00544 d1 = (uint8_t*)ldns_rdf_data(rd1);
00545 d2 = (uint8_t*)ldns_rdf_data(rd2);
00546 for(i = 0; i < i1; i++) {
00547 if (d1[i] < d2[i]) {
00548 return -1;
00549 } else if (d1[i] > d2[i]) {
00550 return +1;
00551 }
00552 }
00553 }
00554 return 0;
00555 }
00556
00557 uint32_t
00558 ldns_str2period(const char *nptr, const char **endptr)
00559 {
00560 int sign = 0;
00561 uint32_t i = 0;
00562 uint32_t seconds = 0;
00563
00564 for(*endptr = nptr; **endptr; (*endptr)++) {
00565 switch (**endptr) {
00566 case ' ':
00567 case '\t':
00568 break;
00569 case '-':
00570 if(sign == 0) {
00571 sign = -1;
00572 } else {
00573 return seconds;
00574 }
00575 break;
00576 case '+':
00577 if(sign == 0) {
00578 sign = 1;
00579 } else {
00580 return seconds;
00581 }
00582 break;
00583 case 's':
00584 case 'S':
00585 seconds += i;
00586 i = 0;
00587 break;
00588 case 'm':
00589 case 'M':
00590 seconds += i * 60;
00591 i = 0;
00592 break;
00593 case 'h':
00594 case 'H':
00595 seconds += i * 60 * 60;
00596 i = 0;
00597 break;
00598 case 'd':
00599 case 'D':
00600 seconds += i * 60 * 60 * 24;
00601 i = 0;
00602 break;
00603 case 'w':
00604 case 'W':
00605 seconds += i * 60 * 60 * 24 * 7;
00606 i = 0;
00607 break;
00608 case '0':
00609 case '1':
00610 case '2':
00611 case '3':
00612 case '4':
00613 case '5':
00614 case '6':
00615 case '7':
00616 case '8':
00617 case '9':
00618 i *= 10;
00619 i += (**endptr - '0');
00620 break;
00621 default:
00622 seconds += i;
00623
00624 return seconds;
00625 }
00626 }
00627 seconds += i;
00628
00629 return seconds;
00630 }