More conventional order of arguments.

And an extra data field in ldns_output_format in which for example a rbtree mapping nsec3 hashes to names could be passed along.

diff --git a/dnssec_verify.c b/dnssec_verify.c
index d3f6c1b6e500920d289755ae2fb047486b9d8e8a..427aae9f7f7066a404149a78e71570e737477e8d 100644 (file)
--- a/dnssec_verify.c
+++ b/dnssec_verify.c
@@ -53,14 +53,13 @@ ldns_dnssec_data_chain_deep_free(ldns_dnssec_data_chain *chain)
 }
 
 void
-ldns_dnssec_data_chain_print_fmt(FILE *out, 
-               const ldns_dnssec_data_chain *chain, 
-               const ldns_output_format *fmt)
+ldns_dnssec_data_chain_print_fmt(FILE *out, const ldns_output_format *fmt,
+               const ldns_dnssec_data_chain *chain)
 {
        ldns_lookup_table *rcode;
        const ldns_rr_descriptor *rr_descriptor;
        if (chain) {
-               ldns_dnssec_data_chain_print_fmt(out, chain->parent, fmt);
+               ldns_dnssec_data_chain_print_fmt(out, fmt, chain->parent);
                if (ldns_rr_list_rr_count(chain->rrset) > 0) {
                        rcode = ldns_lookup_by_id(ldns_rcodes,
                                                                 (int) chain->packet_rcode);
@@ -79,9 +78,9 @@ ldns_dnssec_data_chain_print_fmt(FILE *out,
                                fprintf(out, ";; NODATA response\n");
                        }
                        fprintf(out, "rrset:\n");
-                       ldns_rr_list_print_fmt(out, chain->rrset, fmt);
+                       ldns_rr_list_print_fmt(out, fmt, chain->rrset);
                        fprintf(out, "sigs:\n");
-                       ldns_rr_list_print_fmt(out, chain->signatures, fmt);
+                       ldns_rr_list_print_fmt(out, fmt, chain->signatures);
                        fprintf(out, "---\n");
                } else {
                        fprintf(out, "<no data>\n");
@@ -91,7 +90,8 @@ ldns_dnssec_data_chain_print_fmt(FILE *out,
 void
 ldns_dnssec_data_chain_print(FILE *out, const ldns_dnssec_data_chain *chain)
 {
-       ldns_dnssec_data_chain_print_fmt(out, chain, ldns_output_format_default);
+       ldns_dnssec_data_chain_print_fmt(
+                       out, ldns_output_format_default, chain);
 }
 
 
@@ -496,12 +496,12 @@ print_tabs(FILE *out, size_t nr, uint8_t *map, size_t treedepth)
 
 void
 ldns_dnssec_trust_tree_print_sm_fmt(FILE *out, 
+               const ldns_output_format *fmt,
                ldns_dnssec_trust_tree *tree,
                size_t tabs,
                bool extended,
                uint8_t *sibmap,
-               size_t treedepth,
-               const ldns_output_format *fmt)
+               size_t treedepth)
 {
        size_t i;
        const ldns_rr_descriptor *descriptor;
@@ -597,19 +597,22 @@ ldns_dnssec_trust_tree_print_sm_fmt(FILE *out,
                                                        ERR_print_errors_fp(stdout);
                                                        printf("\n");
                                                }
-                                               ldns_rr_print_fmt(out, tree->parent_signature[i], fmt);
+                                               ldns_rr_print_fmt(out, fmt, 
+                                                       tree->
+                                                       parent_signature[i]);
                                                printf("For RRset:\n");
-                                               ldns_rr_list_print_fmt(out, tree->rrset, fmt);
+                                               ldns_rr_list_print_fmt(out, fmt,
+                                                               tree->rrset);
                                                printf("With key:\n");
-                                               ldns_rr_print_fmt(out, tree->parents[i]->rr, fmt);
+                                               ldns_rr_print_fmt(out, fmt,
+                                                       tree->parents[i]->rr);
                                        }
-                               ldns_dnssec_trust_tree_print_sm_fmt(out,
+                               ldns_dnssec_trust_tree_print_sm_fmt(out, fmt,
                                                tree->parents[i],
                                                tabs+1,
                                                extended,
                                                sibmap,
-                                               treedepth,
-                                               fmt);
+                                               treedepth);
                        }
                } else {
                        print_tabs(out, tabs, sibmap, treedepth);
@@ -632,17 +635,18 @@ ldns_dnssec_trust_tree_print_sm(FILE *out,
                uint8_t *sibmap,
                size_t treedepth)
 {
-       ldns_dnssec_trust_tree_print_sm_fmt(out, tree, tabs, extended, sibmap, treedepth, ldns_output_format_default);
+       ldns_dnssec_trust_tree_print_sm_fmt(out, ldns_output_format_default, 
+                       tree, tabs, extended, sibmap, treedepth);
 }
 
 void
-ldns_dnssec_trust_tree_print_fmt(FILE *out,
+ldns_dnssec_trust_tree_print_fmt(FILE *out, const ldns_output_format *fmt,
                ldns_dnssec_trust_tree *tree,
                size_t tabs,
-               bool extended,
-               const ldns_output_format *fmt)
+               bool extended)
 {
-       ldns_dnssec_trust_tree_print_sm_fmt(out, tree, tabs, extended, NULL, 0, fmt);
+       ldns_dnssec_trust_tree_print_sm_fmt(out, fmt, 
+                       tree, tabs, extended, NULL, 0);
 }
 
 void
@@ -651,7 +655,8 @@ ldns_dnssec_trust_tree_print(FILE *out,
                size_t tabs,
                bool extended)
 {
-       ldns_dnssec_trust_tree_print_fmt(out, tree, tabs, extended, ldns_output_format_default);
+       ldns_dnssec_trust_tree_print_fmt(out, ldns_output_format_default, 
+                       tree, tabs, extended);
 }
 
 

diff --git a/dnssec_zone.c b/dnssec_zone.c
index 71e4ab61af5b04ececc63b06d6fb19e67429cd89..cdd4e2d889e878a2af320a14679a3825e3703dbf 100644 (file)
--- a/dnssec_zone.c
+++ b/dnssec_zone.c
@@ -78,16 +78,17 @@ ldns_dnssec_rrs_add_rr(ldns_dnssec_rrs *rrs, ldns_rr *rr)
 }
 
 void
-ldns_dnssec_rrs_print_fmt(FILE *out, ldns_dnssec_rrs *rrs, const ldns_output_format *fmt)
+ldns_dnssec_rrs_print_fmt(FILE *out, const ldns_output_format *fmt,
+              ldns_dnssec_rrs *rrs)
 {
        if (!rrs) {
                fprintf(out, "<void>");
        } else {
                if (rrs->rr) {
-                       ldns_rr_print_fmt(out, rrs->rr, fmt);
+                       ldns_rr_print_fmt(out, fmt, rrs->rr);
                }
                if (rrs->next) {
-                       ldns_dnssec_rrs_print_fmt(out, rrs->next, fmt);
+                       ldns_dnssec_rrs_print_fmt(out, fmt, rrs->next);
                }
        }
 }
@@ -95,7 +96,7 @@ ldns_dnssec_rrs_print_fmt(FILE *out, ldns_dnssec_rrs *rrs, const ldns_output_for
 void
 ldns_dnssec_rrs_print(FILE *out, ldns_dnssec_rrs *rrs)
 {
-       ldns_dnssec_rrs_print_fmt(out, rrs, ldns_output_format_default);
+       ldns_dnssec_rrs_print_fmt(out, ldns_output_format_default, rrs);
 }
 
 
@@ -269,11 +270,10 @@ ldns_dnssec_rrsets_add_rr(ldns_dnssec_rrsets *rrsets, ldns_rr *rr)
 }
 
 void
-ldns_dnssec_rrsets_print_soa_fmt(FILE *out,
+ldns_dnssec_rrsets_print_soa_fmt(FILE *out, const ldns_output_format *fmt,
                ldns_dnssec_rrsets *rrsets,
                bool follow,
-               bool show_soa,
-               const ldns_output_format *fmt)
+               bool show_soa)
 {
        if (!rrsets) {
                fprintf(out, "<void>\n");
@@ -283,13 +283,15 @@ ldns_dnssec_rrsets_print_soa_fmt(FILE *out,
                        ldns_rr_get_type(rrsets->rrs->rr) != LDNS_RR_TYPE_SOA
                    )
                   ) {
-                       ldns_dnssec_rrs_print_fmt(out, rrsets->rrs, fmt);
+                       ldns_dnssec_rrs_print_fmt(out, fmt, rrsets->rrs);
                        if (rrsets->signatures) {
-                               ldns_dnssec_rrs_print_fmt(out, rrsets->signatures, fmt);
+                               ldns_dnssec_rrs_print_fmt(out, fmt, 
+                                               rrsets->signatures);
                        }
                }
                if (follow && rrsets->next) {
-                       ldns_dnssec_rrsets_print_soa_fmt(out, rrsets->next, follow, show_soa, fmt);
+                       ldns_dnssec_rrsets_print_soa_fmt(out, fmt, 
+                                       rrsets->next, follow, show_soa);
                }
        }
 }
