added wire2host & host2str support for some basic types and WKS

diff --git a/host2str.c b/host2str.c
index 85703eaab9f9d99b280a19b264b2667f783677a8..3a785cd7aef168c291bc7f21e52b3d17e84014fb 100644 (file)
--- a/host2str.c
+++ b/host2str.c
@@ -16,6 +16,7 @@
 
 #include <sys/socket.h>
 #include <arpa/inet.h>
+#include <netdb.h>
 
 #include <ldns/host2str.h>
 
@@ -119,7 +120,7 @@ ldns_rdf2buffer_int32(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 /** 
- * convert A address 
+ * Converts A address 
  */
 ldns_status
 ldns_rdf2buffer_a(ldns_buffer *output, ldns_rdf *rdf)
@@ -133,7 +134,7 @@ ldns_rdf2buffer_a(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 /** 
- * convert AAAA address 
+ * converts AAAA address 
  */
 ldns_status
 ldns_rdf2buffer_aaaa(ldns_buffer *output, ldns_rdf *rdf)
@@ -147,6 +148,9 @@ ldns_rdf2buffer_aaaa(ldns_buffer *output, ldns_rdf *rdf)
        return ldns_buffer_status(output);
 }
 
+/**
+ * Converts TXT rdata
+ */
 ldns_status
 ldns_rdf2buffer_str(ldns_buffer *output, ldns_rdf *rdf)
 {
@@ -170,6 +174,107 @@ ldns_rdf2buffer_str(ldns_buffer *output, ldns_rdf *rdf)
        return ldns_buffer_status(output);
 }
 
+/**
+ * Converts Base 64 encoded data
+ */
+ldns_status
+ldns_rdf2buffer_b64(ldns_buffer *output, ldns_rdf *rdf)
+{
+       ldns_buffer_printf(output, "%s", ldns_rdf_data(rdf));
+       return ldns_buffer_status(output);
+}      
+
+/**
+ * Converts Hex encoded data
+ */
+ldns_status
+ldns_rdf2buffer_hex(ldns_buffer *output, ldns_rdf *rdf)
+{
+       ldns_buffer_printf(output, "%s", ldns_rdf_data(rdf));
+       return ldns_buffer_status(output);
+}      
+
+/**
+ * Converts type encoded data
+ */
+ldns_status
+ldns_rdf2buffer_type(ldns_buffer *output, ldns_rdf *rdf)
+{
+        uint8_t data = ldns_rdf_data(rdf)[0];
+       const ldns_rr_descriptor *descriptor;
+
+       descriptor = ldns_rr_descript(data);
+       if (descriptor->_name) {
+               ldns_buffer_printf(output, "%s", descriptor->_name);
+       } else {
+               ldns_buffer_printf(output, "TYPE%u", data);
+       }
+       return ldns_buffer_status(output);
+}      
+
+/**
+ * Converts class encoded data
+ */
+ldns_status
+ldns_rdf2buffer_class(ldns_buffer *output, ldns_rdf *rdf)
+{
+        uint8_t data = ldns_rdf_data(rdf)[0];
+       ldns_lookup_table *lt;
+
+       lt = ldns_lookup_by_id(ldns_rr_classes, (int) data);
+       if (lt) {
+               ldns_buffer_printf(output, "\t%s", lt->name);
+       } else {
+               ldns_buffer_printf(output, "\tCLASS%d", data);
+       }
+       return ldns_buffer_status(output);
+}      
+
+ldns_status
+ldns_rdf2buffer_wks(ldns_buffer *output, ldns_rdf *rdf)
+{
+       /* protocol, followed by bitmap of services */
+       struct protoent *protocol;
+       char *proto_name = NULL;
+       uint8_t protocol_nr;
+       struct servent *service;
+       uint16_t current_service;
+
+       protocol_nr = ldns_rdf_data(rdf)[0];
+       protocol = getprotobynumber((int) protocol_nr);
+       if (protocol && (protocol->p_name != NULL)) {
+               proto_name = protocol->p_name;
+               ldns_buffer_printf(output, "%s ", protocol->p_name);
+       } else {
+               ldns_buffer_printf(output, "%u ", protocol_nr);
+       }
+
+       for (current_service = 0; 
+            current_service <= ldns_rdf_size(rdf) * 8;
+            current_service++) {
+               if (get_bit_r(&(ldns_rdf_data(rdf)[1]), current_service)) {
+                       service = getservbyport(ntohs(current_service),
+                                               proto_name);
+                       if (service && service->s_name) {
+                               ldns_buffer_printf(output, "%s ", 
+                                                  service->s_name);
+                       } else {
+                               ldns_buffer_printf(output, "%u ",
+                                                  current_service);
+                       }
+               }
+       }
+       return ldns_buffer_status(output);
+}
+
+ldns_status
+ldns_rdf2buffer_todo(ldns_buffer *output, ldns_rdf *rdf)
+{
+       (void) ldns_rdf_data(rdf);
+       ldns_buffer_printf(output, "todo: '%s'\n", ldns_rdf2str(rdf));
+       return ldns_buffer_status(output);
+}
+
 /**
  * Returns string representation of the specified rdf
  * Data is not static
@@ -194,37 +299,56 @@ ldns_rdf2buffer(ldns_buffer *buffer, ldns_rdf *rdf)
        case LDNS_RDF_TYPE_INT32:
                res = ldns_rdf2buffer_int32(buffer, rdf);
                break;
+        case LDNS_RDF_TYPE_TSIGTIME:
+                res = ldns_rdf2buffer_todo(buffer, rdf);
+                break;
        case LDNS_RDF_TYPE_A:
                res = ldns_rdf2buffer_a(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_AAAA:
+               res = ldns_rdf2buffer_aaaa(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_STR:
                res = ldns_rdf2buffer_str(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_APL:
+               res = ldns_rdf2buffer_todo(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_B64:
+               res = ldns_rdf2buffer_b64(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_HEX:
+               res = ldns_rdf2buffer_hex(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_NSEC: 
+               res = ldns_rdf2buffer_todo(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_TYPE: 
+               res = ldns_rdf2buffer_type(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_CLASS:
+               res = ldns_rdf2buffer_class(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_CERT:
+               res = ldns_rdf2buffer_todo(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_ALG:
+               res = ldns_rdf2buffer_todo(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_UNKNOWN:
+               res = ldns_rdf2buffer_todo(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_TIME:
+               res = ldns_rdf2buffer_todo(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_SERVICE:
+               res = ldns_rdf2buffer_todo(buffer, rdf);
                break;
        case LDNS_RDF_TYPE_LOC:
+               res = ldns_rdf2buffer_todo(buffer, rdf);
+               break;
+       case LDNS_RDF_TYPE_WKS:
+               res = ldns_rdf2buffer_wks(buffer, rdf);
                break;
        }
 

diff --git a/ldns/rdata.h b/ldns/rdata.h
index 2303bfc8d78ec7c72c916c76865bc90665cfe25c..3e45887e1816fd502007701a29bcc3b49463b702 100644 (file)
--- a/ldns/rdata.h
+++ b/ldns/rdata.h
@@ -79,7 +79,9 @@ enum ldns_enum_rdf_type
        /** protocol and port bitmaps */
        LDNS_RDF_TYPE_SERVICE,
        /** location data */
-       LDNS_RDF_TYPE_LOC
+       LDNS_RDF_TYPE_LOC,
+       /** well known services */
+       LDNS_RDF_TYPE_WKS
 };
 typedef enum ldns_enum_rdf_type ldns_rdf_type;
 

