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 #ifdef HAVE_SYS_SOCKET_H
00020 #include <sys/socket.h>
00021 #endif
00022 #ifdef HAVE_ARPA_INET_H
00023 #include <arpa/inet.h>
00024 #endif
00025 #ifdef HAVE_NETDB_H
00026 #include <netdb.h>
00027 #endif
00028 #include <time.h>
00029 #include <sys/time.h>
00030
00031 #ifndef INET_ADDRSTRLEN
00032 #define INET_ADDRSTRLEN 16
00033 #endif
00034 #ifndef INET6_ADDRSTRLEN
00035 #define INET6_ADDRSTRLEN 46
00036 #endif
00037
00038
00039
00040
00041 ldns_lookup_table ldns_algorithms[] = {
00042 { LDNS_RSAMD5, "RSAMD5" },
00043 { LDNS_DH, "DH" },
00044 { LDNS_DSA, "DSA" },
00045 { LDNS_ECC, "ECC" },
00046 { LDNS_RSASHA1, "RSASHA1" },
00047 { LDNS_DSA_NSEC3, "DSA-NSEC3-SHA1" },
00048 { LDNS_RSASHA1_NSEC3, "RSASHA1-NSEC3-SHA1" },
00049 #ifdef USE_SHA2
00050 { LDNS_RSASHA256, "RSASHA256"},
00051 { LDNS_RSASHA512, "RSASHA512"},
00052 #endif
00053 #ifdef USE_GOST
00054 { LDNS_ECC_GOST, "ECC-GOST"},
00055 #endif
00056 #ifdef USE_ECDSA
00057 { LDNS_ECDSAP256SHA256, "ECDSAP256SHA256"},
00058 { LDNS_ECDSAP384SHA384, "ECDSAP384SHA384"},
00059 #endif
00060 { LDNS_INDIRECT, "INDIRECT" },
00061 { LDNS_PRIVATEDNS, "PRIVATEDNS" },
00062 { LDNS_PRIVATEOID, "PRIVATEOID" },
00063 { 0, NULL }
00064 };
00065
00066
00067 ldns_lookup_table ldns_cert_algorithms[] = {
00068 { LDNS_CERT_PKIX, "PKIX" },
00069 { LDNS_CERT_SPKI, "SPKI" },
00070 { LDNS_CERT_PGP, "PGP" },
00071 { LDNS_CERT_IPKIX, "IPKIX" },
00072 { LDNS_CERT_ISPKI, "ISPKI" },
00073 { LDNS_CERT_IPGP, "IPGP" },
00074 { LDNS_CERT_ACPKIX, "ACPKIX" },
00075 { LDNS_CERT_IACPKIX, "IACPKIX" },
00076 { LDNS_CERT_URI, "URI" },
00077 { LDNS_CERT_OID, "OID" },
00078 { 0, NULL }
00079 };
00080
00081
00082 ldns_lookup_table ldns_rr_classes[] = {
00083 { LDNS_RR_CLASS_IN, "IN" },
00084 { LDNS_RR_CLASS_CH, "CH" },
00085 { LDNS_RR_CLASS_HS, "HS" },
00086 { LDNS_RR_CLASS_NONE, "NONE" },
00087 { LDNS_RR_CLASS_ANY, "ANY" },
00088 { 0, NULL }
00089 };
00090
00091
00092 ldns_lookup_table ldns_rcodes[] = {
00093 { LDNS_RCODE_NOERROR, "NOERROR" },
00094 { LDNS_RCODE_FORMERR, "FORMERR" },
00095 { LDNS_RCODE_SERVFAIL, "SERVFAIL" },
00096 { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" },
00097 { LDNS_RCODE_NOTIMPL, "NOTIMPL" },
00098 { LDNS_RCODE_REFUSED, "REFUSED" },
00099 { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" },
00100 { LDNS_RCODE_YXRRSET, "YXRRSET" },
00101 { LDNS_RCODE_NXRRSET, "NXRRSET" },
00102 { LDNS_RCODE_NOTAUTH, "NOTAUTH" },
00103 { LDNS_RCODE_NOTZONE, "NOTZONE" },
00104 { 0, NULL }
00105 };
00106
00107 ldns_lookup_table ldns_opcodes[] = {
00108 { LDNS_PACKET_QUERY, "QUERY" },
00109 { LDNS_PACKET_IQUERY, "IQUERY" },
00110 { LDNS_PACKET_STATUS, "STATUS" },
00111 { LDNS_PACKET_NOTIFY, "NOTIFY" },
00112 { LDNS_PACKET_UPDATE, "UPDATE" },
00113 { 0, NULL }
00114 };
00115
00116 const ldns_output_format ldns_output_format_nocomments_record = { 0, NULL };
00117 const ldns_output_format *ldns_output_format_nocomments
00118 = &ldns_output_format_nocomments_record;
00119 const ldns_output_format ldns_output_format_onlykeyids_record = {
00120 LDNS_COMMENT_KEY, NULL
00121 };
00122 const ldns_output_format *ldns_output_format_onlykeyids
00123 = &ldns_output_format_onlykeyids_record;
00124 const ldns_output_format *ldns_output_format_default
00125 = &ldns_output_format_onlykeyids_record;
00126
00127 const ldns_output_format ldns_output_format_bubblebabble_record = {
00128 LDNS_COMMENT_KEY | LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS, NULL
00129 };
00130 const ldns_output_format *ldns_output_format_bubblebabble
00131 = &ldns_output_format_bubblebabble_record;
00132
00133 ldns_status
00134 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode)
00135 {
00136 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode);
00137 if (lt && lt->name) {
00138 ldns_buffer_printf(output, "%s", lt->name);
00139 } else {
00140 ldns_buffer_printf(output, "OPCODE%u", opcode);
00141 }
00142 return ldns_buffer_status(output);
00143 }
00144
00145 ldns_status
00146 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode)
00147 {
00148 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode);
00149 if (lt && lt->name) {
00150 ldns_buffer_printf(output, "%s", lt->name);
00151 } else {
00152 ldns_buffer_printf(output, "RCODE%u", rcode);
00153 }
00154 return ldns_buffer_status(output);
00155 }
00156
00157 ldns_status
00158 ldns_algorithm2buffer_str(ldns_buffer *output,
00159 ldns_algorithm algorithm)
00160 {
00161 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_algorithms,
00162 algorithm);
00163 if (lt && lt->name) {
00164 ldns_buffer_printf(output, "%s", lt->name);
00165 } else {
00166 ldns_buffer_printf(output, "ALG%u", algorithm);
00167 }
00168 return ldns_buffer_status(output);
00169 }
00170
00171 ldns_status
00172 ldns_cert_algorithm2buffer_str(ldns_buffer *output,
00173 ldns_cert_algorithm cert_algorithm)
00174 {
00175 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_cert_algorithms,
00176 cert_algorithm);
00177 if (lt && lt->name) {
00178 ldns_buffer_printf(output, "%s", lt->name);
00179 } else {
00180 ldns_buffer_printf(output, "CERT_ALG%u",
00181 cert_algorithm);
00182 }
00183 return ldns_buffer_status(output);
00184 }
00185
00186 char *
00187 ldns_pkt_opcode2str(ldns_pkt_opcode opcode)
00188 {
00189 char *str;
00190 ldns_buffer *buf;
00191
00192 buf = ldns_buffer_new(12);
00193 if (!buf) {
00194 return NULL;
00195 }
00196
00197 str = NULL;
00198 if (ldns_pkt_opcode2buffer_str(buf, opcode) == LDNS_STATUS_OK) {
00199 str = ldns_buffer_export2str(buf);
00200 }
00201
00202 ldns_buffer_free(buf);
00203 return str;
00204 }
00205
00206 char *
00207 ldns_pkt_rcode2str(ldns_pkt_rcode rcode)
00208 {
00209 char *str;
00210 ldns_buffer *buf;
00211
00212 buf = ldns_buffer_new(10);
00213 if (!buf) {
00214 return NULL;
00215 }
00216
00217 str = NULL;
00218 if (ldns_pkt_rcode2buffer_str(buf, rcode) == LDNS_STATUS_OK) {
00219 str = ldns_buffer_export2str(buf);
00220 }
00221
00222 ldns_buffer_free(buf);
00223 return str;
00224 }
00225
00226 char *
00227 ldns_pkt_algorithm2str(ldns_algorithm algorithm)
00228 {
00229 char *str;
00230 ldns_buffer *buf;
00231
00232 buf = ldns_buffer_new(10);
00233 if (!buf) {
00234 return NULL;
00235 }
00236
00237 str = NULL;
00238 if (ldns_algorithm2buffer_str(buf, algorithm)
00239 == LDNS_STATUS_OK) {
00240 str = ldns_buffer_export2str(buf);
00241 }
00242
00243 ldns_buffer_free(buf);
00244 return str;
00245 }
00246
00247 char *
00248 ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm)
00249 {
00250 char *str;
00251 ldns_buffer *buf;
00252
00253 buf = ldns_buffer_new(10);
00254 if (!buf) {
00255 return NULL;
00256 }
00257
00258 str = NULL;
00259 if (ldns_cert_algorithm2buffer_str(buf, cert_algorithm)
00260 == LDNS_STATUS_OK) {
00261 str = ldns_buffer_export2str(buf);
00262 }
00263
00264 ldns_buffer_free(buf);
00265 return str;
00266 }
00267
00268
00269
00270 ldns_status
00271 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
00272 {
00273
00274 uint8_t src_pos = 0;
00275 uint8_t len;
00276 uint8_t *data;
00277 uint8_t i;
00278 unsigned char c;
00279
00280 data = (uint8_t*)ldns_rdf_data(dname);
00281 len = data[src_pos];
00282
00283 if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) {
00284
00285 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
00286 }
00287
00288
00289 if (1 == ldns_rdf_size(dname)) {
00290 ldns_buffer_printf(output, ".");
00291 } else {
00292 while ((len > 0) && src_pos < ldns_rdf_size(dname)) {
00293 src_pos++;
00294 for(i = 0; i < len; i++) {
00295
00296
00297
00298 c = (unsigned char) data[src_pos];
00299 if(c == '.' || c == ';' ||
00300 c == '(' || c == ')' ||
00301 c == '\\') {
00302 ldns_buffer_printf(output, "\\%c",
00303 data[src_pos]);
00304 } else if (!(isascii(c) && isgraph(c))) {
00305 ldns_buffer_printf(output, "\\%03u",
00306 data[src_pos]);
00307 } else {
00308 ldns_buffer_printf(output, "%c", data[src_pos]);
00309 }
00310 src_pos++;
00311 }
00312
00313 if (src_pos < ldns_rdf_size(dname)) {
00314 ldns_buffer_printf(output, ".");
00315 }
00316 len = data[src_pos];
00317 }
00318 }
00319 return ldns_buffer_status(output);
00320 }
00321
00322 ldns_status
00323 ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
00324 {
00325 uint8_t data = ldns_rdf_data(rdf)[0];
00326 ldns_buffer_printf(output, "%lu", (unsigned long) data);
00327 return ldns_buffer_status(output);
00328 }
00329
00330 ldns_status
00331 ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
00332 {
00333 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
00334 ldns_buffer_printf(output, "%lu", (unsigned long) data);
00335 return ldns_buffer_status(output);
00336 }
00337
00338 ldns_status
00339 ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
00340 {
00341 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
00342 ldns_buffer_printf(output, "%lu", (unsigned long) data);
00343 return ldns_buffer_status(output);
00344 }
00345
00346 ldns_status
00347 ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
00348 {
00349
00350 struct tm tm;
00351 char date_buf[16];
00352
00353 memset(&tm, 0, sizeof(tm));
00354 if (ldns_serial_arithmitics_gmtime_r(ldns_rdf2native_int32(rdf), time(NULL), &tm)
00355 && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
00356 ldns_buffer_printf(output, "%s", date_buf);
00357 }
00358 return ldns_buffer_status(output);
00359 }
00360
00361 ldns_status
00362 ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
00363 {
00364 char str[INET_ADDRSTRLEN];
00365
00366 if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) {
00367 ldns_buffer_printf(output, "%s", str);
00368 }
00369 return ldns_buffer_status(output);
00370 }
00371
00372 ldns_status
00373 ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
00374 {
00375 char str[INET6_ADDRSTRLEN];
00376
00377 if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) {
00378 ldns_buffer_printf(output, "%s", str);
00379 }
00380
00381 return ldns_buffer_status(output);
00382 }
00383
00384 ldns_status
00385 ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
00386 {
00387 const uint8_t *data = ldns_rdf_data(rdf);
00388 uint8_t length = data[0];
00389 size_t i;
00390
00391 ldns_buffer_printf(output, "\"");
00392 for (i = 1; i <= length; ++i) {
00393 char ch = (char) data[i];
00394 if (isprint((int)ch) || ch=='\t') {
00395 if (ch=='\"'||ch=='\\')
00396 ldns_buffer_printf(output, "\\%c", ch);
00397 else
00398 ldns_buffer_printf(output, "%c", ch);
00399 } else {
00400 ldns_buffer_printf(output, "\\%03u",
00401 (unsigned)(uint8_t) ch);
00402 }
00403 }
00404 ldns_buffer_printf(output, "\"");
00405 return ldns_buffer_status(output);
00406 }
00407
00408 ldns_status
00409 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
00410 {
00411 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf));
00412 char *b64 = LDNS_XMALLOC(char, size);
00413 if(!b64) return LDNS_STATUS_MEM_ERR;
00414 if (ldns_b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) {
00415 ldns_buffer_printf(output, "%s", b64);
00416 }
00417 LDNS_FREE(b64);
00418 return ldns_buffer_status(output);
00419 }
00420
00421 ldns_status
00422 ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf)
00423 {
00424 size_t size;
00425 char *b32;
00426 if(ldns_rdf_size(rdf) == 0)
00427 return LDNS_STATUS_OK;
00428
00429 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
00430
00431 b32 = LDNS_XMALLOC(char, size + 1);
00432 if(!b32) return LDNS_STATUS_MEM_ERR;
00433 size = (size_t) ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
00434 ldns_rdf_size(rdf) - 1, b32, size+1);
00435 if (size > 0) {
00436 ldns_buffer_printf(output, "%s", b32);
00437 }
00438 LDNS_FREE(b32);
00439 return ldns_buffer_status(output);
00440 }
00441
00442 ldns_status
00443 ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
00444 {
00445 size_t i;
00446 for (i = 0; i < ldns_rdf_size(rdf); i++) {
00447 ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]);
00448 }
00449
00450 return ldns_buffer_status(output);
00451 }
00452
00453 ldns_status
00454 ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
00455 {
00456 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
00457 const ldns_rr_descriptor *descriptor;
00458
00459 descriptor = ldns_rr_descript(data);
00460 if (descriptor && descriptor->_name) {
00461 ldns_buffer_printf(output, "%s", descriptor->_name);
00462 } else {
00463 ldns_buffer_printf(output, "TYPE%u", data);
00464 }
00465 return ldns_buffer_status(output);
00466 }
00467
00468 ldns_status
00469 ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
00470 {
00471 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
00472 ldns_lookup_table *lt;
00473
00474 lt = ldns_lookup_by_id(ldns_rr_classes, (int) data);
00475 if (lt) {
00476 ldns_buffer_printf(output, "\t%s", lt->name);
00477 } else {
00478 ldns_buffer_printf(output, "\tCLASS%d", data);
00479 }
00480 return ldns_buffer_status(output);
00481 }
00482
00483 ldns_status
00484 ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
00485 {
00486 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
00487 ldns_lookup_table *lt;
00488 lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data);
00489 if (lt) {
00490 ldns_buffer_printf(output, "%s", lt->name);
00491 } else {
00492 ldns_buffer_printf(output, "%d", data);
00493 }
00494 return ldns_buffer_status(output);
00495 }
00496
00497 ldns_status
00498 ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
00499 {
00500
00501
00502 uint8_t data = ldns_rdf_data(rdf)[0];
00503 ldns_buffer_printf(output, "%d", data);
00504 return ldns_buffer_status(output);
00505 }
00506
00507 static void
00508 loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
00509 {
00510 uint8_t i;
00511
00512 if(exponent < 2) {
00513 if(exponent == 1)
00514 mantissa *= 10;
00515 ldns_buffer_printf(output, "0.%02ld", (long)mantissa);
00516 return;
00517 }
00518
00519 ldns_buffer_printf(output, "%d", (int)mantissa);
00520 for(i=0; i<exponent-2; i++)
00521 ldns_buffer_printf(output, "0");
00522 }
00523
00524 ldns_status
00525 ldns_rr_type2buffer_str(ldns_buffer *output, const ldns_rr_type type)
00526 {
00527 const ldns_rr_descriptor *descriptor;
00528
00529 descriptor = ldns_rr_descript(type);
00530
00531 if (descriptor && descriptor->_name) {
00532 ldns_buffer_printf(output, "%s", descriptor->_name);
00533 } else {
00534
00535 switch (type) {
00536 case LDNS_RR_TYPE_IXFR:
00537 ldns_buffer_printf(output, "IXFR");
00538 break;
00539 case LDNS_RR_TYPE_AXFR:
00540 ldns_buffer_printf(output, "AXFR");
00541 break;
00542 case LDNS_RR_TYPE_MAILA:
00543 ldns_buffer_printf(output, "MAILA");
00544 break;
00545 case LDNS_RR_TYPE_MAILB:
00546 ldns_buffer_printf(output, "MAILB");
00547 break;
00548 case LDNS_RR_TYPE_ANY:
00549 ldns_buffer_printf(output, "ANY");
00550 break;
00551 default:
00552 ldns_buffer_printf(output, "TYPE%u", type);
00553 }
00554 }
00555 return ldns_buffer_status(output);
00556 }
00557
00558 char *
00559 ldns_rr_type2str(const ldns_rr_type type)
00560 {
00561 char *str;
00562 ldns_buffer *buf;
00563
00564 buf = ldns_buffer_new(10);
00565 if (!buf) {
00566 return NULL;
00567 }
00568
00569 str = NULL;
00570 if (ldns_rr_type2buffer_str(buf, type) == LDNS_STATUS_OK) {
00571 str = ldns_buffer_export2str(buf);
00572 }
00573
00574 ldns_buffer_free(buf);
00575 return str;
00576 }
00577
00578
00579 ldns_status
00580 ldns_rr_class2buffer_str(ldns_buffer *output,
00581 const ldns_rr_class klass)
00582 {
00583 ldns_lookup_table *lt;
00584
00585 lt = ldns_lookup_by_id(ldns_rr_classes, klass);
00586 if (lt) {
00587 ldns_buffer_printf(output, "%s", lt->name);
00588 } else {
00589 ldns_buffer_printf(output, "CLASS%d", klass);
00590 }
00591 return ldns_buffer_status(output);
00592 }
00593
00594 char *
00595 ldns_rr_class2str(const ldns_rr_class klass)
00596 {
00597 ldns_buffer *buf;
00598 char *str;
00599
00600 buf = ldns_buffer_new(10);
00601 if (!buf) {
00602 return NULL;
00603 }
00604
00605 str = NULL;
00606 if (ldns_rr_class2buffer_str(buf, klass) == LDNS_STATUS_OK) {
00607 str = ldns_buffer_export2str(buf);
00608 }
00609 ldns_buffer_free(buf);
00610 return str;
00611 }
00612
00613 ldns_status
00614 ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
00615 {
00616
00617 uint8_t version = ldns_rdf_data(rdf)[0];
00618 uint8_t size;
00619 uint8_t horizontal_precision;
00620 uint8_t vertical_precision;
00621 uint32_t longitude;
00622 uint32_t latitude;
00623 uint32_t altitude;
00624 char northerness;
00625 char easterness;
00626 uint32_t h;
00627 uint32_t m;
00628 double s;
00629
00630 uint32_t equator = (uint32_t) ldns_power(2, 31);
00631
00632 if (version == 0) {
00633 size = ldns_rdf_data(rdf)[1];
00634 horizontal_precision = ldns_rdf_data(rdf)[2];
00635 vertical_precision = ldns_rdf_data(rdf)[3];
00636
00637 latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]);
00638 longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]);
00639 altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]);
00640
00641 if (latitude > equator) {
00642 northerness = 'N';
00643 latitude = latitude - equator;
00644 } else {
00645 northerness = 'S';
00646 latitude = equator - latitude;
00647 }
00648 h = latitude / (1000 * 60 * 60);
00649 latitude = latitude % (1000 * 60 * 60);
00650 m = latitude / (1000 * 60);
00651 latitude = latitude % (1000 * 60);
00652 s = (double) latitude / 1000.0;
00653 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
00654 h, m, s, northerness);
00655
00656 if (longitude > equator) {
00657 easterness = 'E';
00658 longitude = longitude - equator;
00659 } else {
00660 easterness = 'W';
00661 longitude = equator - longitude;
00662 }
00663 h = longitude / (1000 * 60 * 60);
00664 longitude = longitude % (1000 * 60 * 60);
00665 m = longitude / (1000 * 60);
00666 longitude = longitude % (1000 * 60);
00667 s = (double) longitude / (1000.0);
00668 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
00669 h, m, s, easterness);
00670
00671
00672 s = ((double) altitude) / 100;
00673 s -= 100000;
00674
00675 if(altitude%100 != 0)
00676 ldns_buffer_printf(output, "%.2f", s);
00677 else
00678 ldns_buffer_printf(output, "%.0f", s);
00679
00680 ldns_buffer_printf(output, "m ");
00681
00682 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
00683 ldns_buffer_printf(output, "m ");
00684
00685 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
00686 horizontal_precision & 0x0f);
00687 ldns_buffer_printf(output, "m ");
00688
00689 loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
00690 vertical_precision & 0x0f);
00691 ldns_buffer_printf(output, "m");
00692
00693 return ldns_buffer_status(output);
00694 } else {
00695 return ldns_rdf2buffer_str_hex(output, rdf);
00696 }
00697 }
00698
00699 ldns_status
00700 ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
00701 {
00702 ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
00703 return ldns_rdf2buffer_str_hex(output, rdf);
00704 }
00705
00706 ldns_status
00707 ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
00708 {
00709 ldns_buffer_printf(output, "0x");
00710 return ldns_rdf2buffer_str_hex(output, rdf);
00711 }
00712
00713 ldns_status
00714 ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf)
00715 {
00716 return ldns_rdf2buffer_str_hex(output, rdf);
00717 }
00718
00719 ldns_status
00720 ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
00721 {
00722
00723 struct protoent *protocol;
00724 char *proto_name = NULL;
00725 uint8_t protocol_nr;
00726 struct servent *service;
00727 uint16_t current_service;
00728
00729 protocol_nr = ldns_rdf_data(rdf)[0];
00730 protocol = getprotobynumber((int) protocol_nr);
00731 if (protocol && (protocol->p_name != NULL)) {
00732 proto_name = protocol->p_name;
00733 ldns_buffer_printf(output, "%s ", protocol->p_name);
00734 } else {
00735 ldns_buffer_printf(output, "%u ", protocol_nr);
00736 }
00737
00738 #ifdef HAVE_ENDPROTOENT
00739 endprotoent();
00740 #endif
00741
00742 for (current_service = 0;
00743 current_service < ldns_rdf_size(rdf) * 7; current_service++) {
00744 if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) {
00745 service = getservbyport((int) htons(current_service),
00746 proto_name);
00747 if (service && service->s_name) {
00748 ldns_buffer_printf(output, "%s ", service->s_name);
00749 } else {
00750 ldns_buffer_printf(output, "%u ", current_service);
00751 }
00752 #ifdef HAVE_ENDSERVENT
00753 endservent();
00754 #endif
00755 }
00756 }
00757 return ldns_buffer_status(output);
00758 }
00759
00760 ldns_status
00761 ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
00762 {
00763
00764
00765
00766 uint8_t window_block_nr;
00767 uint8_t bitmap_length;
00768 uint16_t type;
00769 uint16_t pos = 0;
00770 uint16_t bit_pos;
00771 uint8_t *data = ldns_rdf_data(rdf);
00772 const ldns_rr_descriptor *descriptor;
00773
00774 while(pos < ldns_rdf_size(rdf)) {
00775 window_block_nr = data[pos];
00776 bitmap_length = data[pos + 1];
00777 pos += 2;
00778
00779 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
00780 if (ldns_get_bit(&data[pos], bit_pos)) {
00781 type = 256 * (uint16_t) window_block_nr + bit_pos;
00782 descriptor = ldns_rr_descript(type);
00783
00784 if (descriptor && descriptor->_name) {
00785 ldns_buffer_printf(output, "%s ",
00786 descriptor->_name);
00787 } else {
00788 ldns_buffer_printf(output, "TYPE%u ", type);
00789 }
00790 }
00791 }
00792
00793 pos += (uint16_t) bitmap_length;
00794 }
00795
00796 return ldns_buffer_status(output);
00797 }
00798
00799 ldns_status
00800 ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf)
00801 {
00802 uint8_t salt_length;
00803 uint8_t salt_pos;
00804
00805 uint8_t *data = ldns_rdf_data(rdf);
00806
00807 if(ldns_rdf_size(rdf) == 0) {
00808 output->_status = LDNS_STATUS_ERR;
00809 return ldns_buffer_status(output);
00810 }
00811 salt_length = data[0];
00812
00813 if (salt_length == 0 || ((size_t)salt_length)+1 > ldns_rdf_size(rdf)) {
00814 ldns_buffer_printf(output, "- ");
00815 } else {
00816 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) {
00817 ldns_buffer_printf(output, "%02x", data[1 + salt_pos]);
00818 }
00819 ldns_buffer_printf(output, " ");
00820 }
00821
00822 return ldns_buffer_status(output);
00823 }
00824
00825 ldns_status
00826 ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
00827 {
00828
00829 uint32_t p = ldns_read_uint32(ldns_rdf_data(rdf));
00830 ldns_buffer_printf(output, "%u", p);
00831 return ldns_buffer_status(output);
00832 }
00833
00834 ldns_status
00835 ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf)
00836 {
00837
00838 uint64_t tsigtime = 0;
00839 uint8_t *data = ldns_rdf_data(rdf);
00840
00841 if (ldns_rdf_size(rdf) != 6) {
00842 return LDNS_STATUS_ERR;
00843 }
00844
00845 tsigtime = ldns_read_uint16(data);
00846 tsigtime *= 65536;
00847 tsigtime += ldns_read_uint16(data+2);
00848 tsigtime *= 65536;
00849
00850 ldns_buffer_printf(output, "%llu ", tsigtime);
00851
00852 return ldns_buffer_status(output);
00853 }
00854
00855 ldns_status
00856 ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
00857 {
00858 uint8_t *data = ldns_rdf_data(rdf);
00859 uint16_t address_family;
00860 uint8_t prefix;
00861 bool negation;
00862 uint8_t adf_length;
00863 size_t i;
00864 size_t pos = 0;
00865
00866 while (pos < (unsigned int) ldns_rdf_size(rdf)) {
00867 if(pos + 3 >= (unsigned)ldns_rdf_size(rdf))
00868 return LDNS_STATUS_SYNTAX_RDATA_ERR;
00869 address_family = ldns_read_uint16(&data[pos]);
00870 prefix = data[pos + 2];
00871 negation = data[pos + 3] & LDNS_APL_NEGATION;
00872 adf_length = data[pos + 3] & LDNS_APL_MASK;
00873 if (address_family == LDNS_APL_IP4) {
00874
00875 if (negation) {
00876 ldns_buffer_printf(output, "!");
00877 }
00878 ldns_buffer_printf(output, "%u:", address_family);
00879
00880 for (i = 0; i < 4; i++) {
00881 if (i > 0) {
00882 ldns_buffer_printf(output, ".");
00883 }
00884 if (i < (unsigned short) adf_length) {
00885 if(pos+i+4 >= ldns_rdf_size(rdf))
00886 return LDNS_STATUS_SYNTAX_RDATA_ERR;
00887 ldns_buffer_printf(output, "%d",
00888 data[pos + i + 4]);
00889 } else {
00890 ldns_buffer_printf(output, "0");
00891 }
00892 }
00893 ldns_buffer_printf(output, "/%u ", prefix);
00894 } else if (address_family == LDNS_APL_IP6) {
00895
00896 if (negation) {
00897 ldns_buffer_printf(output, "!");
00898 }
00899 ldns_buffer_printf(output, "%u:", address_family);
00900
00901 for (i = 0; i < 16; i++) {
00902 if (i % 2 == 0 && i > 0) {
00903 ldns_buffer_printf(output, ":");
00904 }
00905 if (i < (unsigned short) adf_length) {
00906 if(pos+i+4 >= ldns_rdf_size(rdf))
00907 return LDNS_STATUS_SYNTAX_RDATA_ERR;
00908 ldns_buffer_printf(output, "%02x",
00909 data[pos + i + 4]);
00910 } else {
00911 ldns_buffer_printf(output, "00");
00912 }
00913 }
00914 ldns_buffer_printf(output, "/%u ", prefix);
00915
00916 } else {
00917
00918 ldns_buffer_printf(output, "Unknown address family: %u data: ",
00919 address_family);
00920 for (i = 1; i < (unsigned short) (4 + adf_length); i++) {
00921 if(pos+i >= ldns_rdf_size(rdf))
00922 return LDNS_STATUS_SYNTAX_RDATA_ERR;
00923 ldns_buffer_printf(output, "%02x", data[i]);
00924 }
00925 }
00926 pos += 4 + adf_length;
00927 }
00928 return ldns_buffer_status(output);
00929 }
00930
00931 ldns_status
00932 ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
00933 {
00934
00935 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
00936 char *b64 = LDNS_XMALLOC(char, size);
00937 if(!b64)
00938 return LDNS_STATUS_MEM_ERR;
00939
00940 ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
00941
00942 if (ldns_rdf_size(rdf) > 2 &&
00943 ldns_b64_ntop(ldns_rdf_data(rdf) + 2,
00944 ldns_rdf_size(rdf) - 2,
00945 b64, size)) {
00946 ldns_buffer_printf(output, "%s", b64);
00947 }
00948 LDNS_FREE(b64);
00949 return ldns_buffer_status(output);
00950 }
00951
00952 ldns_status
00953 ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
00954 {
00955
00956
00957
00958 uint8_t *data = ldns_rdf_data(rdf);
00959 uint8_t precedence;
00960 uint8_t gateway_type;
00961 uint8_t algorithm;
00962
00963 ldns_rdf *gateway = NULL;
00964 uint8_t *gateway_data;
00965
00966 size_t public_key_size;
00967 uint8_t *public_key_data;
00968 ldns_rdf *public_key;
00969
00970 size_t offset = 0;
00971 ldns_status status;
00972
00973 precedence = data[0];
00974 gateway_type = data[1];
00975 algorithm = data[2];
00976 offset = 3;
00977
00978 switch (gateway_type) {
00979 case 0:
00980
00981 break;
00982 case 1:
00983 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
00984 if(!gateway_data)
00985 return LDNS_STATUS_MEM_ERR;
00986 memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
00987 gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, LDNS_IP4ADDRLEN , gateway_data);
00988 offset += LDNS_IP4ADDRLEN;
00989 if(!gateway) {
00990 LDNS_FREE(gateway_data);
00991 return LDNS_STATUS_MEM_ERR;
00992 }
00993 break;
00994 case 2:
00995 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
00996 if(!gateway_data)
00997 return LDNS_STATUS_MEM_ERR;
00998 memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
00999 offset += LDNS_IP6ADDRLEN;
01000 gateway =
01001 ldns_rdf_new(LDNS_RDF_TYPE_AAAA, LDNS_IP6ADDRLEN, gateway_data);
01002 if(!gateway) {
01003 LDNS_FREE(gateway_data);
01004 return LDNS_STATUS_MEM_ERR;
01005 }
01006 break;
01007 case 3:
01008 status = ldns_wire2dname(&gateway, data, ldns_rdf_size(rdf), &offset);
01009 if(status != LDNS_STATUS_OK)
01010 return status;
01011 break;
01012 default:
01013
01014 break;
01015 }
01016
01017 public_key_size = ldns_rdf_size(rdf) - offset;
01018 public_key_data = LDNS_XMALLOC(uint8_t, public_key_size);
01019 if(!public_key_data) {
01020 ldns_rdf_free(gateway);
01021 return LDNS_STATUS_MEM_ERR;
01022 }
01023 memcpy(public_key_data, &data[offset], public_key_size);
01024 public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, public_key_size, public_key_data);
01025 if(!public_key) {
01026 LDNS_FREE(public_key_data);
01027 ldns_rdf_free(gateway);
01028 return LDNS_STATUS_MEM_ERR;
01029 }
01030
01031 ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm);
01032 if (gateway)
01033 (void) ldns_rdf2buffer_str(output, gateway);
01034 else
01035 ldns_buffer_printf(output, ".");
01036 ldns_buffer_printf(output, " ");
01037 (void) ldns_rdf2buffer_str(output, public_key);
01038
01039 ldns_rdf_free(gateway);
01040 ldns_rdf_free(public_key);
01041
01042 return ldns_buffer_status(output);
01043 }
01044
01045 ldns_status
01046 ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf)
01047 {
01048
01049 return ldns_rdf2buffer_str_unknown(output, rdf);
01050 }
01051
01052
01053 ldns_status
01054 ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
01055 {
01056 ldns_status res = LDNS_STATUS_OK;
01057
01058
01059 if (rdf) {
01060 switch(ldns_rdf_get_type(rdf)) {
01061 case LDNS_RDF_TYPE_NONE:
01062 break;
01063 case LDNS_RDF_TYPE_DNAME:
01064 res = ldns_rdf2buffer_str_dname(buffer, rdf);
01065 break;
01066 case LDNS_RDF_TYPE_INT8:
01067 res = ldns_rdf2buffer_str_int8(buffer, rdf);
01068 break;
01069 case LDNS_RDF_TYPE_INT16:
01070 res = ldns_rdf2buffer_str_int16(buffer, rdf);
01071 break;
01072 case LDNS_RDF_TYPE_INT32:
01073 res = ldns_rdf2buffer_str_int32(buffer, rdf);
01074 break;
01075 case LDNS_RDF_TYPE_PERIOD:
01076 res = ldns_rdf2buffer_str_period(buffer, rdf);
01077 break;
01078 case LDNS_RDF_TYPE_TSIGTIME:
01079 res = ldns_rdf2buffer_str_tsigtime(buffer, rdf);
01080 break;
01081 case LDNS_RDF_TYPE_A:
01082 res = ldns_rdf2buffer_str_a(buffer, rdf);
01083 break;
01084 case LDNS_RDF_TYPE_AAAA:
01085 res = ldns_rdf2buffer_str_aaaa(buffer, rdf);
01086 break;
01087 case LDNS_RDF_TYPE_STR:
01088 res = ldns_rdf2buffer_str_str(buffer, rdf);
01089 break;
01090 case LDNS_RDF_TYPE_APL:
01091 res = ldns_rdf2buffer_str_apl(buffer, rdf);
01092 break;
01093 case LDNS_RDF_TYPE_B32_EXT:
01094 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
01095 break;
01096 case LDNS_RDF_TYPE_B64:
01097 res = ldns_rdf2buffer_str_b64(buffer, rdf);
01098 break;
01099 case LDNS_RDF_TYPE_HEX:
01100 res = ldns_rdf2buffer_str_hex(buffer, rdf);
01101 break;
01102 case LDNS_RDF_TYPE_NSEC:
01103 res = ldns_rdf2buffer_str_nsec(buffer, rdf);
01104 break;
01105 case LDNS_RDF_TYPE_NSEC3_SALT:
01106 res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf);
01107 break;
01108 case LDNS_RDF_TYPE_TYPE:
01109 res = ldns_rdf2buffer_str_type(buffer, rdf);
01110 break;
01111 case LDNS_RDF_TYPE_CLASS:
01112 res = ldns_rdf2buffer_str_class(buffer, rdf);
01113 break;
01114 case LDNS_RDF_TYPE_CERT_ALG:
01115 res = ldns_rdf2buffer_str_cert_alg(buffer, rdf);
01116 break;
01117 case LDNS_RDF_TYPE_ALG:
01118 res = ldns_rdf2buffer_str_alg(buffer, rdf);
01119 break;
01120 case LDNS_RDF_TYPE_UNKNOWN:
01121 res = ldns_rdf2buffer_str_unknown(buffer, rdf);
01122 break;
01123 case LDNS_RDF_TYPE_TIME:
01124 res = ldns_rdf2buffer_str_time(buffer, rdf);
01125 break;
01126 case LDNS_RDF_TYPE_LOC:
01127 res = ldns_rdf2buffer_str_loc(buffer, rdf);
01128 break;
01129 case LDNS_RDF_TYPE_WKS:
01130 case LDNS_RDF_TYPE_SERVICE:
01131 res = ldns_rdf2buffer_str_wks(buffer, rdf);
01132 break;
01133 case LDNS_RDF_TYPE_NSAP:
01134 res = ldns_rdf2buffer_str_nsap(buffer, rdf);
01135 break;
01136 case LDNS_RDF_TYPE_ATMA:
01137 res = ldns_rdf2buffer_str_atma(buffer, rdf);
01138 break;
01139 case LDNS_RDF_TYPE_IPSECKEY:
01140 res = ldns_rdf2buffer_str_ipseckey(buffer, rdf);
01141 break;
01142 case LDNS_RDF_TYPE_TSIG:
01143 res = ldns_rdf2buffer_str_tsig(buffer, rdf);
01144 break;
01145 case LDNS_RDF_TYPE_INT16_DATA:
01146 res = ldns_rdf2buffer_str_int16_data(buffer, rdf);
01147 break;
01148 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
01149 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
01150 break;
01151 }
01152 } else {
01154 ldns_buffer_printf(buffer, "(null) ");
01155 res = LDNS_STATUS_ERR;
01156 }
01157 return res;
01158 }
01159
01160 ldns_rdf *
01161 ldns_b32_ext2dname(const ldns_rdf *rdf)
01162 {
01163 size_t size;
01164 char *b32;
01165 ldns_rdf *out;
01166 if(ldns_rdf_size(rdf) == 0)
01167 return NULL;
01168
01169 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
01170
01171 b32 = LDNS_XMALLOC(char, size + 2);
01172 if (b32) {
01173 if (ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
01174 ldns_rdf_size(rdf) - 1, b32, size+1) > 0) {
01175 b32[size] = '.';
01176 b32[size+1] = '\0';
01177 if (ldns_str2rdf_dname(&out, b32) == LDNS_STATUS_OK) {
01178 LDNS_FREE(b32);
01179 return out;
01180 }
01181 }
01182 LDNS_FREE(b32);
01183 }
01184 return NULL;
01185 }
01186
01187 ldns_status
01188 ldns_rr2buffer_str_fmt(ldns_buffer *output,
01189 const ldns_output_format *fmt, const ldns_rr *rr)
01190 {
01191 uint16_t i, flags;
01192 ldns_status status = LDNS_STATUS_OK;
01193
01194 if (fmt == NULL) {
01195 fmt = ldns_output_format_default;
01196 }
01197 if (!rr) {
01198 if (LDNS_COMMENT_NULLS & fmt->flags) {
01199 ldns_buffer_printf(output, "; (null)\n");
01200 }
01201 return ldns_buffer_status(output);
01202 }
01203 if (ldns_rr_owner(rr)) {
01204 status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr));
01205 }
01206 if (status != LDNS_STATUS_OK) {
01207 return status;
01208 }
01209
01210
01211 if (!ldns_rr_is_question(rr)) {
01212 ldns_buffer_printf(output, "\t%d", ldns_rr_ttl(rr));
01213 }
01214
01215 ldns_buffer_printf(output, "\t");
01216 status = ldns_rr_class2buffer_str(output, ldns_rr_get_class(rr));
01217 if (status != LDNS_STATUS_OK) {
01218 return status;
01219 }
01220 ldns_buffer_printf(output, "\t");
01221
01222 status = ldns_rr_type2buffer_str(output, ldns_rr_get_type(rr));
01223 if (status != LDNS_STATUS_OK) {
01224 return status;
01225 }
01226
01227 if (ldns_rr_rd_count(rr) > 0) {
01228 ldns_buffer_printf(output, "\t");
01229 } else if (!ldns_rr_is_question(rr)) {
01230 ldns_buffer_printf(output, "\t\\# 0");
01231 }
01232
01233 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
01234
01235 if ((fmt->flags & LDNS_FMT_ZEROIZE_RRSIGS) &&
01236 (ldns_rr_get_type(rr) == LDNS_RR_TYPE_RRSIG) &&
01237 (( i == 4 &&
01238 ldns_rdf_get_type(ldns_rr_rdf(rr, 4)) ==
01239 LDNS_RDF_TYPE_TIME) ||
01240 ( i == 5 &&
01241 ldns_rdf_get_type(ldns_rr_rdf(rr, 5)) ==
01242 LDNS_RDF_TYPE_TIME) ||
01243 ( i == 8 &&
01244 ldns_rdf_get_type(ldns_rr_rdf(rr, 8)) ==
01245 LDNS_RDF_TYPE_B64))) {
01246
01247 ldns_buffer_printf(output, "(null)");
01248 status = ldns_buffer_status(output);
01249 } else if ((fmt->flags & LDNS_FMT_PAD_SOA_SERIAL) &&
01250 (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) &&
01251 i == 2 &&
01252 ldns_rdf_get_type(ldns_rr_rdf(rr, 2)) ==
01253 LDNS_RDF_TYPE_INT32) {
01254 ldns_buffer_printf(output, "%10lu",
01255 (unsigned long) ldns_read_uint32(
01256 ldns_rdf_data(ldns_rr_rdf(rr, 2))));
01257 status = ldns_buffer_status(output);
01258 } else {
01259 status = ldns_rdf2buffer_str(output,
01260 ldns_rr_rdf(rr, i));
01261 }
01262 if(status != LDNS_STATUS_OK)
01263 return status;
01264 if (i < ldns_rr_rd_count(rr) - 1) {
01265 ldns_buffer_printf(output, " ");
01266 }
01267 }
01268
01269
01270
01271 if (ldns_rr_rd_count(rr) > 0) {
01272 switch (ldns_rr_get_type(rr)) {
01273 case LDNS_RR_TYPE_DNSKEY:
01274
01275
01276 if (! (fmt->flags & LDNS_COMMENT_KEY)) {
01277 break;
01278 }
01279 flags = ldns_rdf2native_int16(
01280 ldns_rr_rdf(rr, 0));
01281 ldns_buffer_printf(output, " ;{");
01282 if (fmt->flags & LDNS_COMMENT_KEY_ID) {
01283 ldns_buffer_printf(output, "id = %u",
01284 (unsigned int)
01285 ldns_calc_keytag(rr));
01286 }
01287 if ((fmt->flags & LDNS_COMMENT_KEY_TYPE)
01288 && (flags & LDNS_KEY_ZONE_KEY)){
01289 if (flags & LDNS_KEY_SEP_KEY) {
01290 ldns_buffer_printf(
01291 output, " (ksk)");
01292 }
01293 else {
01294 ldns_buffer_printf(
01295 output, " (zsk)");
01296 }
01297 if (fmt->flags & LDNS_COMMENT_KEY_SIZE){
01298 ldns_buffer_printf(
01299 output, ", ");
01300 }
01301 } else if (fmt->flags
01302 & (LDNS_COMMENT_KEY_ID
01303 |LDNS_COMMENT_KEY_SIZE)) {
01304 ldns_buffer_printf( output, ", ");
01305 }
01306 if (fmt->flags & LDNS_COMMENT_KEY_SIZE) {
01307 ldns_buffer_printf(output, "size = %db",
01308 ldns_rr_dnskey_key_size(rr));
01309 }
01310 ldns_buffer_printf(output, "}");
01311 break;
01312 case LDNS_RR_TYPE_RRSIG:
01313 if ((fmt->flags & LDNS_COMMENT_KEY)
01314 && (fmt->flags
01315 & LDNS_COMMENT_RRSIGS)
01316 && ldns_rr_rdf(rr, 6) != NULL) {
01317 ldns_buffer_printf(output
01318 , " ;{id = %d}"
01319 , ldns_rdf2native_int16(
01320 ldns_rr_rdf(rr, 6)));
01321 }
01322 break;
01323 case LDNS_RR_TYPE_DS:
01324 if ((fmt->flags & LDNS_COMMENT_BUBBLEBABBLE)
01325 && ldns_rr_rdf(rr, 3) != NULL) {
01326 uint8_t *data = ldns_rdf_data(
01327 ldns_rr_rdf(rr, 3));
01328 size_t len = ldns_rdf_size(
01329 ldns_rr_rdf(rr, 3));
01330 char *babble = ldns_bubblebabble(
01331 data, len);
01332 if(babble) {
01333 ldns_buffer_printf(output
01334 , " ;{%s}", babble);
01335 }
01336 LDNS_FREE(babble);
01337 }
01338 break;
01339 case LDNS_RR_TYPE_NSEC3:
01340 if (! (fmt->flags & LDNS_COMMENT_FLAGS) &&
01341 ! (fmt->flags & LDNS_COMMENT_NSEC3_CHAIN)) {
01342 break;
01343 }
01344 ldns_buffer_printf(output, " ;{");
01345 if ((fmt->flags & LDNS_COMMENT_FLAGS)) {
01346 if (ldns_nsec3_optout(rr)) {
01347 ldns_buffer_printf(output,
01348 " flags: optout");
01349 } else {
01350 ldns_buffer_printf(output,
01351 " flags: -");
01352 }
01353 if (fmt->flags & LDNS_COMMENT_NSEC3_CHAIN
01354 && fmt->data != NULL) {
01355 ldns_buffer_printf(output, ", ");
01356 }
01357 }
01358 if (fmt->flags & LDNS_COMMENT_NSEC3_CHAIN
01359 && fmt->data != NULL) {
01360 ldns_rbnode_t *node;
01361 ldns_rdf *key = ldns_dname_label(
01362 ldns_rr_owner(rr), 0);
01363 if (key) {
01364 node = ldns_rbtree_search(
01365 (ldns_rbtree_t *)
01366 fmt->data,
01367 (void *) key);
01368 if (node->data) {
01369 ldns_buffer_printf(
01370 output,
01371 "from: ");
01372 (void)
01373 ldns_rdf2buffer_str(
01374 output,
01375 (ldns_rdf *)
01376 node->data);
01377 }
01378 ldns_rdf_free(key);
01379 }
01380 key = ldns_b32_ext2dname(
01381 ldns_nsec3_next_owner(rr));
01382 if (key) {
01383 node = ldns_rbtree_search(
01384 (ldns_rbtree_t *)
01385 fmt->data,
01386 (void *) key);
01387 if (node->data) {
01388 ldns_buffer_printf(
01389 output,
01390 " to: ");
01391 (void)
01392 ldns_rdf2buffer_str(
01393 output,
01394 (ldns_rdf *)
01395 node->data);
01396 }
01397 ldns_rdf_free(key);
01398 }
01399 }
01400 ldns_buffer_printf(output, "}");
01401 break;
01402 default:
01403 break;
01404
01405 }
01406 }
01407
01408 ldns_buffer_printf(output, "\n");
01409 return ldns_buffer_status(output);
01410 }
01411
01412 ldns_status
01413 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
01414 {
01415 return ldns_rr2buffer_str_fmt(output, ldns_output_format_default, rr);
01416 }
01417
01418 ldns_status
01419 ldns_rr_list2buffer_str_fmt(ldns_buffer *output,
01420 const ldns_output_format *fmt, const ldns_rr_list *list)
01421 {
01422 uint16_t i;
01423
01424 for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
01425 (void) ldns_rr2buffer_str_fmt(output, fmt,
01426 ldns_rr_list_rr(list, i));
01427 }
01428 return ldns_buffer_status(output);
01429 }
01430
01431 ldns_status
01432 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
01433 {
01434 return ldns_rr_list2buffer_str_fmt(
01435 output, ldns_output_format_default, list);
01436 }
01437
01438 ldns_status
01439 ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
01440 {
01441 ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
01442 (int) ldns_pkt_get_opcode(pkt));
01443 ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes,
01444 (int) ldns_pkt_get_rcode(pkt));
01445
01446 ldns_buffer_printf(output, ";; ->>HEADER<<- ");
01447 if (opcode) {
01448 ldns_buffer_printf(output, "opcode: %s, ", opcode->name);
01449 } else {
01450 ldns_buffer_printf(output, "opcode: ?? (%u), ",
01451 ldns_pkt_get_opcode(pkt));
01452 }
01453 if (rcode) {
01454 ldns_buffer_printf(output, "rcode: %s, ", rcode->name);
01455 } else {
01456 ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt));
01457 }
01458 ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt));
01459 ldns_buffer_printf(output, ";; flags: ");
01460
01461 if (ldns_pkt_qr(pkt)) {
01462 ldns_buffer_printf(output, "qr ");
01463 }
01464 if (ldns_pkt_aa(pkt)) {
01465 ldns_buffer_printf(output, "aa ");
01466 }
01467 if (ldns_pkt_tc(pkt)) {
01468 ldns_buffer_printf(output, "tc ");
01469 }
01470 if (ldns_pkt_rd(pkt)) {
01471 ldns_buffer_printf(output, "rd ");
01472 }
01473 if (ldns_pkt_cd(pkt)) {
01474 ldns_buffer_printf(output, "cd ");
01475 }
01476 if (ldns_pkt_ra(pkt)) {
01477 ldns_buffer_printf(output, "ra ");
01478 }
01479 if (ldns_pkt_ad(pkt)) {
01480 ldns_buffer_printf(output, "ad ");
01481 }
01482 ldns_buffer_printf(output, "; ");
01483 ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt));
01484 ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt));
01485 ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt));
01486 ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt));
01487 return ldns_buffer_status(output);
01488 }
01489
01490 ldns_status
01491 ldns_pkt2buffer_str_fmt(ldns_buffer *output,
01492 const ldns_output_format *fmt, const ldns_pkt *pkt)
01493 {
01494 uint16_t i;
01495 ldns_status status = LDNS_STATUS_OK;
01496 char *tmp;
01497 struct timeval time;
01498 time_t time_tt;
01499
01500 if (!pkt) {
01501 ldns_buffer_printf(output, "null");
01502 return LDNS_STATUS_OK;
01503 }
01504
01505 if (ldns_buffer_status_ok(output)) {
01506 status = ldns_pktheader2buffer_str(output, pkt);
01507 if (status != LDNS_STATUS_OK) {
01508 return status;
01509 }
01510
01511 ldns_buffer_printf(output, "\n");
01512
01513 ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
01514
01515
01516 for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
01517 status = ldns_rr2buffer_str_fmt(output, fmt,
01518 ldns_rr_list_rr(
01519 ldns_pkt_question(pkt), i));
01520 if (status != LDNS_STATUS_OK) {
01521 return status;
01522 }
01523 }
01524 ldns_buffer_printf(output, "\n");
01525
01526 ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
01527 for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
01528 status = ldns_rr2buffer_str_fmt(output, fmt,
01529 ldns_rr_list_rr(
01530 ldns_pkt_answer(pkt), i));
01531 if (status != LDNS_STATUS_OK) {
01532 return status;
01533 }
01534
01535 }
01536 ldns_buffer_printf(output, "\n");
01537
01538 ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
01539
01540 for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
01541 status = ldns_rr2buffer_str_fmt(output, fmt,
01542 ldns_rr_list_rr(
01543 ldns_pkt_authority(pkt), i));
01544 if (status != LDNS_STATUS_OK) {
01545 return status;
01546 }
01547 }
01548 ldns_buffer_printf(output, "\n");
01549
01550 ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
01551 for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
01552 status = ldns_rr2buffer_str_fmt(output, fmt,
01553 ldns_rr_list_rr(
01554 ldns_pkt_additional(pkt), i));
01555 if (status != LDNS_STATUS_OK) {
01556 return status;
01557 }
01558
01559 }
01560 ldns_buffer_printf(output, "\n");
01561
01562 ldns_buffer_printf(output, ";; Query time: %d msec\n",
01563 ldns_pkt_querytime(pkt));
01564 if (ldns_pkt_edns(pkt)) {
01565 ldns_buffer_printf(output,
01566 ";; EDNS: version %u; flags:",
01567 ldns_pkt_edns_version(pkt));
01568 if (ldns_pkt_edns_do(pkt)) {
01569 ldns_buffer_printf(output, " do");
01570 }
01571
01572
01573 if (ldns_pkt_edns_extended_rcode(pkt)) {
01574 ldns_buffer_printf(output, " ; ext-rcode: %d",
01575 (ldns_pkt_edns_extended_rcode(pkt) << 4 | ldns_pkt_get_rcode(pkt)));
01576 }
01577 ldns_buffer_printf(output, " ; udp: %u\n",
01578 ldns_pkt_edns_udp_size(pkt));
01579
01580 if (ldns_pkt_edns_data(pkt)) {
01581 ldns_buffer_printf(output, ";; Data: ");
01582 (void)ldns_rdf2buffer_str(output,
01583 ldns_pkt_edns_data(pkt));
01584 ldns_buffer_printf(output, "\n");
01585 }
01586 }
01587 if (ldns_pkt_tsig(pkt)) {
01588 ldns_buffer_printf(output, ";; TSIG:\n;; ");
01589 (void) ldns_rr2buffer_str_fmt(
01590 output, fmt, ldns_pkt_tsig(pkt));
01591 ldns_buffer_printf(output, "\n");
01592 }
01593 if (ldns_pkt_answerfrom(pkt)) {
01594 tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
01595 ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
01596 LDNS_FREE(tmp);
01597 }
01598 time = ldns_pkt_timestamp(pkt);
01599 time_tt = (time_t)time.tv_sec;
01600 ldns_buffer_printf(output, ";; WHEN: %s",
01601 (char*)ctime(&time_tt));
01602
01603 ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n",
01604 (int)ldns_pkt_size(pkt));
01605 } else {
01606 return ldns_buffer_status(output);
01607 }
01608 return status;
01609 }
01610
01611 ldns_status
01612 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
01613 {
01614 return ldns_pkt2buffer_str_fmt(output, ldns_output_format_default, pkt);
01615 }
01616
01617
01618 #ifdef HAVE_SSL
01619 static ldns_status
01620 ldns_hmac_key2buffer_str(ldns_buffer *output, const ldns_key *k)
01621 {
01622 ldns_status status;
01623 size_t i;
01624 ldns_rdf *b64_bignum;
01625
01626 ldns_buffer_printf(output, "Key: ");
01627
01628 i = ldns_key_hmac_size(k);
01629 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k));
01630 status = ldns_rdf2buffer_str(output, b64_bignum);
01631 ldns_rdf_deep_free(b64_bignum);
01632 ldns_buffer_printf(output, "\n");
01633 return status;
01634 }
01635 #endif
01636
01637 #if defined(HAVE_SSL) && defined(USE_GOST)
01638 static ldns_status
01639 ldns_gost_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
01640 {
01641 unsigned char* pp = NULL;
01642 int ret;
01643 ldns_rdf *b64_bignum;
01644 ldns_status status;
01645
01646 ldns_buffer_printf(output, "GostAsn1: ");
01647
01648 ret = i2d_PrivateKey(p, &pp);
01649 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, (size_t)ret, pp);
01650 status = ldns_rdf2buffer_str(output, b64_bignum);
01651
01652 ldns_rdf_deep_free(b64_bignum);
01653 OPENSSL_free(pp);
01654 ldns_buffer_printf(output, "\n");
01655 return status;
01656 }
01657 #endif
01658
01659 ldns_status
01660 ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
01661 {
01662 ldns_status status = LDNS_STATUS_OK;
01663 unsigned char *bignum;
01664 #ifdef HAVE_SSL
01665 # ifndef S_SPLINT_S
01666 uint16_t i;
01667 # endif
01668
01669
01670 ldns_rdf *b64_bignum = NULL;
01671
01672 RSA *rsa;
01673 DSA *dsa;
01674 #endif
01675
01676 if (!k) {
01677 return LDNS_STATUS_ERR;
01678 }
01679
01680 bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
01681 if (!bignum) {
01682 return LDNS_STATUS_ERR;
01683 }
01684
01685 if (ldns_buffer_status_ok(output)) {
01686 #ifdef HAVE_SSL
01687 switch(ldns_key_algorithm(k)) {
01688 case LDNS_SIGN_RSASHA1:
01689 case LDNS_SIGN_RSASHA1_NSEC3:
01690 case LDNS_SIGN_RSASHA256:
01691 case LDNS_SIGN_RSASHA512:
01692 case LDNS_SIGN_RSAMD5:
01693
01694
01695 rsa = ldns_key_rsa_key(k);
01696
01697 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
01698 switch(ldns_key_algorithm(k)) {
01699 case LDNS_SIGN_RSAMD5:
01700 ldns_buffer_printf(output,
01701 "Algorithm: %u (RSA)\n",
01702 LDNS_RSAMD5);
01703 break;
01704 case LDNS_SIGN_RSASHA1:
01705 ldns_buffer_printf(output,
01706 "Algorithm: %u (RSASHA1)\n",
01707 LDNS_RSASHA1);
01708 break;
01709 case LDNS_SIGN_RSASHA1_NSEC3:
01710 ldns_buffer_printf(output,
01711 "Algorithm: %u (RSASHA1_NSEC3)\n",
01712 LDNS_RSASHA1_NSEC3);
01713 break;
01714 #ifdef USE_SHA2
01715 case LDNS_SIGN_RSASHA256:
01716 ldns_buffer_printf(output,
01717 "Algorithm: %u (RSASHA256)\n",
01718 LDNS_RSASHA256);
01719 break;
01720 case LDNS_SIGN_RSASHA512:
01721 ldns_buffer_printf(output,
01722 "Algorithm: %u (RSASHA512)\n",
01723 LDNS_RSASHA512);
01724 break;
01725 #endif
01726 default:
01727 fprintf(stderr, "Warning: unknown signature ");
01728 fprintf(stderr,
01729 "algorithm type %u\n",
01730 ldns_key_algorithm(k));
01731 ldns_buffer_printf(output,
01732 "Algorithm: %u (Unknown)\n",
01733 ldns_key_algorithm(k));
01734 break;
01735 }
01736
01737
01738
01739 ldns_buffer_printf(output, "Modulus: ");
01740 #ifndef S_SPLINT_S
01741 i = (uint16_t)BN_bn2bin(rsa->n, bignum);
01742 if (i > LDNS_MAX_KEYLEN) {
01743 goto error;
01744 }
01745 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01746 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01747 ldns_rdf_deep_free(b64_bignum);
01748 goto error;
01749 }
01750 ldns_rdf_deep_free(b64_bignum);
01751 ldns_buffer_printf(output, "\n");
01752 ldns_buffer_printf(output, "PublicExponent: ");
01753 i = (uint16_t)BN_bn2bin(rsa->e, bignum);
01754 if (i > LDNS_MAX_KEYLEN) {
01755 goto error;
01756 }
01757 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01758 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01759 ldns_rdf_deep_free(b64_bignum);
01760 goto error;
01761 }
01762 ldns_rdf_deep_free(b64_bignum);
01763 ldns_buffer_printf(output, "\n");
01764
01765 ldns_buffer_printf(output, "PrivateExponent: ");
01766 if (rsa->d) {
01767 i = (uint16_t)BN_bn2bin(rsa->d, bignum);
01768 if (i > LDNS_MAX_KEYLEN) {
01769 goto error;
01770 }
01771 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01772 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01773 ldns_rdf_deep_free(b64_bignum);
01774 goto error;
01775 }
01776 ldns_rdf_deep_free(b64_bignum);
01777 ldns_buffer_printf(output, "\n");
01778 } else {
01779 ldns_buffer_printf(output, "(Not available)\n");
01780 }
01781
01782 ldns_buffer_printf(output, "Prime1: ");
01783 if (rsa->p) {
01784 i = (uint16_t)BN_bn2bin(rsa->p, bignum);
01785 if (i > LDNS_MAX_KEYLEN) {
01786 goto error;
01787 }
01788 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01789 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01790 ldns_rdf_deep_free(b64_bignum);
01791 goto error;
01792 }
01793 ldns_rdf_deep_free(b64_bignum);
01794 ldns_buffer_printf(output, "\n");
01795 } else {
01796 ldns_buffer_printf(output, "(Not available)\n");
01797 }
01798
01799 ldns_buffer_printf(output, "Prime2: ");
01800 if (rsa->q) {
01801 i = (uint16_t)BN_bn2bin(rsa->q, bignum);
01802 if (i > LDNS_MAX_KEYLEN) {
01803 goto error;
01804 }
01805 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01806 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01807 ldns_rdf_deep_free(b64_bignum);
01808 goto error;
01809 }
01810 ldns_rdf_deep_free(b64_bignum);
01811 ldns_buffer_printf(output, "\n");
01812 } else {
01813 ldns_buffer_printf(output, "(Not available)\n");
01814 }
01815
01816 ldns_buffer_printf(output, "Exponent1: ");
01817 if (rsa->dmp1) {
01818 i = (uint16_t)BN_bn2bin(rsa->dmp1, bignum);
01819 if (i > LDNS_MAX_KEYLEN) {
01820 goto error;
01821 }
01822 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01823 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01824 ldns_rdf_deep_free(b64_bignum);
01825 goto error;
01826 }
01827 ldns_rdf_deep_free(b64_bignum);
01828 ldns_buffer_printf(output, "\n");
01829 } else {
01830 ldns_buffer_printf(output, "(Not available)\n");
01831 }
01832
01833 ldns_buffer_printf(output, "Exponent2: ");
01834 if (rsa->dmq1) {
01835 i = (uint16_t)BN_bn2bin(rsa->dmq1, bignum);
01836 if (i > LDNS_MAX_KEYLEN) {
01837 goto error;
01838 }
01839 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01840 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01841 ldns_rdf_deep_free(b64_bignum);
01842 goto error;
01843 }
01844 ldns_rdf_deep_free(b64_bignum);
01845 ldns_buffer_printf(output, "\n");
01846 } else {
01847 ldns_buffer_printf(output, "(Not available)\n");
01848 }
01849
01850 ldns_buffer_printf(output, "Coefficient: ");
01851 if (rsa->iqmp) {
01852 i = (uint16_t)BN_bn2bin(rsa->iqmp, bignum);
01853 if (i > LDNS_MAX_KEYLEN) {
01854 goto error;
01855 }
01856 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01857 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01858 ldns_rdf_deep_free(b64_bignum);
01859 goto error;
01860 }
01861 ldns_rdf_deep_free(b64_bignum);
01862 ldns_buffer_printf(output, "\n");
01863 } else {
01864 ldns_buffer_printf(output, "(Not available)\n");
01865 }
01866 #endif
01867
01868 RSA_free(rsa);
01869 break;
01870 case LDNS_SIGN_DSA:
01871 case LDNS_SIGN_DSA_NSEC3:
01872 dsa = ldns_key_dsa_key(k);
01873
01874 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
01875 if (ldns_key_algorithm(k) == LDNS_SIGN_DSA) {
01876 ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n");
01877 } else if (ldns_key_algorithm(k) == LDNS_SIGN_DSA_NSEC3) {
01878 ldns_buffer_printf(output,"Algorithm: 6 (DSA_NSEC3)\n");
01879 }
01880
01881
01882
01883 ldns_buffer_printf(output, "Prime(p): ");
01884 #ifndef S_SPLINT_S
01885 if (dsa->p) {
01886 i = (uint16_t)BN_bn2bin(dsa->p, bignum);
01887 if (i > LDNS_MAX_KEYLEN) {
01888 goto error;
01889 }
01890 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01891 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01892 ldns_rdf_deep_free(b64_bignum);
01893 goto error;
01894 }
01895 ldns_rdf_deep_free(b64_bignum);
01896 ldns_buffer_printf(output, "\n");
01897 } else {
01898 printf("(Not available)\n");
01899 }
01900
01901 ldns_buffer_printf(output, "Subprime(q): ");
01902 if (dsa->q) {
01903 i = (uint16_t)BN_bn2bin(dsa->q, bignum);
01904 if (i > LDNS_MAX_KEYLEN) {
01905 goto error;
01906 }
01907 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01908 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01909 ldns_rdf_deep_free(b64_bignum);
01910 goto error;
01911 }
01912 ldns_rdf_deep_free(b64_bignum);
01913 ldns_buffer_printf(output, "\n");
01914 } else {
01915 printf("(Not available)\n");
01916 }
01917
01918 ldns_buffer_printf(output, "Base(g): ");
01919 if (dsa->g) {
01920 i = (uint16_t)BN_bn2bin(dsa->g, bignum);
01921 if (i > LDNS_MAX_KEYLEN) {
01922 goto error;
01923 }
01924 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01925 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01926 ldns_rdf_deep_free(b64_bignum);
01927 goto error;
01928 }
01929 ldns_rdf_deep_free(b64_bignum);
01930 ldns_buffer_printf(output, "\n");
01931 } else {
01932 printf("(Not available)\n");
01933 }
01934
01935 ldns_buffer_printf(output, "Private_value(x): ");
01936 if (dsa->priv_key) {
01937 i = (uint16_t)BN_bn2bin(dsa->priv_key, bignum);
01938 if (i > LDNS_MAX_KEYLEN) {
01939 goto error;
01940 }
01941 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01942 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01943 ldns_rdf_deep_free(b64_bignum);
01944 goto error;
01945 }
01946 ldns_rdf_deep_free(b64_bignum);
01947 ldns_buffer_printf(output, "\n");
01948 } else {
01949 printf("(Not available)\n");
01950 }
01951
01952 ldns_buffer_printf(output, "Public_value(y): ");
01953 if (dsa->pub_key) {
01954 i = (uint16_t)BN_bn2bin(dsa->pub_key, bignum);
01955 if (i > LDNS_MAX_KEYLEN) {
01956 goto error;
01957 }
01958 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01959 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01960 ldns_rdf_deep_free(b64_bignum);
01961 goto error;
01962 }
01963 ldns_rdf_deep_free(b64_bignum);
01964 ldns_buffer_printf(output, "\n");
01965 } else {
01966 printf("(Not available)\n");
01967 }
01968 #endif
01969 break;
01970 case LDNS_SIGN_ECC_GOST:
01971
01972 #if defined(HAVE_SSL) && defined(USE_GOST)
01973 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
01974 ldns_buffer_printf(output, "Algorithm: %d (ECC-GOST)\n", LDNS_SIGN_ECC_GOST);
01975 status = ldns_gost_key2buffer_str(output,
01976 #ifndef S_SPLINT_S
01977 k->_key.key
01978 #else
01979 NULL
01980 #endif
01981 );
01982 #else
01983 goto error;
01984 #endif
01985 break;
01986 case LDNS_SIGN_ECDSAP256SHA256:
01987 case LDNS_SIGN_ECDSAP384SHA384:
01988 #ifdef USE_ECDSA
01989 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
01990 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
01991 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
01992 #ifndef S_SPLINT_S
01993 ldns_buffer_printf(output, ")\n");
01994 if(k->_key.key) {
01995 EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->_key.key);
01996 const BIGNUM* b = EC_KEY_get0_private_key(ec);
01997 ldns_buffer_printf(output, "PrivateKey: ");
01998 i = (uint16_t)BN_bn2bin(b, bignum);
01999 if (i > LDNS_MAX_KEYLEN) {
02000 goto error;
02001 }
02002 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
02003 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
02004 ldns_rdf_deep_free(b64_bignum);
02005 goto error;
02006 }
02007 ldns_rdf_deep_free(b64_bignum);
02008 ldns_buffer_printf(output, "\n");
02009
02010
02011 EC_KEY_free(ec);
02012 }
02013 #endif
02014 #else
02015 goto error;
02016 #endif
02017 break;
02018 case LDNS_SIGN_HMACMD5:
02019
02020
02021 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
02022 ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n");
02023 status = ldns_hmac_key2buffer_str(output, k);
02024 break;
02025 case LDNS_SIGN_HMACSHA1:
02026 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
02027 ldns_buffer_printf(output, "Algorithm: 158 (HMAC_SHA1)\n");
02028 status = ldns_hmac_key2buffer_str(output, k);
02029 break;
02030 case LDNS_SIGN_HMACSHA256:
02031 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
02032 ldns_buffer_printf(output, "Algorithm: 159 (HMAC_SHA256)\n");
02033 status = ldns_hmac_key2buffer_str(output, k);
02034 break;
02035 }
02036 #endif
02037 } else {
02038 LDNS_FREE(bignum);
02039 return ldns_buffer_status(output);
02040 }
02041 LDNS_FREE(bignum);
02042 return status;
02043
02044 #ifdef HAVE_SSL
02045
02046 error:
02047 LDNS_FREE(bignum);
02048 return LDNS_STATUS_ERR;
02049 #endif
02050
02051 }
02052
02053
02054
02055
02056 char *
02057 ldns_buffer2str(ldns_buffer *buffer)
02058 {
02059 char *str;
02060
02061
02062
02063 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
02064 if (!ldns_buffer_reserve(buffer, 1)) {
02065 return NULL;
02066 }
02067 ldns_buffer_write_u8(buffer, (uint8_t) '\0');
02068 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
02069 return NULL;
02070 }
02071 }
02072
02073 str = strdup((const char *)ldns_buffer_begin(buffer));
02074 if(!str) {
02075 return NULL;
02076 }
02077 return str;
02078 }
02079
02080
02081
02082
02083 char *
02084 ldns_buffer_export2str(ldns_buffer *buffer)
02085 {
02086
02087 if (! ldns_buffer_reserve(buffer, 1)) {
02088 return NULL;
02089 }
02090 ldns_buffer_write_u8(buffer, 0);
02091
02092
02093 ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer));
02094 return ldns_buffer_export(buffer);
02095 }
02096
02097 char *
02098 ldns_rdf2str(const ldns_rdf *rdf)
02099 {
02100 char *result = NULL;
02101 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
02102
02103 if (!tmp_buffer) {
02104 return NULL;
02105 }
02106 if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
02107
02108 result = ldns_buffer_export2str(tmp_buffer);
02109 }
02110 ldns_buffer_free(tmp_buffer);
02111 return result;
02112 }
02113
02114 char *
02115 ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr)
02116 {
02117 char *result = NULL;
02118 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
02119
02120 if (!tmp_buffer) {
02121 return NULL;
02122 }
02123 if (ldns_rr2buffer_str_fmt(tmp_buffer, fmt, rr)
02124 == LDNS_STATUS_OK) {
02125
02126 result = ldns_buffer_export2str(tmp_buffer);
02127 }
02128 ldns_buffer_free(tmp_buffer);
02129 return result;
02130 }
02131
02132 char *
02133 ldns_rr2str(const ldns_rr *rr)
02134 {
02135 return ldns_rr2str_fmt(ldns_output_format_default, rr);
02136 }
02137
02138 char *
02139 ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt)
02140 {
02141 char *result = NULL;
02142 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
02143
02144 if (!tmp_buffer) {
02145 return NULL;
02146 }
02147 if (ldns_pkt2buffer_str_fmt(tmp_buffer, fmt, pkt)
02148 == LDNS_STATUS_OK) {
02149
02150 result = ldns_buffer_export2str(tmp_buffer);
02151 }
02152
02153 ldns_buffer_free(tmp_buffer);
02154 return result;
02155 }
02156
02157 char *
02158 ldns_pkt2str(const ldns_pkt *pkt)
02159 {
02160 return ldns_pkt2str_fmt(ldns_output_format_default, pkt);
02161 }
02162
02163 char *
02164 ldns_key2str(const ldns_key *k)
02165 {
02166 char *result = NULL;
02167 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
02168
02169 if (!tmp_buffer) {
02170 return NULL;
02171 }
02172 if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) {
02173
02174 result = ldns_buffer_export2str(tmp_buffer);
02175 }
02176 ldns_buffer_free(tmp_buffer);
02177 return result;
02178 }
02179
02180 char *
02181 ldns_rr_list2str_fmt(const ldns_output_format *fmt, const ldns_rr_list *list)
02182 {
02183 char *result = NULL;
02184 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
02185
02186 if (!tmp_buffer) {
02187 return NULL;
02188 }
02189 if (list) {
02190 if (ldns_rr_list2buffer_str_fmt(
02191 tmp_buffer, fmt, list)
02192 == LDNS_STATUS_OK) {
02193 }
02194 } else {
02195 if (fmt == NULL) {
02196 fmt = ldns_output_format_default;
02197 }
02198 if (fmt->flags & LDNS_COMMENT_NULLS) {
02199 ldns_buffer_printf(tmp_buffer, "; (null)\n");
02200 }
02201 }
02202
02203
02204 result = ldns_buffer_export2str(tmp_buffer);
02205 ldns_buffer_free(tmp_buffer);
02206 return result;
02207 }
02208
02209 char *
02210 ldns_rr_list2str(const ldns_rr_list *list)
02211 {
02212 return ldns_rr_list2str_fmt(ldns_output_format_default, list);
02213 }
02214
02215 void
02216 ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
02217 {
02218 char *str = ldns_rdf2str(rdf);
02219 if (str) {
02220 fprintf(output, "%s", str);
02221 } else {
02222 fprintf(output, ";Unable to convert rdf to string\n");
02223 }
02224 LDNS_FREE(str);
02225 }
02226
02227 void
02228 ldns_rr_print_fmt(FILE *output,
02229 const ldns_output_format *fmt, const ldns_rr *rr)
02230 {
02231 char *str = ldns_rr2str_fmt(fmt, rr);
02232 if (str) {
02233 fprintf(output, "%s", str);
02234 } else {
02235 fprintf(output, ";Unable to convert rr to string\n");
02236 }
02237 LDNS_FREE(str);
02238 }
02239
02240 void
02241 ldns_rr_print(FILE *output, const ldns_rr *rr)
02242 {
02243 ldns_rr_print_fmt(output, ldns_output_format_default, rr);
02244 }
02245
02246 void
02247 ldns_pkt_print_fmt(FILE *output,
02248 const ldns_output_format *fmt, const ldns_pkt *pkt)
02249 {
02250 char *str = ldns_pkt2str_fmt(fmt, pkt);
02251 if (str) {
02252 fprintf(output, "%s", str);
02253 } else {
02254 fprintf(output, ";Unable to convert packet to string\n");
02255 }
02256 LDNS_FREE(str);
02257 }
02258
02259 void
02260 ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
02261 {
02262 ldns_pkt_print_fmt(output, ldns_output_format_default, pkt);
02263 }
02264
02265 void
02266 ldns_rr_list_print_fmt(FILE *output,
02267 const ldns_output_format *fmt, const ldns_rr_list *lst)
02268 {
02269 size_t i;
02270 for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
02271 ldns_rr_print_fmt(output, fmt, ldns_rr_list_rr(lst, i));
02272 }
02273 }
02274
02275 void
02276 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
02277 {
02278 ldns_rr_list_print_fmt(output, ldns_output_format_default, lst);
02279 }
02280
02281 void
02282 ldns_resolver_print_fmt(FILE *output,
02283 const ldns_output_format *fmt, const ldns_resolver *r)
02284 {
02285 uint16_t i;
02286 ldns_rdf **n;
02287 ldns_rdf **s;
02288 size_t *rtt;
02289 if (!r) {
02290 return;
02291 }
02292 n = ldns_resolver_nameservers(r);
02293 s = ldns_resolver_searchlist(r);
02294 rtt = ldns_resolver_rtt(r);
02295
02296 fprintf(output, "port: %d\n", (int)ldns_resolver_port(r));
02297 fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r));
02298 fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r));
02299
02300 fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r));
02301 fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r));
02302 fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r));
02303 fprintf(output, "fail: %d\n", ldns_resolver_fail(r));
02304 fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r));
02305 fprintf(output, "retrans: %d\n", (int)ldns_resolver_retrans(r));
02306 fprintf(output, "fallback: %d\n", ldns_resolver_fallback(r));
02307 fprintf(output, "random: %d\n", ldns_resolver_random(r));
02308 fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
02309 fprintf(output, "dnssec: %d\n", ldns_resolver_dnssec(r));
02310 fprintf(output, "dnssec cd: %d\n", ldns_resolver_dnssec_cd(r));
02311 fprintf(output, "trust anchors (%d listed):\n",
02312 (int)ldns_rr_list_rr_count(ldns_resolver_dnssec_anchors(r)));
02313 ldns_rr_list_print_fmt(output, fmt, ldns_resolver_dnssec_anchors(r));
02314 fprintf(output, "tsig: %s %s\n",
02315 ldns_resolver_tsig_keyname(r)?ldns_resolver_tsig_keyname(r):"-",
02316 ldns_resolver_tsig_algorithm(r)?ldns_resolver_tsig_algorithm(r):"-");
02317 fprintf(output, "debug: %d\n", ldns_resolver_debug(r));
02318
02319 fprintf(output, "default domain: ");
02320 ldns_rdf_print(output, ldns_resolver_domain(r));
02321 fprintf(output, "\n");
02322 fprintf(output, "apply default domain: %d\n", ldns_resolver_defnames(r));
02323
02324 fprintf(output, "searchlist (%d listed):\n", (int)ldns_resolver_searchlist_count(r));
02325 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
02326 fprintf(output, "\t");
02327 ldns_rdf_print(output, s[i]);
02328 fprintf(output, "\n");
02329 }
02330 fprintf(output, "apply search list: %d\n", ldns_resolver_dnsrch(r));
02331
02332 fprintf(output, "nameservers (%d listed):\n", (int)ldns_resolver_nameserver_count(r));
02333 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
02334 fprintf(output, "\t");
02335 ldns_rdf_print(output, n[i]);
02336
02337 switch ((int)rtt[i]) {
02338 case LDNS_RESOLV_RTT_MIN:
02339 fprintf(output, " - reachable\n");
02340 break;
02341 case LDNS_RESOLV_RTT_INF:
02342 fprintf(output, " - unreachable\n");
02343 break;
02344 }
02345 }
02346 }
02347
02348 void
02349 ldns_resolver_print(FILE *output, const ldns_resolver *r)
02350 {
02351 ldns_resolver_print_fmt(output, ldns_output_format_default, r);
02352 }
02353
02354 void
02355 ldns_zone_print_fmt(FILE *output,
02356 const ldns_output_format *fmt, const ldns_zone *z)
02357 {
02358 if(ldns_zone_soa(z))
02359 ldns_rr_print_fmt(output, fmt, ldns_zone_soa(z));
02360 ldns_rr_list_print_fmt(output, fmt, ldns_zone_rrs(z));
02361 }
02362 void
02363 ldns_zone_print(FILE *output, const ldns_zone *z)
02364 {
02365 ldns_zone_print_fmt(output, ldns_output_format_default, z);
02366 }