sync arg order rdf_new and rdf_new_frm_data

diff --git a/TODO b/TODO
index ad193fb4e0028e9ae8b531ff8caab39a1cd9bbbb..3cd31df34c94481a4f3c4e29c735e025d8050f10 100644 (file)
--- a/TODO
+++ b/TODO
@@ -3,7 +3,6 @@ Current TODO list
 
 Implementation:
 ---------------
-o sync argument order in rdf_new and rdf_new_frm_data 
 o deep free
 o check all conversion routines on missing types
        - wire2host

diff --git a/dnssec.c b/dnssec.c
index 268aae121450bbb29ce47cfc5750f5ebce5b016f..29667ac3db43cfb69c5830f120554f926bdcd05a 100644 (file)
--- a/dnssec.c
+++ b/dnssec.c
@@ -619,7 +619,7 @@ ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data, ui
                return LDNS_STATUS_INVALID_B64;
        }
 
-       time_signed_rdf = ldns_rdf_new(6, LDNS_RDF_TYPE_TSIGTIME, time_signed);
+       time_signed_rdf = ldns_rdf_new(LDNS_RDF_TYPE_TSIGTIME, 6, time_signed);
        
        fudge_rdf = ldns_native2rdf_int16(LDNS_RDF_TYPE_INT16, fudge);
 

diff --git a/host2str.c b/host2str.c
index 739cabe4c6cc7fbe6ac9da7f8d63d57eeabe906c..be49d6f2e1498c68a46f8b52793b2fb36c2a1096 100644 (file)
--- a/host2str.c
+++ b/host2str.c
@@ -681,14 +681,16 @@ ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, ldns_rdf *rdf)
                        /* no gateway */
                        break;
                case 1:
-                       gateway_data = XMALLOC(uint8_t, 4);
-                       memcpy(gateway_data, &data[offset], 4);
-                       gateway = ldns_rdf_new(4, LDNS_RDF_TYPE_A, gateway_data);
+                       gateway_data = XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
+                       memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
+                       gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, 
+                                       LDNS_IP4ADDRLEN , gateway_data);
                        break;
                case 2:
-                       gateway_data = XMALLOC(uint8_t, 16);
-                       memcpy(gateway_data, &data[offset], 16);
-                       gateway = ldns_rdf_new(16, LDNS_RDF_TYPE_AAAA, gateway_data);
+                       gateway_data = XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
+                       memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
+                       gateway = ldns_rdf_new(LDNS_RDF_TYPE_AAAA, 
+                                       LDNS_IP6ADDRLEN, gateway_data);
                        break;
                case 3:
                        status = ldns_wire2dname(&gateway, data, ldns_rdf_size(rdf), &offset);
@@ -701,7 +703,7 @@ ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, ldns_rdf *rdf)
        public_key_size = ldns_rdf_size(rdf) - offset;
        public_key_data = XMALLOC(uint8_t, public_key_size);
        memcpy(public_key_data, &data[offset], public_key_size);
-       public_key = ldns_rdf_new(public_key_size, LDNS_RDF_TYPE_B64, public_key_data);
+       public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, public_key_size, public_key_data);
        
        ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type,
                           algorithm);

diff --git a/ldns/rdata.h b/ldns/rdata.h
index 2fc101ee0ac12091aeb2e119fbdcebb04066acf1..03e70903c76191e3c14cea4a2a0ce7c40fa2a840 100644 (file)
--- a/ldns/rdata.h
+++ b/ldns/rdata.h
@@ -105,7 +105,7 @@ void            ldns_rdf_set_size(ldns_rdf *, uint16_t);
 void            ldns_rdf_set_type(ldns_rdf *, ldns_rdf_type);
 void            ldns_rdf_set_data(ldns_rdf *, void *);
 ldns_rdf_type   ldns_rdf_get_type(const ldns_rdf *);
-ldns_rdf       *ldns_rdf_new(uint16_t, ldns_rdf_type, void *);
+ldns_rdf       *ldns_rdf_new(ldns_rdf_type, uint16_t, void *);
 ldns_rdf       *ldns_rdf_new_frm_data(ldns_rdf_type, uint16_t, const void *);
 ldns_rdf       *ldns_rdf_new_frm_str(ldns_rdf_type, const char *);
 ldns_status     ldns_octet(char *word, size_t *length);

