treewide: avoid memset where it's trivial

More idiomatic code seems better:
- for variable initialization we have = { 0 }
- (mm_)calloc for heap allocations
  sizeof: use variable instead of type (where suitable; not sure why)

diff --git a/daemon/ffimodule.c b/daemon/ffimodule.c
index 073fb188ff06717b078fa9fd82a756303a4b92e1..44809f9485bc09de0cd50136cc45488d616a5b6f 100644 (file)
--- a/daemon/ffimodule.c
+++ b/daemon/ffimodule.c
@@ -257,9 +257,8 @@ static kr_layer_api_t *l_ffi_layer_create(lua_State *L, struct kr_module *module
         * reserve slots after it for references to Lua callbacks. */
        const size_t api_length = offsetof(kr_layer_api_t, cb_slots)
                                + (SLOT_count * sizeof(module->layer->cb_slots[0]));
-       kr_layer_api_t *api = malloc(api_length);
+       kr_layer_api_t *api = calloc(1, api_length);
        if (api) {
-               memset(api, 0, api_length);
                LAYER_REGISTER(L, api, begin);
                LAYER_REGISTER(L, api, finish);
                LAYER_REGISTER(L, api, consume);

diff --git a/daemon/worker.c b/daemon/worker.c
index 71394cfaa62c4327b99457240b093d7f0926fec8..8f7382a4e08c8739b66200e107a363a82663823d 100644 (file)
--- a/daemon/worker.c
+++ b/daemon/worker.c
@@ -343,14 +343,12 @@ static struct request_ctx *request_create(struct worker_ctx *worker,
        };
 
        /* Create request context */
-       struct request_ctx *ctx = mm_alloc(&pool, sizeof(*ctx));
+       struct request_ctx *ctx = mm_calloc(&pool, 1, sizeof(*ctx));
        if (!ctx) {
                pool_release(worker, pool.ctx);
                return NULL;
        }
 
-       memset(ctx, 0, sizeof(*ctx));
-
        /* TODO Relocate pool to struct request */
        ctx->worker = worker;
        if (session) {
@@ -484,11 +482,10 @@ static struct qr_task *qr_task_create(struct request_ctx *ctx)
        }
 
        /* Create resolution task */
-       struct qr_task *task = mm_alloc(&ctx->req.pool, sizeof(*task));
+       struct qr_task *task = mm_calloc(&ctx->req.pool, 1, sizeof(*task));
        if (!task) {
                return NULL;
        }
-       memset(task, 0, sizeof(*task)); /* avoid accidentally unintialized fields */
 
        /* Create packet buffers for answer and subrequests */
        knot_pkt_t *pktbuf = knot_pkt_new(NULL, pktbuf_max, &ctx->req.pool);

diff --git a/daemon/zimport.c b/daemon/zimport.c
index d302120e31ffd1d2a2c60c45a858cb0bc4b449b9..a634454011d8fd815bdaefea74f9dd53d2f5b0bf 100644 (file)
--- a/daemon/zimport.c
+++ b/daemon/zimport.c
@@ -79,7 +79,7 @@ static int RRSET_IS_ALREADY_IMPORTED = 1;
  * @return pointer to zone import context or NULL. */
 static zone_import_ctx_t *zi_ctx_alloc()
 {
-       return (zone_import_ctx_t *)malloc(sizeof(zone_import_ctx_t));
+       return calloc(1, sizeof(zone_import_ctx_t));
 }
 
 /** @internal Free zone import context. */
@@ -140,7 +140,6 @@ zone_import_ctx_t *zi_allocate(struct worker_ctx *worker,
                zi_ctx_free(z_import);
                return NULL;
        }
-       memset(z_import, 0, sizeof(*z_import));
        z_import->pool.ctx = mp;
        z_import->worker = worker;
        int ret = zi_reset(z_import, 0);
@@ -347,8 +346,7 @@ static int zi_rrset_import(zone_import_ctx_t *z_import, knot_rrset_t *rr)
        knot_pkt_put_question(answer, dname, rrclass, rrtype);
        knot_pkt_begin(answer, KNOT_ANSWER);
 
-       struct kr_qflags options;
-       memset(&options, 0, sizeof(options));
+       struct kr_qflags options = { 0 };
        options.DNSSEC_WANT = true;
        options.NO_MINIMIZE = true;
 

diff --git a/lib/cache/knot_pkt.c b/lib/cache/knot_pkt.c
index 1881290ffb0e55fc90a846bc4e0dc0f4830dc582..d913c5d997bd7f1544d0e19832cda5351958c32c 100644 (file)
--- a/lib/cache/knot_pkt.c
+++ b/lib/cache/knot_pkt.c
@@ -48,11 +48,10 @@ static int pkt_alloc_space(knot_pkt_t *pkt, int count)
        }
        /* Allocate pkt->rr_info to be certain, but just leave it zeroed. */
        mm_free(&pkt->mm, pkt->rr_info);
-       pkt->rr_info = mm_alloc(&pkt->mm, sizeof(pkt->rr_info[0]) * pkt->rrset_allocd);
+       pkt->rr_info = mm_calloc(&pkt->mm, pkt->rrset_allocd, sizeof(pkt->rr_info[0]));
        if (!pkt->rr_info) {
                return kr_error(ENOMEM);
        }
-       memset(pkt->rr_info, 0, sizeof(pkt->rr_info[0]) * pkt->rrset_allocd);
        return kr_ok();
 }
 

