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 #include <limits.h>
00018
00019 #include <sys/socket.h>
00020 #include <arpa/inet.h>
00021 #include <netdb.h>
00022 #include <time.h>
00023 #include <sys/time.h>
00024
00025 #ifndef INET_ADDRSTRLEN
00026 #define INET_ADDRSTRLEN 16
00027 #endif
00028 #ifndef INET6_ADDRSTRLEN
00029 #define INET6_ADDRSTRLEN 46
00030 #endif
00031
00032
00033
00034
00035 ldns_lookup_table ldns_algorithms[] = {
00036 { LDNS_RSAMD5, "RSAMD5" },
00037 { LDNS_DH, "DH" },
00038 { LDNS_DSA, "DSA" },
00039 { LDNS_ECC, "ECC" },
00040 { LDNS_RSASHA1, "RSASHA1" },
00041 { LDNS_INDIRECT, "INDIRECT" },
00042 { LDNS_PRIVATEDNS, "PRIVATEDNS" },
00043 { LDNS_PRIVATEOID, "PRIVATEOID" },
00044 { 0, NULL }
00045 };
00046
00047
00048 ldns_lookup_table ldns_cert_algorithms[] = {
00049 { LDNS_CERT_PKIX, "PKIX" },
00050 { LDNS_CERT_SPKI, "SPKI" },
00051 { LDNS_CERT_PGP, "PGP" },
00052 { LDNS_CERT_URI, "URI" },
00053 { LDNS_CERT_OID, "OID" },
00054 { 0, NULL }
00055 };
00056
00057
00058 ldns_lookup_table ldns_rr_classes[] = {
00059 { LDNS_RR_CLASS_IN, "IN" },
00060 { LDNS_RR_CLASS_CH, "CH" },
00061 { LDNS_RR_CLASS_HS, "HS" },
00062 { LDNS_RR_CLASS_ANY, "ANY" },
00063 { 0, NULL }
00064 };
00065
00066
00067 ldns_lookup_table ldns_rcodes[] = {
00068 { LDNS_RCODE_NOERROR, "NOERROR" },
00069 { LDNS_RCODE_FORMERR, "FORMERR" },
00070 { LDNS_RCODE_SERVFAIL, "SERVFAIL" },
00071 { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" },
00072 { LDNS_RCODE_NOTIMPL, "NOTIMPL" },
00073 { LDNS_RCODE_REFUSED, "REFUSED" },
00074 { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" },
00075 { LDNS_RCODE_YXRRSET, "YXRRSET" },
00076 { LDNS_RCODE_NXRRSET, "NXRRSET" },
00077 { LDNS_RCODE_NOTAUTH, "NOTAUTH" },
00078 { LDNS_RCODE_NOTZONE, "NOTZONE" },
00079 { 0, NULL }
00080 };
00081
00082 ldns_lookup_table ldns_opcodes[] = {
00083 { LDNS_PACKET_QUERY, "QUERY" },
00084 { LDNS_PACKET_IQUERY, "IQUERY" },
00085 { LDNS_PACKET_STATUS, "STATUS" },
00086 { LDNS_PACKET_NOTIFY, "NOTIFY" },
00087 { LDNS_PACKET_UPDATE, "UPDATE" },
00088 { 0, NULL }
00089 };
00090
00091
00092 ldns_status
00093 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
00094 {
00095
00096 uint8_t src_pos = 0;
00097 uint8_t len;
00098 uint8_t *data;
00099 uint8_t i;
00100
00101 data = (uint8_t*)ldns_rdf_data(dname);
00102 len = data[src_pos];
00103
00104 if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) {
00105
00106 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
00107 }
00108
00109
00110 if (1 == ldns_rdf_size(dname)) {
00111 ldns_buffer_printf(output, ".");
00112 } else {
00113 while ((len > 0) && src_pos < ldns_rdf_size(dname)) {
00114 src_pos++;
00115 for(i = 0; i < len; i++) {
00116
00117
00118
00119 if (data[src_pos] == '.' ||
00120 data[src_pos] == '(' || data[src_pos] == ')') {
00121 ldns_buffer_printf(output, "\\%c",
00122 data[src_pos]);
00123
00124 } else if (!isprint((int) data[src_pos])) {
00125 ldns_buffer_printf(output, "\\%03u",
00126 data[src_pos]);
00127 } else {
00128 ldns_buffer_printf(output, "%c", data[src_pos]);
00129 }
00130 src_pos++;
00131 }
00132
00133 len = data[src_pos];
00134 ldns_buffer_printf(output, ".");
00135 }
00136 }
00137 return ldns_buffer_status(output);
00138 }
00139
00140 ldns_status
00141 ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
00142 {
00143 uint8_t data = ldns_rdf_data(rdf)[0];
00144 ldns_buffer_printf(output, "%lu", (unsigned long) data);
00145 return ldns_buffer_status(output);
00146 }
00147
00148 ldns_status
00149 ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
00150 {
00151 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
00152 ldns_buffer_printf(output, "%lu", (unsigned long) data);
00153 return ldns_buffer_status(output);
00154 }
00155
00156 ldns_status
00157 ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
00158 {
00159 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
00160 ldns_buffer_printf(output, "%lu", (unsigned long) data);
00161 return ldns_buffer_status(output);
00162 }
00163
00164 ldns_status
00165 ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
00166 {
00167
00168 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
00169 time_t data_time;
00170 struct tm tm;
00171 char date_buf[16];
00172
00173 data_time = 0;
00174 memcpy(&data_time, &data, sizeof(uint32_t));
00175
00176 memset(&tm, 0, sizeof(tm));
00177
00178 if (gmtime_r(&data_time, &tm) && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
00179 ldns_buffer_printf(output, "%s", date_buf);
00180 }
00181 return ldns_buffer_status(output);
00182 }
00183
00184 ldns_status
00185 ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
00186 {
00187 char str[INET_ADDRSTRLEN];
00188
00189 if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) {
00190 ldns_buffer_printf(output, "%s", str);
00191 }
00192 return ldns_buffer_status(output);
00193 }
00194
00195 ldns_status
00196 ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
00197 {
00198 char str[INET6_ADDRSTRLEN];
00199
00200 if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) {
00201 ldns_buffer_printf(output, "%s", str);
00202 }
00203
00204 return ldns_buffer_status(output);
00205 }
00206
00207 ldns_status
00208 ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
00209 {
00210 const uint8_t *data = ldns_rdf_data(rdf);
00211 uint8_t length = data[0];
00212 size_t i;
00213
00214 ldns_buffer_printf(output, "\"");
00215 for (i = 1; i <= length; ++i) {
00216 char ch = (char) data[i];
00217 if (isprint(ch)) {
00218 if (ch == '"' || ch == '\\') {
00219 ldns_buffer_printf(output, "\\");
00220 }
00221 ldns_buffer_printf(output, "%c", ch);
00222 } else {
00223 ldns_buffer_printf(output, "\\%03u", (unsigned) ch);
00224 }
00225 }
00226 ldns_buffer_printf(output, "\"");
00227 return ldns_buffer_status(output);
00228 }
00229
00230 ldns_status
00231 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
00232 {
00233 size_t size = b64_ntop_calculate_size(ldns_rdf_size(rdf));
00234 char *b64 = LDNS_XMALLOC(char, size);
00235 if (b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) {
00236 ldns_buffer_printf(output, "%s", b64);
00237 }
00238 LDNS_FREE(b64);
00239 return ldns_buffer_status(output);
00240 }
00241
00242 ldns_status
00243 ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf)
00244 {
00245 size_t size = b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
00246 char *b32 = LDNS_XMALLOC(char, size + 1);
00247 size = (size_t) b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1, ldns_rdf_size(rdf) - 1, b32, size);
00248 if (size > 0) {
00249 ldns_buffer_printf(output, "%s", b32);
00250 }
00251 LDNS_FREE(b32);
00252 return ldns_buffer_status(output);
00253 }
00254
00255 ldns_status
00256 ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
00257 {
00258 size_t i;
00259 for (i = 0; i < ldns_rdf_size(rdf); i++) {
00260 ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]);
00261 }
00262
00263 return ldns_buffer_status(output);
00264 }
00265
00266 ldns_status
00267 ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
00268 {
00269 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
00270 const ldns_rr_descriptor *descriptor;
00271
00272 descriptor = ldns_rr_descript(data);
00273 if (descriptor && descriptor->_name) {
00274 ldns_buffer_printf(output, "%s", descriptor->_name);
00275 } else {
00276 ldns_buffer_printf(output, "TYPE%u", data);
00277 }
00278 return ldns_buffer_status(output);
00279 }
00280
00281 ldns_status
00282 ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
00283 {
00284 uint8_t data = ldns_rdf_data(rdf)[0];
00285 ldns_lookup_table *lt;
00286
00287 lt = ldns_lookup_by_id(ldns_rr_classes, (int) data);
00288 if (lt) {
00289 ldns_buffer_printf(output, "\t%s", lt->name);
00290 } else {
00291 ldns_buffer_printf(output, "\tCLASS%d", data);
00292 }
00293 return ldns_buffer_status(output);
00294 }
00295
00296 ldns_status
00297 ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
00298 {
00299 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
00300 ldns_lookup_table *lt;
00301 lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data);
00302 if (lt) {
00303 ldns_buffer_printf(output, "%s", lt->name);
00304 } else {
00305 ldns_buffer_printf(output, "%d", data);
00306 }
00307 return ldns_buffer_status(output);
00308 }
00309
00310 ldns_status
00311 ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
00312 {
00313
00314
00315 uint8_t data = ldns_rdf_data(rdf)[0];
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325 ldns_buffer_printf(output, "%d", data);
00326
00327
00328
00329 return ldns_buffer_status(output);
00330 }
00331
00332 static void
00333 loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
00334 {
00335 uint8_t i;
00336
00337 if(exponent < 2) {
00338 if(exponent == 1)
00339 mantissa *= 10;
00340 ldns_buffer_printf(output, "0.%02ld", (long)mantissa);
00341 return;
00342 }
00343
00344 ldns_buffer_printf(output, "%d", (int)mantissa);
00345 for(i=0; i<exponent-2; i++)
00346 ldns_buffer_printf(output, "0");
00347 }
00348
00349 ldns_status
00350 ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
00351 {
00352
00353 uint8_t version = ldns_rdf_data(rdf)[0];
00354 uint8_t size;
00355 uint8_t horizontal_precision;
00356 uint8_t vertical_precision;
00357 uint32_t longitude;
00358 uint32_t latitude;
00359 long altitude;
00360 char northerness;
00361 char easterness;
00362 uint32_t h;
00363 uint32_t m;
00364 double s;
00365
00366 uint32_t equator = (uint32_t) ldns_power(2, 31);
00367
00368 if (version == 0) {
00369 size = ldns_rdf_data(rdf)[1];
00370 horizontal_precision = ldns_rdf_data(rdf)[2];
00371 vertical_precision = ldns_rdf_data(rdf)[3];
00372
00373 latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]);
00374 longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]);
00375 altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]);
00376
00377 if (latitude > equator) {
00378 northerness = 'N';
00379 latitude = latitude - equator;
00380 } else {
00381 northerness = 'S';
00382 latitude = equator - latitude;
00383 }
00384 h = latitude / (1000 * 60 * 60);
00385 latitude = latitude % (1000 * 60 * 60);
00386 m = latitude / (1000 * 60);
00387 latitude = latitude % (1000 * 60);
00388 s = (double) latitude / 1000.0;
00389 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
00390 h, m, s, northerness);
00391
00392 if (longitude > equator) {
00393 easterness = 'E';
00394 longitude = longitude - equator;
00395 } else {
00396 easterness = 'W';
00397 longitude = equator - longitude;
00398 }
00399 h = longitude / (1000 * 60 * 60);
00400 longitude = longitude % (1000 * 60 * 60);
00401 m = longitude / (1000 * 60);
00402 longitude = longitude % (1000 * 60);
00403 s = (double) longitude / (1000.0);
00404 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
00405 h, m, s, easterness);
00406
00407 ldns_buffer_printf(output, "%ld", altitude/100 - 100000);
00408 if(altitude%100 != 0)
00409 ldns_buffer_printf(output, ".%02ld", altitude%100);
00410 ldns_buffer_printf(output, "m ");
00411
00412 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
00413 ldns_buffer_printf(output, "m ");
00414
00415 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
00416 horizontal_precision & 0x0f);
00417 ldns_buffer_printf(output, "m ");
00418
00419 loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
00420 vertical_precision & 0x0f);
00421 ldns_buffer_printf(output, "m ");
00422
00423 return ldns_buffer_status(output);
00424 } else {
00425 return ldns_rdf2buffer_str_hex(output, rdf);
00426 }
00427 }
00428
00429 ldns_status
00430 ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
00431 {
00432 ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
00433 return ldns_rdf2buffer_str_hex(output, rdf);
00434 }
00435
00436 ldns_status
00437 ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
00438 {
00439 ldns_buffer_printf(output, "0x");
00440 return ldns_rdf2buffer_str_hex(output, rdf);
00441 }
00442
00443 ldns_status
00444 ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
00445 {
00446
00447 struct protoent *protocol;
00448 char *proto_name = NULL;
00449 uint8_t protocol_nr;
00450 struct servent *service;
00451 uint16_t current_service;
00452
00453 protocol_nr = ldns_rdf_data(rdf)[0];
00454 protocol = getprotobynumber((int) protocol_nr);
00455 if (protocol && (protocol->p_name != NULL)) {
00456 proto_name = protocol->p_name;
00457 ldns_buffer_printf(output, "%s ", protocol->p_name);
00458 } else {
00459 ldns_buffer_printf(output, "%u ", protocol_nr);
00460 }
00461
00462 endprotoent();
00463
00464 for (current_service = 0;
00465 current_service < ldns_rdf_size(rdf) * 7; current_service++) {
00466 if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) {
00467 service = getservbyport((int) htons(current_service),
00468 proto_name);
00469 if (service && service->s_name) {
00470 ldns_buffer_printf(output, "%s ", service->s_name);
00471 } else {
00472 ldns_buffer_printf(output, "%u ", current_service);
00473 }
00474 endservent();
00475 }
00476 }
00477 return ldns_buffer_status(output);
00478 }
00479
00480 ldns_status
00481 ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
00482 {
00483
00484
00485
00486 uint8_t window_block_nr;
00487 uint8_t bitmap_length;
00488 uint16_t type;
00489 uint16_t pos = 0;
00490 uint16_t bit_pos;
00491 uint8_t *data = ldns_rdf_data(rdf);
00492 const ldns_rr_descriptor *descriptor;
00493
00494 while(pos < ldns_rdf_size(rdf)) {
00495 window_block_nr = data[pos];
00496 bitmap_length = data[pos + 1];
00497 pos += 2;
00498
00499 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
00500 if (ldns_get_bit(&data[pos], bit_pos)) {
00501 type = 256 * (uint16_t) window_block_nr + bit_pos;
00502 descriptor = ldns_rr_descript(type);
00503
00504 if (descriptor && descriptor->_name) {
00505 ldns_buffer_printf(output, "%s ",
00506 descriptor->_name);
00507 } else {
00508 ldns_buffer_printf(output, "TYPE%u ", type);
00509 }
00510 }
00511 }
00512
00513 pos += (uint16_t) bitmap_length;
00514 }
00515
00516 return ldns_buffer_status(output);
00517 }
00518
00519 ldns_status
00520 ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf)
00521 {
00522 uint8_t salt_length;
00523 uint8_t salt_pos;
00524
00525 uint8_t *data = ldns_rdf_data(rdf);
00526 size_t pos;
00527
00528 salt_length = data[0];
00529
00530
00531 pos = 1;
00532 if (salt_length == 0) {
00533 ldns_buffer_printf(output, "- ");
00534 } else {
00535 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) {
00536 ldns_buffer_printf(output, "%02x", data[1 + salt_pos]);
00537 pos++;
00538 }
00539 ldns_buffer_printf(output, " ");
00540 }
00541
00542 return ldns_buffer_status(output);
00543 }
00544
00545 ldns_status
00546 ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
00547 {
00548
00549 uint32_t p = ldns_read_uint32(ldns_rdf_data(rdf));
00550 ldns_buffer_printf(output, "%u", p);
00551 return ldns_buffer_status(output);
00552 }
00553
00554 ldns_status
00555 ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf)
00556 {
00557
00558 uint64_t tsigtime = 0;
00559 uint8_t *data = ldns_rdf_data(rdf);
00560
00561 if (ldns_rdf_size(rdf) != 6) {
00562 return LDNS_STATUS_ERR;
00563 }
00564
00565 tsigtime = ldns_read_uint16(data);
00566 tsigtime *= 65536;
00567 tsigtime += ldns_read_uint16(data+2);
00568 tsigtime *= 65536;
00569
00570 ldns_buffer_printf(output, "%llu ", tsigtime);
00571
00572 return ldns_buffer_status(output);
00573 }
00574
00575 ldns_status
00576 ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
00577 {
00578 uint8_t *data = ldns_rdf_data(rdf);
00579 uint16_t address_family = ldns_read_uint16(data);
00580 uint8_t prefix = data[2];
00581 bool negation;
00582 uint8_t adf_length;
00583 unsigned short i;
00584 unsigned int pos = 0;
00585
00586 while (pos < (unsigned int) ldns_rdf_size(rdf)) {
00587 address_family = ldns_read_uint16(&data[pos]);
00588 prefix = data[pos + 2];
00589 negation = data[pos + 3] & LDNS_APL_NEGATION;
00590 adf_length = data[pos + 3] & LDNS_APL_MASK;
00591 if (address_family == LDNS_APL_IP4) {
00592
00593 if (negation) {
00594 ldns_buffer_printf(output, "!");
00595 }
00596 ldns_buffer_printf(output, "%u:", address_family);
00597
00598 for (i = 0; i < 4; i++) {
00599 if (i > 0) {
00600 ldns_buffer_printf(output, ".");
00601 }
00602 if (i < (unsigned short) adf_length) {
00603 ldns_buffer_printf(output, "%d",
00604 data[pos + i + 4]);
00605 } else {
00606 ldns_buffer_printf(output, "0");
00607 }
00608 }
00609 ldns_buffer_printf(output, "/%u ", prefix);
00610 } else if (address_family == LDNS_APL_IP6) {
00611
00612 if (negation) {
00613 ldns_buffer_printf(output, "!");
00614 }
00615 ldns_buffer_printf(output, "%u:", address_family);
00616
00617 for (i = 0; i < 16; i++) {
00618 if (i % 2 == 0 && i > 0) {
00619 ldns_buffer_printf(output, ":");
00620 }
00621 if (i < (unsigned short) adf_length) {
00622 ldns_buffer_printf(output, "%02x",
00623 data[pos + i + 4]);
00624 } else {
00625 ldns_buffer_printf(output, "00");
00626 }
00627 }
00628 ldns_buffer_printf(output, "/%u ", prefix);
00629
00630 } else {
00631
00632 ldns_buffer_printf(output, "Unknown address family: %u data: ",
00633 address_family);
00634 for (i = 1; i < (unsigned short) (4 + adf_length); i++) {
00635 ldns_buffer_printf(output, "%02x", data[i]);
00636 }
00637 }
00638 pos += 4 + adf_length;
00639 }
00640 return ldns_buffer_status(output);
00641 }
00642
00643 ldns_status
00644 ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
00645 {
00646
00647 size_t size = b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
00648 char *b64 = LDNS_XMALLOC(char, size);
00649
00650 ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
00651
00652 if (ldns_rdf_size(rdf) > 2 &&
00653 b64_ntop(ldns_rdf_data(rdf) + 2, ldns_rdf_size(rdf) - 2, b64, size)) {
00654 ldns_buffer_printf(output, "%s", b64);
00655 }
00656 LDNS_FREE(b64);
00657 return ldns_buffer_status(output);
00658 }
00659
00660 ldns_status
00661 ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
00662 {
00663
00664
00665
00666 uint8_t *data = ldns_rdf_data(rdf);
00667 uint8_t precedence;
00668 uint8_t gateway_type;
00669 uint8_t algorithm;
00670
00671 ldns_rdf *gateway = NULL;
00672 uint8_t *gateway_data;
00673
00674 size_t public_key_size;
00675 uint8_t *public_key_data;
00676 ldns_rdf *public_key;
00677
00678 size_t offset = 0;
00679 ldns_status status;
00680
00681
00682 precedence = data[0];
00683 gateway_type = data[1];
00684 algorithm = data[2];
00685 offset = 3;
00686
00687 switch (gateway_type) {
00688 case 0:
00689
00690 break;
00691 case 1:
00692 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
00693 memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
00694 gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, LDNS_IP4ADDRLEN , gateway_data);
00695 break;
00696 case 2:
00697 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
00698 memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
00699 gateway =
00700 ldns_rdf_new(LDNS_RDF_TYPE_AAAA, LDNS_IP6ADDRLEN, gateway_data);
00701 break;
00702 case 3:
00703 status = ldns_wire2dname(&gateway, data, ldns_rdf_size(rdf), &offset);
00704 break;
00705 default:
00706
00707 break;
00708 }
00709
00710 public_key_size = ldns_rdf_size(rdf) - offset;
00711 public_key_data = LDNS_XMALLOC(uint8_t, public_key_size);
00712 memcpy(public_key_data, &data[offset], public_key_size);
00713 public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, public_key_size, public_key_data);
00714
00715 ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm);
00716 (void) ldns_rdf2buffer_str(output, gateway);
00717 ldns_buffer_printf(output, " ");
00718 (void) ldns_rdf2buffer_str(output, public_key);
00719
00720 ldns_rdf_free(gateway);
00721 ldns_rdf_free(public_key);
00722
00723 return ldns_buffer_status(output);
00724 }
00725
00726 ldns_status
00727 ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf)
00728 {
00729
00730 return ldns_rdf2buffer_str_unknown(output, rdf);
00731 }
00732
00733
00734 ldns_status
00735 ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
00736 {
00737 ldns_status res;
00738
00739
00740 if (rdf) {
00741 switch(ldns_rdf_get_type(rdf)) {
00742 case LDNS_RDF_TYPE_NONE:
00743 break;
00744 case LDNS_RDF_TYPE_DNAME:
00745 res = ldns_rdf2buffer_str_dname(buffer, rdf);
00746 break;
00747 case LDNS_RDF_TYPE_INT8:
00748 res = ldns_rdf2buffer_str_int8(buffer, rdf);
00749 break;
00750 case LDNS_RDF_TYPE_INT16:
00751 res = ldns_rdf2buffer_str_int16(buffer, rdf);
00752 break;
00753 case LDNS_RDF_TYPE_INT32:
00754 res = ldns_rdf2buffer_str_int32(buffer, rdf);
00755 break;
00756 case LDNS_RDF_TYPE_PERIOD:
00757 res = ldns_rdf2buffer_str_period(buffer, rdf);
00758 break;
00759 case LDNS_RDF_TYPE_TSIGTIME:
00760 res = ldns_rdf2buffer_str_tsigtime(buffer, rdf);
00761 break;
00762 case LDNS_RDF_TYPE_A:
00763 res = ldns_rdf2buffer_str_a(buffer, rdf);
00764 break;
00765 case LDNS_RDF_TYPE_AAAA:
00766 res = ldns_rdf2buffer_str_aaaa(buffer, rdf);
00767 break;
00768 case LDNS_RDF_TYPE_STR:
00769 res = ldns_rdf2buffer_str_str(buffer, rdf);
00770 break;
00771 case LDNS_RDF_TYPE_APL:
00772 res = ldns_rdf2buffer_str_apl(buffer, rdf);
00773 break;
00774 case LDNS_RDF_TYPE_B32_EXT:
00775 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
00776 break;
00777 case LDNS_RDF_TYPE_B64:
00778 res = ldns_rdf2buffer_str_b64(buffer, rdf);
00779 break;
00780 case LDNS_RDF_TYPE_HEX:
00781 res = ldns_rdf2buffer_str_hex(buffer, rdf);
00782 break;
00783 case LDNS_RDF_TYPE_NSEC:
00784 res = ldns_rdf2buffer_str_nsec(buffer, rdf);
00785 break;
00786 case LDNS_RDF_TYPE_NSEC3_SALT:
00787 res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf);
00788 break;
00789 case LDNS_RDF_TYPE_TYPE:
00790 res = ldns_rdf2buffer_str_type(buffer, rdf);
00791 break;
00792 case LDNS_RDF_TYPE_CLASS:
00793 res = ldns_rdf2buffer_str_class(buffer, rdf);
00794 break;
00795 case LDNS_RDF_TYPE_CERT_ALG:
00796 res = ldns_rdf2buffer_str_cert_alg(buffer, rdf);
00797 break;
00798 case LDNS_RDF_TYPE_ALG:
00799 res = ldns_rdf2buffer_str_alg(buffer, rdf);
00800 break;
00801 case LDNS_RDF_TYPE_UNKNOWN:
00802 res = ldns_rdf2buffer_str_unknown(buffer, rdf);
00803 break;
00804 case LDNS_RDF_TYPE_TIME:
00805 res = ldns_rdf2buffer_str_time(buffer, rdf);
00806 break;
00807 case LDNS_RDF_TYPE_LOC:
00808 res = ldns_rdf2buffer_str_loc(buffer, rdf);
00809 break;
00810 case LDNS_RDF_TYPE_WKS:
00811 case LDNS_RDF_TYPE_SERVICE:
00812 res = ldns_rdf2buffer_str_wks(buffer, rdf);
00813 break;
00814 case LDNS_RDF_TYPE_NSAP:
00815 res = ldns_rdf2buffer_str_nsap(buffer, rdf);
00816 break;
00817 case LDNS_RDF_TYPE_IPSECKEY:
00818 res = ldns_rdf2buffer_str_ipseckey(buffer, rdf);
00819 break;
00820 case LDNS_RDF_TYPE_TSIG:
00821 res = ldns_rdf2buffer_str_tsig(buffer, rdf);
00822 break;
00823 case LDNS_RDF_TYPE_INT16_DATA:
00824 res = ldns_rdf2buffer_str_int16_data(buffer, rdf);
00825 break;
00826 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
00827 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
00828 break;
00829 }
00830 } else {
00831 ldns_buffer_printf(buffer, "(null) ");
00832 }
00833 return LDNS_STATUS_OK;
00834 }
00835
00836 ldns_status
00837 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
00838 {
00839 uint16_t i;
00840 ldns_status status = LDNS_STATUS_OK;
00841 ldns_lookup_table *lt;
00842 const ldns_rr_descriptor *descriptor;
00843
00844 if (!rr) {
00845 ldns_buffer_printf(output, "(null)\n");
00846 } else {
00847 if (ldns_rr_owner(rr)) {
00848 status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr));
00849 }
00850 if (status != LDNS_STATUS_OK) {
00851 return status;
00852 }
00853
00854
00855
00856
00857
00858 if (ldns_rr_rd_count(rr) > 0) {
00859 ldns_buffer_printf(output, "\t%d", ldns_rr_ttl(rr));
00860 }
00861
00862 lt = ldns_lookup_by_id(ldns_rr_classes, ldns_rr_get_class(rr));
00863 if (lt) {
00864 ldns_buffer_printf(output, "\t%s\t", lt->name);
00865 } else {
00866 ldns_buffer_printf(output, "\tCLASS%d\t",
00867 ldns_rr_get_class(rr));
00868 }
00869
00870 descriptor = ldns_rr_descript(ldns_rr_get_type(rr));
00871
00872 if (descriptor && descriptor->_name) {
00873 ldns_buffer_printf(output, "%s", descriptor->_name);
00874 } else {
00875
00876 if (ldns_rr_get_type(rr) == 251) {
00877 ldns_buffer_printf(output, "IXFR ");
00878 } else if (ldns_rr_get_type(rr) == 252) {
00879 ldns_buffer_printf(output, "AXFR ");
00880 } else if (ldns_rr_get_type(rr) == 253) {
00881 ldns_buffer_printf(output, "MAILB ");
00882 } else if (ldns_rr_get_type(rr) == 254) {
00883 ldns_buffer_printf(output, "MAILA ");
00884 } else if (ldns_rr_get_type(rr) == 255) {
00885 ldns_buffer_printf(output, "ANY ");
00886 } else {
00887 ldns_buffer_printf(output, "TYPE%u",
00888 ldns_rr_get_type(rr));
00889 }
00890 }
00891
00892 if (ldns_rr_rd_count(rr) > 0) {
00893 ldns_buffer_printf(output, "\t");
00894 }
00895 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
00896 status = ldns_rdf2buffer_str(output, ldns_rr_rdf(rr, i));
00897 if (i < ldns_rr_rd_count(rr) - 1) {
00898 ldns_buffer_printf(output, " ");
00899 }
00900 }
00901
00902
00903
00904 if (ldns_rr_rd_count(rr) > 0) {
00905 switch (ldns_rr_get_type(rr)) {
00906 case LDNS_RR_TYPE_DNSKEY:
00907 #ifdef HAVE_SSL
00908 if (ldns_rdf2native_int16(ldns_rr_rdf(rr, 0)) == 256) {
00909 ldns_buffer_printf(output,
00910 " ;{id = %d (zsk), size = %db}",
00911 ldns_calc_keytag(rr),
00912 ldns_rr_dnskey_key_size(rr));
00913 break;
00914 }
00915 if (ldns_rdf2native_int16(ldns_rr_rdf(rr, 0)) == 257) {
00916 ldns_buffer_printf(output,
00917 " ;{id = %d (ksk), size = %db}",
00918 ldns_calc_keytag(rr),
00919 ldns_rr_dnskey_key_size(rr));
00920 break;
00921 }
00922 ldns_buffer_printf(output, " ;{id = %d, size = %db}",
00923 ldns_calc_keytag(rr),
00924 ldns_rr_dnskey_key_size(rr));
00925 #endif
00926 break;
00927 case LDNS_RR_TYPE_RRSIG:
00928 ldns_buffer_printf(output, " ;{id = %d}",
00929 ldns_rdf2native_int16(ldns_rr_rdf(rr, 6)));
00930 break;
00931 default:
00932 break;
00933
00934 }
00935 }
00936
00937 ldns_buffer_printf(output, "\n");
00938 }
00939 return ldns_buffer_status(output);
00940 }
00941
00942 ldns_status
00943 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
00944 {
00945 uint16_t i;
00946
00947 for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
00948 (void) ldns_rr2buffer_str(output, ldns_rr_list_rr(list, i));
00949 }
00950 return ldns_buffer_status(output);
00951 }
00952
00953 ldns_status
00954 ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
00955 {
00956 ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
00957 (int) ldns_pkt_get_opcode(pkt));
00958 ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes,
00959 (int) ldns_pkt_get_rcode(pkt));
00960
00961 ldns_buffer_printf(output, ";; ->>HEADER<<- ");
00962 if (opcode) {
00963 ldns_buffer_printf(output, "opcode: %s, ", opcode->name);
00964 } else {
00965 ldns_buffer_printf(output, "opcode: ?? (%u), ",
00966 ldns_pkt_get_opcode(pkt));
00967 }
00968 if (rcode) {
00969 ldns_buffer_printf(output, "rcode: %s, ", rcode->name);
00970 } else {
00971 ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt));
00972 }
00973 ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt));
00974 ldns_buffer_printf(output, ";; flags: ");
00975
00976 if (ldns_pkt_qr(pkt)) {
00977 ldns_buffer_printf(output, "qr ");
00978 }
00979 if (ldns_pkt_aa(pkt)) {
00980 ldns_buffer_printf(output, "aa ");
00981 }
00982 if (ldns_pkt_tc(pkt)) {
00983 ldns_buffer_printf(output, "tc ");
00984 }
00985 if (ldns_pkt_rd(pkt)) {
00986 ldns_buffer_printf(output, "rd ");
00987 }
00988 if (ldns_pkt_cd(pkt)) {
00989 ldns_buffer_printf(output, "cd ");
00990 }
00991 if (ldns_pkt_ra(pkt)) {
00992 ldns_buffer_printf(output, "ra ");
00993 }
00994 if (ldns_pkt_ad(pkt)) {
00995 ldns_buffer_printf(output, "ad ");
00996 }
00997 ldns_buffer_printf(output, "; ");
00998 ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt));
00999 ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt));
01000 ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt));
01001 ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt));
01002 return ldns_buffer_status(output);
01003 }
01004
01005 ldns_status
01006 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
01007 {
01008 uint16_t i;
01009 ldns_status status = LDNS_STATUS_OK;
01010 char *tmp;
01011 struct timeval time;
01012 time_t time_tt;
01013
01014 if (!pkt) {
01015 ldns_buffer_printf(output, "null");
01016 return LDNS_STATUS_OK;
01017 }
01018
01019 if (ldns_buffer_status_ok(output)) {
01020 status = ldns_pktheader2buffer_str(output, pkt);
01021 if (status != LDNS_STATUS_OK) {
01022 return status;
01023 }
01024
01025 ldns_buffer_printf(output, "\n");
01026
01027 ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
01028
01029
01030 for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
01031 status = ldns_rr2buffer_str(output,
01032 ldns_rr_list_rr(ldns_pkt_question(pkt), i));
01033 if (status != LDNS_STATUS_OK) {
01034 return status;
01035 }
01036 }
01037 ldns_buffer_printf(output, "\n");
01038
01039 ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
01040 for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
01041 status = ldns_rr2buffer_str(output,
01042 ldns_rr_list_rr(ldns_pkt_answer(pkt), i));
01043 if (status != LDNS_STATUS_OK) {
01044 return status;
01045 }
01046
01047 }
01048 ldns_buffer_printf(output, "\n");
01049
01050 ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
01051
01052 for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
01053 status = ldns_rr2buffer_str(output,
01054 ldns_rr_list_rr(ldns_pkt_authority(pkt), i));
01055 if (status != LDNS_STATUS_OK) {
01056 return status;
01057 }
01058 }
01059 ldns_buffer_printf(output, "\n");
01060
01061 ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
01062 for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
01063 status = ldns_rr2buffer_str(output,
01064 ldns_rr_list_rr(ldns_pkt_additional(pkt), i));
01065 if (status != LDNS_STATUS_OK) {
01066 return status;
01067 }
01068
01069 }
01070 ldns_buffer_printf(output, "\n");
01071
01072 ldns_buffer_printf(output, ";; Query time: %d msec\n",
01073 ldns_pkt_querytime(pkt));
01074 if (ldns_pkt_edns(pkt)) {
01075 ldns_buffer_printf(output,
01076 ";; EDNS: version %u; flags:",
01077 ldns_pkt_edns_version(pkt));
01078 if (ldns_pkt_edns_do(pkt)) {
01079 ldns_buffer_printf(output, " do");
01080 }
01081 if (ldns_pkt_edns_extended_rcode(pkt)) {
01082 ldns_buffer_printf(output, " ; ext-rcode: %d",
01083 ldns_pkt_edns_extended_rcode(pkt));
01084 }
01085 ldns_buffer_printf(output, " ; udp: %u\n",
01086 ldns_pkt_edns_udp_size(pkt));
01087
01088 if (ldns_pkt_edns_data(pkt)) {
01089 ldns_buffer_printf(output, ";; Data: ");
01090 (void)ldns_rdf2buffer_str(output,
01091 ldns_pkt_edns_data(pkt));
01092 ldns_buffer_printf(output, "\n");
01093 }
01094 }
01095 if (ldns_pkt_tsig(pkt)) {
01096 ldns_buffer_printf(output, ";; TSIG:\n;; ");
01097 (void) ldns_rr2buffer_str(output, ldns_pkt_tsig(pkt));
01098 ldns_buffer_printf(output, "\n");
01099 }
01100 if (ldns_pkt_answerfrom(pkt)) {
01101 tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
01102 ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
01103 LDNS_FREE(tmp);
01104 }
01105 time = ldns_pkt_timestamp(pkt);
01106 time_tt = (time_t)time.tv_sec;
01107 ldns_buffer_printf(output, ";; WHEN: %s",
01108 (char*)ctime(&time_tt));
01109
01110 ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n",
01111 (int)ldns_pkt_size(pkt));
01112 } else {
01113 return ldns_buffer_status(output);
01114 }
01115 return status;
01116 }
01117
01118 ldns_status
01119 ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
01120 {
01121 ldns_status status = LDNS_STATUS_OK;
01122 unsigned char *bignum;
01123
01124 #ifdef HAVE_SSL
01125
01126 ldns_rdf *b64_bignum = NULL;
01127 uint16_t i;
01128
01129 RSA *rsa;
01130 DSA *dsa;
01131 #endif
01132
01133 if (!k) {
01134 return LDNS_STATUS_ERR;
01135 }
01136
01137 bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
01138 if (!bignum) {
01139 return LDNS_STATUS_ERR;
01140 }
01141
01142 if (ldns_buffer_status_ok(output)) {
01143 #ifdef HAVE_SSL
01144 switch(ldns_key_algorithm(k)) {
01145 case LDNS_SIGN_RSASHA1:
01146 case LDNS_SIGN_RSASHA1_NSEC3:
01147 case LDNS_SIGN_RSASHA256:
01148 case LDNS_SIGN_RSASHA256_NSEC3:
01149 case LDNS_SIGN_RSASHA512:
01150 case LDNS_SIGN_RSASHA512_NSEC3:
01151 case LDNS_SIGN_RSAMD5:
01152
01153
01154 rsa = ldns_key_rsa_key(k);
01155
01156 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
01157 switch(ldns_key_algorithm(k)) {
01158 case LDNS_SIGN_RSAMD5:
01159 ldns_buffer_printf(output,"Algorithm: 1 (RSA)\n");
01160 break;
01161 case LDNS_SIGN_RSASHA1:
01162 case LDNS_SIGN_RSASHA1_NSEC3:
01163 ldns_buffer_printf(output,"Algorithm: 5 (RSASHA1)\n");
01164 break;
01165 case LDNS_SIGN_RSASHA256:
01166 case LDNS_SIGN_RSASHA256_NSEC3:
01167 ldns_buffer_printf(output,"Algorithm: 6 (RSASHA256)\n");
01168 break;
01169 case LDNS_SIGN_RSASHA512:
01170 case LDNS_SIGN_RSASHA512_NSEC3:
01171 ldns_buffer_printf(output,"Algorithm: 7 (RSASHA512)\n");
01172 break;
01173 default:
01174 break;
01175 }
01176
01177
01178
01179
01180
01181 ldns_buffer_printf(output, "Modulus: ");
01182 i = (uint16_t)BN_bn2bin(rsa->n, bignum);
01183 if (i > LDNS_MAX_KEYLEN) {
01184 goto error;
01185 }
01186 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01187 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01188 goto error;
01189 }
01190 ldns_rdf_deep_free(b64_bignum);
01191 ldns_buffer_printf(output, "\n");
01192 ldns_buffer_printf(output, "PublicExponent: ");
01193 i = (uint16_t)BN_bn2bin(rsa->e, bignum);
01194 if (i > LDNS_MAX_KEYLEN) {
01195 goto error;
01196 }
01197 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01198 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01199 goto error;
01200 }
01201 ldns_rdf_deep_free(b64_bignum);
01202 ldns_buffer_printf(output, "\n");
01203
01204 ldns_buffer_printf(output, "PrivateExponent: ");
01205 if (rsa->d) {
01206 i = (uint16_t)BN_bn2bin(rsa->d, bignum);
01207 if (i > LDNS_MAX_KEYLEN) {
01208 goto error;
01209 }
01210 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01211 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01212 goto error;
01213 }
01214 ldns_rdf_deep_free(b64_bignum);
01215 ldns_buffer_printf(output, "\n");
01216 } else {
01217 ldns_buffer_printf(output, "(Not available)\n");
01218 }
01219
01220 ldns_buffer_printf(output, "Prime1: ");
01221 if (rsa->p) {
01222 i = (uint16_t)BN_bn2bin(rsa->p, bignum);
01223 if (i > LDNS_MAX_KEYLEN) {
01224 goto error;
01225 }
01226 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01227 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01228 goto error;
01229 }
01230 ldns_rdf_deep_free(b64_bignum);
01231 ldns_buffer_printf(output, "\n");
01232 } else {
01233 ldns_buffer_printf(output, "(Not available)\n");
01234 }
01235
01236 ldns_buffer_printf(output, "Prime2: ");
01237 if (rsa->q) {
01238 i = (uint16_t)BN_bn2bin(rsa->q, bignum);
01239 if (i > LDNS_MAX_KEYLEN) {
01240 goto error;
01241 }
01242 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01243 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01244 goto error;
01245 }
01246 ldns_rdf_deep_free(b64_bignum);
01247 ldns_buffer_printf(output, "\n");
01248 } else {
01249 ldns_buffer_printf(output, "(Not available)\n");
01250 }
01251
01252 ldns_buffer_printf(output, "Exponent1: ");
01253 if (rsa->dmp1) {
01254 i = (uint16_t)BN_bn2bin(rsa->dmp1, bignum);
01255 if (i > LDNS_MAX_KEYLEN) {
01256 goto error;
01257 }
01258 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01259 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01260 goto error;
01261 }
01262 ldns_rdf_deep_free(b64_bignum);
01263 ldns_buffer_printf(output, "\n");
01264 } else {
01265 ldns_buffer_printf(output, "(Not available)\n");
01266 }
01267
01268 ldns_buffer_printf(output, "Exponent2: ");
01269 if (rsa->dmq1) {
01270 i = (uint16_t)BN_bn2bin(rsa->dmq1, bignum);
01271 if (i > LDNS_MAX_KEYLEN) {
01272 goto error;
01273 }
01274 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01275 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01276 goto error;
01277 }
01278 ldns_rdf_deep_free(b64_bignum);
01279 ldns_buffer_printf(output, "\n");
01280 } else {
01281 ldns_buffer_printf(output, "(Not available)\n");
01282 }
01283
01284 ldns_buffer_printf(output, "Coefficient: ");
01285 if (rsa->iqmp) {
01286 i = (uint16_t)BN_bn2bin(rsa->iqmp, bignum);
01287 if (i > LDNS_MAX_KEYLEN) {
01288 goto error;
01289 }
01290 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01291 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01292 goto error;
01293 }
01294 ldns_rdf_deep_free(b64_bignum);
01295 ldns_buffer_printf(output, "\n");
01296 } else {
01297 ldns_buffer_printf(output, "(Not available)\n");
01298 }
01299
01300 RSA_free(rsa);
01301 break;
01302 case LDNS_SIGN_DSA:
01303 case LDNS_SIGN_DSA_NSEC3:
01304 dsa = ldns_key_dsa_key(k);
01305
01306 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
01307 ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n");
01308
01309
01310
01311 ldns_buffer_printf(output, "Prime(p): ");
01312 if (dsa->p) {
01313 i = (uint16_t)BN_bn2bin(dsa->p, bignum);
01314 if (i > LDNS_MAX_KEYLEN) {
01315 goto error;
01316 }
01317 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01318 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01319 goto error;
01320 }
01321 ldns_rdf_deep_free(b64_bignum);
01322 ldns_buffer_printf(output, "\n");
01323 } else {
01324 printf("(Not available)\n");
01325 }
01326
01327 ldns_buffer_printf(output, "Subprime(q): ");
01328 if (dsa->q) {
01329 i = (uint16_t)BN_bn2bin(dsa->q, bignum);
01330 if (i > LDNS_MAX_KEYLEN) {
01331 goto error;
01332 }
01333 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01334 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01335 goto error;
01336 }
01337 ldns_rdf_deep_free(b64_bignum);
01338 ldns_buffer_printf(output, "\n");
01339 } else {
01340 printf("(Not available)\n");
01341 }
01342
01343 ldns_buffer_printf(output, "Base(g): ");
01344 if (dsa->g) {
01345 i = (uint16_t)BN_bn2bin(dsa->g, bignum);
01346 if (i > LDNS_MAX_KEYLEN) {
01347 goto error;
01348 }
01349 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01350 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01351 goto error;
01352 }
01353 ldns_rdf_deep_free(b64_bignum);
01354 ldns_buffer_printf(output, "\n");
01355 } else {
01356 printf("(Not available)\n");
01357 }
01358
01359 ldns_buffer_printf(output, "Private_value(x): ");
01360 if (dsa->priv_key) {
01361 i = (uint16_t)BN_bn2bin(dsa->priv_key, bignum);
01362 if (i > LDNS_MAX_KEYLEN) {
01363 goto error;
01364 }
01365 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01366 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01367 goto error;
01368 }
01369 ldns_rdf_deep_free(b64_bignum);
01370 ldns_buffer_printf(output, "\n");
01371 } else {
01372 printf("(Not available)\n");
01373 }
01374
01375 ldns_buffer_printf(output, "Public_value(y): ");
01376 if (dsa->pub_key) {
01377 i = (uint16_t)BN_bn2bin(dsa->pub_key, bignum);
01378 if (i > LDNS_MAX_KEYLEN) {
01379 goto error;
01380 }
01381 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01382 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01383 goto error;
01384 }
01385 ldns_rdf_deep_free(b64_bignum);
01386 ldns_buffer_printf(output, "\n");
01387 } else {
01388 printf("(Not available)\n");
01389 }
01390 break;
01391 case LDNS_SIGN_HMACMD5:
01392
01393 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
01394 ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n");
01395 ldns_buffer_printf(output, "Key: ");
01396 i = ldns_key_hmac_size(k);
01397 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k));
01398 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01399 goto error;
01400 }
01401 ldns_rdf_deep_free(b64_bignum);
01402 ldns_buffer_printf(output, "\n");
01403 break;
01404 }
01405 #endif
01406 } else {
01407 #ifdef HAVE_SSL
01408 LDNS_FREE(b64_bignum);
01409 #endif
01410 LDNS_FREE(bignum);
01411 return ldns_buffer_status(output);
01412 }
01413 LDNS_FREE(bignum);
01414 return status;
01415
01416 #ifdef HAVE_SSL
01417
01418 error:
01419 LDNS_FREE(bignum);
01420 return LDNS_STATUS_ERR;
01421 #endif
01422
01423 }
01424
01425
01426
01427
01428 char *
01429 buffer2str(ldns_buffer *buffer)
01430 {
01431 char *tmp_str;
01432 char *str;
01433
01434
01435
01436 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
01437 if (!ldns_buffer_reserve(buffer, 1)) {
01438 return NULL;
01439 }
01440 ldns_buffer_write_u8(buffer, (uint8_t) '\0');
01441 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
01442 return NULL;
01443 }
01444 }
01445
01446 tmp_str = ldns_buffer_export(buffer);
01447 str = LDNS_XMALLOC(char, strlen(tmp_str) + 1);
01448 memcpy(str, tmp_str, strlen(tmp_str) + 1);
01449
01450 return str;
01451 }
01452
01453 char *
01454 ldns_rdf2str(const ldns_rdf *rdf)
01455 {
01456 char *result = NULL;
01457 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01458
01459 if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
01460
01461 result = buffer2str(tmp_buffer);
01462 }
01463
01464 ldns_buffer_free(tmp_buffer);
01465 return result;
01466 }
01467
01468 char *
01469 ldns_rr2str(const ldns_rr *rr)
01470 {
01471 char *result = NULL;
01472 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01473
01474 if (ldns_rr2buffer_str(tmp_buffer, rr) == LDNS_STATUS_OK) {
01475
01476 result = buffer2str(tmp_buffer);
01477 }
01478
01479 ldns_buffer_free(tmp_buffer);
01480 return result;
01481 }
01482
01483 char *
01484 ldns_pkt2str(const ldns_pkt *pkt)
01485 {
01486 char *result = NULL;
01487 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
01488
01489 if (ldns_pkt2buffer_str(tmp_buffer, pkt) == LDNS_STATUS_OK) {
01490
01491 result = buffer2str(tmp_buffer);
01492 }
01493
01494 ldns_buffer_free(tmp_buffer);
01495 return result;
01496 }
01497
01498 char *
01499 ldns_key2str(const ldns_key *k)
01500 {
01501 char *result = NULL;
01502 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01503 if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) {
01504
01505 result = buffer2str(tmp_buffer);
01506 }
01507 ldns_buffer_free(tmp_buffer);
01508 return result;
01509 }
01510
01511 char *
01512 ldns_rr_list2str(const ldns_rr_list *list)
01513 {
01514 char *result = NULL;
01515 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01516
01517 if (list) {
01518 if (ldns_rr_list2buffer_str(tmp_buffer, list) == LDNS_STATUS_OK) {
01519 }
01520 } else {
01521 ldns_buffer_printf(tmp_buffer, "(null)\n");
01522 }
01523
01524
01525 result = buffer2str(tmp_buffer);
01526 ldns_buffer_free(tmp_buffer);
01527 return result;
01528 }
01529
01530 void
01531 ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
01532 {
01533 char *str = ldns_rdf2str(rdf);
01534 if (str) {
01535 fprintf(output, "%s", str);
01536 } else {
01537 fprintf(output, "Unable to convert rdf to string\n");
01538 }
01539 LDNS_FREE(str);
01540 }
01541
01542 void
01543 ldns_rr_print(FILE *output, const ldns_rr *rr)
01544 {
01545 char *str = ldns_rr2str(rr);
01546 if (str) {
01547 fprintf(output, "%s", str);
01548 } else {
01549 fprintf(output, "Unable to convert rr to string\n");
01550 }
01551 LDNS_FREE(str);
01552 }
01553
01554 void
01555 ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
01556 {
01557 char *str = ldns_pkt2str(pkt);
01558 if (str) {
01559 fprintf(output, "%s", str);
01560 } else {
01561 fprintf(output, "Unable to convert packet to string\n");
01562 }
01563 LDNS_FREE(str);
01564 }
01565
01566 void
01567 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
01568 {
01569 size_t i;
01570 for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
01571 ldns_rr_print(output, ldns_rr_list_rr(lst, i));
01572 }
01573 }
01574
01575 void
01576 ldns_resolver_print(FILE *output, const ldns_resolver *r)
01577 {
01578 uint16_t i;
01579 ldns_rdf **n;
01580 ldns_rdf **s;
01581 size_t *rtt;
01582 if (!r) {
01583 return;
01584 }
01585 n = ldns_resolver_nameservers(r);
01586 s = ldns_resolver_searchlist(r);
01587 rtt = ldns_resolver_rtt(r);
01588
01589 fprintf(output, "port: %d\n", (int)ldns_resolver_port(r));
01590 fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r));
01591 fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r));
01592
01593 fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r));
01594 fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r));
01595 fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r));
01596 fprintf(output, "fail: %d\n", ldns_resolver_fail(r));
01597 fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r));
01598 fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
01599
01600 fprintf(output, "default domain: ");
01601 ldns_rdf_print(output, ldns_resolver_domain(r));
01602 fprintf(output, "\n");
01603
01604 fprintf(output, "searchlist:\n");
01605 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
01606 fprintf(output, "\t");
01607 ldns_rdf_print(output, s[i]);
01608 fprintf(output, "\n");
01609 }
01610
01611 fprintf(output, "nameservers:\n");
01612 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
01613 fprintf(output, "\t");
01614 ldns_rdf_print(output, n[i]);
01615
01616 switch ((int)rtt[i]) {
01617 case LDNS_RESOLV_RTT_MIN:
01618 fprintf(output, " - reachable\n");
01619 break;
01620 case LDNS_RESOLV_RTT_INF:
01621 fprintf(output, " - unreachable\n");
01622 break;
01623 }
01624 }
01625 }
01626
01627 void
01628 ldns_zone_print(FILE *output, const ldns_zone *z)
01629 {
01630 ldns_rr_print(output, ldns_zone_soa(z));
01631 ldns_rr_list_print(output, ldns_zone_rrs(z));
01632 }