knot_rdata_* changes

The _t isn't uint8_t* anymore but a structure with .len and .data.

diff --git a/daemon/lua/kres-gen.lua b/daemon/lua/kres-gen.lua
index e00ecb5e21b74a19631760619424bbeabe0e5fd8..4f271090fbd764f39f47175fa0bbc6050a7d62cf 100644 (file)
--- a/daemon/lua/kres-gen.lua
+++ b/daemon/lua/kres-gen.lua
@@ -254,8 +254,6 @@ _Bool knot_dname_is_sub(const knot_dname_t *, const knot_dname_t *);
 int knot_dname_labels(const uint8_t *, const uint8_t *);
 int knot_dname_size(const knot_dname_t *);
 char *knot_dname_to_str(char *, const knot_dname_t *, size_t);
-uint16_t knot_rdata_rdlen(const knot_rdata_t *);
-uint8_t *knot_rdata_data(const knot_rdata_t *);
 size_t knot_rdata_array_size(uint16_t);
 knot_rdata_t *knot_rdataset_at(const knot_rdataset_t *, size_t);
 int knot_rdataset_merge(knot_rdataset_t *, const knot_rdataset_t *, knot_mm_t *);

diff --git a/daemon/lua/kres-gen.sh b/daemon/lua/kres-gen.sh
index 2eb40b6f0c5e3f3e295cfb42b73e2760b346f218..c02b28f8da79beb4c5d10897e22feb736d7145ca 100755 (executable)
--- a/daemon/lua/kres-gen.sh
+++ b/daemon/lua/kres-gen.sh
@@ -105,8 +105,6 @@ printf "\tchar _stub[];\n};\n"
        knot_dname_size
        knot_dname_to_str
 # Resource records
-       knot_rdata_rdlen
-       knot_rdata_data
        knot_rdata_array_size
        knot_rdataset_at
        knot_rdataset_merge