@@ -300,23 +302,24 @@ ldns_dnssec_rrsets_print_soa(FILE *out,
                bool follow,
                bool show_soa)
 {
-       ldns_dnssec_rrsets_print_soa_fmt(out, rrsets, follow, show_soa, ldns_output_format_default);
+       ldns_dnssec_rrsets_print_soa_fmt(out, ldns_output_format_default,
+                       rrsets, follow, show_soa);
 }
 
 
 void
-ldns_dnssec_rrsets_print_fmt(FILE *out, 
+ldns_dnssec_rrsets_print_fmt(FILE *out, const ldns_output_format *fmt,
                ldns_dnssec_rrsets *rrsets, 
-               bool follow,
-               const ldns_output_format *fmt)
+               bool follow)
 {
-       ldns_dnssec_rrsets_print_soa_fmt(out, rrsets, follow, true, fmt);
+       ldns_dnssec_rrsets_print_soa_fmt(out, fmt, rrsets, follow, true);
 }
 
 void
 ldns_dnssec_rrsets_print(FILE *out, ldns_dnssec_rrsets *rrsets, bool follow)
 {
-       ldns_dnssec_rrsets_print_fmt(out, rrsets, follow, ldns_output_format_default);
+       ldns_dnssec_rrsets_print_fmt(out, ldns_output_format_default, 
+                       rrsets, follow);
 }
 
 ldns_dnssec_name *
@@ -559,24 +562,25 @@ ldns_dnssec_zone_find_rrset(ldns_dnssec_zone *zone,
 }
 
 void