diff --git a/rr.c b/rr.c
index 7e24f5151fd2ffb4462b6bfd5cf027e86dbef25f..f7bfce7346a07986f65ada70bdf957f10974fe83 100644 (file)
--- a/rr.c
+++ b/rr.c
@@ -266,7 +266,7 @@ static const ldns_rdf_type type_mb_wireformat[] = { LDNS_RDF_TYPE_DNAME };
 static const ldns_rdf_type type_mg_wireformat[] = { LDNS_RDF_TYPE_DNAME };
 static const ldns_rdf_type type_mr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
 static const ldns_rdf_type type_wks_wireformat[] = {
-       LDNS_RDF_TYPE_A, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_SERVICE
+       LDNS_RDF_TYPE_A, LDNS_RDF_TYPE_WKS
 };
 static const ldns_rdf_type type_ptr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
 static const ldns_rdf_type type_hinfo_wireformat[] = {
@@ -433,7 +433,7 @@ static ldns_rr_descriptor rdata_field_descriptors[] = {
        /* 46 */
        {LDNS_RR_TYPE_RRSIG, "RRSIG", 9, 9, type_rrsig_wireformat, LDNS_RDF_TYPE_NONE },
        /* 47 */
-       {LDNS_RR_TYPE_NSEC, "NSEC", 2, 2, type_nsec_wireformat, LDNS_RDF_TYPE_NONE },
+       {LDNS_RR_TYPE_NSEC, "NSEC", 2, 2, type_nsec_wireformat, LDNS_RDF_TYPE_NSEC },
        /* 48 */
        {LDNS_RR_TYPE_DNSKEY, "DNSKEY", 4, 4, type_dnskey_wireformat, LDNS_RDF_TYPE_NONE }
 };

diff --git a/util.c b/util.c
index b103717be6a6140a3716b711464042fde742344c..02c9e11e0d3443461a6b88c1676ba42265f708d8 100644 (file)
--- a/util.c
+++ b/util.c
@@ -64,3 +64,24 @@ ldns_lookup_by_id(ldns_lookup_table *table, int id)
        return NULL;
 }
 
