removed dname type, back to rdf

diff --git a/ldns/rdata.h b/ldns/rdata.h
index 4bb173d9727739a51c719c58f866f0f0e43bb4fd..f31246132bf64d3d8588139a7d08b78791df9e92 100644 (file)
--- a/ldns/rdata.h
+++ b/ldns/rdata.h
@@ -86,21 +86,6 @@ struct ldns_struct_rdf
 };
 typedef struct ldns_struct_rdf ldns_rdf;
 
-/**
- * \brief type to hold dname's
- *
- * The data is a network ordered array of bytes, which size is specified by
- * the (16-bit) size field. It is always of the LDNS_RDF_TYPE_DNAME
- */
-struct ldns_struct_dname
-{
-       /** \brief The size of the dname (in bytes) */
-       uint16_t _size;
-       /** \brief Pointer to the dname (byte buffer) */
-       void  *_data;
-};
-typedef struct ldns_struct_dname ldns_dname;
-
 /* prototypes */
 uint16_t        ldns_rdf_size(ldns_rdf *);
 void            ldns_rdf_set_size(ldns_rdf *, uint16_t);
@@ -112,12 +97,6 @@ ldns_rdf    *ldns_rdf_new_frm_data(uint16_t, ldns_rdf_type, void *);
 uint8_t         *ldns_rdf_data(ldns_rdf *);
 void            ldns_rdf_free(ldns_rdf *);
 void            ldns_rdf_free_data(ldns_rdf *);
-ldns_dname     *ldns_dname_new_frm_str(const char *);
-ldns_dname     *ldns_dname_new(uint16_t s, void *data);
-uint16_t       ldns_dname_size(ldns_dname *name);
-void *         ldns_dname_data(ldns_dname *name);
-void           ldns_dname_set_size(ldns_dname *name, uint16_t size);
-void           ldns_dname_set_data(ldns_dname *name, void *data);
 ldns_rdf       *ldns_rdf_new_frm_str(const char *, ldns_rdf_type);
 
 #endif /* !_LDNS_RDATA_H */

diff --git a/ldns/resolver.h b/ldns/resolver.h
index 22a4ed60b519de83e8f4a2d3e767e6acc42f301e..e8dabae040e6ae1362a5b4c999e52c3f27a0027a 100644 (file)
--- a/ldns/resolver.h
+++ b/ldns/resolver.h
@@ -40,10 +40,10 @@ struct ldns_struct_resolver
        uint8_t _debug;
        
        /** \brief Default domain to add */
-       ldns_dname *_domain; 
+       ldns_rdf *_domain; 
 
        /** \brief Searchlist array */
-       ldns_dname **_searchlist;
+       ldns_rdf **_searchlist;
        size_t _searchlist_count;
 
        /** \brief How many retries */
@@ -68,22 +68,22 @@ uint16_t ldns_resolver_port(ldns_resolver *);
 /* ldns_rr_list * ldns_resolver_nameservers(ldns_resolver *) pop>? */
 uint8_t ldns_resolver_recursive(ldns_resolver *);
 uint8_t ldns_resolver_debug(ldns_resolver *);
-ldns_dname * ldns_resolver_domain(ldns_resolver *);
-ldns_dname ** ldns_resolver_searchlist(ldns_resolver *);
-ldns_dname ** ldns_resolver_nameservers(ldns_resolver *);
+ldns_rdf * ldns_resolver_domain(ldns_resolver *);
+ldns_rdf ** ldns_resolver_searchlist(ldns_resolver *);
+ldns_rdf ** ldns_resolver_nameservers(ldns_resolver *);
 
 void ldns_resolver_set_port(ldns_resolver *, uint16_t);
 void ldns_resolver_set_recursive(ldns_resolver *, uint8_t);
 void ldns_resolver_set_debug(ldns_resolver *, uint8_t);
 
-ldns_status ldns_resolver_set_domain(ldns_resolver *, ldns_dname *);
-ldns_status ldns_resolver_push_searchlist(ldns_resolver *, ldns_dname *);
+ldns_status ldns_resolver_set_domain(ldns_resolver *, ldns_rdf *);
+ldns_status ldns_resolver_push_searchlist(ldns_resolver *, ldns_rdf *);
 ldns_status ldns_resolver_push_nameserver(ldns_resolver *, ldns_rdf *);
 
 ldns_pkt * ldns_resolver_search();
 ldns_pkt * ldns_resolver_query();
 ldns_pkt * ldns_resolver_bgsend();
