treewide: avoid DNSSEC_EOK

It was zero anyway, just as KNOT_EOK or kr_ok()

diff --git a/daemon/zimport.c b/daemon/zimport.c
index 99ec1f914ce682fc1a72a050cbfe91e284faf42a..76cbef2ffe242e71d2e690c93210bbda82377256 100644 (file)
--- a/daemon/zimport.c
+++ b/daemon/zimport.c
@@ -249,11 +249,11 @@ do_digest:
                if (!z_import->digests[i].active)
                        continue;
                int ret2 = dnssec_digest_finish(z_import->digests[i].ctx, &digs[i]);
-               if (ret == DNSSEC_EOK)
+               if (ret == KNOT_EOK)
                        ret = ret2;
                // we need to keep going to free all digests[*].ctx
        }
-       if (ret != DNSSEC_EOK) {
+       if (ret != KNOT_EOK) {
                for (int i = 0; i < DIGEST_ALG_COUNT; ++i)
                        free(digs[i].data);
                kr_log_error(PREFILL, "error when computing digest: %s\n",

diff --git a/lib/cache/nsec3.c b/lib/cache/nsec3.c
index 24fbd5f91edb518f83565c3706d99d5552fd8de5..ea0e3458adebf7e82b54a02c8ea74775befc1ee4 100644 (file)
--- a/lib/cache/nsec3.c
+++ b/lib/cache/nsec3.c
@@ -95,14 +95,14 @@ static knot_db_val_t key_NSEC3_name(struct key *k, const knot_dname_t *name,
                .data = val.data + val.len,
        };
        int ret = dnssec_nsec3_hash(&dname, &nsec_p->libknot, &hash);
-       if (ret != DNSSEC_EOK) return VAL_EMPTY;
+       if (ret != KNOT_EOK) return VAL_EMPTY;
        if (kr_fails_assert(hash.size == NSEC3_HASH_LEN))
                return VAL_EMPTY;
 
        #else
        dnssec_binary_t hash = { .size = 0, .data = NULL };
        int ret = dnssec_nsec3_hash(&dname, &nsec_p->libknot, &hash);
-       if (ret != DNSSEC_EOK) return VAL_EMPTY;
+       if (ret != KNOT_EOK) return VAL_EMPTY;
        if (kr_fails_assert(hash.size == NSEC3_HASH_LEN && hash.data))
                return VAL_EMPTY;
        memcpy(knot_db_val_bound(val), hash.data, NSEC3_HASH_LEN);

diff --git a/lib/cache/peek.c b/lib/cache/peek.c
index 9c8c4ceb4c41ea456019f7b8de12106a58fd41a9..42445cacacb6a5905bee73c9ebdfd263ac7beaa7 100644 (file)
--- a/lib/cache/peek.c
+++ b/lib/cache/peek.c
@@ -45,7 +45,7 @@ static int nsec_p_init(struct nsec_p *nsec_p, knot_db_val_t nsec_p_entry, bool w
                .data = (uint8_t *)/*const-cast*/nsec_p->raw,
        };
        int ret = dnssec_nsec3_params_from_rdata(&nsec_p->libknot, &rdata);
-       return ret == DNSSEC_EOK ? kr_ok() : kr_error(ret);
+       return ret == KNOT_EOK ? kr_ok() : kr_error(ret);
 }
 
 static void nsec_p_cleanup(struct nsec_p *nsec_p)

diff --git a/lib/dnssec.c b/lib/dnssec.c
index 67e91fd1129030b71dd0d7546fdbc6c4d0988784..baecfe07c912a5e0ea3112aaa80c9a0475674251 100644 (file)
--- a/lib/dnssec.c
+++ b/lib/dnssec.c
@@ -544,8 +544,8 @@ int kr_dnssec_key_match(const uint8_t *key_a_rdata, size_t key_a_rdlen,
        ret = kr_error(ENOENT);
        dnssec_binary_t pk_a, pk_b;
        if (dnssec_key_get_algorithm(key_a) == dnssec_key_get_algorithm(key_b) &&
-           dnssec_key_get_pubkey(key_a, &pk_a) == DNSSEC_EOK &&
-           dnssec_key_get_pubkey(key_b, &pk_b) == DNSSEC_EOK) {
+           dnssec_key_get_pubkey(key_a, &pk_a) == KNOT_EOK &&
+           dnssec_key_get_pubkey(key_b, &pk_b) == KNOT_EOK) {
                if (pk_a.size == pk_b.size && memcmp(pk_a.data, pk_b.data, pk_a.size) == 0) {
                        ret = 0;
                }
@@ -568,17 +568,17 @@ int kr_dnssec_key_from_rdata(struct dnssec_key **key, const knot_dname_t *kown,
        };
 
        int ret = dnssec_key_new(&new_key);
-       if (ret != DNSSEC_EOK) {
+       if (ret != KNOT_EOK) {
                return kr_error(ENOMEM);
        }
        ret = dnssec_key_set_rdata(new_key, &binary_key);
-       if (ret != DNSSEC_EOK) {
+       if (ret != KNOT_EOK) {
                dnssec_key_free(new_key);
                return kr_error(ret);
        }
        if (kown) {
                ret = dnssec_key_set_dname(new_key, kown);
-               if (ret != DNSSEC_EOK) {
+               if (ret != KNOT_EOK) {
                        dnssec_key_free(new_key);
                        return kr_error(ENOMEM);
                }

diff --git a/lib/dnssec.h b/lib/dnssec.h
index 06efa8846ceac2ece592878b826eb0f8957a0326..031970b2cd66d9d6771081ae0791499c23b0a66d 100644 (file)
--- a/lib/dnssec.h
+++ b/lib/dnssec.h
@@ -16,9 +16,6 @@
 #include <libknot/libknot.h>
 // Now some compatibility
 enum {
-       // These should be OK to replace everywhere.
-       DNSSEC_EOK = KNOT_EOK,
-
        // These might not be OK to simply replace everywhere.
        DNSSEC_INVALID_KEY_ALGORITHM = KNOT_INVALID_KEY_ALGORITHM,
        DNSSEC_INVALID_DIGEST_ALGORITHM = KNOT_EALGORITHM,

diff --git a/lib/dnssec/nsec3.c b/lib/dnssec/nsec3.c
index 2e9363d10aea2519b4c807da072e8c89dc0990ba..c4a3f879baf9af4a9bbd3e60607ed65a2cd882b6 100644 (file)
--- a/lib/dnssec/nsec3.c
+++ b/lib/dnssec/nsec3.c
@@ -49,7 +49,7 @@ static int nsec3_parameters(dnssec_nsec3_params_t *params, const knot_rrset_t *n
                return kr_error(EMSGSIZE);
 
        int ret = dnssec_nsec3_params_from_rdata(params, &rdata);
-       if (ret != DNSSEC_EOK)
+       if (ret != KNOT_EOK)
                return kr_error(EINVAL);
 
        return kr_ok();
@@ -80,7 +80,7 @@ static int hash_name(dnssec_binary_t *hash, const dnssec_nsec3_params_t *params,
        };
 
        int ret = dnssec_nsec3_hash(&dname, params, hash);
-       if (ret != DNSSEC_EOK) {
+       if (ret != KNOT_EOK) {
                return kr_error(EINVAL);
        }
 

diff --git a/lib/dnssec/signature.c b/lib/dnssec/signature.c
index b2ef2d5509799e60f143f4307113ec1b6aa63d79..de94833f71eae75f7243bf5e049b70b01008b756 100644 (file)
--- a/lib/dnssec/signature.c
+++ b/lib/dnssec/signature.c
@@ -23,7 +23,7 @@ static int authenticate_ds(const dnssec_key_t *key, dnssec_binary_t *ds_rdata, u
        /* Compute DS RDATA from the DNSKEY. */
        dnssec_binary_t computed_ds = { 0, };
        int ret = dnssec_key_create_ds(key, digest_type, &computed_ds);
-       if (ret != DNSSEC_EOK)
+       if (ret != KNOT_EOK)
                goto fail;
 
        /* DS records contain algorithm, key tag and the digest.
@@ -144,7 +144,7 @@ static int sign_ctx_add_self(dnssec_sign_ctx_t *ctx, const uint8_t *rdata)
        };
 
        result = dnssec_sign_add(ctx, &header);
-       if (result != DNSSEC_EOK)
+       if (result != KNOT_EOK)
                return result;
 
        // signer name

diff --git a/lib/kru.inc.c b/lib/kru.inc.c
index 6526c6305760f481305ef38d3a9d3ee435d435a3..35dd2e2908a5a153edba0649601cb34309ff9252 100644 (file)
--- a/lib/kru.inc.c
+++ b/lib/kru.inc.c
@@ -227,7 +227,7 @@ static bool kru_initialize(struct kru *kru, int capacity_log, kru_price_t max_de
 
        kru->loads_bits = loads_bits;
 
-       if (dnssec_random_buffer((uint8_t *)&kru->hash_key, sizeof(kru->hash_key)) != DNSSEC_EOK) {
+       if (dnssec_random_buffer((uint8_t *)&kru->hash_key, sizeof(kru->hash_key)) != KNOT_EOK) {
                return false;
        }