host2str.c

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

Generated on Wed Dec 19 16:56:49 2012 for ldns by  doxygen 1.4.7