tried to debug some network code

Some further drill modifications to allow secure trace to work

diff --git a/dnssec.c b/dnssec.c
index 0f98b0049a5941a1e765d00155d7347263585e2b..09ca33f424955acc4876a5d23036f81d892b5333 100644 (file)
--- a/dnssec.c
+++ b/dnssec.c
@@ -87,6 +87,10 @@ ldns_verify(ldns_rr_list *rrset, ldns_rr_list *rrsig, ldns_rr_list *keys, ldns_r
 
        valid = false;
 
+       if (ldns_rr_list_rr_count(rrset) < 1) {
+               return LDNS_STATUS_ERR;
+       }
+
        if (ldns_rr_list_rr_count(rrsig) < 1) {
                return LDNS_STATUS_CRYPTO_NO_RRSIG;
        }

diff --git a/drill/drill_util.c b/drill/drill_util.c
index 8cff7bec1227817d3dc2893c74b87f5b3a61fad6..fc8ef4028e70d0b4a032f9721baf7eeafc60b809 100644 (file)
--- a/drill/drill_util.c
+++ b/drill/drill_util.c
@@ -86,28 +86,59 @@ print_ds_of_keys(ldns_pkt *p)
        }
 }
 
-/* print some of the elements of a signature */
-void
-print_rrsig_abbr(FILE *fp, ldns_rr *sig) {
+static void
+print_class_type(FILE *fp, ldns_rr *r)
+{
        ldns_lookup_table *lt;
-       if (!sig) {
+        lt = ldns_lookup_by_id(ldns_rr_classes, ldns_rr_get_class(r));
+        if (lt) {
+                       fprintf(fp, " %s", lt->name);
+        } else {
+               fprintf(fp, " CLASS%d", ldns_rr_get_class(r));
+        }
+       /* okay not THE way - but the quickest */
+       switch (ldns_rr_get_type(r)) {
+               case LDNS_RR_TYPE_RRSIG:
+                       fprintf(fp, " RRSIG ");
+                       break;
+               case LDNS_RR_TYPE_DNSKEY:
+                       fprintf(fp, " DNSKEY ");
+                       break;
+               case LDNS_RR_TYPE_DS:
+                       fprintf(fp, " DS ");
+                       break;
+               default:
+                       break;
+       }
+}
+
+
+void
+print_ds_abbr(FILE *fp, ldns_rr *ds)
+{
+       if (!ds || (ldns_rr_get_type(ds) != LDNS_RR_TYPE_DS)) {
                return;
        }
 
-       if (ldns_rr_get_type(sig) != LDNS_RR_TYPE_RRSIG) {
+       ldns_rdf_print(fp, ldns_rr_owner(ds));
+       fprintf(fp, " %d", (int)ldns_rr_ttl(ds));
+       print_class_type(fp, ds);
+       ldns_rdf_print(fp, ldns_rr_rdf(ds, 0)); fprintf(fp, " ");
+       ldns_rdf_print(fp, ldns_rr_rdf(ds, 1)); fprintf(fp, " ");
+       ldns_rdf_print(fp, ldns_rr_rdf(ds, 2)); fprintf(fp, " ");
+       ldns_rdf_print(fp, ldns_rr_rdf(ds, 3)); fprintf(fp, " ");
+}
+
+/* print some of the elements of a signature */
+void
+print_rrsig_abbr(FILE *fp, ldns_rr *sig) {
+       if (!sig || (ldns_rr_get_type(sig) != LDNS_RR_TYPE_RRSIG)) {
                return;
        }
 
        ldns_rdf_print(fp, ldns_rr_owner(sig));
        fprintf(fp, " %d", (int)ldns_rr_ttl(sig));
-
-        lt = ldns_lookup_by_id(ldns_rr_classes, ldns_rr_get_class(sig));
-        if (lt) {
-                       fprintf(fp, " %s", lt->name);
-        } else {
-               fprintf(fp, " CLASS%d", ldns_rr_get_class(sig));
-        }
-       fprintf(fp, " RRSIG ");
+       print_class_type(fp, sig);
 
        /* print a number of rdf's */
        /* typecovered */
@@ -126,39 +157,16 @@ print_rrsig_abbr(FILE *fp, ldns_rr *sig) {
        ldns_rdf_print(fp, ldns_rr_rdf(sig, 7));
 }
 
-void
-print_rrsig_list_abbr(FILE *fp, ldns_rr_list *sig)
-{
-       size_t i;
-
-       for(i = 0; i < ldns_rr_list_rr_count(sig); i++) {
-               print_rrsig_abbr(fp, ldns_rr_list_rr(sig, i));
-               fputs("\n", fp);
-       }
-}
-
 void
 print_dnskey_abbr(FILE *fp, ldns_rr *key)
 {
-       ldns_lookup_table *lt;
-        if (!key) {
-                return;
-        }
-
-        if (ldns_rr_get_type(key) != LDNS_RR_TYPE_DNSKEY) {
+        if (!key || (ldns_rr_get_type(key) != LDNS_RR_TYPE_DNSKEY)) {
                 return;
         }
 
         ldns_rdf_print(fp, ldns_rr_owner(key));
         fprintf(fp, " %d", (int)ldns_rr_ttl(key));
-
-        lt = ldns_lookup_by_id(ldns_rr_classes, ldns_rr_get_class(key));
-        if (lt) {
-                fprintf(fp, " %s", lt->name);
-        } else {
-                fprintf(fp, " CLASS%d", ldns_rr_get_class(key));
-        }
-        fprintf(fp, " DNSKEY ");
+       print_class_type(fp, key);
 
         /* print a number of rdf's */
         /* flags */
@@ -182,13 +190,46 @@ print_dnskey_abbr(FILE *fp, ldns_rr *key)
                        (int)ldns_rr_dnskey_key_size(key));
 }
 
+
+void
+print_rrsig_list_abbr(FILE *fp, ldns_rr_list *sig, char *usr)
+{
+       size_t i;
+
+       for(i = 0; i < ldns_rr_list_rr_count(sig); i++) {
+               print_rrsig_abbr(fp, ldns_rr_list_rr(sig, i));
+               if (usr) {
+                       fprintf(fp, "%s", usr);
+               }
+               fputs("\n", fp);
+       }
+}
+
 void
-print_dnskey_list_abbr(FILE *fp, ldns_rr_list *key)
+print_dnskey_list_abbr(FILE *fp, ldns_rr_list *key, char *usr)
 {
        size_t i;
 
        for(i = 0; i < ldns_rr_list_rr_count(key); i++) {
                print_dnskey_abbr(fp, ldns_rr_list_rr(key, i));
+               if (usr) {
+                       fprintf(fp, "%s", usr);
+               }
+               fputs("\n", fp);
+       }
+}
+
+/* need extra arg to put something after the RR's */
+void
+print_ds_list_abbr(FILE *fp, ldns_rr_list *ds, char *usr)
+{
+       size_t i;
+
+       for(i = 0; i < ldns_rr_list_rr_count(ds); i++) {
+               print_ds_abbr(fp, ldns_rr_list_rr(ds, i));
+               if (usr) {
+                       fprintf(fp, "%s", usr);
+               }
                fputs("\n", fp);
        }
 }

diff --git a/drill/drill_util.h b/drill/drill_util.h
index 2e5e72a89b7d51a6f41006d1b75a9e9206153c06..c4c8f4f41a53306acb543a28ef1891c7355cab3d 100644 (file)
--- a/drill/drill_util.h
+++ b/drill/drill_util.h
@@ -27,21 +27,27 @@ void print_ds_of_keys(ldns_pkt *p);
  * print some rdfs of a signature
  */
 void print_rrsig_abbr(FILE *fp, ldns_rr *sig);
-
 /**
- * print some rdfs of a signature list
+ * print some rdfs of a dnskey
  */
-void print_rrsig_list_abbr(FILE *fp, ldns_rr_list *sig);
-
+void print_dnskey_abbr(FILE *fp, ldns_rr *key);
 /**
- * print some rdfs of a dnskey
+ * print some rdfs of a ds
  */
-void print_dnskey_abbr(FILE *fp, ldns_rr *sig);
+void print_ds_abbr(FILE *fp, ldns_rr *ds);
 
 /**
  * print some rdfs of a dnskey list
  */
-void print_dnskey_list_abbr(FILE *fp, ldns_rr_list *sig);
+void print_dnskey_list_abbr(FILE *fp, ldns_rr_list *sig, char *usr);
+/**
+ * print some rdfs of a signature list
+ */
+void print_rrsig_list_abbr(FILE *fp, ldns_rr_list *sig, char *usr);
+/**
+ * print some rdfs of a ds list
+ */
+void print_ds_list_abbr(FILE *fp, ldns_rr_list *sig, char *usr);
 
 /**
  * Alloc some memory, with error checking

diff --git a/drill/securetrace.c b/drill/securetrace.c
index d46e64af02f5477866081a7f3528a25b7761feee..98c00ab3216b5244516800a516c746af01037b2a 100644 (file)
--- a/drill/securetrace.c
+++ b/drill/securetrace.c
@@ -80,9 +80,9 @@ check_ds_key_equiv_rr_list(ldns_rr_list *key, ldns_rr_list *ds)
 static ldns_rr_list *
 get_dnssec_rr(ldns_resolver *r, ldns_rdf *name, ldns_rr_type t, ldns_rr_list **sig)
 {
-       ldns_pkt *p;
-       ldns_rr_list *rr;
-       ldns_rr_list *sigs;
+       ldns_pkt *p = NULL;
+       ldns_rr_list *rr = NULL;
+       ldns_rr_list *sigs = NULL;
 
        /* ldns_resolver_set_dnssec(r, true); */
 
@@ -90,9 +90,10 @@ get_dnssec_rr(ldns_resolver *r, ldns_rdf *name, ldns_rr_type t, ldns_rr_list **s
        if (!p) {
                return NULL;
        }
+       /* ldns_pkt_print(stdout, p); */
 
        rr = ldns_pkt_rr_list_by_name_and_type(p, name, t, LDNS_SECTION_ANSWER);
-       /* there must be a sig there too... */
+       /* there SHOULD be a sig there too... */
        sigs = ldns_pkt_rr_list_by_name_and_type(p, name, LDNS_RR_TYPE_RRSIG, 
                        LDNS_SECTION_ANSWER);
 
@@ -147,8 +148,7 @@ do_secure_trace(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t,
        ldns_rr_list *sig_list;
        ldns_rr_list *ds_list;
 
-       ldns_rr_list *validated_key;  /* keys that are cryptographic 'good' */
-       ldns_rr_list *validated_ds;   /* ds that are cryptographic 'good' */
+       ldns_rr_list *validated;  /* stuff (DNSKEY/DS) that are cryptographic 'good' */
 
        secure = true;
        authname = NULL;
@@ -162,11 +162,9 @@ do_secure_trace(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t,
        res = ldns_resolver_new();
        sig_list = ldns_rr_list_new();
 
-       validated_key = ldns_rr_list_new();
-       validated_ds  = ldns_rr_list_new();
-
+       validated = ldns_rr_list_new();
 
-       if (!p || !res || !sig_list) {
+       if (!p || !res || !sig_list || !validated) {
                error("Memory allocation failed");
                return NULL;
        }
@@ -288,26 +286,31 @@ do_secure_trace(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t,
                key_list = get_key(res, authname, &sig_list);
 
                if (key_list) {
-                       if (ldns_verify(key_list, sig_list, key_list, NULL) == LDNS_STATUS_OK) {
-                               ldns_rr_list_push_rr_list(key_list, validated_key);
-                               printf(";; DNSSEC RRs\n");
-                               print_dnskey_list_abbr(stdout, key_list); 
-                               print_rrsig_list_abbr(stdout, sig_list); 
 
-                       } else {
-                               printf(";; DNSSEC RRs\n");
-                               print_dnskey_list_abbr(stdout, key_list);
-                               /*
-                               printf(";; RRSIG RRs\n");
-                               print_rrsig_list_abbr(stdout, sig_list); 
-                               */
+
+               
+                       printf(";; DNSSEC RRs\n");
+                       print_dnskey_list_abbr(stdout, key_list, NULL); 
+                       print_rrsig_list_abbr(stdout, sig_list, NULL); 
+                       print_rrsig_list_abbr(stdout, validated, NULL); 
+#if 0
+                       if (sig_list) {
+                       if (ldns_verify(key_list, sig_list, key_list, validated) ==
+                                       LDNS_STATUS_OK) {
+                               print_dnskey_list_abbr(stdout, validated, "[Validated]"); 
+                       }
                        }
+#endif
 
-                       ds_list = get_ds(res, authname, &sig_list);
                } else {
                        printf(";; No DNSSEC RRs found, not attemping validation\n");
                }
 
+               ds_list = get_ds(res, authname, &sig_list);
+               if (ds_list) {
+                       print_ds_list_abbr(stdout, ds_list, NULL);
+               }
+
                /* /DNSSEC */
 
 
@@ -367,38 +370,30 @@ do_secure_trace(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t,
                labels[i] = ldns_dname_left_chop(labels[i - 1]);
        }
 
+               /* DNSSEC */
        /* recurse on the name at this server */
        for(i = (ssize_t)labels_count_current - 1; i >= 0; i--) {
 
-               /* DNSSEC */
                key_list = get_key(res, labels[i], &sig_list);
+               ds_list = get_ds(res, labels[i], &sig_list);
                if (key_list) {
-                       if (ldns_verify(key_list, sig_list, key_list, NULL) == LDNS_STATUS_OK) {
-                               ldns_rr_list_push_rr_list(key_list, validated_key);
-                               printf(";; DNSSEC RRs\n");
-                               print_dnskey_list_abbr(stdout, key_list); 
-                               print_rrsig_list_abbr(stdout, sig_list); 
-
-                       } else {
-                               printf(";; DNSSEC RRs\n");
-                               print_dnskey_list_abbr(stdout, key_list); 
-                               /*
-                                  printf(";; RRSIG RRs\n");
-                                  print_rrsig_list_abbr(stdout, sig_list); puts("");
-                                  */
-                       }
-
-                       ds_list = get_ds(res, labels[i], &sig_list);
+                       printf(";; DNSSEC RRs\n");
+                       print_dnskey_list_abbr(stdout, key_list, NULL); 
+                       print_rrsig_list_abbr(stdout, sig_list, NULL); 
                } else {
                        printf(";; No DNSSEC RRs found, not attemping validation\n");
                }
+               if (ds_list) {
+                       print_ds_list_abbr(stdout, ds_list, NULL);
+
+               }
 
-               /* /DNSSEC */
                ldns_rr_list_deep_free(sig_list);
                sig_list = ldns_rr_list_new();
                puts("");
                
        }
+       /* /DNSSEC */
 
        
 #if 0

diff --git a/net.c b/net.c
index 89d6fb7c887abc36d18abf4a5ffa9741ba343916..c2d28a4a076715b404815c6296b12525ccf07fd8 100644 (file)
--- a/net.c
+++ b/net.c
@@ -347,8 +347,7 @@ ldns_udp_read_wire(int sockfd, size_t *size, struct sockaddr_storage *from,
                if (fromlen) {
                        *fromlen = flen;
                }
-               dprintf("from len %d\n", (int)flen);
-       } 
+       }
 
        /* recvfrom can also return 0 */
        if (wire_size == -1 || wire_size == 0) {
@@ -497,8 +496,6 @@ ldns_rdf2native_sockaddr_storage(const ldns_rdf *rd, uint16_t port, size_t *size
         }
 }
 
-/* code from rdata.c */
-/* the other way around - for lua-ldns */
 ldns_rdf *
 ldns_sockaddr_storage2rdf(struct sockaddr_storage *sock, uint16_t *port)
 {