diff --git a/lib/rplan.c b/lib/rplan.c
index 02e32d3e469b5e54b1c09d189c8178785ad40806..88dc12d0c4d42d9d2b8e4c69fce4dcc84bbfc2e9 100644 (file)
--- a/lib/rplan.c
+++ b/lib/rplan.c
@@ -69,12 +69,11 @@ void kr_qflags_clear(struct kr_qflags *fl1, struct kr_qflags fl2)
 
 static struct kr_query *query_create(knot_mm_t *pool, const knot_dname_t *name, uint32_t uid)
 {
-       struct kr_query *qry = mm_alloc(pool, sizeof(struct kr_query));
+       struct kr_query *qry = mm_calloc(pool, 1, sizeof(*qry));
        if (qry == NULL) {
                return NULL;
        }
 
-       memset(qry, 0, sizeof(struct kr_query));
        if (name != NULL) {
                qry->sname = knot_dname_copy(name, pool);
                if (qry->sname == NULL) {

diff --git a/lib/selection.c b/lib/selection.c
index d6ef22fbf0810550b2e1fed8d09634ab5df3a2f2..2c155e4a2978cc15a8d6fb9d9bec5269e629adef 100644 (file)
--- a/lib/selection.c
+++ b/lib/selection.c
@@ -321,8 +321,7 @@ struct kr_transport *select_transport(struct choice choices[], int choices_len,
                return NULL;
        }
 
-       struct kr_transport *transport = mm_alloc(mempool, sizeof(struct kr_transport));
-       memset(transport, 0, sizeof(struct kr_transport));
+       struct kr_transport *transport = mm_calloc(mempool, 1, sizeof(*transport));
 
        int choice = 0;
        if (kr_rand_coin(EPSILON_NOMIN, EPSILON_DENOM) || choices_len == 0) {
@@ -552,8 +551,7 @@ void error(struct kr_query *qry, struct address_state *addr_state,
 void kr_server_selection_init(struct kr_query *qry)
 {
        struct knot_mm *mempool = &qry->request->pool;
-       struct local_state *local_state = mm_alloc(mempool, sizeof(struct local_state));
-       memset(local_state, 0, sizeof(struct local_state));
+       struct local_state *local_state = mm_calloc(mempool, 1, sizeof(*local_state));
 
        if (qry->flags.FORWARD || qry->flags.STUB) {
                qry->server_selection = (struct kr_server_selection){

diff --git a/lib/selection_forward.c b/lib/selection_forward.c
index b311fc9f95752cedb297bb6c550fead23b8a303a..8125f887c03a928142ccdf66fe35fc01dba8ed8a 100644 (file)
--- a/lib/selection_forward.c
+++ b/lib/selection_forward.c
@@ -20,15 +20,13 @@ void forward_local_state_alloc(struct knot_mm *mm, void **local_state,
                               struct kr_request *req)
 {
        assert(req->selection_context.forwarding_targets.at);
-       *local_state = mm_alloc(mm, sizeof(struct forward_local_state));
-       memset(*local_state, 0, sizeof(struct forward_local_state));
+       *local_state = mm_calloc(mm, 1, sizeof(struct forward_local_state));
 
        struct forward_local_state *forward_state = *local_state;
        forward_state->targets = &req->selection_context.forwarding_targets;
 
-       size_t as_bytes = sizeof(struct address_state) * forward_state->targets->len;
-       forward_state->addr_states = mm_alloc(mm, as_bytes);
-       memset(forward_state->addr_states, 0, as_bytes);
+       forward_state->addr_states = mm_calloc(mm, forward_state->targets->len,
+                                               sizeof(struct address_state));
 }
 
 void forward_choose_transport(struct kr_query *qry,

diff --git a/lib/selection_iter.c b/lib/selection_iter.c
index 388f29f8ea85941daa9a3b5789d4014ce3214d4d..394609f149df1fce01e07dfefe554ca48d3bcc0a 100644 (file)
--- a/lib/selection_iter.c
+++ b/lib/selection_iter.c
@@ -34,8 +34,7 @@ struct iter_name_state {
 
 void iter_local_state_alloc(struct knot_mm *mm, void **local_state)
 {
-       *local_state = mm_alloc(mm, sizeof(struct iter_local_state));
-       memset(*local_state, 0, sizeof(struct iter_local_state));
+       *local_state = mm_calloc(mm, 1, sizeof(struct iter_local_state));
 }
 
 static struct address_state *get_address_state(struct iter_local_state *local_state,
@@ -89,8 +88,7 @@ static void unpack_state_from_zonecut(struct iter_local_state *local_state,
                                               knot_dname_size(dname));
                if (!*val) {
                        /* We encountered this name for the first time. */
-                       *val = mm_alloc(mm, sizeof(struct iter_name_state));
-                       memset(*val, 0, sizeof(struct iter_name_state));
+                       *val = mm_calloc(mm, 1, sizeof(struct iter_name_state));
                }
                struct iter_name_state *name_state = *val;
                name_state->generation = current_generation;
@@ -112,8 +110,7 @@ static void unpack_state_from_zonecut(struct iter_local_state *local_state,
                                                        address_len);
                        if (!*tval) {
                                /* We have have not seen this address before. */
-                               *tval = mm_alloc(mm, sizeof(struct address_state));
-                               memset(*tval, 0, sizeof(struct address_state));
+                               *tval = mm_calloc(mm, 1, sizeof(struct address_state));
                        }
                        struct address_state *address_state = *tval;
                        address_state->generation = current_generation;

diff --git a/lib/utils.c b/lib/utils.c
index 50a6848a053e0be9cf5eac982f60ea97178ca405..a13a615e2bf49e9ec5b4ad44aeb7a7d1517dce80 100644 (file)
--- a/lib/utils.c
+++ b/lib/utils.c
@@ -752,11 +752,10 @@ int kr_ranked_rrarray_add(ranked_rr_array_t *array, const knot_rrset_t *rr,
                return kr_error(ret);
        }
 
-       ranked_rr_array_entry_t *entry = mm_alloc(pool, sizeof(ranked_rr_array_entry_t));
+       ranked_rr_array_entry_t *entry = mm_calloc(pool, 1, sizeof(*entry));
        if (!entry) {
                return kr_error(ENOMEM);
        }
-       memset(entry, 0, sizeof(*entry)); /* default all to zeros */
 
        knot_rrset_t *rr_new = knot_rrset_new(rr->owner, rr->type, rr->rclass, rr->ttl, pool);
        if (!rr_new) {

diff --git a/modules/bogus_log/bogus_log.c b/modules/bogus_log/bogus_log.c
index 3c0b4fcb331e88adbc0441decbdf5ec755488213..6237c14575b27ad6c6bdcf59e7c0efb4a448f784 100644 (file)
--- a/modules/bogus_log/bogus_log.c
+++ b/modules/bogus_log/bogus_log.c
@@ -112,11 +112,10 @@ int bogus_log_init(struct kr_module *module)
        };
        module->props = props;
 
-       struct stat_data *data = malloc(sizeof(*data));
+       struct stat_data *data = calloc(1, sizeof(*data));
        if (!data) {
                return kr_error(ENOMEM);
        }
-       memset(data, 0, sizeof(*data));
        module->data = data;
        lru_create(&data->frequent, FREQUENT_COUNT, NULL, NULL);
        return kr_ok();

diff --git a/modules/dnstap/dnstap.c b/modules/dnstap/dnstap.c
index ccddc67ef15377c3dd4611203b48c0a08cf43dee..9dcb7bba1d757aa0cdfa1995aef6262467e42fd7 100644 (file)
--- a/modules/dnstap/dnstap.c
+++ b/modules/dnstap/dnstap.c
@@ -256,11 +256,10 @@ int dnstap_init(struct kr_module *module) {
        module->layer = &layer;
 
        /* allocated memory for internal data */
-       struct dnstap_data *data = malloc(sizeof(*data));
+       struct dnstap_data *data = calloc(1, sizeof(*data));
        if (!data) {
                return kr_error(ENOMEM);
        }
-       memset(data, 0, sizeof(*data));
 
        /* save pointer to internal struct in module for future reference */
        module->data = data;

diff --git a/modules/stats/stats.c b/modules/stats/stats.c
index f9c47ba82b22de2c96b306493e821f15b7584405..54b7a87c44bd5188ff394f02e4cd5fa4f7b49f30 100644 (file)
--- a/modules/stats/stats.c
+++ b/modules/stats/stats.c
@@ -473,11 +473,10 @@ int stats_init(struct kr_module *module)
        };
        module->props = props;
 
-       struct stat_data *data = malloc(sizeof(*data));
+       struct stat_data *data = calloc(1, sizeof(*data));
        if (!data) {
                return kr_error(ENOMEM);
        }
-       memset(data, 0, sizeof(*data));
        data->map = map_make(NULL);
        module->data = data;
        lru_create(&data->queries.frequent, FREQUENT_COUNT, NULL, NULL);

diff --git a/tests/unit/test.h b/tests/unit/test.h
index b79f3734b2658f0a34c0ac5d693a959ecca530de..2c609973c571d438823e0a02a994901145b16810 100644 (file)
--- a/tests/unit/test.h
+++ b/tests/unit/test.h
@@ -85,7 +85,7 @@ static inline void test_randstr(char* dst, size_t len)
  */
 static inline void test_random_rr(knot_rrset_t *rr, uint32_t ttl)
 {
-       static uint8_t owner_buf[KNOT_DNAME_MAXLEN];
+       static uint8_t owner_buf[KNOT_DNAME_MAXLEN] = { 0 };
        static uint8_t rdata_buf[65535];
        knot_rdata_t *rdata = (knot_rdata_t *)rdata_buf;
 
@@ -93,7 +93,6 @@ static inline void test_random_rr(knot_rrset_t *rr, uint32_t ttl)
        uint8_t tmp_buf[KNOT_DNAME_MAXLEN];
 
        /* Create random label. */
-       memset(owner_buf, 0, sizeof(owner_buf));
        uint8_t label_len = num % KNOT_DNAME_MAXLABELLEN;
        owner_buf[0] = label_len;
        test_randstr((char *)(owner_buf + 1), label_len);