-ldns_dnssec_name_print_soa_fmt(FILE *out, 
+ldns_dnssec_name_print_soa_fmt(FILE *out, const ldns_output_format *fmt,
                ldns_dnssec_name *name, 
-               bool show_soa, 
-               const ldns_output_format *fmt)
+               bool show_soa)
 {
        if (name) {
                if(name->rrsets) {
-                       ldns_dnssec_rrsets_print_soa_fmt(out, name->rrsets, true, show_soa, fmt);
+                       ldns_dnssec_rrsets_print_soa_fmt(out, fmt, 
+                                       name->rrsets, true, show_soa);
                } else {
                        fprintf(out, ";; Empty nonterminal: ");
                        ldns_rdf_print(out, name->name);
                        fprintf(out, "\n");
                }
                if(name->nsec) {
-                       ldns_rr_print_fmt(out, name->nsec, fmt);
+                       ldns_rr_print_fmt(out, fmt, name->nsec);
                }
                if (name->nsec_signatures) {
-                       ldns_dnssec_rrs_print_fmt(out, name->nsec_signatures, fmt);
+                       ldns_dnssec_rrs_print_fmt(out, fmt, 
+                                       name->nsec_signatures);
                }
        } else {
                fprintf(out, "<void>\n");
@@ -586,22 +590,21 @@ ldns_dnssec_name_print_soa_fmt(FILE *out,
 void
 ldns_dnssec_name_print_soa(FILE *out, ldns_dnssec_name *name, bool show_soa)
 {
-       ldns_dnssec_name_print_soa_fmt(
-                       out, name, show_soa, ldns_output_format_default);
+       ldns_dnssec_name_print_soa_fmt(out, ldns_output_format_default,
+                      name, show_soa);
 }
 
 void
-ldns_dnssec_name_print_fmt(FILE *out, 
-               ldns_dnssec_name *name, 
-               const ldns_output_format *fmt)
+ldns_dnssec_name_print_fmt(FILE *out, const ldns_output_format *fmt,
+               ldns_dnssec_name *name)
 {
-       ldns_dnssec_name_print_soa_fmt(out, name, true, fmt);
+       ldns_dnssec_name_print_soa_fmt(out, fmt, name, true);
 }
 
 void
 ldns_dnssec_name_print(FILE *out, ldns_dnssec_name *name)
 {
-       ldns_dnssec_name_print_fmt(out, name, ldns_output_format_default);
+       ldns_dnssec_name_print_fmt(out, ldns_output_format_default, name);
 }
 
 
@@ -759,10 +762,9 @@ ldns_dnssec_zone_add_rr(ldns_dnssec_zone *zone, ldns_rr *rr)
 #endif /* HAVE_SSL */
 
 void
-ldns_dnssec_zone_names_print_fmt(FILE *out, 
+ldns_dnssec_zone_names_print_fmt(FILE *out, const ldns_output_format *fmt,
                ldns_rbtree_t *tree, 
-               bool print_soa,
-               const ldns_output_format *fmt)
+               bool print_soa)
 {
        ldns_rbnode_t *node;
        ldns_dnssec_name *name;
@@ -770,7 +772,7 @@ ldns_dnssec_zone_names_print_fmt(FILE *out,
        node = ldns_rbtree_first(tree);
        while (node != LDNS_RBTREE_NULL) {
                name = (ldns_dnssec_name *) node->data;
-               ldns_dnssec_name_print_soa_fmt(out, name, print_soa, fmt);
+               ldns_dnssec_name_print_soa_fmt(out, fmt, name, print_soa);
                fprintf(out, ";\n");
                node = ldns_rbtree_next(node);
        }
@@ -779,11 +781,13 @@ ldns_dnssec_zone_names_print_fmt(FILE *out,
 void
 ldns_dnssec_zone_names_print(FILE *out, ldns_rbtree_t *tree, bool print_soa)
 {
-       ldns_dnssec_zone_names_print_fmt(out, tree, print_soa, ldns_output_format_default);
+       ldns_dnssec_zone_names_print_fmt(out, ldns_output_format_default,
+                      tree, print_soa);
 }
 
 void
-ldns_dnssec_zone_print_fmt(FILE *out, ldns_dnssec_zone *zone, const ldns_output_format *fmt)
+ldns_dnssec_zone_print_fmt(FILE *out, const ldns_output_format *fmt,
+              ldns_dnssec_zone *zone)
 {
        if (zone) {
                if (zone->soa) {
@@ -791,18 +795,17 @@ ldns_dnssec_zone_print_fmt(FILE *out, ldns_dnssec_zone *zone, const ldns_output_
                        ldns_rdf_print(out,
                                        ldns_dnssec_name_name(zone->soa));
                        fprintf(out, "\n;\n");
-                       ldns_dnssec_rrsets_print_fmt(out,
+                       ldns_dnssec_rrsets_print_fmt(out, fmt,
                                        ldns_dnssec_name_find_rrset(
                                                zone->soa, 
                                                LDNS_RR_TYPE_SOA), 
-                                       false,
-                                       fmt);
+                                       false);
                        fprintf(out, ";\n");
                }
 
                if (zone->names) {
-                       ldns_dnssec_zone_names_print_fmt(
-                                       out, zone->names, false, fmt);
+                       ldns_dnssec_zone_names_print_fmt(out, fmt, 
+                                       zone->names, false);
                }
        }
 }
@@ -810,7 +813,7 @@ ldns_dnssec_zone_print_fmt(FILE *out, ldns_dnssec_zone *zone, const ldns_output_
 void
 ldns_dnssec_zone_print(FILE *out, ldns_dnssec_zone *zone)
 {
-       ldns_dnssec_zone_print_fmt(out, zone, ldns_output_format_default);
+       ldns_dnssec_zone_print_fmt(out, ldns_output_format_default, zone);
 }
 
 ldns_status

diff --git a/examples/ldns-read-zone.c b/examples/ldns-read-zone.c
index 066ba164aab186b0fcbf0caa06c794a43aace4d2..e2aa15f17f18b37d1c99051e12670d9b2d49319d 100644 (file)
--- a/examples/ldns-read-zone.c
+++ b/examples/ldns-read-zone.c
@@ -147,9 +147,9 @@ main(int argc, char **argv)
                }
 
                if (print_soa && ldns_zone_soa(z)) {
-                       ldns_rr_print_fmt(stdout, ldns_zone_soa(z), fmt);
+                       ldns_rr_print_fmt(stdout, fmt, ldns_zone_soa(z));
                }
-               ldns_rr_list_print_fmt(stdout, ldns_zone_rrs(z), fmt);
+               ldns_rr_list_print_fmt(stdout, fmt, ldns_zone_rrs(z));
 
                ldns_zone_deep_free(z);
        } else {

diff --git a/host2str.c b/host2str.c
index d9706aea8329ec4ea182b3a04deaca869cc79b24..bf1ddf565e964294ae8f18e6cd805aa8673777fd 100644 (file)
--- a/host2str.c
+++ b/host2str.c
@@ -113,25 +113,22 @@ ldns_lookup_table ldns_opcodes[] = {
         { 0, NULL }
 };
 
-const ldns_output_format   ldns_output_format_nocomments_record = { 0 };
+const ldns_output_format   ldns_output_format_nocomments_record = { 0, NULL };
 const ldns_output_format  *ldns_output_format_nocomments 
                        = &ldns_output_format_nocomments_record;
 const ldns_output_format   ldns_output_format_onlykeyids_record = {
-       LDNS_COMMENT_KEY
+       LDNS_COMMENT_KEY, NULL
 };
 const ldns_output_format  *ldns_output_format_onlykeyids
                        = &ldns_output_format_onlykeyids_record;
 const ldns_output_format  *ldns_output_format_default
                        = &ldns_output_format_onlykeyids_record;
 const ldns_output_format   ldns_output_format_bubblebabble_record = { 
-       LDNS_COMMENT_KEY | LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS
+       LDNS_COMMENT_KEY | LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS, NULL
 };
 const ldns_output_format  *ldns_output_format_bubblebabble 
                        = &ldns_output_format_bubblebabble_record;
 
-
-
-
 ldns_status
 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode)
 {
@@ -1160,8 +1157,8 @@ ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
 
 
 ldns_status
-ldns_rr2buffer_str_fmt(
-               ldns_buffer *output, const ldns_rr *rr, const ldns_output_format *fmt)
+ldns_rr2buffer_str_fmt(ldns_buffer *output, 
+               const ldns_output_format *fmt, const ldns_rr *rr)
 {
        uint16_t i, flags;
        ldns_status status = LDNS_STATUS_OK;
@@ -1294,18 +1291,18 @@ ldns_rr2buffer_str_fmt(
 ldns_status
 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
 {
-       return ldns_rr2buffer_str_fmt(output, rr, ldns_output_format_default);
+       return ldns_rr2buffer_str_fmt(output, ldns_output_format_default, rr);
 }
 
 ldns_status
-ldns_rr_list2buffer_str_fmt(
-               ldns_buffer *output, const ldns_rr_list *list, const ldns_output_format *fmt)
+ldns_rr_list2buffer_str_fmt(ldns_buffer *output, 
+               const ldns_output_format *fmt, const ldns_rr_list *list)
 {
        uint16_t i;
 
        for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
-               (void) ldns_rr2buffer_str_fmt(
-                               output, ldns_rr_list_rr(list, i), fmt);
+               (void) ldns_rr2buffer_str_fmt(output, fmt, 
+                               ldns_rr_list_rr(list, i));
        }
        return ldns_buffer_status(output);
 }
@@ -1314,7 +1311,7 @@ ldns_status
 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
 {
        return ldns_rr_list2buffer_str_fmt(
-                       output, list, ldns_output_format_default);
+                       output, ldns_output_format_default, list);
 }
 
 ldns_status
@@ -1370,8 +1367,8 @@ ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
 }
 
 ldns_status
-ldns_pkt2buffer_str_fmt(
-               ldns_buffer *output, const ldns_pkt *pkt, const ldns_output_format *fmt)
+ldns_pkt2buffer_str_fmt(ldns_buffer *output, 
+               const ldns_output_format *fmt, const ldns_pkt *pkt)
 {
        uint16_t i;
        ldns_status status = LDNS_STATUS_OK;
@@ -1396,9 +1393,9 @@ ldns_pkt2buffer_str_fmt(
 
 
                for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
-                       status = ldns_rr2buffer_str_fmt(output,
-                                      ldns_rr_list_rr(ldns_pkt_question(pkt), i),
-                                      fmt);
+                       status = ldns_rr2buffer_str_fmt(output, fmt,
+                                      ldns_rr_list_rr(
+                                              ldns_pkt_question(pkt), i));
                        if (status != LDNS_STATUS_OK) {
                                return status;
                        }
@@ -1407,9 +1404,9 @@ ldns_pkt2buffer_str_fmt(
 
                ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
                for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
-                       status = ldns_rr2buffer_str_fmt(output,
-                                      ldns_rr_list_rr(ldns_pkt_answer(pkt), i),
-                                      fmt);
+                       status = ldns_rr2buffer_str_fmt(output, fmt,
+                                      ldns_rr_list_rr(
+                                              ldns_pkt_answer(pkt), i));
                        if (status != LDNS_STATUS_OK) {
                                return status;
                        }
@@ -1420,9 +1417,9 @@ ldns_pkt2buffer_str_fmt(
                ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
 
                for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
-                       status = ldns_rr2buffer_str_fmt(output,
-                                      ldns_rr_list_rr(ldns_pkt_authority(pkt), i),
-                                      fmt);
+                       status = ldns_rr2buffer_str_fmt(output, fmt,
+                                      ldns_rr_list_rr(
+                                              ldns_pkt_authority(pkt), i));
                        if (status != LDNS_STATUS_OK) {
                                return status;
                        }
@@ -1431,9 +1428,9 @@ ldns_pkt2buffer_str_fmt(
 
                ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
                for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
-                       status = ldns_rr2buffer_str_fmt(output,
-                                      ldns_rr_list_rr(ldns_pkt_additional(pkt), i),
-                                      fmt);
+                       status = ldns_rr2buffer_str_fmt(output, fmt,
+                                      ldns_rr_list_rr(
+                                              ldns_pkt_additional(pkt), i));
                        if (status != LDNS_STATUS_OK) {
                                return status;
                        }
@@ -1469,7 +1466,7 @@ ldns_pkt2buffer_str_fmt(
                if (ldns_pkt_tsig(pkt)) {
                        ldns_buffer_printf(output, ";; TSIG:\n;; ");
                        (void) ldns_rr2buffer_str_fmt(
-                                       output, ldns_pkt_tsig(pkt), fmt);
+                                       output, fmt, ldns_pkt_tsig(pkt));
                        ldns_buffer_printf(output, "\n");
                }
                if (ldns_pkt_answerfrom(pkt)) {
@@ -1493,7 +1490,7 @@ ldns_pkt2buffer_str_fmt(
 ldns_status
 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
 {
-       return ldns_pkt2buffer_str_fmt(output, pkt, ldns_output_format_default);
+       return ldns_pkt2buffer_str_fmt(output, ldns_output_format_default, pkt);
 }
 
 
@@ -1967,7 +1964,7 @@ ldns_rdf2str(const ldns_rdf *rdf)
 }
 
 char *
-ldns_rr2str_fmt(const ldns_rr *rr, const ldns_output_format *fmt)
+ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr)
 {
        char *result = NULL;
        ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
@@ -1975,7 +1972,7 @@ ldns_rr2str_fmt(const ldns_rr *rr, const ldns_output_format *fmt)
        if (!tmp_buffer) {
                return NULL;
        }
-       if (ldns_rr2buffer_str_fmt(tmp_buffer, rr, fmt)
+       if (ldns_rr2buffer_str_fmt(tmp_buffer, fmt, rr)
                        == LDNS_STATUS_OK) {
                /* export and return string, destroy rest */
                result = ldns_buffer2str(tmp_buffer);
@@ -1987,11 +1984,11 @@ ldns_rr2str_fmt(const ldns_rr *rr, const ldns_output_format *fmt)
 char *
 ldns_rr2str(const ldns_rr *rr)
 {
-       return ldns_rr2str_fmt(rr, ldns_output_format_default);
+       return ldns_rr2str_fmt(ldns_output_format_default, rr);
 }
 
 char *
-ldns_pkt2str_fmt(const ldns_pkt *pkt, const ldns_output_format *fmt)
+ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt)
 {
        char *result = NULL;
        ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
@@ -1999,7 +1996,7 @@ ldns_pkt2str_fmt(const ldns_pkt *pkt, const ldns_output_format *fmt)
        if (!tmp_buffer) {
                return NULL;
        }
-       if (ldns_pkt2buffer_str_fmt(tmp_buffer, pkt, fmt)
+       if (ldns_pkt2buffer_str_fmt(tmp_buffer, fmt, pkt)
                        == LDNS_STATUS_OK) {
                /* export and return string, destroy rest */
                result = ldns_buffer2str(tmp_buffer);
@@ -2012,7 +2009,7 @@ ldns_pkt2str_fmt(const ldns_pkt *pkt, const ldns_output_format *fmt)
 char *
 ldns_pkt2str(const ldns_pkt *pkt)
 {
-       return ldns_pkt2str_fmt(pkt, ldns_output_format_default);
+       return ldns_pkt2str_fmt(ldns_output_format_default, pkt);
 }
 
 char *
@@ -2033,7 +2030,7 @@ ldns_key2str(const ldns_key *k)
 }
 
 char *
-ldns_rr_list2str_fmt(const ldns_rr_list *list, const ldns_output_format *fmt)
+ldns_rr_list2str_fmt(const ldns_output_format *fmt, const ldns_rr_list *list)
 {
        char *result = NULL;
        ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
@@ -2043,7 +2040,7 @@ ldns_rr_list2str_fmt(const ldns_rr_list *list, const ldns_output_format *fmt)
        }
        if (list) {
                if (ldns_rr_list2buffer_str_fmt(
-                                  tmp_buffer, list, fmt)
+                                  tmp_buffer, fmt, list)
                                == LDNS_STATUS_OK) {
                }
        } else {
@@ -2064,7 +2061,7 @@ ldns_rr_list2str_fmt(const ldns_rr_list *list, const ldns_output_format *fmt)
 char *
 ldns_rr_list2str(const ldns_rr_list *list)
 {
-       return ldns_rr_list2str_fmt(list, ldns_output_format_default);
+       return ldns_rr_list2str_fmt(ldns_output_format_default, list);
 }
 
 void
@@ -2080,9 +2077,10 @@ ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
 }
 
 void
-ldns_rr_print_fmt(FILE *output, const ldns_rr *rr, const ldns_output_format *fmt)
+ldns_rr_print_fmt(FILE *output, 
+               const ldns_output_format *fmt, const ldns_rr *rr)
 {
-       char *str = ldns_rr2str_fmt(rr, fmt);
+       char *str = ldns_rr2str_fmt(fmt, rr);
        if (str) {
                fprintf(output, "%s", str);
        } else {
@@ -2094,13 +2092,14 @@ ldns_rr_print_fmt(FILE *output, const ldns_rr *rr, const ldns_output_format *fmt
 void
 ldns_rr_print(FILE *output, const ldns_rr *rr)
 {
-       ldns_rr_print_fmt(output, rr, ldns_output_format_default);
+       ldns_rr_print_fmt(output, ldns_output_format_default, rr);
 }
 
 void
-ldns_pkt_print_fmt(FILE *output, const ldns_pkt *pkt, const ldns_output_format *fmt)
+ldns_pkt_print_fmt(FILE *output, 
+               const ldns_output_format *fmt, const ldns_pkt *pkt)
 {
-       char *str = ldns_pkt2str_fmt(pkt, fmt);
+       char *str = ldns_pkt2str_fmt(fmt, pkt);
        if (str) {
                fprintf(output, "%s", str);
        } else {
@@ -2112,26 +2111,28 @@ ldns_pkt_print_fmt(FILE *output, const ldns_pkt *pkt, const ldns_output_format *
 void
 ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
 {
-       ldns_pkt_print_fmt(output, pkt, ldns_output_format_default);
+       ldns_pkt_print_fmt(output, ldns_output_format_default, pkt);
 }
 
 void
-ldns_rr_list_print_fmt(FILE *output, const ldns_rr_list *lst, const ldns_output_format *fmt)
+ldns_rr_list_print_fmt(FILE *output, 
+               const ldns_output_format *fmt, const ldns_rr_list *lst)
 {
        size_t i;
        for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
-               ldns_rr_print_fmt(output, ldns_rr_list_rr(lst, i), fmt);
+               ldns_rr_print_fmt(output, fmt, ldns_rr_list_rr(lst, i));
        }
 }
 
 void
 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
 {
-       ldns_rr_list_print_fmt(output, lst, ldns_output_format_default);
+       ldns_rr_list_print_fmt(output, ldns_output_format_default, lst);
 }
 
 void
-ldns_resolver_print_fmt(FILE *output, const ldns_resolver *r, const ldns_output_format *fmt)
+ldns_resolver_print_fmt(FILE *output, 
+               const ldns_output_format *fmt, const ldns_resolver *r)
 {
        uint16_t i;
        ldns_rdf **n;
@@ -2161,7 +2162,7 @@ ldns_resolver_print_fmt(FILE *output, const ldns_resolver *r, const ldns_output_
        fprintf(output, "dnssec cd: %d\n", ldns_resolver_dnssec_cd(r));
        fprintf(output, "trust anchors (%d listed):\n",
                (int)ldns_rr_list_rr_count(ldns_resolver_dnssec_anchors(r)));
-       ldns_rr_list_print_fmt(output, ldns_resolver_dnssec_anchors(r), fmt);
+       ldns_rr_list_print_fmt(output, fmt, ldns_resolver_dnssec_anchors(r));
        fprintf(output, "tsig: %s %s\n",
                 ldns_resolver_tsig_keyname(r)?ldns_resolver_tsig_keyname(r):"-",
                 ldns_resolver_tsig_algorithm(r)?ldns_resolver_tsig_algorithm(r):"-");
@@ -2199,18 +2200,19 @@ ldns_resolver_print_fmt(FILE *output, const ldns_resolver *r, const ldns_output_
 void
 ldns_resolver_print(FILE *output, const ldns_resolver *r)
 {
-       ldns_resolver_print_fmt(output, r, ldns_output_format_default);
+       ldns_resolver_print_fmt(output, ldns_output_format_default, r);
 }
 
 void
-ldns_zone_print_fmt(FILE *output, const ldns_zone *z, const ldns_output_format *fmt)
+ldns_zone_print_fmt(FILE *output, 
+               const ldns_output_format *fmt, const ldns_zone *z)
 {
        if(ldns_zone_soa(z))
-               ldns_rr_print_fmt(output, ldns_zone_soa(z), fmt);
-       ldns_rr_list_print_fmt(output, ldns_zone_rrs(z), fmt);
+               ldns_rr_print_fmt(output, fmt, ldns_zone_soa(z));
+       ldns_rr_list_print_fmt(output, fmt, ldns_zone_rrs(z));
 }
 void
 ldns_zone_print(FILE *output, const ldns_zone *z)
 {
-       ldns_zone_print_fmt(output, z, ldns_output_format_default);
+       ldns_zone_print_fmt(output, ldns_output_format_default, z);
 }

diff --git a/ldns/dnssec_verify.h b/ldns/dnssec_verify.h
index 07d80f9ba144ddee1b9e50c9556b7c2e1e53618f..992b1e7c300767383d9f84ec414caed4cd9f8391 100644 (file)
--- a/ldns/dnssec_verify.h
+++ b/ldns/dnssec_verify.h
@@ -57,8 +57,8 @@ void ldns_dnssec_data_chain_deep_free(ldns_dnssec_data_chain *chain);
  */
 void ldns_dnssec_data_chain_print(FILE *out, const ldns_dnssec_data_chain *chain);
 void ldns_dnssec_data_chain_print_fmt(FILE *out, 
-               const ldns_dnssec_data_chain *chain, 
-               const ldns_output_format *fmt);
+               const ldns_output_format *fmt,
+               const ldns_dnssec_data_chain *chain);
 
 /**
  * Build an ldns_dnssec_data_chain, which contains all
@@ -166,10 +166,10 @@ void ldns_dnssec_trust_tree_print(FILE *out,
                size_t tabs,
                bool extended);
 void ldns_dnssec_trust_tree_print_fmt(FILE *out,
+               const ldns_output_format *fmt,
                ldns_dnssec_trust_tree *tree,
                size_t tabs,
-               bool extended,
-               const ldns_output_format *fmt);
+               bool extended);
 
 /**
  * Adds a trust tree as a parent for the given trust tree

diff --git a/ldns/dnssec_zone.h b/ldns/dnssec_zone.h
index 9da3d74fc1d6f4f940457be138b6d3484bfd5dd1..8fcaba6172e28003fa8c196368327bfcd9480de3 100644 (file)
--- a/ldns/dnssec_zone.h
+++ b/ldns/dnssec_zone.h
@@ -136,7 +136,7 @@ ldns_status ldns_dnssec_rrs_add_rr(ldns_dnssec_rrs *rrs, ldns_rr *rr);
  */
 void ldns_dnssec_rrs_print(FILE *out, ldns_dnssec_rrs *rrs);
 void ldns_dnssec_rrs_print_fmt(FILE *out, 
-               ldns_dnssec_rrs *rrs, const ldns_output_format *fmt);
+               const ldns_output_format *fmt, ldns_dnssec_rrs *rrs);
 
 /**
  * Creates a new list (entry) of RRsets
@@ -199,9 +199,9 @@ void ldns_dnssec_rrsets_print(FILE *out,
                ldns_dnssec_rrsets *rrsets,
                bool follow);
 void ldns_dnssec_rrsets_print_fmt(FILE *out,
+               const ldns_output_format *fmt,
                ldns_dnssec_rrsets *rrsets,
-               bool follow,
-               const ldns_output_format *fmt);
+               bool follow);
 
 
 /**
@@ -325,7 +325,7 @@ ldns_dnssec_rrsets *ldns_dnssec_zone_find_rrset(ldns_dnssec_zone *zone,
  */
 void ldns_dnssec_name_print(FILE *out, ldns_dnssec_name *name);
 void ldns_dnssec_name_print_fmt(FILE *out, 
-               ldns_dnssec_name *name, const ldns_output_format *fmt);
+               const ldns_output_format *fmt, ldns_dnssec_name *name);
 
 /**
  * Creates a new dnssec_zone structure
@@ -368,8 +368,8 @@ ldns_status ldns_dnssec_zone_add_rr(ldns_dnssec_zone *zone,
  * \param[in] print_soa if true, print SOA records, if false, skip them
  */
 void ldns_dnssec_zone_names_print(FILE *out, ldns_rbtree_t *tree, bool print_soa);
-void ldns_dnssec_zone_names_print_fmt(FILE *out, ldns_rbtree_t *tree, 
-               bool print_soa, const ldns_output_format *fmt);
+void ldns_dnssec_zone_names_print_fmt(FILE *out, const ldns_output_format *fmt,
+               ldns_rbtree_t *tree, bool print_soa);
 
 /**
  * Prints the complete zone to the given file descriptor
@@ -379,7 +379,7 @@ void ldns_dnssec_zone_names_print_fmt(FILE *out, ldns_rbtree_t *tree,
  */
 void ldns_dnssec_zone_print(FILE *out, ldns_dnssec_zone *zone);
 void ldns_dnssec_zone_print_fmt(FILE *out, 
-               ldns_dnssec_zone *zone, const ldns_output_format *fmt);
+               const ldns_output_format *fmt, ldns_dnssec_zone *zone);
 
 /**
  * Adds explicit dnssec_name structures for the empty nonterminals

diff --git a/ldns/host2str.h b/ldns/host2str.h
index d7744743baa0a1ced6348c0864cd88ea9da291c7..07f7c7b5e1241d1557f4a97c2eb7613046be56e6 100644 (file)
--- a/ldns/host2str.h
+++ b/ldns/host2str.h
@@ -39,19 +39,21 @@ extern "C" {
 #define LDNS_APL_MASK           0x7f
 #define LDNS_APL_NEGATION       0x80
 
-#define LDNS_COMMENT_NULLS     0x01
-#define LDNS_COMMENT_KEY_ID    0x02
-#define LDNS_COMMENT_KEY_TYPE  0x04
-#define LDNS_COMMENT_KEY_SIZE  0x08
-#define LDNS_COMMENT_KEY       (LDNS_COMMENT_KEY_ID  \
-                               |LDNS_COMMENT_KEY_TYPE\
-                               |LDNS_COMMENT_KEY_SIZE)
+#define LDNS_COMMENT_NULLS             0x01
+#define LDNS_COMMENT_KEY_ID            0x02
+#define LDNS_COMMENT_KEY_TYPE          0x04
+#define LDNS_COMMENT_KEY_SIZE          0x08
+#define LDNS_COMMENT_KEY               (LDNS_COMMENT_KEY_ID  \
+                                       |LDNS_COMMENT_KEY_TYPE\
+                                       |LDNS_COMMENT_KEY_SIZE)
 #define LDNS_COMMENT_BUBBLEBABBLE      0x10
-#define LDNS_COMMENT_FLAGS     0x20
+#define LDNS_COMMENT_FLAGS             0x20
+#define LDNS_COMMENT_NSEC3_CHAIN       0x40
 
 struct ldns_struct_output_format
 {
-       int flags;
+       int   flags;
+       void *data;
 };
 typedef struct ldns_struct_output_format ldns_output_format;
 
@@ -382,29 +384,8 @@ ldns_status ldns_rdf2buffer_str(ldns_buffer *output, const ldns_rdf *rdf);
  * \return status
  */
 ldns_status ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr);
-
-/**
- * Converts the data in the resource record to presentation
- * format (as char *) and appends it to the given buffer
- *
- * \param[in] output pointer to the buffer to append the data to
- * \param[in] rr the pointer to the rr field to convert
- * \param[in] comments flags indicating what type of comments should
- *            annotate the presentation format. Can be any of
- *            LDNS_COMMENT_NULL (to also indicate an NULL rr,
- *            LDNS_COMMENT_KEY_ID (to show key identity),
- *            LDNS_COMMENT_KEY_TYPE (to show if the key is a ksk or a zsk),
- *            LDNS_COMMENT_KEY_SIZE (to show the key size),
- *            LDNS_COMMENT_KEY (to show all key annotations),
- *            LDNS_COMMENT_BUBBLEBABBLE (to show readable and communicable
- *                                       version of a blob of binary data 
- *                                       (currently only with DS records)),
- *            LDNS_COMMENT_FLAGS (to show what flags are set (currently only
- *                                if optout flag is set with NSEC3 records))
- * \return status
- */
-ldns_status ldns_rr2buffer_str_fmt(
-               ldns_buffer *output, const ldns_rr *rr, const ldns_output_format *fmt);
+ldns_status ldns_rr2buffer_str_fmt(ldns_buffer *output, 
+               const ldns_output_format *fmt, const ldns_rr *rr);
 
 /**
  * Converts the data in the DNS packet to presentation
@@ -415,8 +396,8 @@ ldns_status ldns_rr2buffer_str_fmt(
  * \return status
  */
 ldns_status ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt);
-ldns_status ldns_pkt2buffer_str_fmt(
-               ldns_buffer *output, const ldns_pkt *pkt, const ldns_output_format *fmt);
+ldns_status ldns_pkt2buffer_str_fmt(ldns_buffer *output,
+               const ldns_output_format *fmt, const ldns_pkt *pkt);
 
 /** 
  * Converts an LDNS_RDF_TYPE_NSEC3_SALT rdata element to string format and adds it to the output buffer 
@@ -488,7 +469,7 @@ char *ldns_rdf2str(const ldns_rdf *rdf);
  * \return null terminated char * data, or NULL on error
  */
 char *ldns_rr2str(const ldns_rr *rr);
-char *ldns_rr2str_fmt(const ldns_rr *rr, const ldns_output_format *fmt);
+char *ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr);
 
 /**
  * Converts the data in the DNS packet to presentation format and
@@ -499,7 +480,7 @@ char *ldns_rr2str_fmt(const ldns_rr *rr, const ldns_output_format *fmt);
  * \return null terminated char * data, or NULL on error
  */
 char *ldns_pkt2str(const ldns_pkt *pkt);
-char *ldns_pkt2str_fmt(const ldns_pkt *pkt, const ldns_output_format *fmt);
+char *ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt);
 
 /**
  * Converts a private key to the test presentation fmt and
@@ -520,7 +501,8 @@ char *ldns_key2str(const ldns_key *k);
  * \return null terminated char * data, or NULL on error
  */
 char *ldns_rr_list2str(const ldns_rr_list *rr_list);
-char *ldns_rr_list2str_fmt(const ldns_rr_list *rr_list, const ldns_output_format *fmt);
+char *ldns_rr_list2str_fmt(
+               const ldns_output_format *fmt, const ldns_rr_list *rr_list);
 
 /**
  * Returns the data in the buffer as a null terminated char * string
@@ -550,7 +532,8 @@ void ldns_rdf_print(FILE *output, const ldns_rdf *rdf);
  * \return void
  */
 void ldns_rr_print(FILE *output, const ldns_rr *rr);
-void ldns_rr_print_fmt(FILE *output, const ldns_rr *rr, const ldns_output_format *fmt);
+void ldns_rr_print_fmt(FILE *output, 
+               const ldns_output_format *fmt, const ldns_rr *rr);
 
 /**
  * Prints the data in the DNS packet to the given file stream
@@ -561,7 +544,8 @@ void ldns_rr_print_fmt(FILE *output, const ldns_rr *rr, const ldns_output_format
  * \return void
  */
 void ldns_pkt_print(FILE *output, const ldns_pkt *pkt);
-void ldns_pkt_print_fmt(FILE *output, const ldns_pkt *pkt, const ldns_output_format *fmt);
+void ldns_pkt_print_fmt(FILE *output, 
+               const ldns_output_format *fmt, const ldns_pkt *pkt);
 
 /**
  * Converts a rr_list to presentation format and appends it to
@@ -571,7 +555,8 @@ void ldns_pkt_print_fmt(FILE *output, const ldns_pkt *pkt, const ldns_output_for
  * \return ldns_status
  */
 ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list);
-ldns_status ldns_rr_list2buffer_str_fmt(ldns_buffer *output, const ldns_rr_list *list, const ldns_output_format *fmt);
+ldns_status ldns_rr_list2buffer_str_fmt(ldns_buffer *output, 
+               const ldns_output_format *fmt, const ldns_rr_list *list);
 
 /**
  * Converts the header of a packet to presentation format and appends it to
@@ -588,7 +573,8 @@ ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt);
  * param[in] list the rr_list to print
  */
 void ldns_rr_list_print(FILE *output, const ldns_rr_list *list);
-void ldns_rr_list_print_fmt(FILE *output, const ldns_rr_list *list, const ldns_output_format *fmt);
+void ldns_rr_list_print_fmt(FILE *output, 
+               const ldns_output_format *fmt, const ldns_rr_list *list);
 
 /**
  * Print a resolver (in sofar that is possible) state
@@ -597,7 +583,8 @@ void ldns_rr_list_print_fmt(FILE *output, const ldns_rr_list *list, const ldns_o
  * \param[in] r the resolver to print
  */
 void ldns_resolver_print(FILE *output, const ldns_resolver *r);
-void ldns_resolver_print_fmt(FILE *output, const ldns_resolver *r, const ldns_output_format *fmt);
+void ldns_resolver_print_fmt(FILE *output, 
+               const ldns_output_format *fmt, const ldns_resolver *r);
 
 /**
  * Print a zone structure * to output. Note the SOA record
@@ -606,7 +593,8 @@ void ldns_resolver_print_fmt(FILE *output, const ldns_resolver *r, const ldns_ou
  * \param[in] z the zone to print
  */
 void ldns_zone_print(FILE *output, const ldns_zone *z);
-void ldns_zone_print_fmt(FILE *output, const ldns_zone *z, const ldns_output_format *fmt);
+void ldns_zone_print_fmt(FILE *output, 
+               const ldns_output_format *fmt, const ldns_zone *z);
 
 /**
  * Print the ldns_rdf containing a dname to the buffer