-x works correctly for (parts of) ipv4 ip addresses

diff --git a/dname.c b/dname.c
index f2fd6bdc4e2f1984db2a60e5944628be7dd547c1..16920e479cbc3ed3978970f33d1bedf3a5e5c0c9 100644 (file)
--- a/dname.c
+++ b/dname.c
@@ -22,6 +22,37 @@
 #include <netdb.h>
 #include <arpa/inet.h>
 
+void
+prdf(const ldns_rdf *r)
+{
+       size_t i;
+       for (i=0; i<ldns_rdf_size(r); i++) {
+               if (i>0&&i%20==0) {
+                       printf("\n");
+               }
+               printf("%02x ", ldns_rdf_data(r)[i]);
+       }
+       printf("\n");
+}
+
+void
+pprdf(const char *txt, const ldns_rdf *r)
+{
+       printf("%s: ", txt);
+       ldns_rdf_print(stdout, r);
+       printf("\n");
+       prdf(r);
+       printf("\n");
+}
+
+void
+sprdf(const char *txt, const ldns_rdf *r)
+{
+       printf("%s: ", txt);
+       ldns_rdf_print(stdout, r);
+       printf("\n");
+}
+
 ldns_rdf *
 ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2)
 {
@@ -35,15 +66,15 @@ ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2)
        }
 
        /* we overwrite the nullbyte of rd1 */
-       new_size = ldns_rdf_size(rd1) + ldns_rdf_size(rd2) - 1;
+       new_size = ldns_rdf_size(rd1) + ldns_rdf_size(rd2);
        buf = LDNS_XMALLOC(uint8_t, new_size);
        if (!buf) {
                return NULL;
        }
 
        /* put the two dname's after each other */
-       memcpy(buf, ldns_rdf_data(rd1), ldns_rdf_size(rd1) - 1);
-       memcpy(buf + ldns_rdf_size(rd1) - 1, ldns_rdf_data(rd2), ldns_rdf_size(rd2));
+       memcpy(buf, ldns_rdf_data(rd1), ldns_rdf_size(rd1));
+       memcpy(buf + ldns_rdf_size(rd1), ldns_rdf_data(rd2), ldns_rdf_size(rd2));
        
        new = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, new_size, buf);
 
