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