diff --git a/rdata.c b/rdata.c
index d556a2c6a683a04e71d5998f914dcc0def9f88de..e63e4330baf297cd7810115fa6182314a1b7ef46 100644 (file)
--- a/rdata.c
+++ b/rdata.c
@@ -190,7 +190,7 @@ ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value)
 {
        uint16_t *rdf_data = XMALLOC(uint16_t, 1);
        write_uint16(rdf_data, value);
-       return ldns_rdf_new(2, type, rdf_data);
+       return ldns_rdf_new(type, 2, rdf_data);
 }
 
 /**
@@ -204,7 +204,7 @@ ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value)
 {
        uint32_t *rdf_data = XMALLOC(uint32_t, 1);
        write_uint32(rdf_data, value);
-       return ldns_rdf_new(4, type, rdf_data);
+       return ldns_rdf_new(type, 4, rdf_data);
 }
 
 /**
@@ -219,7 +219,7 @@ ldns_native2rdf_int16_data(uint16_t size, uint8_t *data)
        uint8_t *rdf_data = XMALLOC(uint8_t, (size_t) size + 2);
        write_uint16(rdf_data, size);
        memcpy(rdf_data + 2, data, size);
-       return ldns_rdf_new(size + 2, LDNS_RDF_TYPE_INT16_DATA, rdf_data);
+       return ldns_rdf_new(LDNS_RDF_TYPE_INT16_DATA, size + 2, rdf_data);
 }
 
 /**
@@ -227,7 +227,7 @@ ldns_native2rdf_int16_data(uint16_t size, uint8_t *data)
  * fill it and return it
  */
 ldns_rdf *
-ldns_rdf_new(uint16_t s, ldns_rdf_type t, void *d)
+ldns_rdf_new(ldns_rdf_type t, uint16_t s, void *d)
 {
        ldns_rdf *rd;
        rd = MALLOC(ldns_rdf);
@@ -277,8 +277,8 @@ ldns_rdf *
 ldns_rdf_deep_clone(const ldns_rdf *r)
 {
        return (ldns_rdf_new_frm_data(
-                               ldns_rdf_get_type(r),
                                ldns_rdf_size(r), 
+                               ldns_rdf_get_type(r),
                                ldns_rdf_data(r)));
 }
 

diff --git a/run-test0.c b/run-test0.c
index b8fb9bdfd5809f0642fc24ed2ccf0f2229714bc1..ec7f0acaff8b8945771b5ffe46ca4557291092e6 100644 (file)
--- a/run-test0.c
+++ b/run-test0.c
@@ -65,7 +65,7 @@ main(void)
        rdf_data[9] = 3;
        memcpy(rdf_data+10, "net", 3);
        rdf_data[13] = 0;
-       rd_f = ldns_rdf_new(20, LDNS_RDF_TYPE_DNAME, rdf_data);
+       rd_f = ldns_rdf_new(LDNS_RDF_TYPE_DNAME, 20, rdf_data);
        
        ldns_rr_push_rdf(rr, rd_f);
        status = ldns_wire2pkt(&packet, wire, sizeof(wire));

diff --git a/wire2host.c b/wire2host.c
index 8653c779ea58b74f8053755376d0d2dcdae676ee..26d7b74d144c667e43ef1aea58c5aaf82b262383 100644 (file)
--- a/wire2host.c
+++ b/wire2host.c
@@ -210,9 +210,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_ar);
+       *dname = ldns_rdf_new(LDNS_RDF_TYPE_DNAME, 
+                       (uint16_t) dname_pos, dname_ar);
        if (!*dname) {
                FREE(dname_ar);
                return LDNS_STATUS_MEM_ERR;
@@ -352,8 +351,8 @@ printf("\n");
                        }
                        memcpy(data, &wire[*pos], cur_rdf_length);
                        
-                       cur_rdf = ldns_rdf_new(cur_rdf_length,
-                                              cur_rdf_type,
+                       cur_rdf = ldns_rdf_new(cur_rdf_type,
+                                              cur_rdf_length,
                                               data);
                        *pos = *pos + cur_rdf_length;
                }