@@ -54,22 +85,65 @@ ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2)
 ldns_status
 ldns_dname_cat(ldns_rdf *rd1, ldns_rdf *rd2)
 {
+       uint16_t left_size;
        uint16_t size;
 
+/*
+pprdf("CATTING", rd1);
+pprdf("AND", rd2);
+*/
        if (ldns_rdf_get_type(rd1) != LDNS_RDF_TYPE_DNAME ||
                        ldns_rdf_get_type(rd2) != LDNS_RDF_TYPE_DNAME) {
                return LDNS_STATUS_ERR;
        }
 
-       size = ldns_rdf_size(rd1) + ldns_rdf_size(rd2) - 1;
+       /* remove root label if it is present at the end of the left
+        * rd, by reducing the size with 1
+        */
+       left_size = ldns_rdf_size(rd1);
+       if (ldns_rdf_data(rd1)[left_size - 1] == 0) {
+/*
+printf("reducing size, left hand has root\n");
+*/
+               left_size--;
+       }
+
+       size = left_size + ldns_rdf_size(rd2);
+
        ldns_rdf_set_data(rd1, LDNS_XREALLOC(ldns_rdf_data(rd1), uint8_t, size));
-       memcpy(ldns_rdf_data(rd1) + ldns_rdf_size(rd1) - 1, ldns_rdf_data(rd2), 
+       memcpy(ldns_rdf_data(rd1) + left_size, ldns_rdf_data(rd2), 
                        ldns_rdf_size(rd2));
        ldns_rdf_set_size(rd1, size);
 
        return LDNS_STATUS_OK;
 }
 
+ldns_rdf *
+ldns_dname_reverse(const ldns_rdf *d)
+{
+       ldns_rdf *new;
+       ldns_rdf *tmp;
+       ldns_rdf *d_tmp;
+       ldns_status status;
+
+       d_tmp = ldns_rdf_clone(d);
+
+       new = ldns_dname_new_frm_str(".");
+
+       while(ldns_dname_label_count(d_tmp) > 0) {
+               tmp = ldns_dname_label(d_tmp, 0);
+               status = ldns_dname_cat(tmp, new);
+               ldns_rdf_deep_free(new);
+               new = tmp;
+               tmp = ldns_dname_left_chop(d_tmp);
+               ldns_rdf_deep_free(d_tmp);
+               d_tmp = tmp;
+       }
+       ldns_rdf_deep_free(d_tmp);
+
+       return new;
+}
+
 ldns_rdf *
 ldns_dname_left_chop(ldns_rdf *d)
 {

diff --git a/drill/drill.c b/drill/drill.c
index d11c1501f793c584d71482ced505f914115ed0eb..2ef8c344b2ce41a1e16d11c8c322be1ff77d63db 100644 (file)
--- a/drill/drill.c
+++ b/drill/drill.c
@@ -550,13 +550,27 @@ main(int argc, char *argv[])
                        break;
                case DRILL_REVERSE:
                        /* name should be an ip addr */
-                       qname = ldns_rdf_new_addr_frm_str(name);
+                       /*qname = ldns_rdf_new_addr_frm_str(name);*/
+                       /* ipv4 or ipv6 addr? */
+                       if (strchr(name, ':')) {
+                               printf("Reverse lookup for IPv6 not implemented yet, please use normal PTR query for the required address\n");
+                               exit(1);
+                       } else {
+                               qname = ldns_dname_new_frm_str(name);
+                               qname_tmp = ldns_dname_reverse(qname);
+                               ldns_rdf_deep_free(qname);
+                               qname = qname_tmp;
+                               qname_tmp = ldns_dname_new_frm_str("in-addr.arpa.");
+                               status = ldns_dname_cat(qname, qname_tmp);
+                               if (status != LDNS_STATUS_OK) {
+                                       fprintf(stderr, "error creating reverse address for ipv4: %s\n", ldns_get_errorstr_by_id(status));
+                                       exit(status);
+                               }
+                               ldns_rdf_deep_free(qname_tmp);
+                       }
                        if (!qname) {
                                error("%s", "-x implies an ip address");
                        }
-                       qname_tmp = qname;
-                       qname = ldns_rdf_address_reverse(qname);
-                       ldns_rdf_deep_free(qname_tmp);
                        
                        /* create a packet and set the RD flag on it */
                        pkt = ldns_resolver_query(res, qname, type, clas, qflags);

diff --git a/ldns/dname.h b/ldns/dname.h
index db0543ce7ca0821086693500e24fe027833b3fcd..1c3383d392edcfc3dff2b52911e07743ebd34d15 100644 (file)
--- a/ldns/dname.h
+++ b/ldns/dname.h
@@ -25,6 +25,7 @@
  * \return a new rdf with leftside/rightside
  */
 ldns_rdf *ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2);
+
 /**
  * concatenates rd2 after rd1 (rd2 is copied, rd1 is modified)
  * \param[in] rd1 the leftside
@@ -33,6 +34,14 @@ ldns_rdf *ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2);
  */
 ldns_status    ldns_dname_cat(ldns_rdf *rd1, ldns_rdf *rd2);
 
+/**
+ * Returns a clone of the given dname with the labels
+ * reversed
+ * \param[in] d the dname to reverse
+ * \return clone of the dname with the labels reversed.
+ */
+ldns_rdf *ldns_dname_reverse(const ldns_rdf *d);
+
 /**
  * chop one label off the left side of a dname. so 
  * wwww.nlnetlabs.nl, becomes nlnetlabs.nl