+int 
+get_bit(uint8_t bits[], size_t index)
+{
+       /*
+        * The bits are counted from left to right, so bit #0 is the
+        * left most bit.
+        */
+       return (int) (bits[index / 8] & (1 << (7 - index % 8)));
+}
+
+
+int 
+get_bit_r(uint8_t bits[], size_t index)
+{
+       /*
+        * The bits are counted from right to left, so bit #0 is the
+        * right most bit.
+        */
+       return (int) bits[index / 8] & (1 << (index % 8));
+}
+

diff --git a/util.h b/util.h
index a3850d3a747a806ebb96f57ce040123ff10212bf..50fcc0f3e6a2c48755900286e05d8029f40ccb53 100644 (file)
--- a/util.h
+++ b/util.h
@@ -39,7 +39,7 @@
 #define FREE(ptr) \
        do { free((ptr)); (ptr) = NULL; } while (0)
 
-#define DEP     printf("DEPRICATED FUNCTION!\n");
+#define DEP     printf("DEPRECATED FUNCTION!\n");
 
 /*
  * Copy data allowing for unaligned accesses in network byte order
@@ -118,4 +118,19 @@ ldns_lookup_table *ldns_lookup_by_name(ldns_lookup_table table[],
  */
 ldns_lookup_table *ldns_lookup_by_id(ldns_lookup_table table[], int id);
 
+/**
+ * Returns the value of the specified bit
+ * The bits are counted from left to right, so bit #0 is the
+ * left most bit.
+ */
+int get_bit(uint8_t bits[], size_t index);
+
+
+/**
+ * Returns the value of the specified bit
+ * The bits are counted from right to left, so bit #0 is the
+ * right most bit.
+ */
+int get_bit_r(uint8_t bits[], size_t index);
+
 #endif /* !_UTIL_H */

diff --git a/wire2host.c b/wire2host.c
index c3fc317f411e08ab3c04a5b415313459df03a8c9..cd8aae325adb5dc00c27d2daf0bc1f0b713a3d48 100644 (file)
--- a/wire2host.c
+++ b/wire2host.c
@@ -316,8 +316,12 @@ ldns_wire2rdf(ldns_rr *rr, const uint8_t *wire,
                case LDNS_RDF_TYPE_UNKNOWN:
                case LDNS_RDF_TYPE_SERVICE:
                case LDNS_RDF_TYPE_LOC:
+               case LDNS_RDF_TYPE_WKS:
                case LDNS_RDF_TYPE_NONE:
-                       cur_rdf_length = (size_t) rd_length;
+                       /*
+                        * Read to end of rr rdata
+                        */
+                       cur_rdf_length = end - *pos;
                        break;
                }
                /* fixed length rdata */
@@ -371,6 +375,7 @@ ldns_wire2rr(ldns_rr **rr_p, const uint8_t *wire, size_t max,
        }
 
        *rr_p = rr;
+
        return LDNS_STATUS_OK;
        
        status_error: