From: Daniel Salzman <daniel.salzman@nic.cz>
Date: Tue, 21 Oct 2025 07:52:41 +0000 (+0200)
Subject: Replace DNSSEC_EINVAL with KNOT_EINVAL
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=e7e7052f7bd35db4dd83d1062a98e7b7310ba8ae;p=thirdparty%2Fknot-dns.git

Replace DNSSEC_EINVAL with KNOT_EINVAL
---

diff --git a/src/knot/dnssec/kasp/keystore.c b/src/knot/dnssec/kasp/keystore.c
index 4d67737a4c..98a255bfeb 100644
--- a/src/knot/dnssec/kasp/keystore.c
+++ b/src/knot/dnssec/kasp/keystore.c
@@ -33,7 +33,7 @@ static char *fix_path(const char *config, const char *base_path)
 int keystore_load(const char *config, unsigned backend,
                   const char *kasp_base_path, dnssec_keystore_t **keystore)
 {
-	int ret = DNSSEC_EINVAL;
+	int ret = KNOT_EINVAL;
 	char *fixed_config = NULL;
 
 	switch (backend) {
diff --git a/src/libknot/dnssec/binary.c b/src/libknot/dnssec/binary.c
index c8ba5427d6..d153461b10 100644
--- a/src/libknot/dnssec/binary.c
+++ b/src/libknot/dnssec/binary.c
@@ -17,7 +17,7 @@ _public_
 int dnssec_binary_alloc(dnssec_binary_t *data, size_t size)
 {
 	if (!data || size == 0) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	uint8_t *new_data = calloc(1, size);
@@ -46,7 +46,7 @@ _public_
 int dnssec_binary_dup(const dnssec_binary_t *from, dnssec_binary_t *to)
 {
 	if (!from || !to) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	uint8_t *copy = malloc(from->size);
@@ -66,7 +66,7 @@ _public_
 int dnssec_binary_resize(dnssec_binary_t *data, size_t new_size)
 {
 	if (!data) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	uint8_t *new_data = realloc(data->data, new_size);
@@ -116,13 +116,13 @@ int dnssec_binary_from_base64(const dnssec_binary_t *base64,
 			      dnssec_binary_t *binary)
 {
 	if (!base64 || !binary) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	uint8_t *data;
 	int32_t size = knot_base64_decode_alloc(base64->data, base64->size, &data);
 	if (size < 0) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	binary->data = data;
@@ -136,13 +136,13 @@ int dnssec_binary_to_base64(const dnssec_binary_t *binary,
 			    dnssec_binary_t *base64)
 {
 	if (!binary || !base64) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	uint8_t *data;
 	int32_t size = knot_base64_encode_alloc(binary->data, binary->size, &data);
 	if (size < 0) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	base64->data = data;
diff --git a/src/libknot/dnssec/digest.c b/src/libknot/dnssec/digest.c
index 1d6e891bf2..156dd96473 100644
--- a/src/libknot/dnssec/digest.c
+++ b/src/libknot/dnssec/digest.c
@@ -29,7 +29,7 @@ _public_
 int dnssec_digest_init(dnssec_digest_t algorithm, dnssec_digest_ctx_t **out_ctx)
 {
 	if (out_ctx == NULL) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	gnutls_digest_algorithm_t gtalg = lookup_algorithm(algorithm);
@@ -62,7 +62,7 @@ _public_
 int dnssec_digest(dnssec_digest_ctx_t *ctx, dnssec_binary_t *data)
 {
 	if (ctx == NULL || data == NULL) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	int r = gnutls_hash(ctx->gtctx, data->data, data->size);
@@ -77,7 +77,7 @@ _public_
 int dnssec_digest_finish(dnssec_digest_ctx_t *ctx, dnssec_binary_t *out)
 {
 	if (ctx == NULL || out == NULL) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	int r = dnssec_binary_resize(out, ctx->size);
diff --git a/src/libknot/dnssec/error.c b/src/libknot/dnssec/error.c
index c76a6344b7..5e74845ea0 100644
--- a/src/libknot/dnssec/error.c
+++ b/src/libknot/dnssec/error.c
@@ -17,7 +17,7 @@ static const error_message_t ERROR_MESSAGES[] = {
 	{ KNOT_EOK,			"no error" },
 
 	{ KNOT_ENOMEM,		"not enough memory" },
-	{ DNSSEC_EINVAL,		"invalid argument" },
+	{ KNOT_EINVAL,		"invalid argument" },
 	{ DNSSEC_ENOENT,		"no such file or directory" },
 
 	{ DNSSEC_ERROR,			"unspecified error" },
diff --git a/src/libknot/dnssec/error.h b/src/libknot/dnssec/error.h
index 4ab3ca88ff..88f47848bf 100644
--- a/src/libknot/dnssec/error.h
+++ b/src/libknot/dnssec/error.h
@@ -27,7 +27,7 @@ enum dnssec_error {
 	KNOT_EOK = 0,
 
 	KNOT_ENOMEM = -ENOMEM,
-	DNSSEC_EINVAL = -EINVAL,
+	KNOT_EINVAL = -EINVAL,
 	DNSSEC_ENOENT = -ENOENT,
 
 	DNSSEC_ERROR_MIN = -1500,
diff --git a/src/libknot/dnssec/key/algorithm.c b/src/libknot/dnssec/key/algorithm.c
index a9d1be0058..9cc08e9890 100644
--- a/src/libknot/dnssec/key/algorithm.c
+++ b/src/libknot/dnssec/key/algorithm.c
@@ -117,7 +117,7 @@ int dnssec_algorithm_key_size_range(dnssec_key_algorithm_t algorithm,
 				    unsigned *min_ptr, unsigned *max_ptr)
 {
 	if (!min_ptr && !max_ptr) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	const struct limits *limits = get_limits(algorithm);
diff --git a/src/libknot/dnssec/key/ds.c b/src/libknot/dnssec/key/ds.c
index 9f6fb0fb4a..ca215f20e1 100644
--- a/src/libknot/dnssec/key/ds.c
+++ b/src/libknot/dnssec/key/ds.c
@@ -61,7 +61,7 @@ int dnssec_key_create_ds(const dnssec_key_t *key,
 			 dnssec_binary_t *rdata_ptr)
 {
 	if (!key || !rdata_ptr) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	if (!key->dname) {
diff --git a/src/libknot/dnssec/key/key.c b/src/libknot/dnssec/key/key.c
index 072129f3a8..633cdd0c87 100644
--- a/src/libknot/dnssec/key/key.c
+++ b/src/libknot/dnssec/key/key.c
@@ -43,7 +43,7 @@ _public_
 int dnssec_key_new(dnssec_key_t **key_ptr)
 {
 	if (!key_ptr) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	dnssec_key_t *key = calloc(1, sizeof(*key));
@@ -172,7 +172,7 @@ _public_
 int dnssec_key_set_dname(dnssec_key_t *key, const uint8_t *dname)
 {
 	if (!key) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	uint8_t *copy = NULL;
@@ -207,7 +207,7 @@ _public_
 int dnssec_key_set_flags(dnssec_key_t *key, uint16_t flags)
 {
 	if (!key) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	wire_ctx_t wire = binary_init(&key->rdata);
@@ -233,7 +233,7 @@ _public_
 int dnssec_key_set_protocol(dnssec_key_t *key, uint8_t protocol)
 {
 	if (!key) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	wire_ctx_t wire = binary_init(&key->rdata);
@@ -294,7 +294,7 @@ _public_
 int dnssec_key_set_algorithm(dnssec_key_t *key, uint8_t algorithm)
 {
 	if (!key) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	if (!can_change_algorithm(key, algorithm)) {
@@ -312,7 +312,7 @@ _public_
 int dnssec_key_get_pubkey(const dnssec_key_t *key, dnssec_binary_t *pubkey)
 {
 	if (!key || !pubkey) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	wire_ctx_t wire = binary_init(&key->rdata);
@@ -326,7 +326,7 @@ _public_
 int dnssec_key_set_pubkey(dnssec_key_t *key, const dnssec_binary_t *pubkey)
 {
 	if (!key || !pubkey || !pubkey->data) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	if (key->public_key) {
@@ -384,7 +384,7 @@ _public_
 int dnssec_key_get_keyid(const dnssec_key_t *key, char **id)
 {
 	if (!key || !id) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	return keyid_pubkey_hex(key->public_key, id);
@@ -394,7 +394,7 @@ _public_
 int dnssec_key_get_rdata(const dnssec_key_t *key, dnssec_binary_t *rdata)
 {
 	if (!key || !rdata) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	*rdata = key->rdata;
@@ -406,7 +406,7 @@ _public_
 int dnssec_key_set_rdata(dnssec_key_t *key, const dnssec_binary_t *rdata)
 {
 	if (!key || !rdata || !rdata->data) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	if (rdata->size < DNSKEY_RDATA_MIN_SIZE) {
diff --git a/src/libknot/dnssec/key/keytag.c b/src/libknot/dnssec/key/keytag.c
index f1df0dd4d7..653d30f48e 100644
--- a/src/libknot/dnssec/key/keytag.c
+++ b/src/libknot/dnssec/key/keytag.c
@@ -59,7 +59,7 @@ _public_
 int dnssec_keytag(const dnssec_binary_t *rdata, uint16_t *keytag)
 {
 	if (!rdata || !keytag) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	if (!rdata->data || rdata->size < DNSKEY_RDATA_OFFSET_PUBKEY) {
diff --git a/src/libknot/dnssec/key/simple.c b/src/libknot/dnssec/key/simple.c
index ae07a59800..f8efaa4a6a 100644
--- a/src/libknot/dnssec/key/simple.c
+++ b/src/libknot/dnssec/key/simple.c
@@ -21,7 +21,7 @@ _public_
 int dnssec_key_load_pkcs8(dnssec_key_t *key, const dnssec_binary_t *pem)
 {
 	if (!key || !pem || !pem->data) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	if (dnssec_key_get_algorithm(key) == 0) {
diff --git a/src/libknot/dnssec/keystore/keystore.c b/src/libknot/dnssec/keystore/keystore.c
index e19747d063..0b0b865240 100644
--- a/src/libknot/dnssec/keystore/keystore.c
+++ b/src/libknot/dnssec/keystore/keystore.c
@@ -48,7 +48,7 @@ _public_
 int dnssec_keystore_deinit(dnssec_keystore_t *store)
 {
 	if (!store) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	dnssec_keystore_close(store);
@@ -63,7 +63,7 @@ _public_
 int dnssec_keystore_init(dnssec_keystore_t *store, const char *config)
 {
 	if (!store) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	return store->functions->init(store->ctx, config);
@@ -73,7 +73,7 @@ _public_
 int dnssec_keystore_open(dnssec_keystore_t *store, const char *config)
 {
 	if (!store) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	return store->functions->open(store->ctx, config);
@@ -83,7 +83,7 @@ _public_
 int dnssec_keystore_close(dnssec_keystore_t *store)
 {
 	if (!store) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	return store->functions->close(store->ctx);
@@ -95,7 +95,7 @@ int dnssec_keystore_generate(dnssec_keystore_t *store,
 			     unsigned bits, const char *label, char **id_ptr)
 {
 	if (!store || !_algorithm || !id_ptr) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	// prepare parameters
@@ -117,7 +117,7 @@ int dnssec_keystore_import(dnssec_keystore_t *store, const dnssec_binary_t *pem,
 			   char **id_ptr)
 {
 	if (!store || !pem || !id_ptr) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	return store->functions->import_key(store->ctx, pem, id_ptr);
@@ -127,7 +127,7 @@ _public_
 int dnssec_keystore_remove(dnssec_keystore_t *store, const char *id)
 {
 	if (!store || !id) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	return store->functions->remove_key(store->ctx, id);
@@ -138,7 +138,7 @@ int dnssec_keystore_get_private(dnssec_keystore_t *store, const char *id,
 				dnssec_key_t *key)
 {
 	if (!store || !id || dnssec_key_get_algorithm(key) == 0 || !key) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	if (key->private_key) {
@@ -164,7 +164,7 @@ _public_
 int dnssec_keystore_set_private(dnssec_keystore_t *store, dnssec_key_t *key)
 {
 	if (!store || !key) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	if (!key->private_key) {
diff --git a/src/libknot/dnssec/keystore/pkcs8.c b/src/libknot/dnssec/keystore/pkcs8.c
index bb7149c263..6b647a2779 100644
--- a/src/libknot/dnssec/keystore/pkcs8.c
+++ b/src/libknot/dnssec/keystore/pkcs8.c
@@ -104,7 +104,7 @@ static int key_open_write(const char *dir_name, const char *id, int *fd_ptr)
 static int pkcs8_dir_read(pkcs8_dir_handle_t *handle, const char *id, dnssec_binary_t *pem)
 {
 	if (!handle || !id || !pem) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	// open file and get it's size
@@ -212,7 +212,7 @@ static int pem_generate(gnutls_pk_algorithm_t algorithm, unsigned bits,
 static int pkcs8_ctx_new(void **ctx_ptr)
 {
 	if (!ctx_ptr) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	pkcs8_dir_handle_t *ctx = calloc(1, sizeof(*ctx));
@@ -233,7 +233,7 @@ static void pkcs8_ctx_free(void *ctx)
 static int pkcs8_init(void *ctx, const char *config)
 {
 	if (!ctx || !config) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	return make_dir(config, DIR_INIT_MODE, true);
@@ -242,7 +242,7 @@ static int pkcs8_init(void *ctx, const char *config)
 static int pkcs8_open(void *ctx, const char *config)
 {
 	if (!ctx || !config) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	pkcs8_dir_handle_t *handle = ctx;
@@ -260,7 +260,7 @@ static int pkcs8_open(void *ctx, const char *config)
 static int pkcs8_close(void *ctx)
 {
 	if (!ctx) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	pkcs8_dir_handle_t *handle = ctx;
@@ -275,7 +275,7 @@ static int pkcs8_generate_key(void *ctx, gnutls_pk_algorithm_t algorithm,
 			      unsigned bits, const char *label, char **id_ptr)
 {
 	if (!ctx || !id_ptr) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	(void)label;
@@ -321,7 +321,7 @@ static int pkcs8_generate_key(void *ctx, gnutls_pk_algorithm_t algorithm,
 static int pkcs8_import_key(void *ctx, const dnssec_binary_t *pem, char **id_ptr)
 {
 	if (!ctx || !pem || !id_ptr) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	pkcs8_dir_handle_t *handle = ctx;
@@ -373,7 +373,7 @@ static int pkcs8_import_key(void *ctx, const dnssec_binary_t *pem, char **id_ptr
 static int pkcs8_remove_key(void *ctx, const char *id)
 {
 	if (!ctx || !id) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	pkcs8_dir_handle_t *handle = ctx;
@@ -393,7 +393,7 @@ static int pkcs8_remove_key(void *ctx, const char *id)
 static int pkcs8_get_private(void *ctx, const char *id, gnutls_privkey_t *key_ptr)
 {
 	if (!ctx || !id || !key_ptr) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	pkcs8_dir_handle_t *handle = ctx;
@@ -450,7 +450,7 @@ static int pkcs8_get_private(void *ctx, const char *id, gnutls_privkey_t *key_pt
 static int pkcs8_set_private(void *ctx, gnutls_privkey_t key)
 {
 	if (!ctx) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	_cleanup_binary_ dnssec_binary_t pem = { 0 };
diff --git a/src/libknot/dnssec/nsec/hash.c b/src/libknot/dnssec/nsec/hash.c
index b05ab59380..087ff3422d 100644
--- a/src/libknot/dnssec/nsec/hash.c
+++ b/src/libknot/dnssec/nsec/hash.c
@@ -88,7 +88,7 @@ int dnssec_nsec3_hash(const dnssec_binary_t *data,
 		      dnssec_binary_t *hash)
 {
 	if (!data || !params || !hash) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	gnutls_digest_algorithm_t algorithm = algorithm_d2g(params->algorithm);
diff --git a/src/libknot/dnssec/nsec/nsec.c b/src/libknot/dnssec/nsec/nsec.c
index b104b42e54..1cb563905b 100644
--- a/src/libknot/dnssec/nsec/nsec.c
+++ b/src/libknot/dnssec/nsec/nsec.c
@@ -34,7 +34,7 @@ int dnssec_nsec3_params_from_rdata(dnssec_nsec3_params_t *params,
                                    const dnssec_binary_t *rdata)
 {
 	if (!params || !rdata || !rdata->data) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	dnssec_nsec3_params_t new_params = { 0 };
diff --git a/src/libknot/dnssec/pem.c b/src/libknot/dnssec/pem.c
index 3aa565dfe8..9a1b94f81c 100644
--- a/src/libknot/dnssec/pem.c
+++ b/src/libknot/dnssec/pem.c
@@ -18,7 +18,7 @@ _public_
 int dnssec_pem_to_x509(const dnssec_binary_t *pem, gnutls_x509_privkey_t *key)
 {
 	if (!pem || !key) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	gnutls_datum_t data = binary_to_datum(pem);
@@ -47,7 +47,7 @@ _public_
 int dnssec_pem_to_privkey(const dnssec_binary_t *pem, gnutls_privkey_t *key)
 {
 	if (!pem || !key) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	gnutls_x509_privkey_t key_x509 = NULL;
@@ -92,7 +92,7 @@ _public_
 int dnssec_pem_from_x509(gnutls_x509_privkey_t key, dnssec_binary_t *pem)
 {
 	if (!key || !pem) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	dnssec_binary_t _pem = { 0 };
@@ -130,7 +130,7 @@ _public_
 int dnssec_pem_from_privkey(gnutls_privkey_t key, dnssec_binary_t *pem)
 {
 	if (!key || !pem) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	_cleanup_x509_privkey_ gnutls_x509_privkey_t _key = NULL;
diff --git a/src/libknot/dnssec/random.c b/src/libknot/dnssec/random.c
index 4c50c194d4..e25acd5743 100644
--- a/src/libknot/dnssec/random.c
+++ b/src/libknot/dnssec/random.c
@@ -19,7 +19,7 @@ _public_
 int dnssec_random_buffer(uint8_t *data, size_t size)
 {
 	if (!data) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	int result = gnutls_rnd(GNUTLS_RND_RANDOM, data, size);
@@ -35,7 +35,7 @@ _public_
 int dnssec_random_binary(dnssec_binary_t *binary)
 {
 	if (!binary) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	return dnssec_random_buffer(binary->data, binary->size);
diff --git a/src/libknot/dnssec/sign/der.c b/src/libknot/dnssec/sign/der.c
index 54c1ee0950..5f71f9aaeb 100644
--- a/src/libknot/dnssec/sign/der.c
+++ b/src/libknot/dnssec/sign/der.c
@@ -126,7 +126,7 @@ int dss_sig_value_decode(const dnssec_binary_t *der,
 			 dnssec_binary_t *r, dnssec_binary_t *s)
 {
 	if (!der || !der->data || !r || !s) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	wire_ctx_t wire = binary_init(der);
@@ -180,7 +180,7 @@ int dss_sig_value_encode(const dnssec_binary_t *r, const dnssec_binary_t *s,
 			 dnssec_binary_t *der)
 {
 	if (!r || !r->data || !s || !s->data || !der) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	size_t r_size = bignum_size_s(r);
diff --git a/src/libknot/dnssec/sign/sign.c b/src/libknot/dnssec/sign/sign.c
index b016fb923f..a00f0c0df8 100644
--- a/src/libknot/dnssec/sign/sign.c
+++ b/src/libknot/dnssec/sign/sign.c
@@ -229,7 +229,7 @@ _public_
 int dnssec_sign_new(dnssec_sign_ctx_t **ctx_ptr, const dnssec_key_t *key)
 {
 	if (!ctx_ptr) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	dnssec_sign_ctx_t *ctx = calloc(1, sizeof(*ctx));
@@ -271,7 +271,7 @@ _public_
 int dnssec_sign_init(dnssec_sign_ctx_t *ctx)
 {
 	if (!ctx) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	if (vpool_get_buf(&ctx->buffer) != NULL) {
@@ -287,7 +287,7 @@ _public_
 int dnssec_sign_add(dnssec_sign_ctx_t *ctx, const dnssec_binary_t *data)
 {
 	if (!ctx || !data || !data->data) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	void *result = vpool_insert(&ctx->buffer, vpool_get_length(&ctx->buffer), data->data, data->size);
@@ -302,7 +302,7 @@ _public_
 int dnssec_sign_write(dnssec_sign_ctx_t *ctx, dnssec_sign_flags_t flags, dnssec_binary_t *signature)
 {
 	if (!ctx || !signature) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	if (!dnssec_key_can_sign(ctx->key)) {
@@ -337,7 +337,7 @@ _public_
 int dnssec_sign_verify(dnssec_sign_ctx_t *ctx, bool sign_cmp, const dnssec_binary_t *signature)
 {
 	if (!ctx || !signature) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	if (sign_cmp && dnssec_key_can_sign(ctx->key)) {
diff --git a/src/libknot/dnssec/tsig.c b/src/libknot/dnssec/tsig.c
index 32fe15639e..115a1251d5 100644
--- a/src/libknot/dnssec/tsig.c
+++ b/src/libknot/dnssec/tsig.c
@@ -150,7 +150,7 @@ int dnssec_tsig_new(dnssec_tsig_ctx_t **ctx_ptr,
 		    const dnssec_binary_t *key)
 {
 	if (!ctx_ptr || !key) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	dnssec_tsig_ctx_t *ctx = calloc(1, sizeof(*ctx));
@@ -190,7 +190,7 @@ _public_
 int dnssec_tsig_add(dnssec_tsig_ctx_t *ctx, const dnssec_binary_t *data)
 {
 	if (!ctx || !data) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	int result = gnutls_hmac(ctx->hash, data->data, data->size);
@@ -222,7 +222,7 @@ _public_
 int dnssec_tsig_write(dnssec_tsig_ctx_t *ctx, uint8_t *mac)
 {
 	if (!ctx || !mac) {
-		return DNSSEC_EINVAL;
+		return KNOT_EINVAL;
 	}
 
 	gnutls_hmac_output(ctx->hash, mac);
diff --git a/src/utils/knsec3hash/knsec3hash.c b/src/utils/knsec3hash/knsec3hash.c
index 8704286b52..ed9aeb2f15 100644
--- a/src/utils/knsec3hash/knsec3hash.c
+++ b/src/utils/knsec3hash/knsec3hash.c
@@ -41,7 +41,7 @@ static int str_to_salt(const char *str, dnssec_binary_t *salt)
 		return KNOT_EOK;
 	} else {
 		salt->data = hex_to_bin(str, &salt->size);
-		return (salt->data != NULL ? KNOT_EOK : DNSSEC_EINVAL);
+		return (salt->data != NULL ? KNOT_EOK : KNOT_EINVAL);
 	}
 }
 
diff --git a/tests/libknot/test_dnssec_key_algorithm.c b/tests/libknot/test_dnssec_key_algorithm.c
index 6891b790ac..855b9d0873 100644
--- a/tests/libknot/test_dnssec_key_algorithm.c
+++ b/tests/libknot/test_dnssec_key_algorithm.c
@@ -25,7 +25,7 @@ static void null_range(void)
 	int r;
 
 	r = dnssec_algorithm_key_size_range(algo, NULL, NULL);
-	ok(r == DNSSEC_EINVAL, "dnssec_algorithm_key_size_range() all null");
+	ok(r == KNOT_EINVAL, "dnssec_algorithm_key_size_range() all null");
 	r = dnssec_algorithm_key_size_range(algo, &val, NULL);
 	ok(r == KNOT_EOK && val == 1024, "dnssec_algorithm_key_size_range() min only");
 	r = dnssec_algorithm_key_size_range(algo, NULL, &val);
diff --git a/tests/libknot/test_dnssec_key_ds.c b/tests/libknot/test_dnssec_key_ds.c
index cca5f9a7b9..dc4a55fd70 100644
--- a/tests/libknot/test_dnssec_key_ds.c
+++ b/tests/libknot/test_dnssec_key_ds.c
@@ -57,7 +57,7 @@ static void test_errors(const struct key_parameters *params)
 	dnssec_binary_t ds = { 0 };
 
 	int r = dnssec_key_create_ds(key, DNSSEC_KEY_DIGEST_SHA1, &ds);
-	is_int(DNSSEC_EINVAL, r, "dnssec_key_create_ds() no key");
+	is_int(KNOT_EINVAL, r, "dnssec_key_create_ds() no key");
 	dnssec_binary_free(&ds);
 
 	dnssec_key_new(&key);
@@ -70,7 +70,7 @@ static void test_errors(const struct key_parameters *params)
 
 	dnssec_key_set_rdata(key, &params->rdata);
 	r = dnssec_key_create_ds(key, DNSSEC_KEY_DIGEST_SHA1, NULL);
-	is_int(DNSSEC_EINVAL, r, "dnssec_key_create_ds() no RDATA buffer");
+	is_int(KNOT_EINVAL, r, "dnssec_key_create_ds() no RDATA buffer");
 
 	r = dnssec_key_create_ds(key, 3, &ds);
 	is_int(DNSSEC_INVALID_DS_ALGORITHM, r, "dnssec_key_create_ds() unsupported algorithm");