lib/cookies/helper.c: replace asserts

diff --git a/lib/cookies/helper.c b/lib/cookies/helper.c
index 55c4fbcd91f3e5aed8b0f09ab8e5cf773ddaf6a7..d7c04f170107c882c2bb315194ce7bb13e579b60 100644 (file)
--- a/lib/cookies/helper.c
+++ b/lib/cookies/helper.c
@@ -2,7 +2,6 @@
  *  SPDX-License-Identifier: GPL-3.0-or-later
  */
 
-#include <assert.h>
 #include <libknot/rrtype/opt.h>
 #include <libknot/rrtype/opt-cookie.h>
 
@@ -16,12 +15,12 @@
 static const uint8_t *peek_and_check_cc(kr_cookie_lru_t *cache, const void *sa,
                                         const uint8_t *cc, uint16_t cc_len)
 {
-       assert(cache && sa && cc && cc_len);
+       if (!kr_assume(cache && sa && cc && cc_len))
+               return NULL;
 
        const uint8_t *cached_opt = kr_cookie_lru_get(cache, sa);
-       if (!cached_opt) {
+       if (!cached_opt)
                return NULL;
-       }
 
        const uint8_t *cached_cc = knot_edns_opt_get_data((uint8_t *) cached_opt);
 
@@ -39,34 +38,35 @@ static const uint8_t *peek_and_check_cc(kr_cookie_lru_t *cache, const void *sa,
 static int opt_rr_put_cookie(knot_rrset_t *opt_rr, uint8_t *data,
                              uint16_t data_len, knot_mm_t *mm)
 {
-       assert(opt_rr && data && data_len > 0);
+       if (!kr_assume(opt_rr && data && data_len > 0))
+               return kr_error(EINVAL);
 
        const uint8_t *cc = NULL, *sc = NULL;
        uint16_t cc_len = 0, sc_len = 0;
 
        int ret = knot_edns_opt_cookie_parse(data, data_len, &cc, &cc_len,
                                             &sc, &sc_len);
-       if (ret != KNOT_EOK) {
+       if (ret != KNOT_EOK)
+               return kr_error(EINVAL);
+       if (!kr_assume(data_len == cc_len + sc_len))
                return kr_error(EINVAL);
-       }
-       assert(data_len == cc_len + sc_len);
 
        uint16_t cookies_size = data_len;
        uint8_t *cookies_data = NULL;
 
        ret = knot_edns_reserve_unique_option(opt_rr, KNOT_EDNS_OPTION_COOKIE,
                                              cookies_size, &cookies_data, mm);
-       if (ret != KNOT_EOK) {
+       if (ret != KNOT_EOK)
+               return kr_error(EINVAL);
+       if (!kr_assume(cookies_data))
                return kr_error(EINVAL);
-       }
-       assert(cookies_data != NULL);
 
        cookies_size = knot_edns_opt_cookie_write(cc, cc_len, sc, sc_len,
                                                  cookies_data, cookies_size);
-       if (cookies_size == 0) {
+       if (cookies_size == 0)
+               return kr_error(EINVAL);
+       if (!kr_assume(cookies_size == data_len))
                return kr_error(EINVAL);
-       }
-       assert(cookies_size == data_len);
 
        return kr_ok();
 }
@@ -76,18 +76,17 @@ static int opt_rr_put_cookie(knot_rrset_t *opt_rr, uint8_t *data,
  */
 static int opt_rr_put_cookie_opt(knot_rrset_t *opt_rr, uint8_t *option, knot_mm_t *mm)
 {
-       assert(opt_rr && option);
+       if (!kr_assume(opt_rr && option))
+               return kr_error(EINVAL);
 
        uint16_t opt_code = knot_edns_opt_get_code(option);
-       if (opt_code != KNOT_EDNS_OPTION_COOKIE) {
+       if (opt_code != KNOT_EDNS_OPTION_COOKIE)
                return kr_error(EINVAL);
-       }
 
        uint16_t opt_len = knot_edns_opt_get_length(option);
        uint8_t *opt_data = knot_edns_opt_get_data(option);
-       if (!opt_data || opt_len == 0) {
+       if (!opt_data || opt_len == 0)
                return kr_error(EINVAL);
-       }
 
        return opt_rr_put_cookie(opt_rr, opt_data, opt_len, mm);
 }
@@ -98,17 +97,14 @@ int kr_request_put_cookie(const struct kr_cookie_comp *clnt_comp,
                           const struct sockaddr *srvr_sa,
                           struct kr_request *req)
 {
-       if (!clnt_comp || !req) {
+       if (!clnt_comp || !req)
                return kr_error(EINVAL);
-       }
 
-       if (!req->ctx->opt_rr) {
+       if (!req->ctx->opt_rr)
                return kr_ok();
-       }
 
-       if (!clnt_comp->secr || (clnt_comp->alg_id < 0) || !cookie_cache) {
+       if (!clnt_comp->secr || (clnt_comp->alg_id < 0) || !cookie_cache)
                return kr_error(EINVAL);
-       }
 
        /*
         * Generate client cookie from client address, server address and
@@ -123,14 +119,13 @@ int kr_request_put_cookie(const struct kr_cookie_comp *clnt_comp,
        uint8_t cc[KNOT_OPT_COOKIE_CLNT];
        uint16_t cc_len = KNOT_OPT_COOKIE_CLNT;
        const struct knot_cc_alg *cc_alg = kr_cc_alg_get(clnt_comp->alg_id);
-       if (!cc_alg) {
+       if (!cc_alg)
+               return kr_error(EINVAL);
+       if (!kr_assume(cc_alg->gen_func))
                return kr_error(EINVAL);
-       }
-       assert(cc_alg->gen_func);
        cc_len = cc_alg->gen_func(&input, cc, cc_len);
-       if (cc_len != KNOT_OPT_COOKIE_CLNT) {
+       if (cc_len != KNOT_OPT_COOKIE_CLNT)
                return kr_error(EINVAL);
-       }
 
        const uint8_t *cached_cookie = peek_and_check_cc(cookie_cache,
                                                         srvr_sa, cc, cc_len);
@@ -153,9 +148,8 @@ int kr_answer_write_cookie(struct knot_sc_input *sc_input,
                            const struct kr_nonce_input *nonce,
                            const struct knot_sc_alg *alg, knot_pkt_t *pkt)
 {
-       if (!sc_input || !sc_input->cc || sc_input->cc_len == 0) {
+       if (!sc_input || !sc_input->cc || sc_input->cc_len == 0)
                return kr_error(EINVAL);
-       }
 
        if (!sc_input->srvr_data || !sc_input->srvr_data->clnt_sockaddr ||
            !sc_input->srvr_data->secret_data ||
@@ -163,17 +157,14 @@ int kr_answer_write_cookie(struct knot_sc_input *sc_input,
                return kr_error(EINVAL);
        }
 
-       if (!nonce) {
+       if (!nonce)
                return kr_error(EINVAL);
-       }
 
-       if (!alg || !alg->hash_size || !alg->hash_func) {
+       if (!alg || !alg->hash_size || !alg->hash_func)
                return kr_error(EINVAL);
-       }
 
-       if (!pkt || !pkt->opt_rr) {
+       if (!pkt || !pkt->opt_rr)
                return kr_error(EINVAL);
-       }
 
        uint16_t nonce_len = KR_NONCE_LEN;
        uint16_t hash_len = alg->hash_size;
@@ -185,26 +176,24 @@ int kr_answer_write_cookie(struct knot_sc_input *sc_input,
        uint8_t *cookie = NULL;
        uint16_t cookie_len = knot_edns_opt_cookie_data_len(sc_input->cc_len,
                                                            nonce_len + hash_len);
-       if (cookie_len == 0) {
+       if (cookie_len == 0)
                return kr_error(EINVAL);
-       }
 
        int ret = knot_edns_reserve_unique_option(pkt->opt_rr,
                                                  KNOT_EDNS_OPTION_COOKIE,
                                                  cookie_len, &cookie,
                                                  &pkt->mm);
-       if (ret != KNOT_EOK) {
+       if (ret != KNOT_EOK)
                return kr_error(ENOMEM);
-       }
-       assert(cookie != NULL);
+       if (!kr_assume(cookie))
+               return kr_error(EFAULT);
 
        /*
         * Function knot_edns_opt_cookie_data_len() returns the sum of its
         * parameters or zero. Anyway, let's check again.
         */
-       if (cookie_len < (sc_input->cc_len + nonce_len + hash_len)) {
+       if (cookie_len < (sc_input->cc_len + nonce_len + hash_len))
                return kr_error(EINVAL);
-       }
 
        /* Copy client cookie data portion. */
        memcpy(cookie, sc_input->cc, sc_input->cc_len);
@@ -239,9 +228,8 @@ int kr_pkt_set_ext_rcode(knot_pkt_t *pkt, uint16_t whole_rcode)
         * |   8-bit extended RCODE  | 4-bit RCODE |
         */
 
-       if (!pkt || !knot_pkt_has_edns(pkt)) {
+       if (!pkt || !knot_pkt_has_edns(pkt))
                return kr_error(EINVAL);
-       }
 
        uint8_t rcode = whole_rcode & 0x0f;
        uint8_t ext_rcode = whole_rcode >> 4;
@@ -253,28 +241,24 @@ int kr_pkt_set_ext_rcode(knot_pkt_t *pkt, uint16_t whole_rcode)
 
 uint8_t *kr_no_question_cookie_query(const knot_pkt_t *pkt)
 {
-       if (!pkt || knot_wire_get_qdcount(pkt->wire) > 0) {
+       if (!pkt || knot_wire_get_qdcount(pkt->wire) > 0)
                return false;
-       }
 
-       if (knot_wire_get_qr(pkt->wire) != 0 || !pkt->opt_rr) {
+       if (knot_wire_get_qr(pkt->wire) != 0 || !pkt->opt_rr)
                return false;
-       }
 
        return knot_edns_get_option(pkt->opt_rr, KNOT_EDNS_OPTION_COOKIE);
 }
 
 int kr_parse_cookie_opt(uint8_t *cookie_opt, struct knot_dns_cookies *cookies)
 {
-       if (!cookie_opt || !cookies) {
+       if (!cookie_opt || !cookies)
                return kr_error(EINVAL);
-       }
 
        const uint8_t *cookie_data = knot_edns_opt_get_data(cookie_opt);
        uint16_t cookie_len = knot_edns_opt_get_length(cookie_opt);
-       if (!cookie_data || cookie_len == 0) {
+       if (!cookie_data || cookie_len == 0)
                return kr_error(EINVAL);
-       }
 
        int ret =  knot_edns_opt_cookie_parse(cookie_data, cookie_len,
                                              &cookies->cc, &cookies->cc_len,