From 94ae366b28f0d51d3b9e9e26ec6ff1db7c2f06a2 Mon Sep 17 00:00:00 2001 From: Daniel Salzman Date: Wed, 4 Jul 2018 20:57:27 +0200 Subject: [PATCH] libknot/rdataset: rename structure items --- src/knot/ctl/commands.c | 2 +- src/knot/dnssec/ds_query.c | 2 +- src/knot/dnssec/nsec3-chain.c | 2 +- src/knot/dnssec/rrset-sign.c | 6 +- src/knot/dnssec/zone-nsec.c | 2 +- src/knot/dnssec/zone-sign.c | 6 +- src/knot/events/handlers/refresh.c | 2 +- src/knot/journal/serialization.c | 10 +-- src/knot/nameserver/process_query.c | 2 +- src/knot/updates/apply.c | 18 +++--- src/knot/updates/ddns.c | 8 +-- src/knot/zone/contents.c | 8 +-- src/knot/zone/node.c | 4 +- src/knot/zone/semantic-check.c | 20 +++--- src/knot/zone/zone-diff.c | 6 +- src/knot/zone/zone-dump.c | 8 +-- src/knot/zone/zonefile.c | 2 +- src/libknot/packet/pkt.c | 8 +-- src/libknot/packet/rrset-wire.c | 10 +-- src/libknot/rdataset.c | 96 ++++++++++++++--------------- src/libknot/rdataset.h | 10 +-- src/libknot/rrset-dump.c | 4 +- src/libknot/rrset.c | 4 +- src/libknot/rrset.h | 2 +- src/libknot/rrtype/opt.c | 4 +- src/libknot/rrtype/rrsig.h | 2 +- src/libknot/tsig-op.c | 4 +- src/utils/common/exec.c | 4 +- src/utils/kjournalprint/main.c | 2 +- tests/knot/test_node.c | 2 +- tests/knot/test_zone-update.c | 10 +-- tests/libknot/test_edns.c | 2 +- tests/libknot/test_rdataset.c | 42 ++++++------- tests/libknot/test_rrset.c | 4 +- 34 files changed, 159 insertions(+), 159 deletions(-) diff --git a/src/knot/ctl/commands.c b/src/knot/ctl/commands.c index cf203b6ad..49c5eca53 100644 --- a/src/knot/ctl/commands.c +++ b/src/knot/ctl/commands.c @@ -540,7 +540,7 @@ static int send_rrset(knot_rrset_t *rrset, send_ctx_t *ctx) return KNOT_ESPACE; } - for (size_t i = 0; i < rrset->rrs.rr_count; ++i) { + for (size_t i = 0; i < rrset->rrs.count; ++i) { ret = knot_rrset_txt_dump_data(rrset, i, ctx->rdata, sizeof(ctx->rdata), &ctx->style); if (ret < 0) { diff --git a/src/knot/dnssec/ds_query.c b/src/knot/dnssec/ds_query.c index 57cb0f22e..7db9926b6 100644 --- a/src/knot/dnssec/ds_query.c +++ b/src/knot/dnssec/ds_query.c @@ -94,7 +94,7 @@ static int ds_query_consume(knot_layer_t *layer, knot_pkt_t *pkt) for (size_t j = 0; j < answer->count; j++) { const knot_rrset_t *rr = knot_pkt_rr(answer, j); - if (!rr || rr->type != KNOT_RRTYPE_DS || rr->rrs.rr_count != 1) { + if (!rr || rr->type != KNOT_RRTYPE_DS || rr->rrs.count != 1) { ns_log(LOG_WARNING, data->zone_name, LOG_OPERATION_PARENT, LOG_DIRECTION_OUT, data->remote, "malformed message"); return KNOT_STATE_FAIL; diff --git a/src/knot/dnssec/nsec3-chain.c b/src/knot/dnssec/nsec3-chain.c index b13826f86..2aa60aa08 100644 --- a/src/knot/dnssec/nsec3-chain.c +++ b/src/knot/dnssec/nsec3-chain.c @@ -44,7 +44,7 @@ inline static bool valid_nsec3_node(const zone_node_t *node) return false; } - if (nsec3->rr_count != 1) { + if (nsec3->count != 1) { return false; } diff --git a/src/knot/dnssec/rrset-sign.c b/src/knot/dnssec/rrset-sign.c index a0ecb5d0a..dfbb3ed39 100644 --- a/src/knot/dnssec/rrset-sign.c +++ b/src/knot/dnssec/rrset-sign.c @@ -281,11 +281,11 @@ int knot_synth_rrsig(uint16_t type, const knot_rdataset_t *rrsig_rrs, return KNOT_ENOENT; } - if (out_sig == NULL || out_sig->rr_count > 0) { + if (out_sig == NULL || out_sig->count > 0) { return KNOT_EINVAL; } - for (int i = 0; i < rrsig_rrs->rr_count; ++i) { + for (int i = 0; i < rrsig_rrs->count; ++i) { if (type == knot_rrsig_type_covered(rrsig_rrs, i)) { const knot_rdata_t *rr_to_copy = knot_rdataset_at(rrsig_rrs, i); int ret = knot_rdataset_add(out_sig, rr_to_copy, mm); @@ -296,7 +296,7 @@ int knot_synth_rrsig(uint16_t type, const knot_rdataset_t *rrsig_rrs, } } - return out_sig->rr_count > 0 ? KNOT_EOK : KNOT_ENOENT; + return out_sig->count > 0 ? KNOT_EOK : KNOT_ENOENT; } /*- Verification of signatures -----------------------------------------------*/ diff --git a/src/knot/dnssec/zone-nsec.c b/src/knot/dnssec/zone-nsec.c index a410c1b53..172fe7409 100644 --- a/src/knot/dnssec/zone-nsec.c +++ b/src/knot/dnssec/zone-nsec.c @@ -174,7 +174,7 @@ static bool nsec3param_valid(const knot_rdataset_t *rrs, } // multiple NSEC3 records - if (rrs->rr_count != 1) { + if (rrs->count != 1) { return false; } diff --git a/src/knot/dnssec/zone-sign.c b/src/knot/dnssec/zone-sign.c index 8f2cc1bf8..df8975505 100644 --- a/src/knot/dnssec/zone-sign.c +++ b/src/knot/dnssec/zone-sign.c @@ -110,7 +110,7 @@ static bool valid_signature_exists(const knot_rrset_t *covered, return false; } - uint16_t rrsigs_rdata_count = rrsigs->rrs.rr_count; + uint16_t rrsigs_rdata_count = rrsigs->rrs.count; for (uint16_t i = 0; i < rrsigs_rdata_count; i++) { uint16_t rr_keytag = knot_rrsig_key_tag(&rrsigs->rrs, i); uint16_t rr_covered = knot_rrsig_type_covered(&rrsigs->rrs, i); @@ -278,7 +278,7 @@ static int remove_expired_rrsigs(const knot_rrset_t *covered, return KNOT_EOK; } - uint16_t rrsig_rdata_count = synth_rrsig.rrs.rr_count; + uint16_t rrsig_rdata_count = synth_rrsig.rrs.count; for (uint16_t i = 0; i < rrsig_rdata_count; i++) { struct keyptr_dynarray keys = get_matching_zone_keys(&synth_rrsig, i, zone_keys); int endloop = 0; // 1 - continue; 2 - break @@ -481,7 +481,7 @@ static int remove_standalone_rrsigs(const zone_node_t *node, return KNOT_EOK; } - uint16_t rrsigs_rdata_count = rrsigs->rrs.rr_count; + uint16_t rrsigs_rdata_count = rrsigs->rrs.count; for (uint16_t i = 0; i < rrsigs_rdata_count; ++i) { uint16_t type_covered = knot_rrsig_type_covered(&rrsigs->rrs, i); if (!node_rrtype_exists(node, type_covered)) { diff --git a/src/knot/events/handlers/refresh.c b/src/knot/events/handlers/refresh.c index 13879c7cd..d5320604d 100644 --- a/src/knot/events/handlers/refresh.c +++ b/src/knot/events/handlers/refresh.c @@ -832,7 +832,7 @@ static int soa_query_consume(knot_layer_t *layer, knot_pkt_t *pkt) const knot_pktsection_t *answer = knot_pkt_section(pkt, KNOT_ANSWER); const knot_rrset_t *rr = answer->count == 1 ? knot_pkt_rr(answer, 0) : NULL; - if (!rr || rr->type != KNOT_RRTYPE_SOA || rr->rrs.rr_count != 1) { + if (!rr || rr->type != KNOT_RRTYPE_SOA || rr->rrs.count != 1) { REFRESH_LOG(LOG_WARNING, data->zone->name, data->remote, "malformed message"); return KNOT_STATE_FAIL; diff --git a/src/knot/journal/serialization.c b/src/knot/journal/serialization.c index 6a207feb0..6d234fc4b 100644 --- a/src/knot/journal/serialization.c +++ b/src/knot/journal/serialization.c @@ -114,7 +114,7 @@ void serialize_prepare(serialize_ctx_t *ctx, size_t max_size, size_t *realsize) size_t candidate = 0; long tmp_phase = ctx->rrset_phase; while (1) { - if (tmp_phase >= ctx->rrset_buf[ctx->rrset_buf_size - 1].rrs.rr_count) { + if (tmp_phase >= ctx->rrset_buf[ctx->rrset_buf_size - 1].rrs.count) { if (ctx->rrset_buf_size >= RRSET_BUF_MAXSIZE) { return; } @@ -145,7 +145,7 @@ void serialize_chunk(serialize_ctx_t *ctx, uint8_t *dst_chunk, size_t chunk_size wire_ctx_t wire = wire_ctx_init(dst_chunk, chunk_size); for (size_t i = 0; ; ) { - if (ctx->rrset_phase >= ctx->rrset_buf[i].rrs.rr_count) { + if (ctx->rrset_phase >= ctx->rrset_buf[i].rrs.count) { if (++i >= ctx->rrset_buf_size) { break; } @@ -160,7 +160,7 @@ void serialize_chunk(serialize_ctx_t *ctx, uint8_t *dst_chunk, size_t chunk_size wire_ctx_skip(&wire, size); wire_ctx_write_u16(&wire, ctx->rrset_buf[i].type); wire_ctx_write_u16(&wire, ctx->rrset_buf[i].rclass); - wire_ctx_write_u16(&wire, ctx->rrset_buf[i].rrs.rr_count); + wire_ctx_write_u16(&wire, ctx->rrset_buf[i].rrs.count); } else { const knot_rdata_t *rr = knot_rdataset_at(&ctx->rrset_buf[i].rrs, ctx->rrset_phase); @@ -265,7 +265,7 @@ int deserialize_rrset_chunks(wire_ctx_t *wire, knot_rrset_t *rrset, static uint64_t rrset_binary_size(const knot_rrset_t *rrset) { - if (rrset == NULL || rrset->rrs.rr_count == 0) { + if (rrset == NULL || rrset->rrs.count == 0) { return 0; } @@ -273,7 +273,7 @@ static uint64_t rrset_binary_size(const knot_rrset_t *rrset) uint64_t size = knot_dname_size(rrset->owner) + 3 * sizeof(uint16_t); // RRs. - for (uint16_t i = 0; i < rrset->rrs.rr_count; i++) { + for (uint16_t i = 0; i < rrset->rrs.count; i++) { const knot_rdata_t *rr = knot_rdataset_at(&rrset->rrs, i); assert(rr); diff --git a/src/knot/nameserver/process_query.c b/src/knot/nameserver/process_query.c index c49d6bb7f..b8ecd99ed 100644 --- a/src/knot/nameserver/process_query.c +++ b/src/knot/nameserver/process_query.c @@ -824,7 +824,7 @@ int process_query_put_rr(knot_pkt_t *pkt, knotd_qdata_t *qdata, const knot_rrset_t *rr, const knot_rrset_t *rrsigs, uint16_t compr_hint, uint32_t flags) { - if (rr->rrs.rr_count < 1) { + if (rr->rrs.count < 1) { return KNOT_EMALF; } diff --git a/src/knot/updates/apply.c b/src/knot/updates/apply.c index 977f2ba32..f61359ec6 100644 --- a/src/knot/updates/apply.c +++ b/src/knot/updates/apply.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2017 CZ.NIC, z.s.p.o. +/* Copyright (C) 2018 CZ.NIC, z.s.p.o. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -76,10 +76,10 @@ static int replace_rdataset_with_copy(zone_node_t *node, uint16_t type) return KNOT_ENOMEM; } - memcpy(copy, rrs->data, knot_rdataset_size(rrs)); + memcpy(copy, rrs->rdata, knot_rdataset_size(rrs)); // Store new data into node RRS. - rrs->data = copy; + rrs->rdata = copy; return KNOT_EOK; } @@ -126,7 +126,7 @@ static bool can_remove(const zone_node_t *node, const knot_rrset_t *rr) return false; } - for (uint16_t i = 0; i < rr->rrs.rr_count; ++i) { + for (uint16_t i = 0; i < rr->rrs.count; ++i) { knot_rdata_t *rr_cmp = knot_rdataset_at(&rr->rrs, i); if (knot_rdataset_member(node_rrs, rr_cmp)) { // At least one RR matches. @@ -264,7 +264,7 @@ int apply_add_rr(apply_ctx_t *ctx, const knot_rrset_t *rr) knot_rrset_t changed_rrset = node_rrset(node, rr->type); if (!knot_rrset_empty(&changed_rrset)) { // Modifying existing RRSet. - knot_rdata_t *old_data = changed_rrset.rrs.data; + knot_rdata_t *old_data = changed_rrset.rrs.rdata; int ret = replace_rdataset_with_copy(node, rr->type); if (ret != KNOT_EOK) { return ret; @@ -283,7 +283,7 @@ int apply_add_rr(apply_ctx_t *ctx, const knot_rrset_t *rr) if (ret == KNOT_EOK || ret == KNOT_ETTL) { // RR added, store for possible rollback. knot_rdataset_t *rrs = node_rdataset(node, rr->type); - int data_ret = add_new_data(ctx, rrs->data); + int data_ret = add_new_data(ctx, rrs->rdata); if (data_ret != KNOT_EOK) { knot_rdataset_clear(rrs, NULL); return data_ret; @@ -326,7 +326,7 @@ int apply_remove_rr(apply_ctx_t *ctx, const knot_rrset_t *rr) contents->nsec3_nodes : contents->nodes; knot_rrset_t removed_rrset = node_rrset(node, rr->type); - knot_rdata_t *old_data = removed_rrset.rrs.data; + knot_rdata_t *old_data = removed_rrset.rrs.rdata; int ret = replace_rdataset_with_copy(node, rr->type); if (ret != KNOT_EOK) { return ret; @@ -347,9 +347,9 @@ int apply_remove_rr(apply_ctx_t *ctx, const knot_rrset_t *rr) return ret; } - if (changed_rrs->rr_count > 0) { + if (changed_rrs->count > 0) { // Subtraction left some data in RRSet, store it for rollback. - ret = add_new_data(ctx, changed_rrs->data); + ret = add_new_data(ctx, changed_rrs->rdata); if (ret != KNOT_EOK) { knot_rdataset_clear(changed_rrs, NULL); return ret; diff --git a/src/knot/updates/ddns.c b/src/knot/updates/ddns.c index 7119f2065..8b82ab34e 100644 --- a/src/knot/updates/ddns.c +++ b/src/knot/updates/ddns.c @@ -163,7 +163,7 @@ static int check_not_in_use(zone_update_t *update, /*!< \brief Returns true if rrset has 0 data or RDATA of size 0 (we need TTL).*/ static bool rrset_empty(const knot_rrset_t *rrset) { - uint16_t rr_count = rrset->rrs.rr_count; + uint16_t rr_count = rrset->rrs.count; if (rr_count == 0) { return true; } @@ -282,7 +282,7 @@ static bool node_contains_rr(const zone_node_t *node, { const knot_rdataset_t *zone_rrs = node_rdataset(node, rr->type); if (zone_rrs) { - assert(rr->rrs.rr_count == 1); + assert(rr->rrs.count == 1); return knot_rdataset_member(zone_rrs, knot_rdataset_at(&rr->rrs, 0)); } else { return false; @@ -494,7 +494,7 @@ static int process_rem_rr(const knot_rrset_t *rr, // Zone without apex NS. return KNOT_EOK; } - if (ns_rrs->rr_count == 1) { + if (ns_rrs->count == 1) { // Cannot remove last apex NS RR. return KNOT_EOK; } @@ -507,7 +507,7 @@ static int process_rem_rr(const knot_rrset_t *rr, } knot_rdataset_t *rrs = node_rdataset(node, rr->type); - if (!knot_rdataset_member(rrs, rr->rrs.data)) { + if (!knot_rdataset_member(rrs, rr->rrs.rdata)) { // Node does not contain this RR return KNOT_EOK; } diff --git a/src/knot/zone/contents.c b/src/knot/zone/contents.c index da24c9022..9a7719233 100644 --- a/src/knot/zone/contents.c +++ b/src/knot/zone/contents.c @@ -120,7 +120,7 @@ static int discover_additionals(const knot_dname_t *owner, struct rr_data *rr_da rr_data->additional = NULL; const knot_rdataset_t *rrs = &rr_data->rrs; - uint16_t rdcount = rrs->rr_count; + uint16_t rdcount = rrs->count; uint16_t mandatory_count = 0; uint16_t others_count = 0; @@ -353,7 +353,7 @@ static int adjust_nsec3_node(zone_node_t **tnode, void *data) // check if this node belongs to correct chain const knot_rdataset_t *nsec3_rrs = node_rdataset(node, KNOT_RRTYPE_NSEC3); - for (uint16_t i = 0; nsec3_rrs != NULL && i < nsec3_rrs->rr_count; i++) { + for (uint16_t i = 0; nsec3_rrs != NULL && i < nsec3_rrs->count; i++) { if (nsec3_params_match(nsec3_rrs, &args->zone->nsec3_params, i)) { node->flags |= NODE_FLAGS_IN_NSEC3_CHAIN; } @@ -641,7 +641,7 @@ static int remove_rr(zone_contents_t *z, const knot_rrset_t *rr, return ret; } - if (node_rrs->rr_count == 0) { + if (node_rrs->count == 0) { // RRSet is empty now, remove it from node, all data freed. node_remove_rdataset(node, rr->type); // If node is empty now, delete it from zone tree. @@ -966,7 +966,7 @@ static int load_nsec3param(zone_contents_t *contents) return KNOT_EOK; } - if (rrs->rr_count < 1) { + if (rrs->count < 1) { return KNOT_EINVAL; } diff --git a/src/knot/zone/node.c b/src/knot/zone/node.c index 8474bc6b3..c621035e0 100644 --- a/src/knot/zone/node.c +++ b/src/knot/zone/node.c @@ -76,7 +76,7 @@ static int add_rrset_no_merge(zone_node_t *node, const knot_rrset_t *rrset, /*! \brief Checks if the added RR has the same TTL as the first RR in the node. */ static bool ttl_changed(struct rr_data *node_data, const knot_rrset_t *rrset) { - if (rrset->type == KNOT_RRTYPE_RRSIG || node_data->rrs.rr_count == 0) { + if (rrset->type == KNOT_RRTYPE_RRSIG || node_data->rrs.count == 0) { return false; } @@ -272,7 +272,7 @@ bool node_rrtype_is_signed(const zone_node_t *node, uint16_t type) return false; } - uint16_t rrsigs_rdata_count = rrsigs->rr_count; + uint16_t rrsigs_rdata_count = rrsigs->count; for (uint16_t i = 0; i < rrsigs_rdata_count; ++i) { const uint16_t type_covered = knot_rrsig_type_covered(rrsigs, i); diff --git a/src/knot/zone/semantic-check.c b/src/knot/zone/semantic-check.c index f106a6af1..f7765cc6c 100644 --- a/src/knot/zone/semantic-check.c +++ b/src/knot/zone/semantic-check.c @@ -349,7 +349,7 @@ static int check_rrsig_rdata(sem_handler_t *handler, return KNOT_EOK; } - for (int i = 0; i < dnskeys->rr_count; i++) { + for (int i = 0; i < dnskeys->count; i++) { uint16_t flags = knot_dnskey_flags(dnskeys, i); uint8_t proto = knot_dnskey_proto(dnskeys, i); /* RFC 4034 2.1.1 & 2.1.2 */ @@ -432,7 +432,7 @@ static int check_rrsig_in_rrset(sem_handler_t *handler, } bool verified = false; - for (uint16_t i = 0; ret == KNOT_EOK && i < (&rrsigs)->rr_count; ++i) { + for (uint16_t i = 0; ret == KNOT_EOK && i < (&rrsigs)->count; ++i) { ret = check_rrsig_rdata(handler, zone, node, &rrsigs, i, rrset, context, level, &verified); } @@ -468,7 +468,7 @@ static int check_delegation(const zone_node_t *node, semchecks_data_t *data) } // check glue record for delegation - for (int i = 0; i < ns_rrs->rr_count; ++i) { + for (int i = 0; i < ns_rrs->count; ++i) { const knot_dname_t *ns_dname = knot_ns_name(ns_rrs, i); if (!knot_dname_is_sub(ns_dname, node->owner)) { continue; @@ -515,11 +515,11 @@ static int check_submission(const zone_node_t *node, semchecks_data_t *data) return KNOT_EOK; } - if (cdss->rr_count != 1) { + if (cdss->count != 1) { data->handler->cb(data->handler, data->zone, node, SEM_ERR_CDS_MULTIPLE, NULL); } - if (cdnskeys->rr_count != 1) { + if (cdnskeys->count != 1) { data->handler->cb(data->handler, data->zone, node, SEM_ERR_CDNSKEY_MULTIPLE, NULL); } @@ -530,7 +530,7 @@ static int check_submission(const zone_node_t *node, semchecks_data_t *data) const knot_rdataset_t *dnskeys = node_rdataset(data->zone->apex, KNOT_RRTYPE_DNSKEY); - for (int i = 0; dnskeys != NULL && i < dnskeys->rr_count; i++) { + for (int i = 0; dnskeys != NULL && i < dnskeys->count; i++) { knot_rdata_t *dnskey = knot_rdataset_at(dnskeys, i); if (knot_rdata_cmp(dnskey, cdnskey) != 0) { continue; @@ -585,7 +585,7 @@ static int check_ds(const zone_node_t *node, semchecks_data_t *data) return KNOT_EOK; } - for (int i = 0; i < dss->rr_count; i++) { + for (int i = 0; i < dss->count; i++) { uint16_t keytag = knot_ds_key_tag(dss, i); uint8_t digest_type = knot_ds_digest_type(dss, i); @@ -772,7 +772,7 @@ static int check_nsec(const zone_node_t *node, semchecks_data_t *data) } /* Test that only one record is in the NSEC RRSet */ - if (nsec_rrs->rr_count != 1) { + if (nsec_rrs->count != 1) { data->handler->cb(data->handler, data->zone, node, SEM_ERR_NSEC_RDATA_MULTIPLE, NULL); } @@ -1015,7 +1015,7 @@ static int check_cname(const zone_node_t *node, semchecks_data_t *data) data->handler->cb(data->handler, data->zone, node, SEM_ERR_CNAME_EXTRA_RECORDS, NULL); } - if (cname_rrs->rr_count != 1) { + if (cname_rrs->count != 1) { data->handler->fatal_error = true; data->handler->cb(data->handler, data->zone, node, SEM_ERR_CNAME_MULTIPLE, NULL); @@ -1114,7 +1114,7 @@ static void check_dnskey(zone_contents_t *zone, sem_handler_t *handler) return; } - for (int i = 0; i < dnskeys->rr_count; i++) { + for (int i = 0; i < dnskeys->count; i++) { knot_rdata_t *dnskey = knot_rdataset_at(dnskeys, i); dnssec_key_t *key; int ret = dnssec_key_from_rdata(&key, zone->apex->owner, diff --git a/src/knot/zone/zone-diff.c b/src/knot/zone/zone-diff.c index 9f26e6ccd..d9e1cb6f5 100644 --- a/src/knot/zone/zone-diff.c +++ b/src/knot/zone/zone-diff.c @@ -46,8 +46,8 @@ static int load_soas(const zone_contents_t *zone1, const zone_contents_t *zone2, return KNOT_EINVAL; } - if (soa_rrset1.rrs.rr_count == 0 || - soa_rrset2.rrs.rr_count == 0) { + if (soa_rrset1.rrs.count == 0 || + soa_rrset2.rrs.count == 0) { return KNOT_EINVAL; } @@ -129,7 +129,7 @@ static int rdata_return_changes(const knot_rrset_t *rrset1, * changed/removed rdatas. This has awful computation time. */ bool ttl_differ = rrset1->ttl != rrset2->ttl; - uint16_t rr1_count = rrset1->rrs.rr_count; + uint16_t rr1_count = rrset1->rrs.count; for (uint16_t i = 0; i < rr1_count; ++i) { if (ttl_differ || !rr_exists(rrset2, rrset1, i)) { /* diff --git a/src/knot/zone/zone-dump.c b/src/knot/zone/zone-dump.c index f72ea66c2..9729cbc08 100644 --- a/src/knot/zone/zone-dump.c +++ b/src/knot/zone/zone-dump.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2016 CZ.NIC, z.s.p.o. +/* Copyright (C) 2018 CZ.NIC, z.s.p.o. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -48,7 +48,7 @@ static int apex_node_dump_text(zone_node_t *node, dump_params_t *params) if (ret < 0) { return ret; } - params->rr_count += soa.rrs.rr_count; + params->rr_count += soa.rrs.count; fprintf(params->file, "%s", params->buf); params->buf[0] = '\0'; } @@ -72,7 +72,7 @@ static int apex_node_dump_text(zone_node_t *node, dump_params_t *params) if (ret < 0) { return ret; } - params->rr_count += rrset.rrs.rr_count; + params->rr_count += rrset.rrs.count; fprintf(params->file, "%s", params->buf); params->buf[0] = '\0'; } @@ -128,7 +128,7 @@ static int node_dump_text(zone_node_t *node, void *data) if (ret < 0) { return ret; } - params->rr_count += rrset.rrs.rr_count; + params->rr_count += rrset.rrs.count; fprintf(params->file, "%s", params->buf); params->buf[0] = '\0'; } diff --git a/src/knot/zone/zonefile.c b/src/knot/zone/zonefile.c index d8f4c256f..37fc90bfd 100644 --- a/src/knot/zone/zonefile.c +++ b/src/knot/zone/zonefile.c @@ -76,7 +76,7 @@ static bool handle_err(zcreator_t *zc, const knot_rrset_t *rr, int ret, bool mas int zcreator_step(zcreator_t *zc, const knot_rrset_t *rr) { - if (zc == NULL || rr == NULL || rr->rrs.rr_count != 1) { + if (zc == NULL || rr == NULL || rr->rrs.count != 1) { return KNOT_EINVAL; } diff --git a/src/libknot/packet/pkt.c b/src/libknot/packet/pkt.c index 07078f11a..15be29b17 100644 --- a/src/libknot/packet/pkt.c +++ b/src/libknot/packet/pkt.c @@ -43,8 +43,8 @@ static bool pkt_contains(const knot_pkt_t *packet, const knot_rrset_t *rrset) for (int i = 0; i < packet->rrset_count; ++i) { const uint16_t type = packet->rr[i].type; - const knot_rdata_t *data = packet->rr[i].rrs.data; - if (type == rrset->type && data == rrset->rrs.data) { + const knot_rdata_t *data = packet->rr[i].rrs.rdata; + if (type == rrset->type && data == rrset->rrs.rdata) { return true; } } @@ -544,7 +544,7 @@ int knot_pkt_put_rotate(knot_pkt_t *pkt, uint16_t compr_hint, const knot_rrset_t } size_t len = ret; - uint16_t rr_added = rr->rrs.rr_count; + uint16_t rr_added = rr->rrs.count; /* Keep reference to special types. */ if (rr->type == KNOT_RRTYPE_OPT) { @@ -736,7 +736,7 @@ static int parse_payload(knot_pkt_t *pkt, unsigned flags) const knot_pktsection_t *ar = knot_pkt_section(pkt, KNOT_ADDITIONAL); if (pkt->tsig_rr != NULL) { const knot_rrset_t *last_rr = knot_pkt_rr(ar, ar->count - 1); - if (ar->count > 0 && pkt->tsig_rr->rrs.data != last_rr->rrs.data) { + if (ar->count > 0 && pkt->tsig_rr->rrs.rdata != last_rr->rrs.rdata) { return KNOT_EMALF; } } diff --git a/src/libknot/packet/rrset-wire.c b/src/libknot/packet/rrset-wire.c index a7a5fb06f..b2cd5af29 100644 --- a/src/libknot/packet/rrset-wire.c +++ b/src/libknot/packet/rrset-wire.c @@ -316,7 +316,7 @@ static int write_fixed_header(const knot_rrset_t *rrset, uint16_t rrset_index, uint8_t **dst, size_t *dst_avail) { assert(rrset); - assert(rrset_index < rrset->rrs.rr_count); + assert(rrset_index < rrset->rrs.count); assert(dst && *dst); assert(dst_avail); @@ -420,7 +420,7 @@ static int write_rdata(const knot_rrset_t *rrset, uint16_t rrset_index, uint8_t **dst, size_t *dst_avail, knot_compr_t *compr) { assert(rrset); - assert(rrset_index < rrset->rrs.rr_count); + assert(rrset_index < rrset->rrs.count); assert(dst && *dst); assert(dst_avail); @@ -486,17 +486,17 @@ int knot_rrset_to_wire_rotate(const knot_rrset_t *rrset, uint8_t *wire, if (rrset == NULL || wire == NULL) { return KNOT_EINVAL; } - if (rrset->rrs.rr_count == 0) { + if (rrset->rrs.count == 0) { return 0; } if (rotate != 0) { - rotate %= rrset->rrs.rr_count; + rotate %= rrset->rrs.count; } uint8_t *write = wire; size_t capacity = max_size; - uint16_t count = rrset->rrs.rr_count; + uint16_t count = rrset->rrs.count; for (uint16_t i = rotate; i < count + rotate; i++) { uint16_t pos = (i < count) ? i : (i - count); int ret = write_rr(rrset, pos, &write, &capacity, compr); diff --git a/src/libknot/rdataset.c b/src/libknot/rdataset.c index b07e03799..097104d6e 100644 --- a/src/libknot/rdataset.c +++ b/src/libknot/rdataset.c @@ -26,10 +26,10 @@ static knot_rdata_t *rr_seek(const knot_rdataset_t *rrs, uint16_t pos) { assert(rrs); - assert(0 < rrs->rr_count); - assert(pos < rrs->rr_count); + assert(0 < rrs->count); + assert(pos < rrs->count); - uint8_t *raw = (uint8_t *)(rrs->data); + uint8_t *raw = (uint8_t *)(rrs->rdata); for (uint16_t i = 0; i < pos; ++i) { raw += knot_rdata_size(((knot_rdata_t *)raw)->len); } @@ -39,7 +39,7 @@ static knot_rdata_t *rr_seek(const knot_rdataset_t *rrs, uint16_t pos) static int find_rr_pos(const knot_rdataset_t *rrs, const knot_rdata_t *rr) { - for (uint16_t i = 0; i < rrs->rr_count; ++i) { + for (uint16_t i = 0; i < rrs->count; ++i) { const knot_rdata_t *search_rr = rr_seek(rrs, i); if (knot_rdata_cmp(rr, search_rr) == 0) { return i; @@ -54,9 +54,9 @@ static int add_rr_at(knot_rdataset_t *rrs, const knot_rdata_t *rr, uint16_t pos, { assert(rrs); assert(rr); - assert(pos <= rrs->rr_count); + assert(pos <= rrs->count); - if (rrs->rr_count == UINT16_MAX) { + if (rrs->count == UINT16_MAX) { return KNOT_ESPACE; } @@ -64,17 +64,17 @@ static int add_rr_at(knot_rdataset_t *rrs, const knot_rdata_t *rr, uint16_t pos, size_t new_size = knot_rdata_size(rr->len); // Realloc RDATA. - knot_rdata_t *tmp = mm_realloc(mm, rrs->data, total_size + new_size, + knot_rdata_t *tmp = mm_realloc(mm, rrs->rdata, total_size + new_size, total_size); if (tmp == NULL) { return KNOT_ENOMEM; } else { - rrs->data = tmp; + rrs->rdata = tmp; } - if (rrs->rr_count == 0 || pos == rrs->rr_count) { + if (rrs->count == 0 || pos == rrs->count) { // No need to rearange RDATA. - rrs->rr_count++; + rrs->count++; knot_rdata_t *new_rr = rr_seek(rrs, pos); knot_rdata_init(new_rr, rr->len, rr->data); return KNOT_EOK; @@ -82,7 +82,7 @@ static int add_rr_at(knot_rdataset_t *rrs, const knot_rdata_t *rr, uint16_t pos, // RDATA have to be rearanged. knot_rdata_t *old_rr = rr_seek(rrs, pos); - knot_rdata_t *last_rr = rr_seek(rrs, rrs->rr_count - 1); + knot_rdata_t *last_rr = rr_seek(rrs, rrs->count - 1); // Make space for new RDATA by moving the array. uint8_t *dst = (uint8_t *)old_rr + new_size; @@ -93,7 +93,7 @@ static int add_rr_at(knot_rdataset_t *rrs, const knot_rdata_t *rr, uint16_t pos, // Set new RDATA. knot_rdata_init(old_rr, rr->len, rr->data); - rrs->rr_count++; + rrs->count++; return KNOT_EOK; } @@ -101,11 +101,11 @@ static int add_rr_at(knot_rdataset_t *rrs, const knot_rdata_t *rr, uint16_t pos, static int remove_rr_at(knot_rdataset_t *rrs, uint16_t pos, knot_mm_t *mm) { assert(rrs); - assert(0 < rrs->rr_count); - assert(pos < rrs->rr_count); + assert(0 < rrs->count); + assert(pos < rrs->count); knot_rdata_t *old_rr = rr_seek(rrs, pos); - knot_rdata_t *last_rr = rr_seek(rrs, rrs->rr_count - 1); + knot_rdata_t *last_rr = rr_seek(rrs, rrs->count - 1); size_t total_size = knot_rdataset_size(rrs); size_t old_size = knot_rdata_size(old_rr->len); @@ -116,21 +116,21 @@ static int remove_rr_at(knot_rdataset_t *rrs, uint16_t pos, knot_mm_t *mm) assert(old_threshold <= last_threshold); memmove(old_rr, old_threshold, last_threshold - old_threshold); - if (rrs->rr_count > 1) { + if (rrs->count > 1) { // Realloc RDATA. - knot_rdata_t *tmp = mm_realloc(mm, rrs->data, total_size - old_size, + knot_rdata_t *tmp = mm_realloc(mm, rrs->rdata, total_size - old_size, total_size); if (tmp == NULL) { return KNOT_ENOMEM; } else { - rrs->data = tmp; + rrs->rdata = tmp; } } else { // Free RDATA. - mm_free(mm, rrs->data); - rrs->data = NULL; + mm_free(mm, rrs->rdata); + rrs->rdata = NULL; } - rrs->rr_count--; + rrs->count--; return KNOT_EOK; } @@ -142,7 +142,7 @@ void knot_rdataset_clear(knot_rdataset_t *rrs, knot_mm_t *mm) return; } - mm_free(mm, rrs->data); + mm_free(mm, rrs->rdata); knot_rdataset_init(rrs); } @@ -153,14 +153,14 @@ int knot_rdataset_copy(knot_rdataset_t *dst, const knot_rdataset_t *src, knot_mm return KNOT_EINVAL; } - dst->rr_count = src->rr_count; + dst->count = src->count; size_t src_size = knot_rdataset_size(src); - dst->data = mm_alloc(mm, src_size); - if (dst->data == NULL) { + dst->rdata = mm_alloc(mm, src_size); + if (dst->rdata == NULL) { return KNOT_ENOMEM; } - memcpy(dst->data, src->data, src_size); + memcpy(dst->rdata, src->rdata, src_size); return KNOT_EOK; } @@ -168,7 +168,7 @@ int knot_rdataset_copy(knot_rdataset_t *dst, const knot_rdataset_t *src, knot_mm _public_ knot_rdata_t *knot_rdataset_at(const knot_rdataset_t *rrs, uint16_t pos) { - if (rrs == NULL || rrs->rr_count == 0 || pos >= rrs->rr_count) { + if (rrs == NULL || rrs->count == 0 || pos >= rrs->count) { return NULL; } @@ -178,12 +178,12 @@ knot_rdata_t *knot_rdataset_at(const knot_rdataset_t *rrs, uint16_t pos) _public_ size_t knot_rdataset_size(const knot_rdataset_t *rrs) { - if (rrs == NULL || rrs->rr_count == 0) { + if (rrs == NULL || rrs->count == 0) { return 0; } - const knot_rdata_t *last = rr_seek(rrs, rrs->rr_count - 1); - return (uint8_t *)last + knot_rdata_size(last->len) - (uint8_t *)rrs->data; + const knot_rdata_t *last = rr_seek(rrs, rrs->count - 1); + return (uint8_t *)last + knot_rdata_size(last->len) - (uint8_t *)rrs->rdata; } _public_ @@ -194,11 +194,11 @@ int knot_rdataset_add(knot_rdataset_t *rrs, const knot_rdata_t *rr, knot_mm_t *m } // First insert to empty rdataset. - if (rrs->rr_count == 0) { + if (rrs->count == 0) { return add_rr_at(rrs, rr, 0, mm); } - for (int i = rrs->rr_count - 1; i >= 0; --i) { + for (int i = rrs->count - 1; i >= 0; --i) { const knot_rdata_t *rrset_rr = rr_seek(rrs, i); int cmp = knot_rdata_cmp(rrset_rr, rr); if (cmp == 0) { @@ -219,22 +219,22 @@ int knot_rdataset_reserve(knot_rdataset_t *rrs, uint16_t size, knot_mm_t *mm) { if (rrs == NULL) { return KNOT_EINVAL; - } else if (rrs->rr_count == UINT16_MAX) { + } else if (rrs->count == UINT16_MAX) { return KNOT_ESPACE; } size_t old_size = knot_rdataset_size(rrs); size_t new_size = old_size + knot_rdata_size(size); - knot_rdata_t *tmp = mm_realloc(mm, rrs->data, new_size, old_size); + knot_rdata_t *tmp = mm_realloc(mm, rrs->rdata, new_size, old_size); if (tmp == NULL) { return KNOT_ENOMEM; } - rrs->data = tmp; - rrs->rr_count++; + rrs->rdata = tmp; + rrs->count++; // We have to initialise the 'size' field in the reserved space. - rr_seek(rrs, rrs->rr_count - 1)->len = size; + rr_seek(rrs, rrs->count - 1)->len = size; return KNOT_EOK; } @@ -242,21 +242,21 @@ int knot_rdataset_reserve(knot_rdataset_t *rrs, uint16_t size, knot_mm_t *mm) _public_ int knot_rdataset_unreserve(knot_rdataset_t *rrs, knot_mm_t *mm) { - if (rrs == NULL || rrs->rr_count == 0) { + if (rrs == NULL || rrs->count == 0) { return KNOT_EINVAL; } - return remove_rr_at(rrs, rrs->rr_count - 1, mm); + return remove_rr_at(rrs, rrs->count - 1, mm); } _public_ bool knot_rdataset_eq(const knot_rdataset_t *rrs1, const knot_rdataset_t *rrs2) { - if (rrs1 == NULL || rrs2 == NULL || rrs1->rr_count != rrs2->rr_count) { + if (rrs1 == NULL || rrs2 == NULL || rrs1->count != rrs2->count) { return false; } - for (uint16_t i = 0; i < rrs1->rr_count; ++i) { + for (uint16_t i = 0; i < rrs1->count; ++i) { const knot_rdata_t *rr1 = rr_seek(rrs1, i); const knot_rdata_t *rr2 = rr_seek(rrs2, i); if (knot_rdata_cmp(rr1, rr2) != 0) { @@ -274,7 +274,7 @@ bool knot_rdataset_member(const knot_rdataset_t *rrs, const knot_rdata_t *rr) return false; } - for (uint16_t i = 0; i < rrs->rr_count; ++i) { + for (uint16_t i = 0; i < rrs->count; ++i) { const knot_rdata_t *cmp_rr = rr_seek(rrs, i); int cmp = knot_rdata_cmp(cmp_rr, rr); if (cmp == 0) { @@ -297,7 +297,7 @@ int knot_rdataset_merge(knot_rdataset_t *rrs1, const knot_rdataset_t *rrs2, return KNOT_EINVAL; } - for (uint16_t i = 0; i < rrs2->rr_count; ++i) { + for (uint16_t i = 0; i < rrs2->count; ++i) { const knot_rdata_t *rr = rr_seek(rrs2, i); int ret = knot_rdataset_add(rrs1, rr, mm); if (ret != KNOT_EOK) { @@ -317,7 +317,7 @@ int knot_rdataset_intersect(const knot_rdataset_t *rrs1, const knot_rdataset_t * } knot_rdataset_init(out); - for (uint16_t i = 0; i < rrs1->rr_count; ++i) { + for (uint16_t i = 0; i < rrs1->count; ++i) { const knot_rdata_t *rr = rr_seek(rrs1, i); if (knot_rdataset_member(rrs2, rr)) { // Add RR into output intersection RRSet. @@ -340,13 +340,13 @@ int knot_rdataset_subtract(knot_rdataset_t *from, const knot_rdataset_t *what, return KNOT_EINVAL; } - if (from->data == what->data) { + if (from->rdata == what->rdata) { knot_rdataset_clear(from, mm); knot_rdataset_init((knot_rdataset_t *) what); return KNOT_EOK; } - for (uint16_t i = 0; i < what->rr_count; ++i) { + for (uint16_t i = 0; i < what->count; ++i) { const knot_rdata_t *to_remove = rr_seek(what, i); int pos_to_remove = find_rr_pos(from, to_remove); if (pos_to_remove >= 0) { @@ -363,14 +363,14 @@ int knot_rdataset_subtract(knot_rdataset_t *from, const knot_rdataset_t *what, _public_ int knot_rdataset_sort_at(knot_rdataset_t *rrs, uint16_t pos, knot_mm_t *mm) { - if (rrs == NULL || rrs->rr_count == 0 || pos >= rrs->rr_count) { + if (rrs == NULL || rrs->count == 0 || pos >= rrs->count) { return KNOT_EINVAL; } const knot_rdata_t *rr = rr_seek(rrs, pos); knot_rdata_t *earlier_rr = NULL; - for (uint16_t i = 0; i < rrs->rr_count; ++i) { + for (uint16_t i = 0; i < rrs->count; ++i) { if (i == pos) { // It already is at the position. return KNOT_EOK; diff --git a/src/libknot/rdataset.h b/src/libknot/rdataset.h index 1cb170d96..61d8aed80 100644 --- a/src/libknot/rdataset.h +++ b/src/libknot/rdataset.h @@ -34,8 +34,8 @@ /*!< \brief Set of RRs. */ typedef struct { - uint16_t rr_count; /*!< \brief Count of RRs stored in the structure. */ - knot_rdata_t *data; /*!< \brief Actual data, canonically sorted. */ + uint16_t count; /*!< \brief Count of RRs stored in the structure. */ + knot_rdata_t *rdata; /*!< \brief Serialized rdata, canonically sorted. */ } knot_rdataset_t; /*! @@ -46,8 +46,8 @@ typedef struct { inline static void knot_rdataset_init(knot_rdataset_t *rrs) { if (rrs != NULL) { - rrs->rr_count = 0; - rrs->data = NULL; + rrs->count = 0; + rrs->rdata = NULL; } } @@ -211,7 +211,7 @@ int knot_rdataset_sort_at(knot_rdataset_t *rrs, uint16_t pos, knot_mm_t *mm); /*! \brief Check helper. */ #define KNOT_RDATASET_CHECK(rrs, pos) \ - assert(rrs && rrs->data && rrs->rr_count > 0 && pos < rrs->rr_count); + assert(rrs && rrs->rdata && rrs->count > 0 && pos < rrs->count); /*! \brief Access helper. */ static inline diff --git a/src/libknot/rrset-dump.c b/src/libknot/rrset-dump.c index ac0f4c4c2..465924464 100644 --- a/src/libknot/rrset-dump.c +++ b/src/libknot/rrset-dump.c @@ -1921,7 +1921,7 @@ int knot_rrset_txt_dump_header(const knot_rrset_t *rrset, } else if (knot_rrtype_to_string(rrset->type, buf, sizeof(buf)) < 0) { return KNOT_ESPACE; } - if (rrset->rrs.rr_count > 0) { + if (rrset->rrs.count > 0) { ret = snprintf(dst + len, maxlen - len, "%s%c", buf, sep); } else { ret = snprintf(dst + len, maxlen - len, "%s", buf); @@ -1946,7 +1946,7 @@ static int rrset_txt_dump(const knot_rrset_t *rrset, dst[0] = '\0'; // Loop over rdata in rrset. - uint16_t rr_count = rrset->rrs.rr_count; + uint16_t rr_count = rrset->rrs.count; for (uint16_t i = 0; i < rr_count; i++) { // Dump rdata owner, class, ttl and type. uint32_t ttl = ((style->original_ttl && rrset->type == KNOT_RRTYPE_RRSIG) ? diff --git a/src/libknot/rrset.c b/src/libknot/rrset.c index d45bd7d69..a7484453e 100644 --- a/src/libknot/rrset.c +++ b/src/libknot/rrset.c @@ -149,7 +149,7 @@ bool knot_rrset_is_nsec3rel(const knot_rrset_t *rr) _public_ int knot_rrset_rr_to_canonical(knot_rrset_t *rrset) { - if (rrset == NULL || rrset->rrs.rr_count != 1) { + if (rrset == NULL || rrset->rrs.count != 1) { return KNOT_EINVAL; } @@ -214,7 +214,7 @@ size_t knot_rrset_size(const knot_rrset_t *rrset) return 0; } - uint16_t rr_count = rrset->rrs.rr_count; + uint16_t rr_count = rrset->rrs.count; size_t total_size = knot_dname_size(rrset->owner) * rr_count; diff --git a/src/libknot/rrset.h b/src/libknot/rrset.h index 31e4bf5f6..aac9a4c04 100644 --- a/src/libknot/rrset.h +++ b/src/libknot/rrset.h @@ -165,7 +165,7 @@ bool knot_rrset_equal(const knot_rrset_t *r1, const knot_rrset_t *r2, */ inline static bool knot_rrset_empty(const knot_rrset_t *rrset) { - return rrset == NULL || rrset->rrs.rr_count == 0; + return rrset == NULL || rrset->rrs.count == 0; } /*! diff --git a/src/libknot/rrtype/opt.c b/src/libknot/rrtype/opt.c index a7387a187..775f0d080 100644 --- a/src/libknot/rrtype/opt.c +++ b/src/libknot/rrtype/opt.c @@ -139,7 +139,7 @@ void knot_edns_set_version(knot_rrset_t *opt_rr, uint8_t version) static uint8_t *edns_add(knot_rrset_t *opt, uint16_t code, uint16_t size, knot_mm_t *mm) { - assert(opt->rrs.rr_count == 1); + assert(opt->rrs.count == 1); // extract old RDATA @@ -244,7 +244,7 @@ _public_ int knot_edns_get_options(knot_rrset_t *opt_rr, knot_edns_options_t **out, knot_mm_t *mm) { - if (opt_rr == NULL || opt_rr->rrs.rr_count > 1 || out == NULL) { + if (opt_rr == NULL || opt_rr->rrs.count > 1 || out == NULL) { return KNOT_EINVAL; } diff --git a/src/libknot/rrtype/rrsig.h b/src/libknot/rrtype/rrsig.h index d1ffabaf6..60ae05e37 100644 --- a/src/libknot/rrtype/rrsig.h +++ b/src/libknot/rrtype/rrsig.h @@ -91,7 +91,7 @@ void knot_rrsig_signature(const knot_rdataset_t *rrs, size_t pos, return; } - if (rrs == NULL || pos >= rrs->rr_count) { + if (rrs == NULL || pos >= rrs->count) { *signature = NULL; *signature_size = 0; return; diff --git a/src/libknot/tsig-op.c b/src/libknot/tsig-op.c index b66bf9051..acbcafb44 100644 --- a/src/libknot/tsig-op.c +++ b/src/libknot/tsig-op.c @@ -543,7 +543,7 @@ static int check_digest(const knot_rrset_t *tsig_rr, uint8_t digest_tmp[KNOT_TSIG_MAX_DIGEST_SIZE]; size_t digest_tmp_len = 0; - assert(tsig_rr->rrs.rr_count > 0); + assert(tsig_rr->rrs.count > 0); if (use_times) { /* Wire is not a single packet, TSIG RRs must be stripped already. */ @@ -558,7 +558,7 @@ static int check_digest(const knot_rrset_t *tsig_rr, tsig_rr, tsig_key); } - assert(tsig_rr->rrs.rr_count > 0); + assert(tsig_rr->rrs.count > 0); free(wire_to_sign); if (ret != KNOT_EOK) { diff --git a/src/utils/common/exec.c b/src/utils/common/exec.c index ca1293e14..402d9aa00 100644 --- a/src/utils/common/exec.c +++ b/src/utils/common/exec.c @@ -359,7 +359,7 @@ static void print_section_dig(const knot_rrset_t *rrsets, for (size_t i = 0; i < count; i++) { const knot_rrset_t *rrset = &rrsets[i]; - uint16_t rrset_rdata_count = rrset->rrs.rr_count; + uint16_t rrset_rdata_count = rrset->rrs.count; for (uint16_t j = 0; j < rrset_rdata_count; j++) { while (knot_rrset_txt_dump_data(rrset, j, buf, buflen, &(style->style)) < 0) { @@ -403,7 +403,7 @@ static void print_section_host(const knot_rrset_t *rrsets, } descr = knot_lookup_by_id(rtypes, rrset->type); - uint16_t rrset_rdata_count = rrset->rrs.rr_count; + uint16_t rrset_rdata_count = rrset->rrs.count; for (uint16_t j = 0; j < rrset_rdata_count; j++) { if (rrset->type == KNOT_RRTYPE_CNAME && style->hide_cname) { diff --git a/src/utils/kjournalprint/main.c b/src/utils/kjournalprint/main.c index 57528a3b2..9cbcf8162 100644 --- a/src/utils/kjournalprint/main.c +++ b/src/utils/kjournalprint/main.c @@ -110,7 +110,7 @@ static int rrtypelist_callback(zone_node_t *node, void *data) for (int i = 0; i < node->rrset_count; i++) { knot_rrset_t rrset = node_rrset_at(node, i); rrtypelist_add(ctx->arr, rrset.type); - *ctx->counter += rrset.rrs.rr_count; + *ctx->counter += rrset.rrs.count; } return KNOT_EOK; } diff --git a/tests/knot/test_node.c b/tests/knot/test_node.c index c289d809e..ef2a01d18 100644 --- a/tests/knot/test_node.c +++ b/tests/knot/test_node.c @@ -136,7 +136,7 @@ int main(int argc, char *argv[]) // Test remove RRset node_remove_rdataset(node, KNOT_RRTYPE_AAAA); ok(node->rrset_count == 2, "Node: remove non-existent rdataset."); - void *to_free = node_rdataset(node, KNOT_RRTYPE_TXT)->data; + void *to_free = node_rdataset(node, KNOT_RRTYPE_TXT)->rdata; node_remove_rdataset(node, KNOT_RRTYPE_TXT); ok(node->rrset_count == 1, "Node: remove existing rdataset."); diff --git a/tests/knot/test_zone-update.c b/tests/knot/test_zone-update.c index 71579cf48..8ba84face 100644 --- a/tests/knot/test_zone-update.c +++ b/tests/knot/test_zone-update.c @@ -41,7 +41,7 @@ static bool node_contains_rr(const zone_node_t *node, { const knot_rdataset_t *zone_rrs = node_rdataset(node, rr->type); if (zone_rrs) { - for (size_t i = 0; i < rr->rrs.rr_count; ++i) { + for (size_t i = 0; i < rr->rrs.count; ++i) { if (!knot_rdataset_member(zone_rrs, knot_rdataset_at(&rr->rrs, i))) { return false; } @@ -124,7 +124,7 @@ void test_full(zone_t *zone, zs_scanner_t *sc) knot_rdataset_clear(&rrset.rrs, NULL); knot_dname_t *rem_node_name = knot_dname_from_str_alloc("node.test"); node = (zone_node_t *) zone_update_get_node(&update, rem_node_name); - assert(node && node_rdataset(node, KNOT_RRTYPE_TXT)->rr_count == 2); + assert(node && node_rdataset(node, KNOT_RRTYPE_TXT)->count == 2); /* Node removal */ ret = zone_update_remove_node(&update, rem_node_name); node = (zone_node_t *) zone_update_get_node(&update, rem_node_name); @@ -201,7 +201,7 @@ void test_incremental(zone_t *zone, zs_scanner_t *sc) is_int(KNOT_EOK, ret, "incremental zone update: addition"); const zone_node_t *synth_node = zone_update_get_apex(&update); - ok(synth_node && node_rdataset(synth_node, KNOT_RRTYPE_TXT)->rr_count == 2, + ok(synth_node && node_rdataset(synth_node, KNOT_RRTYPE_TXT)->count == 2, "incremental zone update: add change"); if (zs_set_input_string(sc, del_str, strlen(del_str)) != 0 || @@ -214,7 +214,7 @@ void test_incremental(zone_t *zone, zs_scanner_t *sc) knot_rdataset_clear(&rrset.rrs, NULL); synth_node = zone_update_get_apex(&update); - ok(synth_node && node_rdataset(synth_node, KNOT_RRTYPE_TXT)->rr_count == 1, + ok(synth_node && node_rdataset(synth_node, KNOT_RRTYPE_TXT)->count == 1, "incremental zone update: del change"); /* Prepare node removal */ @@ -228,7 +228,7 @@ void test_incremental(zone_t *zone, zs_scanner_t *sc) knot_dname_t *rem_node_name = knot_dname_from_str_alloc("node.test"); synth_node = zone_update_get_node(&update, rem_node_name); - assert(synth_node && node_rdataset(synth_node, KNOT_RRTYPE_TXT)->rr_count == 2); + assert(synth_node && node_rdataset(synth_node, KNOT_RRTYPE_TXT)->count == 2); /* Node Removal */ ret = zone_update_remove_node(&update, rem_node_name); synth_node = zone_update_get_node(&update, rem_node_name); diff --git a/tests/libknot/test_edns.c b/tests/libknot/test_edns.c index d8210556d..e97faee99 100644 --- a/tests/libknot/test_edns.c +++ b/tests/libknot/test_edns.c @@ -143,7 +143,7 @@ static void check_header(knot_rrset_t *opt_rr, uint16_t payload, uint8_t ver, ok(check, "%s: max payload", msg); /* The OPT RR should have exactly one RDATA. */ - check = (opt_rr->rrs.rr_count == 1); + check = (opt_rr->rrs.count == 1); ok(check, "%s: RR count == 1", msg); knot_rdata_t *rdata = knot_rdataset_at(&opt_rr->rrs, 0); diff --git a/tests/libknot/test_rdataset.c b/tests/libknot/test_rdataset.c index 572fec728..3b7f2a6d7 100644 --- a/tests/libknot/test_rdataset.c +++ b/tests/libknot/test_rdataset.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2017 CZ.NIC, z.s.p.o. +/* Copyright (C) 2018 CZ.NIC, z.s.p.o. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -34,7 +34,7 @@ int main(int argc, char *argv[]) // Test init knot_rdataset_t rdataset; knot_rdataset_init(&rdataset); - ok(rdataset.data == NULL && rdataset.rr_count == 0, "rdataset: init."); + ok(rdataset.rdata == NULL && rdataset.count == 0, "rdataset: init."); // Test rdata addition uint8_t buf_gt[knot_rdata_size(4)]; @@ -44,16 +44,16 @@ int main(int argc, char *argv[]) int ret = knot_rdataset_add(NULL, NULL, NULL); is_int(KNOT_EINVAL, ret, "rdataset: add NULL."); ret = knot_rdataset_add(&rdataset, rdata_gt, NULL); - bool add_ok = ret == KNOT_EOK && rdataset.rr_count == 1 && - knot_rdata_cmp(rdata_gt, rdataset.data) == 0; + bool add_ok = ret == KNOT_EOK && rdataset.count == 1 && + knot_rdata_cmp(rdata_gt, rdataset.rdata) == 0; ok(add_ok, "rdataset: add."); uint8_t buf_lo[knot_rdata_size(4)]; knot_rdata_t *rdata_lo = (knot_rdata_t *)buf_lo; knot_rdata_init(rdata_lo, 4, (uint8_t *)"abcd"); ret = knot_rdataset_add(&rdataset, rdata_lo, NULL); - add_ok = ret == KNOT_EOK && rdataset.rr_count == 2 && - knot_rdata_cmp(rdata_lo, rdataset.data) == 0; + add_ok = ret == KNOT_EOK && rdataset.count == 2 && + knot_rdata_cmp(rdata_lo, rdataset.rdata) == 0; ok(add_ok, "rdataset: add lower."); // Test getters @@ -69,9 +69,9 @@ int main(int argc, char *argv[]) "rdataset: copy NULL."); knot_rdataset_t copy; ret = knot_rdataset_copy(©, &rdataset, NULL); - const bool copy_ok = ret == KNOT_EOK && copy.rr_count == rdataset.rr_count && + const bool copy_ok = ret == KNOT_EOK && copy.count == rdataset.count && knot_rdataset_size(©) == knot_rdataset_size(&rdataset) && - memcmp(rdataset.data, copy.data, + memcmp(rdataset.rdata, copy.rdata, knot_rdataset_size(&rdataset)) == 0; ok(copy_ok, "rdataset: copy"); @@ -80,7 +80,7 @@ int main(int argc, char *argv[]) // Test clear knot_rdataset_clear(©, NULL); - ok(copy.rr_count == 0 && copy.data == NULL, "rdataset: clear."); + ok(copy.count == 0 && copy.rdata == NULL, "rdataset: clear."); // Test not equal (different count) ok(!knot_rdataset_eq(&rdataset, ©), "rdataset: not equal - count"); @@ -100,10 +100,10 @@ int main(int argc, char *argv[]) ret = knot_rdataset_merge(&empty, &rdataset, NULL); bool merge_ok = ret == KNOT_EOK && knot_rdataset_eq(&empty, &rdataset); ok(merge_ok, "rdataset: merge empty."); - knot_rdata_t *data_before = rdataset.data; + knot_rdata_t *data_before = rdataset.rdata; ret = knot_rdataset_merge(&rdataset, &rdataset, NULL); - merge_ok = ret == KNOT_EOK && rdataset.rr_count == 2 && - data_before == rdataset.data; + merge_ok = ret == KNOT_EOK && rdataset.count == 2 && + data_before == rdataset.rdata; ok(merge_ok, "rdataset: merge self."); knot_rdataset_clear(&empty, NULL); @@ -143,7 +143,7 @@ int main(int argc, char *argv[]) RDATASET_INIT_WITH(rdataset_lo, rdata_lo); RDATASET_INIT_WITH(rdataset_gt, rdata_gt); ret = knot_rdataset_intersect(&rdataset_lo, &rdataset_gt, &intersection, NULL); - intersect_ok = ret == KNOT_EOK && intersection.rr_count == 0; + intersect_ok = ret == KNOT_EOK && intersection.count == 0; ok(intersect_ok, "rdataset: intersect no common."); ret = knot_rdataset_intersect(&rdataset, &rdataset_lo, &intersection, NULL); @@ -157,29 +157,29 @@ int main(int argc, char *argv[]) ret = knot_rdataset_copy(©, &rdataset, NULL); assert(ret == KNOT_EOK); ok(knot_rdataset_subtract(©, ©, NULL) == KNOT_EOK && - copy.rr_count == 0, "rdataset: subtract self."); + copy.count == 0, "rdataset: subtract self."); ret = knot_rdataset_copy(©, &rdataset, NULL); assert(ret == KNOT_EOK); ret = knot_rdataset_subtract(©, &rdataset, NULL); - bool subtract_ok = ret == KNOT_EOK && copy.rr_count == 0; + bool subtract_ok = ret == KNOT_EOK && copy.count == 0; ok(subtract_ok, "rdataset: subtract identical."); RDATASET_INIT_WITH(rdataset_lo, rdata_lo); RDATASET_INIT_WITH(rdataset_gt, rdata_gt); - data_before = rdataset_lo.data; + data_before = rdataset_lo.rdata; ret = knot_rdataset_subtract(&rdataset_lo, &rdataset_gt, NULL); - subtract_ok = ret == KNOT_EOK && rdataset_lo.rr_count == 1 && - rdataset_lo.data == data_before; + subtract_ok = ret == KNOT_EOK && rdataset_lo.count == 1 && + rdataset_lo.rdata == data_before; ok(subtract_ok, "rdataset: subtract no common."); ret = knot_rdataset_subtract(&rdataset, &rdataset_gt, NULL); - subtract_ok = ret == KNOT_EOK && rdataset.rr_count == 1; + subtract_ok = ret == KNOT_EOK && rdataset.count == 1; ok(subtract_ok, "rdataset: subtract the second."); ret = knot_rdataset_subtract(&rdataset, &rdataset_lo, NULL); - subtract_ok = ret == KNOT_EOK && rdataset.rr_count == 0 && - rdataset.data == NULL; + subtract_ok = ret == KNOT_EOK && rdataset.count == 0 && + rdataset.rdata == NULL; ok(subtract_ok, "rdataset: subtract last."); RDATASET_INIT_WITH(rdataset, rdata_gt); diff --git a/tests/libknot/test_rrset.c b/tests/libknot/test_rrset.c index 487d4ef97..a0f1d53b8 100644 --- a/tests/libknot/test_rrset.c +++ b/tests/libknot/test_rrset.c @@ -31,7 +31,7 @@ static bool check_rrset(const knot_rrset_t *rrset, const knot_dname_t *owner, const bool dname_cmp = owner == NULL ? rrset->owner == NULL : knot_dname_is_equal(rrset->owner, owner); return rrset->type == type && rrset->rclass == rclass && dname_cmp && - rrset->ttl == ttl && rrset->rrs.rr_count == 0; // We do not test rdataset here + rrset->ttl == ttl && rrset->rrs.count == 0; // We do not test rdataset here } int main(int argc, char *argv[]) @@ -102,7 +102,7 @@ int main(int argc, char *argv[]) // Test empty ok(knot_rrset_empty(rrset), "rrset: empty."); ok(knot_rrset_empty(NULL), "rrset: empty NULL."); - copy->rrs.rr_count = 1; + copy->rrs.count = 1; ok(!knot_rrset_empty(copy), "rrset: not empty."); // Test init empty