-ldns_pkt * ldns_resolver_send(ldns_resolver *, ldns_dname*, ldns_rr_type, ldns_rr_class);
+ldns_pkt * ldns_resolver_send(ldns_resolver *, ldns_rdf*, ldns_rr_type, ldns_rr_class);
 
 ldns_resolver *ldns_resolver_new(void);
 

diff --git a/ldns/rr.h b/ldns/rr.h
index 3bae604cd5866a6a2f0e7488668a3d2ba70f6bd4..20d9e1ba70962ebde42d6984681f0791a95e88ba 100644 (file)
--- a/ldns/rr.h
+++ b/ldns/rr.h
@@ -161,7 +161,7 @@ typedef enum ldns_enum_rr_type ldns_rr_type;
 struct ldns_struct_rr
 {
        /** \brief Owner name, uncompressed */
-       ldns_dname      *_owner;        
+       ldns_rdf        *_owner;        
        /** \brief Time to live  */
        uint32_t        _ttl;   
        /** \brief Number of data fields */
@@ -214,14 +214,14 @@ typedef struct ldns_struct_rr_descriptor ldns_rr_descriptor;
  * \param none 
  */
 ldns_rr * ldns_rr_new(void);
-void ldns_rr_set_owner(ldns_rr *, ldns_dname *);
+void ldns_rr_set_owner(ldns_rr *, ldns_rdf *);
 void ldns_rr_set_ttl(ldns_rr *, uint32_t);
 void ldns_rr_set_rd_count(ldns_rr *, uint16_t);
 void ldns_rr_set_type(ldns_rr *, ldns_rr_type);
 void ldns_rr_set_class(ldns_rr *, ldns_rr_class);
 bool ldns_rr_push_rdf(ldns_rr *, ldns_rdf *);
 ldns_rdf *ldns_rr_rdf(ldns_rr *rr, uint16_t nr);
-ldns_dname *ldns_rr_owner(ldns_rr *);
+ldns_rdf *ldns_rr_owner(ldns_rr *);
 uint32_t ldns_rr_ttl(ldns_rr *);
 uint16_t ldns_rr_rd_count(ldns_rr *);
 ldns_rr_type ldns_rr_get_type(ldns_rr *);

diff --git a/ldns/str2host.h b/ldns/str2host.h
index 2a89079bf2fcccbde173d7b0706cc6d1d03a38c2..9b5fd4e886ab3f6534eb50d590cfc6c2ac6b0d6c 100644 (file)
--- a/ldns/str2host.h
+++ b/ldns/str2host.h
@@ -32,6 +32,6 @@ ldns_status ldns_str2rdf_loc(ldns_rdf **, const uint8_t*);
 ldns_status ldns_str2rdf_wks(ldns_rdf **, const uint8_t*);
 ldns_status ldns_str2rdf_nsap(ldns_rdf **, const uint8_t*);
 
-ldns_status ldns_str2rdf_dname(ldns_dname **, const uint8_t*);
+ldns_status ldns_str2rdf_dname(ldns_rdf **, const uint8_t*);
 
 #endif

diff --git a/rdata.c b/rdata.c
index a1f254cfb12f28fa95950ca13d73b40101748586..37b6c5c216af5621d268c31756d122ee37de42a8 100644 (file)
--- a/rdata.c
+++ b/rdata.c
@@ -196,83 +196,6 @@ ldns_rdf_free(ldns_rdf *rd)
        FREE(rd);
 }
 
