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

Generated on Fri Jun 8 17:07:46 2012 for ldns by  doxygen 1.4.7