diff --git a/daemon/lua/kres.lua b/daemon/lua/kres.lua
index ecf2676727364fa51a08f38f02d5937fb9433149..16a5f493119e89d515274995b81870e68fd0e1f8 100644 (file)
--- a/daemon/lua/kres.lua
+++ b/daemon/lua/kres.lua
@@ -373,7 +373,7 @@ ffi.metatype( knot_rrset_t, {
                rdata = function(rr, i)
                        assert(ffi.istype(knot_rrset_t, rr))
                        local rdata = knot.knot_rdataset_at(rr.rrs, i)
-                       return ffi.string(knot.knot_rdata_data(rdata), knot.knot_rdata_rdlen(rdata))
+                       return ffi.string(rdata.data, rdata.len)
                end,
                get = function(rr, i)
                        assert(ffi.istype(knot_rrset_t, rr))

diff --git a/lib/cache/api.c b/lib/cache/api.c
index 0fedc22c14c0e7e48887d267a1f49bfb792fb401..63fe1caf76689dad774ebd9a626380e3ffc564d7 100644 (file)
--- a/lib/cache/api.c
+++ b/lib/cache/api.c
@@ -475,19 +475,18 @@ static ssize_t stash_rrset(struct kr_cache *cache, const struct kr_query *qry,
                }
 
                assert(rr->type == KNOT_RRTYPE_NSEC3);
-               const knot_rdata_t *np_data = knot_rdata_data(rr->rrs.data);
-               const int rdlen = knot_rdata_rdlen(rr->rrs.data);
-               if (rdlen <= 4) return kr_error(EILSEQ); /*< data from outside; less trust */
-               const int np_dlen = nsec_p_rdlen(np_data);
-               if (np_dlen > rdlen) return kr_error(EILSEQ);
-               key = key_NSEC3(k, encloser, nsec_p_mkHash(np_data));
+               const knot_rdata_t * const rdata = rr->rrs.data;
+               if (rdata->len <= 4) return kr_error(EILSEQ); /*< data from outside; less trust */
+               const int np_dlen = nsec_p_rdlen(rdata->data);
+               if (np_dlen > rdata->len) return kr_error(EILSEQ);
+               key = key_NSEC3(k, encloser, nsec_p_mkHash(rdata->data));
                if (npp && !*npp) {
                        *npp = mm_alloc(&qry->request->pool, np_dlen);
                        if (!*npp) {
                                assert(!ENOMEM);
                                break;
                        }
-                       memcpy(*npp, np_data, np_dlen);
+                       memcpy(*npp, rdata->data, np_dlen);
                }
                break;
        default:

diff --git a/lib/cache/entry_rr.c b/lib/cache/entry_rr.c
index 7d3f13b22af92e8d95320979adc3337efb030ee2..34c133135ada87ee4551b72a4841265a90e794b6 100644 (file)
--- a/lib/cache/entry_rr.c
+++ b/lib/cache/entry_rr.c
@@ -34,10 +34,10 @@ int rdataset_dematerialize(const knot_rdataset_t *rds, uint8_t * restrict data)
 
        knot_rdata_t *rd = rds ? rds->data : NULL;
        for (int i = 0; i < rr_count; ++i, rd = kr_rdataset_next(rd)) {
-               const uint16_t len = knot_rdata_rdlen(rd);
+               const uint16_t len = rd->len;
                memcpy(data, &len, sizeof(len));
                data += sizeof(len);
-               memcpy(data, knot_rdata_data(rd), len);
+               memcpy(data, rd->data, len);
                data += len;
        }
        //return data - data0;

diff --git a/lib/dnssec.c b/lib/dnssec.c
index 568ad63badae2b2b469848d647c89b8c2d06157a..14e37f681b6a407f1916f06fd6dd3dcf84983c0d 100644 (file)
--- a/lib/dnssec.c
+++ b/lib/dnssec.c
@@ -181,7 +181,7 @@ static int kr_rrset_validate_with_key(kr_rrset_validation_ctx_t *vctx,
        if (key == NULL) {
                const knot_rdata_t *krr = knot_rdataset_at(&keys->rrs, key_pos);
                int ret = kr_dnssec_key_from_rdata(&created_key, keys->owner,
-                                              knot_rdata_data(krr), knot_rdata_rdlen(krr));
+                                                  krr->data, krr->len);
                if (ret != 0) {
                        vctx->result = ret;
                        return vctx->result;
@@ -292,14 +292,14 @@ int kr_dnskeys_trusted(kr_rrset_validation_ctx_t *vctx, const knot_rrset_t *ta)
         */
        for (uint16_t i = 0; i < keys->rrs.rr_count; ++i) {
                /* RFC4035 5.3.1, bullet 8 */ /* ZSK */
+               /* LATER(optim.): more efficient way to iterate than _at() */
                const knot_rdata_t *krr = knot_rdataset_at(&keys->rrs, i);
-               const uint8_t *key_data = knot_rdata_data(krr);
-               if (!kr_dnssec_key_zsk(key_data) || kr_dnssec_key_revoked(key_data)) {
+               if (!kr_dnssec_key_zsk(krr->data) || kr_dnssec_key_revoked(krr->data)) {
                        continue;
                }
                
                struct dseckey *key = NULL;
-               if (kr_dnssec_key_from_rdata(&key, keys->owner, key_data, knot_rdata_rdlen(krr)) != 0) {
+               if (kr_dnssec_key_from_rdata(&key, keys->owner, krr->data, krr->len) != 0) {
                        continue;
                }
                if (kr_authenticate_referral(ta, (dnssec_key_t *) key) != 0) {

diff --git a/lib/dnssec/nsec3.c b/lib/dnssec/nsec3.c
index ef0944bbb53259329164fed538024d9914ef5716..19bc74efa8ac44787c8d3c88ead28573c69f7808 100644 (file)
--- a/lib/dnssec/nsec3.c
+++ b/lib/dnssec/nsec3.c
@@ -55,9 +55,9 @@ static int nsec3_parameters(dnssec_nsec3_params_t *params, const knot_rrset_t *n
        const size_t SALT_OFFSET = 5; /* First 5 octets contain { Alg, Flags, Iterations, Salt length } */
        dnssec_binary_t rdata = {
                .size = SALT_OFFSET + (size_t) knot_nsec3_salt_length(&nsec3->rrs, 0),
-               .data = knot_rdata_data(rr),
+               .data = /*const-cast*/(uint8_t *)rr->data,
        };
-       if (rdata.size > knot_rdata_rdlen(rr))
+       if (rdata.size > rr->len)
                return kr_error(EMSGSIZE);
 
        int ret = dnssec_nsec3_params_from_rdata(params, &rdata);

diff --git a/lib/dnssec/signature.c b/lib/dnssec/signature.c
index 928520f16bca3b07292ae6edcb3f8443aaa5b8dc..934792c51503328ddb53e0ed051341e586873c03 100644 (file)
--- a/lib/dnssec/signature.c
+++ b/lib/dnssec/signature.c
@@ -67,14 +67,14 @@ int kr_authenticate_referral(const knot_rrset_t *ref, const dnssec_key_t *key)
        knot_rdata_t *rd = ref->rrs.data;
        for (uint16_t i = 0; i < ref->rrs.rr_count; ++i) {
                dnssec_binary_t ds_rdata = {
-                       .size = knot_rdata_rdlen(rd),
-                       .data = knot_rdata_data(rd)
+                       .size = rd->len,
+                       .data = rd->data
                };
                ret = authenticate_ds(key, &ds_rdata, knot_ds_digest_type(&ref->rrs, i));
                if (ret == 0) { /* Found a good DS */
                        return kr_ok();
                }
-               rd = kr_rdataset_next(rd);
+               rd = knot_rdataset_next(rd);
        }
 
        return kr_error(ret);
@@ -287,10 +287,9 @@ int kr_check_signature(const knot_rrset_t *rrsigs, size_t pos,
        }
 
        uint32_t orig_ttl = knot_rrsig_original_ttl(&rrsigs->rrs, pos);
-       const knot_rdata_t *rr_data = knot_rdataset_at(&rrsigs->rrs, pos);
-       uint8_t *rdata = knot_rdata_data(rr_data);
+       const knot_rdata_t *rd = knot_rdataset_at(&rrsigs->rrs, pos);
 
-       if (sign_ctx_add_data(sign_ctx, rdata, covered, orig_ttl, trim_labels) != 0) {
+       if (sign_ctx_add_data(sign_ctx, rd->data, covered, orig_ttl, trim_labels) != 0) {
                ret = kr_error(ENOMEM);
                goto fail;
        }

diff --git a/lib/layer/iterate.c b/lib/layer/iterate.c
index 84b728139fbbe7a672041ae46683a5f73076a1ff..2c10013ac58546d9dfccff6a63a4d4fb146ce2c1 100644 (file)
--- a/lib/layer/iterate.c
+++ b/lib/layer/iterate.c
@@ -158,19 +158,17 @@ static int update_nsaddr(const knot_rrset_t *rr, struct kr_query *query, int *gl
 {
        if (rr->type == KNOT_RRTYPE_A || rr->type == KNOT_RRTYPE_AAAA) {
                const knot_rdata_t *rdata = rr->rrs.data;
-               const void *addr = knot_rdata_data(rdata);
-               const int addr_len = knot_rdata_rdlen(rdata);
                char name_str[KR_DNAME_STR_MAXLEN];
                char addr_str[INET6_ADDRSTRLEN];
                WITH_VERBOSE(query) {
-                       const int af = (addr_len == sizeof(struct in_addr)) ?
+                       const int af = (rdata->len == sizeof(struct in_addr)) ?
                                       AF_INET : AF_INET6;
                        knot_dname_to_str(name_str, rr->owner, sizeof(name_str));
                        name_str[sizeof(name_str) - 1] = 0;
-                       inet_ntop(af, addr, addr_str, sizeof(addr_str));
+                       inet_ntop(af, rdata->data, addr_str, sizeof(addr_str));
                }
                if (!(query->flags.ALLOW_LOCAL) &&
-                       !is_valid_addr(addr, addr_len)) {
+                       !is_valid_addr(rdata->data, rdata->len)) {
                        QVERBOSE_MSG(query, "<= ignoring invalid glue for "
                                     "'%s': '%s'\n", name_str, addr_str);
                        return KR_STATE_CONSUME; /* Ignore invalid addresses */

diff --git a/lib/utils.h b/lib/utils.h
index ba60ce46481081e49b6802bd428c6ff7c336d6d6..4a222cc93bbbec8886714b062a13ed39ea278703 100644 (file)
--- a/lib/utils.h
+++ b/lib/utils.h
@@ -184,8 +184,6 @@ typedef array_t(ranked_rr_array_entry_t *) ranked_rr_array_t;
 
 /** @internal RDATA array maximum size. */
 #define RDATA_ARR_MAX (UINT16_MAX + sizeof(uint64_t))
-/** @internal Next RDATA shortcut. */
-#define kr_rdataset_next(rd) (rd + knot_rdata_array_size(knot_rdata_rdlen(rd)))
 
 /** Concatenate N strings. */
 KR_EXPORT

diff --git a/lib/zonecut.c b/lib/zonecut.c
index d578132ab72db4bf98f155c1afe0d9ccb255e508..8ba28a9ac9bfdeac4fafe0a5f7992be25ab04fab 100644 (file)
--- a/lib/zonecut.c
+++ b/lib/zonecut.c
@@ -184,17 +184,15 @@ int kr_zonecut_add(struct kr_zonecut *cut, const knot_dname_t *ns, const knot_rd
                return kr_ok();
        }
        /* Check for duplicates */
-       uint16_t rdlen = knot_rdata_rdlen(rdata);
-       uint8_t *raw_addr = knot_rdata_data(rdata);
-       if (pack_obj_find(*pack, raw_addr, rdlen)) {
+       if (pack_obj_find(*pack, rdata->data, rdata->len)) {
                return kr_ok();
        }
        /* Push new address */
-       int ret = pack_reserve_mm(**pack, 1, rdlen, kr_memreserve, cut->pool);
+       int ret = pack_reserve_mm(**pack, 1, rdata->len, kr_memreserve, cut->pool);
        if (ret != 0) {
                return kr_error(ENOMEM);
        }
-       return pack_obj_push(*pack, raw_addr, rdlen);
+       return pack_obj_push(*pack, rdata->data, rdata->len);
 }
 
 int kr_zonecut_del(struct kr_zonecut *cut, const knot_dname_t *ns, const knot_rdata_t *rdata)
@@ -211,7 +209,7 @@ int kr_zonecut_del(struct kr_zonecut *cut, const knot_dname_t *ns, const knot_rd
        }
        /* Remove address from the pack. */
        if (rdata) {
-               ret = pack_obj_del(pack, knot_rdata_data(rdata), knot_rdata_rdlen(rdata));
+               ret = pack_obj_del(pack, rdata->data, rdata->len);
        }
        /* No servers left, remove NS from the set. */
        if (pack->len == 0) {
@@ -306,7 +304,7 @@ static void fetch_addr(struct kr_zonecut *cut, struct kr_cache *cache,
        knot_rdata_t *rd = cached_rr.rrs.data;
        for (uint16_t i = 0; i < cached_rr.rrs.rr_count; ++i) {
                (void) kr_zonecut_add(cut, ns, rd);
-               rd = kr_rdataset_next(rd);
+               rd = knot_rdataset_next(rd);
        }
 }
 

diff --git a/modules/priming/priming.lua b/modules/priming/priming.lua
index 6f05d7fdbf2db8c7f7d2483859e06742ea175902..917f201f3bc8d6fa5b83ff22ed19700146701a67 100644 (file)
--- a/modules/priming/priming.lua
+++ b/modules/priming/priming.lua
@@ -1,6 +1,5 @@
 -- Module interface
 local ffi = require('ffi')
-local knot = ffi.load(libknot_SONAME)
 
 local priming = {}
 priming.retry_time = 10 * sec -- retry time when priming fail
@@ -51,9 +50,7 @@ local function address_callback(pkt, req)
                        local rr = section[i]
                        if rr.type == kres.type.A or rr.type == kres.type.AAAA then
                                for k = 0, rr.rrs.rr_count-1 do
-                                       local rdata = knot.knot_rdataset_at(rr.rrs, k)
-                                       rdata = ffi.string(rdata, knot.knot_rdata_array_size(knot.knot_rdata_rdlen(rdata)))
-                                       table.insert(internal.nsset[rr:owner()], rdata)
+                                       table.insert(internal.nsset[rr:owner()], rr.rrs:rdata(k))
                                end
                        end
                end

diff --git a/tests/test.h b/tests/test.h
index 8f06db568e24fcfe170d77c7af46e8b78fb27dc8..5526cfd8e1d0e096101f0f962ca3561268323270 100644 (file)
--- a/tests/test.h
+++ b/tests/test.h
@@ -99,6 +99,7 @@ static inline void test_random_rr(knot_rrset_t *rr, uint32_t ttl)
 {
        static uint8_t owner_buf[KNOT_DNAME_MAXLEN];
        static uint8_t rdata_buf[65535];
+       knot_rdata_t *rdata = (knot_rdata_t *)rdata_buf;
 
        uint16_t num = rand() % (sizeof(owner_buf) - 2);
        uint8_t tmp_buf[KNOT_DNAME_MAXLEN];
@@ -112,11 +113,11 @@ static inline void test_random_rr(knot_rrset_t *rr, uint32_t ttl)
        /* Create payload */
        tmp_buf[0] = num;
        test_randstr((char *)(tmp_buf + 1), tmp_buf[0] + 1);
-       knot_rdata_init(rdata_buf, num + 1, tmp_buf);
+       knot_rdata_init(rdata, num + 1, tmp_buf);
 
        /* Assign static buffers. */
        knot_rrset_init(rr, owner_buf, KNOT_RRTYPE_TXT, KNOT_CLASS_IN, ttl);
        rr->rrs.rr_count = 1;
-       rr->rrs.data = rdata_buf;
+       rr->rrs.data = rdata;
 }