-/**
- * Create a new ldns_dname from a string
- * \param[in] str string to use
- * \return ldns_dname*
- */
-ldns_dname *
-ldns_dname_new_frm_str(const char *str)
-{
-       ldns_dname *d;
-       if (ldns_str2rdf_dname(&d, (const uint8_t*) str) != LDNS_STATUS_OK) {
-               return NULL ;
-       }
-       return d;
-}
-
-uint16_t
-ldns_dname_size(ldns_dname *name)
-{
-       return name->_size;
-}
-
-void *
-ldns_dname_data(ldns_dname *name)
-{
-       return name->_data;
-}
-
-void
-ldns_dname_set_size(ldns_dname *name, uint16_t size)
-{
-       name->_size = size;
-}
-
-void
-ldns_dname_set_data(ldns_dname *name, void *data)
-{
-       name->_data = data;
-}
-
-/**
- * Allocate a new dname structure and fill it.
- * This function _does_ copy the contents from
- * the buffer, unlinke ldns_rdf_new()
- * \param[in] s size of the buffer
- * \param[in] buf pointer to the buffer to be copied
- * \return the new dname structure or NULL on failure
- */
-ldns_dname *
-ldns_dname_new_frm_data(uint16_t s, void *buf)
-{
-       ldns_dname *d;
-       d = MALLOC(ldns_dname);
-       if (!d) {
-               return NULL;
-       }
-       d->_data = XMALLOC(uint8_t, s);
-       if (!d->_data) {
-               return NULL;
-       }
-       d->_size = s;
-       memcpy(d->_data, buf, s);
-       return d;
-}
-
-/**
- * free a rdf structure _and_ free the
- * data. rdf should be created with _new_frm_data
- * \param[in] rd the rdf structure to be freed
- * \return void
- */
-void
-ldns_dname_free_data(ldns_dname *d)
-{
-       FREE(d->_data);
-       FREE(d);
-}
-
 /**
  * Create a new rdf from a string
  * \param[in] str string to use

diff --git a/resolver.c b/resolver.c
index 6342a9f847091c43acdb95f1c6dd7c747b30f9db..b90587149b7f2d42e717d238b3a285099cbf10dc 100644 (file)
--- a/resolver.c
+++ b/resolver.c
@@ -55,13 +55,13 @@ ldns_resolver_configured(ldns_resolver *r)
        return r->_configured;
 }
 
-ldns_dname *
+ldns_rdf *
 ldns_resolver_domain(ldns_resolver *r)
 {
        return r->_domain;
 }
 
-ldns_dname **
+ldns_rdf **
 ldns_resolver_searchlist(ldns_resolver *r)
 {
        return r->_searchlist;
@@ -113,7 +113,7 @@ ldns_resolver_set_debug(ldns_resolver *r, uint8_t d)
 }
 
 ldns_status
-ldns_resolver_set_domain(ldns_resolver *r, ldns_dname *d)
+ldns_resolver_set_domain(ldns_resolver *r, ldns_rdf *d)
 {
        r->_domain = d;
        return LDNS_STATUS_OK;
@@ -121,7 +121,7 @@ ldns_resolver_set_domain(ldns_resolver *r, ldns_dname *d)
 
 /* this is not the way to go for the search list XXX */
 ldns_status
