upstream/knot-dns
1
0
Fork 0
mirror of https://gitlab.nic.cz/knot/knot-dns.git synced 2026-06-09 08:33:59 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

libknot/rdataset: rename structure items

Browse source
This commit is contained in:
Daniel Salzman 2018-07-04 20:57:27 +02:00
parent 90f073b555
commit 94ae366b28
34 changed files with 159 additions and 159 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/knot/ctl/commands.c
View file

@ -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) {

2
src/knot/dnssec/ds_query.c
View file

@ -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;

2
src/knot/dnssec/nsec3-chain.c
View file

@ -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;
}

6
src/knot/dnssec/rrset-sign.c
View file

@ -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 -----------------------------------------------*/

2
src/knot/dnssec/zone-nsec.c
View file

@ -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;
}

6
src/knot/dnssec/zone-sign.c
View file

@ -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)) {

2
src/knot/events/handlers/refresh.c
View file

@ -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;

10
src/knot/journal/serialization.c
View file

@ -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);

2
src/knot/nameserver/process_query.c
View file

@ -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;
}

18
src/knot/updates/apply.c
View file

@ -1,4 +1,4 @@
/* Copyright (C) 2017 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
/* Copyright (C) 2018 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
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;

8
src/knot/updates/ddns.c
View file

@ -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;
}

8
src/knot/zone/contents.c
View file

@ -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;
}

4
src/knot/zone/node.c
View file

@ -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);

20
src/knot/zone/semantic-check.c
View file

@ -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,

6
src/knot/zone/zone-diff.c
View file

@ -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)) {
/*

8
src/knot/zone/zone-dump.c
View file

@ -1,4 +1,4 @@
/* Copyright (C) 2016 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
/* Copyright (C) 2018 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
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';
}

2
src/knot/zone/zonefile.c
View file

@ -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;
}

8
src/libknot/packet/pkt.c
View file

@ -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;
}
}

10
src/libknot/packet/rrset-wire.c
View file

@ -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);

96
src/libknot/rdataset.c
View file

@ -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;

10
src/libknot/rdataset.h
View file

@ -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

4
src/libknot/rrset-dump.c
View file

@ -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) ?

4
src/libknot/rrset.c
View file

@ -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;

2
src/libknot/rrset.h
View file

@ -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;
}
/*!

4
src/libknot/rrtype/opt.c
View file

@ -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;
}

2
src/libknot/rrtype/rrsig.h
View file

@ -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;

4
src/libknot/tsig-op.c
View file

@ -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) {

4
src/utils/common/exec.c
View file

@ -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) {

2
src/utils/kjournalprint/main.c
View file

@ -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;
}

2
tests/knot/test_node.c
View file

@ -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.");

10
tests/knot/test_zone-update.c
View file

@ -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);

2
tests/libknot/test_edns.c
View file

@ -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);

42
tests/libknot/test_rdataset.c
View file

@ -1,4 +1,4 @@
/* Copyright (C) 2017 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
/* Copyright (C) 2018 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
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(&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(&copy) == 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(&copy, 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, &copy), "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(&copy, &rdataset, NULL);
assert(ret == KNOT_EOK);
ok(knot_rdataset_subtract(&copy, &copy, NULL) == KNOT_EOK &&
copy.rr_count == 0, "rdataset: subtract self.");
copy.count == 0, "rdataset: subtract self.");
ret = knot_rdataset_copy(&copy, &rdataset, NULL);
assert(ret == KNOT_EOK);
ret = knot_rdataset_subtract(&copy, &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);

4
tests/libknot/test_rrset.c
View file

@ -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