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