-ldns_resolver_push_searchlist(ldns_resolver *r, ldns_dname *d)
+ldns_resolver_push_searchlist(ldns_resolver *r, ldns_rdf *d)
 {
        r->_searchlist[++r->_searchlist_count] = d;
        return LDNS_STATUS_OK;
@@ -159,7 +159,7 @@ ldns_resolver_new(void)
 
        r = MALLOC(ldns_resolver);
 
-       r->_searchlist = XMALLOC(ldns_dname *, 3);
+       r->_searchlist = XMALLOC(ldns_rdf *, 3);
        r->_nameservers = XMALLOC(ldns_rdf *, 3);
        
        r->_configured = 0; /* no config has happened yet */
@@ -195,7 +195,7 @@ ldns_resolver_query()
  * \return ldns_pkt* a packet with the reply from the nameserver
  */
 ldns_pkt *
-ldns_resolver_send(ldns_resolver *r, ldns_dname *name, ldns_rr_type type, ldns_rr_class class)
+ldns_resolver_send(ldns_resolver *r, ldns_rdf *name, ldns_rr_type type, ldns_rr_class class)
 {
        ldns_pkt *query_pkt;
        ldns_pkt *answer_pkt;

diff --git a/rr.c b/rr.c
index 413eb552edc6156bf25402f20bdc47d57b1e3be4..020d402f68f502e02d8b98074ea53eeccd8109af 100644 (file)
--- a/rr.c
+++ b/rr.c
@@ -59,7 +59,7 @@ ldns_rr_free(ldns_rr *rr)
  * \return void
  */
 void
-ldns_rr_set_owner(ldns_rr *rr, ldns_dname *owner)
+ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner)
 {
        rr->_owner = owner;
 }
@@ -163,7 +163,7 @@ ldns_rr_rdf(ldns_rr *rr, uint16_t nr)
  * \param[in] *rr rr to operate on
  * \return ldns_rdf * 
  */
-ldns_dname *
+ldns_rdf *
 ldns_rr_owner(ldns_rr *rr)
 {
        return rr->_owner;

diff --git a/run-test4.c b/run-test4.c
index 2aa07f1a181b64aff259f401f9d86a087c24369d..dbeccfc44b12d8ec1226e116b23f9d61665695e5 100644 (file)
--- a/run-test4.c
+++ b/run-test4.c
@@ -13,8 +13,8 @@ int
 main(void)
 {       
         ldns_resolver *res;
-        ldns_dname *default_dom;
-        ldns_dname *qname;
+        ldns_rdf *default_dom;
+        ldns_rdf *qname;
         ldns_rdf *nameserver;
         ldns_pkt *pkt;
                 
@@ -24,7 +24,7 @@ main(void)
                 return 1;
 
         /* create a default domain and add it */
-        default_dom = ldns_dname_new_frm_str("miek.nl.");
+        default_dom = ldns_rdf_new_frm_str("miek.nl.", LDNS_RDF_TYPE_DNAME);
         nameserver  = ldns_rdf_new_frm_str("127.0.0.1", LDNS_RDF_TYPE_A);
                 
         if (ldns_resolver_set_domain(res, default_dom) != LDNS_STATUS_OK)
@@ -33,7 +33,7 @@ main(void)
                 return 1;
         
         /* setup the question */
-        qname = ldns_dname_new_frm_str("www");
+        qname = ldns_rdf_new_frm_str("www", LDNS_RDF_TYPE_DNAME);
         
         /* fire it off. "miek.nl." will be added */
         pkt = ldns_resolver_send(res, qname, LDNS_RR_TYPE_MX, 0);

diff --git a/str2host.c b/str2host.c
index e3d5da5cb8038bf0fc2afb2b9ddd5a4bbd7d94f0..5beb4daa3134cbecaa8dd4619fd77e77eebec949 100644 (file)
--- a/str2host.c
+++ b/str2host.c
@@ -144,7 +144,7 @@ ldns_str2rdf_int8(ldns_rdf **rd, const uint8_t *bytestr)
  * label_chars2 is used for debugging. TODO: remove
  */
 ldns_status
-ldns_str2rdf_dname(ldns_dname **d, const uint8_t* str)
+ldns_str2rdf_dname(ldns_rdf **d, const uint8_t* str)
 {
        unsigned int label_chars;
        unsigned int label_chars2;
@@ -194,7 +194,7 @@ ldns_str2rdf_dname(ldns_dname **d, const uint8_t* str)
        *q = '\00'; /* end the string */
 
        /* s - buf_str works because no magic is done * in the above for-loop */
-       *d = ldns_dname_new_frm_data((s - buf_str + 1) , buf); 
+       *d = ldns_rdf_new_frm_data((s - buf_str + 1) , LDNS_RDF_TYPE_DNAME , buf); 
        return LDNS_STATUS_OK;
 }
 

diff --git a/wire2host.c b/wire2host.c
index 8d9d3acfc41355f73c82e90a0eb42304a2da5210..5f6710251548cdc1417be39c939e4dded2fdb3f6 100644 (file)
--- a/wire2host.c
+++ b/wire2host.c
@@ -213,7 +213,8 @@ ldns_wire2dname(ldns_rdf **dname, const uint8_t *wire, size_t max, size_t *pos)
        }
        memcpy(dname_ar, tmp_dname, dname_pos);
        
-       *dname = ldns_rdf_new((uint16_t) dname_pos, LDNS_RDF_TYPE_DNAME,
+       *dname = ldns_rdf_new((uint16_t) dname_pos,
+                             LDNS_RDF_TYPE_DNAME,
                              dname_ar);
        if (!*dname) {
                FREE(dname_ar);