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