From: Daniel Salzman Date: Wed, 11 Jul 2018 19:24:20 +0000 (+0200) Subject: Adapt to new rrtype and rdataset API X-Git-Tag: v2.7.0~34 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=8ebd8667d2e9934d3efde9da46de696c996da498;p=thirdparty%2Fknot-dns.git Adapt to new rrtype and rdataset API --- diff --git a/src/knot/ctl/commands.c b/src/knot/ctl/commands.c index 49c5eca53a..8164c6be32 100644 --- a/src/knot/ctl/commands.c +++ b/src/knot/ctl/commands.c @@ -182,7 +182,7 @@ static int zone_status(zone_t *zone, ctl_args_t *args) if (zone->contents != NULL) { knot_rdataset_t *soa = node_rdataset(zone->contents->apex, KNOT_RRTYPE_SOA); - ret = snprintf(buff, sizeof(buff), "%u", knot_soa_serial(soa)); + ret = snprintf(buff, sizeof(buff), "%u", knot_soa_serial(soa->rdata)); } else { ret = snprintf(buff, sizeof(buff), "none"); } diff --git a/src/knot/dnssec/ds_query.c b/src/knot/dnssec/ds_query.c index 7db9926b65..c560c44420 100644 --- a/src/knot/dnssec/ds_query.c +++ b/src/knot/dnssec/ds_query.c @@ -100,7 +100,7 @@ static int ds_query_consume(knot_layer_t *layer, knot_pkt_t *pkt) return KNOT_STATE_FAIL; } - if (match_key_ds(data->key, knot_rdataset_at(&rr->rrs, 0))) { + if (match_key_ds(data->key, rr->rrs.rdata)) { match = true; break; } diff --git a/src/knot/dnssec/nsec3-chain.c b/src/knot/dnssec/nsec3-chain.c index 2aa60aa085..534db6cebe 100644 --- a/src/knot/dnssec/nsec3-chain.c +++ b/src/knot/dnssec/nsec3-chain.c @@ -370,14 +370,13 @@ static zone_node_t *create_nsec3_node_for_node(const zone_node_t *node, static int connect_nsec3_base(knot_rdataset_t *a_rrs, const knot_dname_t *b_name) { assert(a_rrs); - uint8_t algorithm = knot_nsec3_algorithm(a_rrs, 0); + uint8_t algorithm = knot_nsec3_alg(a_rrs->rdata); if (algorithm == 0) { return KNOT_EINVAL; } - uint8_t *raw_hash = NULL; - uint8_t raw_length = 0; - knot_nsec3_next_hashed(a_rrs, 0, &raw_hash, &raw_length); + uint8_t raw_length = knot_nsec3_next_len(a_rrs->rdata); + uint8_t *raw_hash = (uint8_t *)knot_nsec3_next(a_rrs->rdata); if (raw_hash == NULL) { return KNOT_EINVAL; } @@ -606,7 +605,8 @@ static int fix_nsec3_for_node(zone_update_t *update, const dnssec_nsec3_params_t ret = changeset_add_removal(chgset, &rem_rrsig, 0); } } - knot_nsec3_next_hashed(&rem_nsec3.rrs, 0, &next_hash, &next_length); + next_hash = (uint8_t *)knot_nsec3_next(rem_nsec3.rrs.rdata); + next_length = knot_nsec3_next_len(rem_nsec3.rrs.rdata); } } @@ -621,9 +621,8 @@ static int fix_nsec3_for_node(zone_update_t *update, const dnssec_nsec3_params_t // copy hash of next element from removed record if (next_hash != NULL) { - uint8_t *raw_hash = NULL; - uint8_t raw_length = 0; - knot_nsec3_next_hashed(&add_nsec3.rrs, 0, &raw_hash, &raw_length); + uint8_t *raw_hash = (uint8_t *)knot_nsec3_next(add_nsec3.rrs.rdata); + uint8_t raw_length = knot_nsec3_next_len(add_nsec3.rrs.rdata); assert(raw_hash != NULL); if (raw_length != next_length) { ret = KNOT_EMALF; diff --git a/src/knot/dnssec/policy.c b/src/knot/dnssec/policy.c index 5fd68ac8c2..b695b2b7a9 100644 --- a/src/knot/dnssec/policy.c +++ b/src/knot/dnssec/policy.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 @@ -22,7 +22,7 @@ static uint32_t zone_soa_min_ttl(const zone_contents_t *zone) { knot_rrset_t soa = node_rrset(zone->apex, KNOT_RRTYPE_SOA); - return knot_soa_minimum(&soa.rrs); + return knot_soa_minimum(soa.rrs.rdata); } static uint32_t zone_soa_ttl(const zone_contents_t *zone) diff --git a/src/knot/dnssec/rrset-sign.c b/src/knot/dnssec/rrset-sign.c index dfbb3ed390..d8c91c396a 100644 --- a/src/knot/dnssec/rrset-sign.c +++ b/src/knot/dnssec/rrset-sign.c @@ -285,15 +285,16 @@ int knot_synth_rrsig(uint16_t type, const knot_rdataset_t *rrsig_rrs, return KNOT_EINVAL; } + knot_rdata_t *rr_to_copy = rrsig_rrs->rdata; 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); + if (type == knot_rrsig_type_covered(rr_to_copy)) { int ret = knot_rdataset_add(out_sig, rr_to_copy, mm); if (ret != KNOT_EOK) { knot_rdataset_clear(out_sig, mm); return ret; } } + rr_to_copy = knot_rdataset_next(rr_to_copy); } return out_sig->count > 0 ? KNOT_EOK : KNOT_ENOENT; @@ -304,19 +305,17 @@ int knot_synth_rrsig(uint16_t type, const knot_rdataset_t *rrsig_rrs, /*! * \brief Check if the signature is expired. * - * \param rrsigs RR set with RRSIGs. - * \param pos Number of RR in the RR set. + * \param rrsig RRSIG rdata. * \param policy DNSSEC policy. * * \return Signature is expired or should be replaced soon. */ -static bool is_expired_signature(const knot_rrset_t *rrsigs, size_t pos, - uint32_t now, uint32_t refresh_before) +static bool is_expired_signature(const knot_rdata_t *rrsig, uint32_t now, + uint32_t refresh_before) { - assert(!knot_rrset_empty(rrsigs)); - assert(rrsigs->type == KNOT_RRTYPE_RRSIG); + assert(rrsig); - uint32_t expire_at = knot_rrsig_sig_expiration(&rrsigs->rrs, pos); + uint32_t expire_at = knot_rrsig_sig_expiration(rrsig); uint32_t expire_in = expire_at > now ? expire_at - now : 0; return expire_in <= refresh_before; @@ -333,21 +332,21 @@ int knot_check_signature(const knot_rrset_t *covered, return KNOT_EINVAL; } - if (is_expired_signature(rrsigs, pos, dnssec_ctx->now, + knot_rdata_t *rrsig = knot_rdataset_at(&rrsigs->rrs, pos); + assert(rrsig); + + if (is_expired_signature(rrsig, dnssec_ctx->now, dnssec_ctx->policy->rrsig_refresh_before)) { return DNSSEC_INVALID_SIGNATURE; } // identify fields in the signature being validated - uint8_t *rdata = knot_rdataset_at(&rrsigs->rrs, pos)->data; - if (!rdata) { - return KNOT_EINVAL; - } - - dnssec_binary_t signature = { 0 }; - knot_rrsig_signature(&rrsigs->rrs, pos, &signature.data, &signature.size); - if (!signature.data) { + dnssec_binary_t signature = { + .size = knot_rrsig_signature_len(rrsig), + .data = (uint8_t *)knot_rrsig_signature(rrsig) + }; + if (signature.data == NULL) { return KNOT_EINVAL; } @@ -358,7 +357,7 @@ int knot_check_signature(const knot_rrset_t *covered, return result; } - result = knot_sign_ctx_add_data(sign_ctx, rdata, covered); + result = knot_sign_ctx_add_data(sign_ctx, rrsig->data, covered); if (result != KNOT_EOK) { return result; } diff --git a/src/knot/dnssec/zone-events.c b/src/knot/dnssec/zone-events.c index 7cf5c4d388..73893ea37a 100644 --- a/src/knot/dnssec/zone-events.c +++ b/src/knot/dnssec/zone-events.c @@ -269,8 +269,8 @@ int knot_dnssec_sign_update(zone_update_t *update, zone_sign_reschedule_t *resch goto done; } - bool soa_changed = (knot_soa_serial(node_rdataset(update->zone->contents->apex, KNOT_RRTYPE_SOA)) != - knot_soa_serial(node_rdataset(update->new_cont->apex, KNOT_RRTYPE_SOA))); + bool soa_changed = (knot_soa_serial(node_rdataset(update->zone->contents->apex, KNOT_RRTYPE_SOA)->rdata) != + knot_soa_serial(node_rdataset(update->new_cont->apex, KNOT_RRTYPE_SOA)->rdata)); if (zone_update_no_change(update) && !soa_changed && !knot_zone_sign_soa_expired(update->new_cont, &keyset, &ctx)) { diff --git a/src/knot/dnssec/zone-nsec.c b/src/knot/dnssec/zone-nsec.c index 172fe74095..ddc9e5769c 100644 --- a/src/knot/dnssec/zone-nsec.c +++ b/src/knot/dnssec/zone-nsec.c @@ -178,10 +178,9 @@ static bool nsec3param_valid(const knot_rdataset_t *rrs, return false; } - knot_rdata_t *rrd = knot_rdataset_at(rrs, 0); dnssec_binary_t rdata = { - .size = rrd->len, - .data = rrd->data, + .size = rrs->rdata->len, + .data = rrs->rdata->data, }; dnssec_nsec3_params_t parsed = { 0 }; @@ -342,7 +341,7 @@ int knot_zone_create_nsec_chain(zone_update_t *update, return KNOT_EINVAL; } - uint32_t nsec_ttl = knot_soa_minimum(soa); + uint32_t nsec_ttl = knot_soa_minimum(soa->rdata); dnssec_nsec3_params_t params = nsec3param_init(ctx->policy, ctx->zone); changeset_t ch; @@ -409,8 +408,8 @@ int knot_zone_fix_nsec_chain(zone_update_t *update, return KNOT_EINVAL; } - uint32_t nsec_ttl_old = knot_soa_minimum(soa_old); - uint32_t nsec_ttl_new = knot_soa_minimum(soa_new); + uint32_t nsec_ttl_old = knot_soa_minimum(soa_old->rdata); + uint32_t nsec_ttl_new = knot_soa_minimum(soa_new->rdata); dnssec_nsec3_params_t params = nsec3param_init(ctx->policy, ctx->zone); changeset_t ch; diff --git a/src/knot/dnssec/zone-sign.c b/src/knot/dnssec/zone-sign.c index df8975505c..afcbaf48e6 100644 --- a/src/knot/dnssec/zone-sign.c +++ b/src/knot/dnssec/zone-sign.c @@ -111,9 +111,11 @@ static bool valid_signature_exists(const knot_rrset_t *covered, } uint16_t rrsigs_rdata_count = rrsigs->rrs.count; + knot_rdata_t *rdata = rrsigs->rrs.rdata; 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); + uint16_t rr_keytag = knot_rrsig_key_tag(rdata); + uint16_t rr_covered = knot_rrsig_type_covered(rdata); + rdata = knot_rdataset_next(rdata); uint16_t keytag = dnssec_key_get_keytag(key); if (rr_keytag != keytag || rr_covered != covered->type) { @@ -200,40 +202,18 @@ static bool all_signatures_exist(const knot_rrset_t *covered, return true; } -/*! - * \brief Get zone key for given RRSIG (checks key tag only). - * - * \param rrsigs RR set with RRSIGs. - * \param pos Number of RR in RR set. - * \param keys Zone keys. - * - * \return Dynarray of such keys. - */ -static keyptr_dynarray_t get_matching_zone_keys(const knot_rrset_t *rrsigs, - size_t pos, const zone_keyset_t *keys) -{ - assert(rrsigs && rrsigs->type == KNOT_RRTYPE_RRSIG); - assert(keys); - - uint16_t keytag = knot_rrsig_key_tag(&rrsigs->rrs, pos); - - return get_zone_keys(keys, keytag); -} - /*! * \brief Note earliest expiration of a signature. * - * \param rrsigs RR set with RRSIGs. - * \param pos Position of RR in rrsigs. + * \param rrsig RRSIG rdata. * \param expires_at Current earliest expiration, will be updated. */ -static void note_earliest_expiration(const knot_rrset_t *rrsigs, size_t pos, - knot_time_t *expires_at) +static void note_earliest_expiration(const knot_rdata_t *rrsig, knot_time_t *expires_at) { - assert(rrsigs); + assert(rrsig); assert(expires_at); - uint32_t curr_rdata = knot_rrsig_sig_expiration(&rrsigs->rrs, pos); + uint32_t curr_rdata = knot_rrsig_sig_expiration(rrsig); knot_time_t current = knot_time_from_u32(curr_rdata); *expires_at = knot_time_min(current, *expires_at); } @@ -280,7 +260,10 @@ static int remove_expired_rrsigs(const knot_rrset_t *covered, 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); + knot_rdata_t *rr = knot_rdataset_at(&synth_rrsig.rrs, i); + uint16_t keytag = knot_rrsig_key_tag(rr); + + struct keyptr_dynarray keys = get_zone_keys(zone_keys, keytag); int endloop = 0; // 1 - continue; 2 - break dynarray_foreach(keyptr, zone_key_t *, key, keys) { @@ -291,7 +274,7 @@ static int remove_expired_rrsigs(const knot_rrset_t *covered, (*key)->key, (*key)->ctx, dnssec_ctx); if (result == KNOT_EOK) { // valid signature - note_earliest_expiration(&synth_rrsig, i, expires_at); + note_earliest_expiration(rr, expires_at); endloop = 1; break; } else if (result != DNSSEC_INVALID_SIGNATURE) { @@ -311,8 +294,7 @@ static int remove_expired_rrsigs(const knot_rrset_t *covered, to_remove = create_empty_rrsigs_for(&synth_rrsig); } - knot_rdata_t *rr_rem = knot_rdataset_at(&synth_rrsig.rrs, i); - result = knot_rdataset_add(&to_remove.rrs, rr_rem, NULL); + result = knot_rdataset_add(&to_remove.rrs, rr, NULL); if (result != KNOT_EOK) { break; } @@ -482,14 +464,14 @@ static int remove_standalone_rrsigs(const zone_node_t *node, } uint16_t rrsigs_rdata_count = rrsigs->rrs.count; + knot_rdata_t *rdata = rrsigs->rrs.rdata; for (uint16_t i = 0; i < rrsigs_rdata_count; ++i) { - uint16_t type_covered = knot_rrsig_type_covered(&rrsigs->rrs, i); + uint16_t type_covered = knot_rrsig_type_covered(rdata); if (!node_rrtype_exists(node, type_covered)) { knot_rrset_t to_remove; knot_rrset_init(&to_remove, rrsigs->owner, rrsigs->type, rrsigs->rclass, rrsigs->ttl); - knot_rdata_t *rr_rem = knot_rdataset_at(&rrsigs->rrs, i); - int ret = knot_rdataset_add(&to_remove.rrs, rr_rem, NULL); + int ret = knot_rdataset_add(&to_remove.rrs, rdata, NULL); if (ret != KNOT_EOK) { return ret; } @@ -499,6 +481,7 @@ static int remove_standalone_rrsigs(const zone_node_t *node, return ret; } } + rdata = knot_rdataset_next(rdata); } return KNOT_EOK; diff --git a/src/knot/events/handlers/load.c b/src/knot/events/handlers/load.c index 20bc200246..7fdb79977c 100644 --- a/src/knot/events/handlers/load.c +++ b/src/knot/events/handlers/load.c @@ -239,7 +239,7 @@ int event_load(conf_t *conf, zone_t *zone) // Schedule depedent events. const knot_rdataset_t *soa = zone_soa(zone); - zone->timers.soa_expire = knot_soa_expire(soa); + zone->timers.soa_expire = knot_soa_expire(soa->rdata); if (dnssec_enable) { event_dnssec_reschedule(conf, zone, &dnssec_refresh, false); // false since we handle NOTIFY below diff --git a/src/knot/events/handlers/notify.c b/src/knot/events/handlers/notify.c index e979e53890..bcd81bfe15 100644 --- a/src/knot/events/handlers/notify.c +++ b/src/knot/events/handlers/notify.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 @@ -109,7 +109,7 @@ static int send_notify(conf_t *conf, zone_t *zone, const knot_rrset_t *soa, if (ret == KNOT_EOK) { NOTIFY_LOG(LOG_INFO, zone->name, dst, - "serial %u", knot_soa_serial(&soa->rrs)); + "serial %u", knot_soa_serial(soa->rrs.rdata)); } else if (knot_pkt_ext_rcode(req->resp) == 0) { NOTIFY_LOG(LOG_WARNING, zone->name, dst, "failed (%s)", knot_strerror(ret)); diff --git a/src/knot/events/handlers/refresh.c b/src/knot/events/handlers/refresh.c index d5320604d4..da1f2469f1 100644 --- a/src/knot/events/handlers/refresh.c +++ b/src/knot/events/handlers/refresh.c @@ -420,15 +420,15 @@ static int ixfr_finalize(struct refresh_data *data) uint32_t old_serial = local_serial; changeset_t *chs = NULL; WALK_LIST(chs, data->ixfr.changesets) { - master_serial = knot_soa_serial(&chs->soa_to->rrs); - knot_soa_serial_set(&chs->soa_from->rrs, local_serial); + master_serial = knot_soa_serial(chs->soa_to->rrs.rdata); + knot_soa_serial_set(chs->soa_from->rrs.rdata, local_serial); if (have_lastsigned && (serial_compare(lastsigned_serial, local_serial) & SERIAL_MASK_GEQ)) { local_serial = lastsigned_serial; } if (serial_compare(master_serial, local_serial) != SERIAL_GREATER) { conf_val_t val = conf_zone_get(data->conf, C_SERIAL_POLICY, data->zone->name); local_serial = serial_next(local_serial, conf_opt(&val)); - knot_soa_serial_set(&chs->soa_to->rrs, local_serial); + knot_soa_serial_set(chs->soa_to->rrs.rdata, local_serial); } else { local_serial = master_serial; } @@ -698,7 +698,7 @@ static enum xfr_type determine_xfr_type(const knot_pktsection_t *answer, if (answer->count == 1) { if (rr_one->type == KNOT_RRTYPE_SOA) { - return serial_is_current(zone_serial, knot_soa_serial(&rr_one->rrs)) ? + return serial_is_current(zone_serial, knot_soa_serial(rr_one->rrs.rdata)) ? XFR_TYPE_UPTODATE : XFR_TYPE_UNDETERMINED; } return XFR_TYPE_ERROR; @@ -731,7 +731,7 @@ static int ixfr_consume(knot_pkt_t *pkt, struct refresh_data *data) if (data->ixfr.proc == NULL) { const knot_pktsection_t *answer = knot_pkt_section(pkt, KNOT_ANSWER); - uint32_t master_serial = knot_soa_serial(&data->soa->rrs); + uint32_t master_serial = knot_soa_serial(data->soa->rrs.rdata); (void)zone_get_master_serial(data->zone, &master_serial); data->xfr_type = determine_xfr_type(answer, master_serial, data->initial_soa_copy); @@ -838,9 +838,9 @@ static int soa_query_consume(knot_layer_t *layer, knot_pkt_t *pkt) return KNOT_STATE_FAIL; } - uint32_t local_serial = knot_soa_serial(&data->soa->rrs); + uint32_t local_serial = knot_soa_serial(data->soa->rrs.rdata); (void)zone_get_master_serial(data->zone, &local_serial); - uint32_t remote_serial = knot_soa_serial(&rr->rrs); + uint32_t remote_serial = knot_soa_serial(rr->rrs.rdata); bool current = serial_is_current(local_serial, remote_serial); bool master_uptodate = serial_is_current(remote_serial, local_serial); @@ -876,7 +876,7 @@ static int transfer_produce(knot_layer_t *layer, knot_pkt_t *pkt) knot_rrset_free(sending_soa, data->mm); return KNOT_STATE_FAIL; } - knot_soa_serial_set(&sending_soa->rrs, master_serial); + knot_soa_serial_set(sending_soa->rrs.rdata, master_serial); knot_pkt_begin(pkt, KNOT_AUTHORITY); knot_pkt_put(pkt, KNOT_COMPR_HINT_QNAME, sending_soa, 0); knot_rrset_free(sending_soa, data->mm); @@ -1114,13 +1114,13 @@ int event_refresh(conf_t *conf, zone_t *zone) const knot_rdataset_t *soa = zone_soa(zone); if (ret == KNOT_EOK) { - zone->timers.soa_expire = knot_soa_expire(soa); + zone->timers.soa_expire = knot_soa_expire(soa->rdata); zone->timers.last_refresh = now; - zone->timers.next_refresh = now + knot_soa_refresh(soa); + zone->timers.next_refresh = now + knot_soa_refresh(soa->rdata); } else { time_t next = 0; if (soa) { - next = knot_soa_retry(soa); + next = knot_soa_retry(soa->rdata); } else { next = bootstrap_next(&zone->timers); } diff --git a/src/knot/journal/journal.c b/src/knot/journal/journal.c index e30f306bb1..2d0a414b1f 100644 --- a/src/knot/journal/journal.c +++ b/src/knot/journal/journal.c @@ -1003,7 +1003,7 @@ int journal_load_bootstrap(journal_t *j, list_t *dst) goto jlb_end; } add_tail(dst, &bch->n); - uint32_t from = knot_soa_serial(&bch->soa_to->rrs); + uint32_t from = knot_soa_serial(bch->soa_to->rrs.rdata); uint32_t ls = txn->shadow_md.last_serial; iterate(j, txn, load_list_itercb, JOURNAL_ITERATION_CHANGESETS, &dst, @@ -1286,7 +1286,7 @@ static int merge_unflushed_changesets(journal_t *j, txn_t *_txn, changeset_t **m txn->ret = load_one(j, txn, from, mch); if (!was_merged && was_flushed && txn->ret == KNOT_EOK) { // we have to jump to ONE AFTER last_flushed - from = knot_soa_serial(&(*mch)->soa_to->rrs); + from = knot_soa_serial((*mch)->soa_to->rrs.rdata); changeset_free(*mch); *mch = NULL; txn->ret = load_one(j, txn, from, mch); @@ -1295,7 +1295,7 @@ static int merge_unflushed_changesets(journal_t *j, txn_t *_txn, changeset_t **m if (txn->ret != KNOT_EOK) { goto m_u_ch_end; } - from = knot_soa_serial(&(*mch)->soa_to->rrs); + from = knot_soa_serial((*mch)->soa_to->rrs.rdata); if (!serial_equal(from, txn->shadow_md.last_serial_to)) { txn->ret = iterate(j, txn, merge_itercb, JOURNAL_ITERATION_CHANGESETS, @@ -1437,7 +1437,7 @@ static int store_changesets(journal_t *j, list_t *changesets) // PART 4: continuity and duplicity check changeset_t * chs_head = (HEAD(*changesets)); bool is_first_bootstrap = (chs_head->soa_from == NULL); - uint32_t serial = is_first_bootstrap ? 0 : knot_soa_serial(&chs_head->soa_from->rrs); + uint32_t serial = is_first_bootstrap ? 0 : knot_soa_serial(chs_head->soa_from->rrs.rdata); if (md_flag(txn, SERIAL_TO_VALID) && (is_first_bootstrap || !serial_equal(txn->shadow_md.last_serial_to, serial)) && !inserting_bootstrap /* if inserting bootstrap, drop_journal() was called, so no discontinuity */) { @@ -1455,7 +1455,7 @@ static int store_changesets(journal_t *j, list_t *changesets) txn_restart(txn); } WALK_LIST(ch, *changesets) { - uint32_t serial_to = knot_soa_serial(&ch->soa_to->rrs); + uint32_t serial_to = knot_soa_serial(ch->soa_to->rrs.rdata); bool is_this_bootstrap = (ch->soa_from == NULL); bool is_this_merged = (inserting_merged && ch == TAIL(*changesets)); if (is_this_bootstrap || is_this_merged) { @@ -1497,8 +1497,8 @@ static int store_changesets(journal_t *j, list_t *changesets) bool is_this_merged = (inserting_merged && ch == TAIL(*changesets)); bool is_this_bootstrap = (ch->soa_from == NULL); - uint32_t serial = is_this_bootstrap ? 0 : knot_soa_serial(&ch->soa_from->rrs); - uint32_t serial_to = knot_soa_serial(&ch->soa_to->rrs); + uint32_t serial = is_this_bootstrap ? 0 : knot_soa_serial(ch->soa_from->rrs.rdata); + uint32_t serial_to = knot_soa_serial(ch->soa_to->rrs.rdata); while (serialize_unfinished(sctx)) { size_t chunk_size; @@ -2088,7 +2088,7 @@ int journal_check(journal_t *j, journal_check_level_t warn_level) ret = load_bootstrap_changeset(j, txn, &ch); switch (ret) { case KNOT_EOK: - sto = knot_soa_serial(&ch->soa_to->rrs); + sto = knot_soa_serial(ch->soa_to->rrs.rdata); jch_info("bootstrap changeset loaded, sto %u", sto); changeset_free(ch); break; @@ -2108,7 +2108,7 @@ int journal_check(journal_t *j, journal_check_level_t warn_level) goto check_merged; } - sfrom = knot_soa_serial(&ch->soa_from->rrs), sto = knot_soa_serial(&ch->soa_to->rrs); + sfrom = knot_soa_serial(ch->soa_from->rrs.rdata), sto = knot_soa_serial(ch->soa_to->rrs.rdata); if (!serial_equal(txn->shadow_md.first_serial, sfrom)) { jch_warn("first changeset's serial 'from' %u is not ok", sfrom); } @@ -2120,7 +2120,7 @@ int journal_check(journal_t *j, journal_check_level_t warn_level) jch_warn("can't read last flushed changeset %u (%s)", txn->shadow_md.last_flushed, knot_strerror(ret)); } else { - first_unflushed = knot_soa_serial(&ch->soa_to->rrs); + first_unflushed = knot_soa_serial(ch->soa_to->rrs.rdata); } } if (ret == KNOT_EOK) { @@ -2135,7 +2135,7 @@ int journal_check(journal_t *j, journal_check_level_t warn_level) if (ret != KNOT_EOK) { jch_warn("can't read second changeset %u (%s)", sto, knot_strerror(ret)); } else { - sfrom = knot_soa_serial(&ch->soa_from->rrs); + sfrom = knot_soa_serial(ch->soa_from->rrs.rdata); if (!serial_equal(sfrom, sto)) { jch_warn("second changeset's serial 'from' %u is not ok", sfrom); } @@ -2160,14 +2160,14 @@ int journal_check(journal_t *j, journal_check_level_t warn_level) } ch = HEAD(l); - if (!serial_equal(sfrom, knot_soa_serial(&ch->soa_from->rrs))) { + if (!serial_equal(sfrom, knot_soa_serial(ch->soa_from->rrs.rdata))) { jch_warn("first listed changeset's serial 'from' %u is not ok", - knot_soa_serial(&ch->soa_from->rrs)); + knot_soa_serial(ch->soa_from->rrs.rdata)); } ch = TAIL(l); - if (!serial_equal(sto, knot_soa_serial(&ch->soa_to->rrs))) { + if (!serial_equal(sto, knot_soa_serial(ch->soa_to->rrs.rdata))) { jch_warn("last listed changeset's serial 'to' %u is not ok", - knot_soa_serial(&ch->soa_to->rrs)); + knot_soa_serial(ch->soa_to->rrs.rdata)); } changesets_free(&l); @@ -2181,8 +2181,8 @@ check_merged: if (ret != KNOT_EOK) { jch_warn("can't read merged changeset (%s)", knot_strerror(ret)); } else { - sfrom = knot_soa_serial(&ch->soa_from->rrs); - sto = knot_soa_serial(&ch->soa_to->rrs); + sfrom = knot_soa_serial(ch->soa_from->rrs.rdata); + sto = knot_soa_serial(ch->soa_to->rrs.rdata); jch_info("merged changeset %u -> %u (size %zu)", sfrom, sto, changeset_serialized_size(ch)); if (!serial_equal(sfrom, txn->shadow_md.merged_serial)) { diff --git a/src/knot/journal/serialization.c b/src/knot/journal/serialization.c index 2cae7fd4c5..75e18a2a91 100644 --- a/src/knot/journal/serialization.c +++ b/src/knot/journal/serialization.c @@ -272,12 +272,11 @@ static uint64_t rrset_binary_size(const knot_rrset_t *rrset) uint64_t size = knot_dname_size(rrset->owner) + 3 * sizeof(uint16_t); // RRs. + knot_rdata_t *rr = rrset->rrs.rdata; for (uint16_t i = 0; i < rrset->rrs.count; i++) { - const knot_rdata_t *rr = knot_rdataset_at(&rrset->rrs, i); - assert(rr); - // TTL + RR size + RR. size += sizeof(uint32_t) + sizeof(uint16_t) + rr->len; + rr = knot_rdataset_next(rr); } return size; diff --git a/src/knot/modules/onlinesign/onlinesign.c b/src/knot/modules/onlinesign/onlinesign.c index 9bb4c5a77f..2ad8e0c0ed 100644 --- a/src/knot/modules/onlinesign/onlinesign.c +++ b/src/knot/modules/onlinesign/onlinesign.c @@ -93,7 +93,7 @@ static uint32_t dnskey_ttl(knotd_qdata_t *qdata) static uint32_t nsec_ttl(knotd_qdata_t *qdata) { knot_rrset_t soa = knotd_qdata_zone_apex_rrset(qdata, KNOT_RRTYPE_SOA); - return knot_soa_minimum(&soa.rrs); + return knot_soa_minimum(soa.rrs.rdata); } /*! diff --git a/src/knot/modules/rrl/rrl.c b/src/knot/modules/rrl/rrl.c index 7f95fad55e..46571b122e 100644 --- a/src/knot/modules/rrl/rrl.c +++ b/src/knot/modules/rrl/rrl.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 @@ -59,7 +59,7 @@ static const knot_dname_t *name_from_rrsig(const knot_rrset_t *rr) } // This is a signature. - return knot_rrsig_signer_name(&rr->rrs, 0); + return knot_rrsig_signer_name(rr->rrs.rdata); } static const knot_dname_t *name_from_authrr(const knot_rrset_t *rr) diff --git a/src/knot/modules/stats/stats.c b/src/knot/modules/stats/stats.c index 9bb2132bb1..94413a4966 100644 --- a/src/knot/modules/stats/stats.c +++ b/src/knot/modules/stats/stats.c @@ -355,7 +355,7 @@ static void incr_edns_option(knotd_mod_t *mod, const knot_pkt_t *pkt, unsigned c return; } - knot_rdata_t *rdata = knot_rdataset_at(&pkt->opt_rr->rrs, 0); + knot_rdata_t *rdata = pkt->opt_rr->rrs.rdata; if (rdata == NULL || rdata->len == 0) { return; } diff --git a/src/knot/nameserver/internet.c b/src/knot/nameserver/internet.c index 56efa08852..e2fc8262a3 100644 --- a/src/knot/nameserver/internet.c +++ b/src/knot/nameserver/internet.c @@ -72,7 +72,7 @@ static int dname_cname_synth(const knot_rrset_t *dname_rr, /* Replace last labels of qname with DNAME. */ const knot_dname_t *dname_wire = dname_rr->owner; - const knot_dname_t *dname_tgt = knot_dname_target(&dname_rr->rrs); + const knot_dname_t *dname_tgt = knot_dname_target(dname_rr->rrs.rdata); size_t labels = knot_dname_labels(dname_wire, NULL); knot_dname_t *cname = knot_dname_replace_suffix(qname, labels, dname_tgt, mm); if (cname == NULL) { @@ -102,10 +102,10 @@ static int dname_cname_synth(const knot_rrset_t *dname_rr, static bool dname_cname_cannot_synth(const knot_rrset_t *rrset, const knot_dname_t *qname) { if (knot_dname_labels(qname, NULL) - knot_dname_labels(rrset->owner, NULL) + - knot_dname_labels(knot_dname_target(&rrset->rrs), NULL) > KNOT_DNAME_MAXLABELS) { + knot_dname_labels(knot_dname_target(rrset->rrs.rdata), NULL) > KNOT_DNAME_MAXLABELS) { return true; } else if (knot_dname_size(qname) - knot_dname_size(rrset->owner) + - knot_dname_size(knot_dname_target(&rrset->rrs)) > KNOT_DNAME_MAXLEN) { + knot_dname_size(knot_dname_target(rrset->rrs.rdata)) > KNOT_DNAME_MAXLEN) { return true; } else { return false; @@ -309,7 +309,7 @@ static int follow_cname(knot_pkt_t *pkt, uint16_t rrtype, knotd_qdata_t *qdata) } /* Now follow the next CNAME TARGET. */ - qdata->name = knot_cname_name(&cname_rr.rrs); + qdata->name = knot_cname_name(cname_rr.rrs.rdata); return KNOTD_IN_STATE_FOLLOW; } diff --git a/src/knot/nameserver/ixfr.c b/src/knot/nameserver/ixfr.c index 5b3c2424bf..bf09e4eb41 100644 --- a/src/knot/nameserver/ixfr.c +++ b/src/knot/nameserver/ixfr.c @@ -102,7 +102,7 @@ static int ixfr_load_chsets(chgset_ctx_list_t *chgsets, zone_t *zone, /* Compare serials. */ uint32_t serial_to = zone_contents_serial(zone->contents); - uint32_t serial_from = knot_soa_serial(&their_soa->rrs); + uint32_t serial_from = knot_soa_serial(their_soa->rrs.rdata); if (serial_compare(serial_to, serial_from) & SERIAL_MASK_LEQ) { /* We have older/same age zone. */ return KNOT_EUPTODATE; } diff --git a/src/knot/nameserver/notify.c b/src/knot/nameserver/notify.c index ba2177ef22..fe9273bde1 100644 --- a/src/knot/nameserver/notify.c +++ b/src/knot/nameserver/notify.c @@ -70,7 +70,7 @@ int notify_process_query(knot_pkt_t *pkt, knotd_qdata_t *qdata) if (answer->count > 0) { const knot_rrset_t *soa = knot_pkt_rr(answer, 0); if (soa->type == KNOT_RRTYPE_SOA) { - uint32_t serial = knot_soa_serial(&soa->rrs); + uint32_t serial = knot_soa_serial(soa->rrs.rdata); uint32_t zone_serial = zone_contents_serial(zone->contents); (void)zone_get_master_serial(zone, &zone_serial); NOTIFY_LOG(LOG_INFO, qdata, "received, serial %u", serial); diff --git a/src/knot/updates/apply.c b/src/knot/updates/apply.c index f61359ec61..5864712424 100644 --- a/src/knot/updates/apply.c +++ b/src/knot/updates/apply.c @@ -114,24 +114,25 @@ static int add_new_data(apply_ctx_t *ctx, knot_rdata_t *new_data) } /*! \brief Returns true if given RR is present in node and can be removed. */ -static bool can_remove(const zone_node_t *node, const knot_rrset_t *rr) +static bool can_remove(const zone_node_t *node, const knot_rrset_t *rrset) { if (node == NULL) { // Node does not exist, cannot remove anything. return false; } - const knot_rdataset_t *node_rrs = node_rdataset(node, rr->type); + const knot_rdataset_t *node_rrs = node_rdataset(node, rrset->type); if (node_rrs == NULL) { // Node does not have this type at all. return false; } - for (uint16_t i = 0; i < rr->rrs.count; ++i) { - knot_rdata_t *rr_cmp = knot_rdataset_at(&rr->rrs, i); + knot_rdata_t *rr_cmp = rrset->rrs.rdata; + for (uint16_t i = 0; i < rrset->rrs.count; ++i) { if (knot_rdataset_member(node_rrs, rr_cmp)) { // At least one RR matches. return true; } + rr_cmp = knot_rdataset_next(rr_cmp); } // Node does have the type, but no RRs match. @@ -194,7 +195,7 @@ static int apply_single(apply_ctx_t *ctx, const changeset_t *chset) // check if serial matches const knot_rdataset_t *soa = node_rdataset(contents->apex, KNOT_RRTYPE_SOA); - if (soa == NULL || (!ignore_soa && knot_soa_serial(soa) != knot_soa_serial(&chset->soa_from->rrs))) { + if (soa == NULL || (!ignore_soa && knot_soa_serial(soa->rdata) != knot_soa_serial(chset->soa_from->rrs.rdata))) { return KNOT_EINVAL; } diff --git a/src/knot/updates/ddns.c b/src/knot/updates/ddns.c index 8b82ab34ea..52f3b8dea4 100644 --- a/src/knot/updates/ddns.c +++ b/src/knot/updates/ddns.c @@ -160,18 +160,17 @@ 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).*/ +/*!< \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.count; - if (rr_count == 0) { + switch (rrset->rrs.count) { + case 0: return true; + case 1: + return rrset->rrs.rdata->len == 0; + default: + return false; } - if (rr_count == 1) { - const knot_rdata_t *rr = knot_rdataset_at(&rrset->rrs, 0); - return rr->len == 0; - } - return false; } /*< \brief Returns true if DDNS should deny updating DNSSEC-related record. */ @@ -278,12 +277,12 @@ static bool should_replace(const knot_rrset_t *rrset) /*!< \brief Returns true if node contains given RR in its RRSets. */ static bool node_contains_rr(const zone_node_t *node, - const knot_rrset_t *rr) + const knot_rrset_t *rrset) { - const knot_rdataset_t *zone_rrs = node_rdataset(node, rr->type); - if (zone_rrs) { - assert(rr->rrs.count == 1); - return knot_rdataset_member(zone_rrs, knot_rdataset_at(&rr->rrs, 0)); + const knot_rdataset_t *zone_rrs = node_rdataset(node, rrset->type); + if (zone_rrs != NULL) { + assert(rrset->rrs.count == 1); + return knot_rdataset_member(zone_rrs, rrset->rrs.rdata); } else { return false; } @@ -313,7 +312,7 @@ static bool skip_soa(const knot_rrset_t *rr, int64_t sn) { if (rr->type == KNOT_RRTYPE_SOA && (rr->rclass == KNOT_CLASS_NONE || rr->rclass == KNOT_CLASS_ANY || - (serial_compare(knot_soa_serial(&rr->rrs), sn) != SERIAL_GREATER))) { + (serial_compare(knot_soa_serial(rr->rrs.rdata), sn) != SERIAL_GREATER))) { return true; } @@ -740,7 +739,7 @@ int ddns_process_update(const zone_t *zone, const knot_pkt_t *query, return KNOT_EINVAL; } - uint32_t sn_old = knot_soa_serial(zone_update_from(update)); + uint32_t sn_old = knot_soa_serial(zone_update_from(update)->rdata); // Process all RRs in the authority section. const knot_pktsection_t *authority = knot_pkt_section(query, KNOT_AUTHORITY); diff --git a/src/knot/updates/zone-update.c b/src/knot/updates/zone-update.c index b42add718a..ce79e7294f 100644 --- a/src/knot/updates/zone-update.c +++ b/src/knot/updates/zone-update.c @@ -242,7 +242,7 @@ uint32_t zone_update_current_serial(zone_update_t *update) { const zone_node_t *apex = zone_update_get_apex(update); if (apex != NULL) { - return knot_soa_serial(node_rdataset(apex, KNOT_RRTYPE_SOA)); + return knot_soa_serial(node_rdataset(apex, KNOT_RRTYPE_SOA)->rdata); } else { return 0; } @@ -538,7 +538,7 @@ static int set_new_soa(zone_update_t *update, unsigned serial_policy) return ret; } - uint32_t old_serial = knot_soa_serial(&soa_cpy->rrs); + uint32_t old_serial = knot_soa_serial(soa_cpy->rrs.rdata); uint32_t new_serial = serial_next(old_serial, serial_policy); if (serial_compare(old_serial, new_serial) != SERIAL_LOWER) { log_zone_warning(update->zone->name, "updated SOA serial is lower " @@ -546,7 +546,7 @@ static int set_new_soa(zone_update_t *update, unsigned serial_policy) old_serial, new_serial); ret = KNOT_ESOAINVAL; } else { - knot_soa_serial_set(&soa_cpy->rrs, new_serial); + knot_soa_serial_set(soa_cpy->rrs.rdata, new_serial); ret = zone_update_add(update, soa_cpy); } diff --git a/src/knot/zone/contents.c b/src/knot/zone/contents.c index 9a77192330..3d4e99efff 100644 --- a/src/knot/zone/contents.c +++ b/src/knot/zone/contents.c @@ -129,7 +129,8 @@ static int discover_additionals(const knot_dname_t *owner, struct rr_data *rr_da /* Scan new additional nodes. */ for (uint16_t i = 0; i < rdcount; i++) { - const knot_dname_t *dname = knot_rdata_name(rrs, i, rr_data->type); + knot_rdata_t *rdata = knot_rdataset_at(rrs, i); + const knot_dname_t *dname = knot_rdata_name(rdata, rr_data->type); const zone_node_t *node = NULL, *encloser = NULL, *prev = NULL; /* Try to find node for the dname in the RDATA. */ @@ -286,10 +287,12 @@ static bool nsec3_params_match(const knot_rdataset_t *rrs, assert(rrs != NULL); assert(params != NULL); - return (knot_nsec3_algorithm(rrs, rdata_pos) == params->algorithm - && knot_nsec3_iterations(rrs, rdata_pos) == params->iterations - && knot_nsec3_salt_length(rrs, rdata_pos) == params->salt.size - && memcmp(knot_nsec3_salt(rrs, rdata_pos), params->salt.data, + knot_rdata_t *rdata = knot_rdataset_at(rrs, rdata_pos); + + return (knot_nsec3_alg(rdata) == params->algorithm + && knot_nsec3_iters(rdata) == params->iterations + && knot_nsec3_salt_len(rdata) == params->salt.size + && memcmp(knot_nsec3_salt(rdata), params->salt.data, params->salt.size) == 0); } @@ -970,10 +973,9 @@ static int load_nsec3param(zone_contents_t *contents) return KNOT_EINVAL; } - knot_rdata_t *rr = knot_rdataset_at(rrs, 0); dnssec_binary_t rdata = { - .size = rr->len, - .data = rr->data, + .size = rrs->rdata->len, + .data = rrs->rdata->data, }; dnssec_nsec3_params_t new_params = { 0 }; @@ -1148,14 +1150,14 @@ uint32_t zone_contents_serial(const zone_contents_t *zone) return 0; } - return knot_soa_serial(soa); + return knot_soa_serial(soa->rdata); } void zone_contents_set_soa_serial(zone_contents_t *zone, uint32_t new_serial) { knot_rdataset_t *soa; if (zone != NULL && (soa = node_rdataset(zone->apex, KNOT_RRTYPE_SOA)) != NULL) { - knot_soa_serial_set(soa, new_serial); + knot_soa_serial_set(soa->rdata, new_serial); } } diff --git a/src/knot/zone/node.c b/src/knot/zone/node.c index c621035e04..3db7c45ad6 100644 --- a/src/knot/zone/node.c +++ b/src/knot/zone/node.c @@ -273,12 +273,12 @@ bool node_rrtype_is_signed(const zone_node_t *node, uint16_t type) } uint16_t rrsigs_rdata_count = rrsigs->count; + knot_rdata_t *rrsig = rrsigs->rdata; for (uint16_t i = 0; i < rrsigs_rdata_count; ++i) { - const uint16_t type_covered = - knot_rrsig_type_covered(rrsigs, i); - if (type_covered == type) { + if (knot_rrsig_type_covered(rrsig) == type) { return true; } + rrsig = knot_rdataset_next(rrsig); } return false; diff --git a/src/knot/zone/semantic-check.c b/src/knot/zone/semantic-check.c index f7765cc6cb..253afea5a8 100644 --- a/src/knot/zone/semantic-check.c +++ b/src/knot/zone/semantic-check.c @@ -223,18 +223,20 @@ static int dnssec_key_from_rdata(dnssec_key_t **key, const knot_dname_t *owner, return KNOT_EOK; } -static int check_signature(const knot_rdataset_t *rrsigs, size_t pos, - const dnssec_key_t *key, const knot_rrset_t *covered) +static int check_signature(const knot_rdata_t *rrsig, const dnssec_key_t *key, + const knot_rrset_t *covered) { - if (!rrsigs || !key || !dnssec_key_can_verify(key)) { + if (!rrsig || !key || !dnssec_key_can_verify(key)) { return KNOT_EINVAL; } int ret = KNOT_EOK; dnssec_sign_ctx_t *sign_ctx = NULL; - dnssec_binary_t signature = { 0 }; - knot_rrsig_signature(rrsigs, pos, &signature.data, &signature.size); + dnssec_binary_t signature = { + .size = knot_rrsig_signature_len(rrsig), + .data = (uint8_t *)knot_rrsig_signature(rrsig) + }; if (!signature.data || !signature.size) { ret = KNOT_EINVAL; goto fail; @@ -245,8 +247,7 @@ static int check_signature(const knot_rdataset_t *rrsigs, size_t pos, goto fail; } - const knot_rdata_t *rr_data = knot_rdataset_at(rrsigs, pos); - if (knot_sign_ctx_add_data(sign_ctx, rr_data->data, covered) != KNOT_EOK) { + if (knot_sign_ctx_add_data(sign_ctx, rrsig->data, covered) != KNOT_EOK) { ret = KNOT_ENOMEM; goto fail; } @@ -267,8 +268,7 @@ fail: * \param handler Pointer on function to be called in case of negative check. * \param zone The zone the rrset is in. * \param node The node in the zone contents. - * \param rrsig RRSIG rdataset. - * \param rr_pos Position of the RRSIG rdata in question (in the rdataset). + * \param rrsig RRSIG rdata. * \param rrset RRSet signed by the RRSIG. * \param context The time stamp we check the rrsig validity according to. * \param level Level of the check. @@ -280,8 +280,7 @@ fail: static int check_rrsig_rdata(sem_handler_t *handler, const zone_contents_t *zone, const zone_node_t *node, - const knot_rdataset_t *rrsig, - size_t rr_pos, + const knot_rdata_t *rrsig, const knot_rrset_t *rrset, time_t context, check_level_t level, @@ -296,13 +295,13 @@ static int check_rrsig_rdata(sem_handler_t *handler, return KNOT_ENOMEM; } - if (knot_rrsig_type_covered(rrsig, 0) != rrset->type) { + if (knot_rrsig_type_covered(rrsig) != rrset->type) { handler->cb(handler, zone, node, SEM_ERR_RRSIG_RDATA_TYPE_COVERED, info_str); } /* label number at the 2nd index should be same as owner's */ - uint8_t labels_rdata = knot_rrsig_labels(rrsig, rr_pos); + uint8_t labels_rdata = knot_rrsig_labels(rrsig); size_t tmp = knot_dname_labels(rrset->owner, NULL) - labels_rdata; if (tmp != 0) { @@ -317,26 +316,26 @@ static int check_rrsig_rdata(sem_handler_t *handler, } /* Check original TTL. */ - uint32_t original_ttl = knot_rrsig_original_ttl(rrsig, rr_pos); + uint32_t original_ttl = knot_rrsig_original_ttl(rrsig); if (original_ttl != rrset->ttl) { handler->cb(handler, zone, node, SEM_ERR_RRSIG_RDATA_TTL, info_str); } /* Check for expired signature. */ - if (knot_rrsig_sig_expiration(rrsig, rr_pos) < context) { + if (knot_rrsig_sig_expiration(rrsig) < context) { handler->cb(handler, zone, node, SEM_ERR_RRSIG_RDATA_EXPIRATION, info_str); } /* Check inception */ - if (knot_rrsig_sig_inception(rrsig, rr_pos) > context) { + if (knot_rrsig_sig_inception(rrsig) > context) { handler->cb(handler, zone, node, SEM_ERR_RRSIG_RDATA_INCEPTION, info_str); } /* Check signer name. */ - const knot_dname_t *signer = knot_rrsig_signer_name(rrsig, rr_pos); + const knot_dname_t *signer = knot_rrsig_signer_name(rrsig); if (!knot_dname_is_equal(signer, zone->apex->owner)) { handler->cb(handler, zone, node, SEM_ERR_RRSIG_RDATA_OWNER, info_str); @@ -350,11 +349,11 @@ static int check_rrsig_rdata(sem_handler_t *handler, } for (int i = 0; i < dnskeys->count; i++) { - uint16_t flags = knot_dnskey_flags(dnskeys, i); - uint8_t proto = knot_dnskey_proto(dnskeys, i); + knot_rdata_t *dnskey = knot_rdataset_at(dnskeys, i); + uint16_t flags = knot_dnskey_flags(dnskey); + uint8_t proto = knot_dnskey_proto(dnskey); /* RFC 4034 2.1.1 & 2.1.2 */ if (flags & DNSKEY_FLAGS_ZSK && proto == 3) { - knot_rdata_t *dnskey = knot_rdataset_at(dnskeys, i); dnssec_key_t *key; ret = dnssec_key_from_rdata(&key, zone->apex->owner, @@ -363,7 +362,7 @@ static int check_rrsig_rdata(sem_handler_t *handler, continue; } - ret = check_signature(rrsig, rr_pos, key, rrset); + ret = check_signature(rrsig, key, rrset); dnssec_key_free(key); if (ret == KNOT_EOK) { *verified = true; @@ -432,9 +431,11 @@ static int check_rrsig_in_rrset(sem_handler_t *handler, } bool verified = false; - for (uint16_t i = 0; ret == KNOT_EOK && i < (&rrsigs)->count; ++i) { - ret = check_rrsig_rdata(handler, zone, node, &rrsigs, i, rrset, + knot_rdata_t *rrsig = rrsigs.rdata; + for (uint16_t i = 0; ret == KNOT_EOK && i < rrsigs.count; ++i) { + ret = check_rrsig_rdata(handler, zone, node, rrsig, rrset, context, level, &verified); + rrsig = knot_rdataset_next(rrsig); } /* Only one rrsig of covered record needs to be verified by DNSKEY. */ if (!verified) { @@ -469,7 +470,8 @@ 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->count; ++i) { - const knot_dname_t *ns_dname = knot_ns_name(ns_rrs, i); + knot_rdata_t *ns_rr = knot_rdataset_at(ns_rrs, i); + const knot_dname_t *ns_dname = knot_ns_name(ns_rr); if (!knot_dname_is_sub(ns_dname, node->owner)) { continue; } @@ -524,9 +526,9 @@ static int check_submission(const zone_node_t *node, semchecks_data_t *data) SEM_ERR_CDNSKEY_MULTIPLE, NULL); } - knot_rdata_t *cdnskey = knot_rdataset_at(cdnskeys, 0); - knot_rdata_t *cds = knot_rdataset_at(cdss, 0); - uint8_t digest_type = knot_ds_digest_type(cdss, 0); + knot_rdata_t *cdnskey = cdnskeys->rdata; + knot_rdata_t *cds = cdss->rdata; + uint8_t digest_type = knot_ds_digest_type(cdss->rdata); const knot_rdataset_t *dnskeys = node_rdataset(data->zone->apex, KNOT_RRTYPE_DNSKEY); @@ -586,8 +588,9 @@ static int check_ds(const zone_node_t *node, semchecks_data_t *data) } 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); + knot_rdata_t *ds = knot_rdataset_at(dss, i); + uint16_t keytag = knot_ds_key_tag(ds); + uint8_t digest_type = knot_ds_digest_type(ds); char info[100] = ""; (void)snprintf(info, sizeof(info), "(keytag %d)", keytag); @@ -599,9 +602,7 @@ static int check_ds(const zone_node_t *node, semchecks_data_t *data) // Sizes for different digest algorithms. const uint16_t digest_sizes [] = { 0, 20, 32, 32, 48}; - uint8_t *digest; - uint16_t digest_size; - knot_ds_digest(dss, i, &digest, &digest_size); + uint16_t digest_size = knot_ds_digest_len(ds); if (digest_sizes[digest_type] != digest_size) { data->handler->cb(data->handler, data->zone, node, @@ -724,12 +725,14 @@ static int check_nsec_bitmap(const zone_node_t *node, semchecks_data_t *data) dnssec_nsec_bitmap_free(node_bitmap); // get NSEC bitmap from NSEC node - uint8_t *nsec_wire = NULL; + const uint8_t *nsec_wire = NULL; uint16_t nsec_wire_size = 0; if (nsec) { - knot_nsec_bitmap(nsec_rrs, &nsec_wire, &nsec_wire_size); + nsec_wire = knot_nsec_bitmap(nsec_rrs->rdata); + nsec_wire_size = knot_nsec_bitmap_len(nsec_rrs->rdata); } else { - knot_nsec3_bitmap(nsec_rrs, 0, &nsec_wire, &nsec_wire_size); + nsec_wire = knot_nsec3_bitmap(nsec_rrs->rdata); + nsec_wire_size = knot_nsec3_bitmap_len(nsec_rrs->rdata); } if (node_wire_size != nsec_wire_size || @@ -789,7 +792,7 @@ static int check_nsec(const zone_node_t *node, semchecks_data_t *data) * so checking should only be matter of testing * the next link in each node. */ - const knot_dname_t *next_domain = knot_nsec_next(nsec_rrs); + const knot_dname_t *next_domain = knot_nsec_next(nsec_rrs->rdata); data->next_nsec = zone_contents_find_node(data->zone, next_domain); if (data->next_nsec == NULL) { @@ -850,7 +853,7 @@ static int check_nsec3_opt_out(const zone_node_t *node, semchecks_data_t *data) assert(previous_rrs); /* Check for opt-out flag. */ - uint8_t flags = knot_nsec3_flags(previous_rrs, 0); + uint8_t flags = knot_nsec3_flags(previous_rrs->rdata); if (!(flags & 1)) { data->handler->cb(data->handler, data->zone, node, SEM_ERR_NSEC3_INSECURE_DELEGATION_OPT, NULL); @@ -895,7 +898,7 @@ static int check_nsec3(const zone_node_t *node, semchecks_data_t *data) const knot_rdataset_t *soa_rrs = node_rdataset(data->zone->apex, KNOT_RRTYPE_SOA); assert(soa_rrs); - uint32_t minimum_ttl = knot_soa_minimum(soa_rrs); + uint32_t minimum_ttl = knot_soa_minimum(soa_rrs->rdata); if (nsec3_rrs.ttl != minimum_ttl) { data->handler->cb(data->handler, data->zone, node, SEM_ERR_NSEC3_RDATA_TTL, info); @@ -904,22 +907,24 @@ static int check_nsec3(const zone_node_t *node, semchecks_data_t *data) // Check parameters. const knot_rdataset_t *nsec3param = node_rdataset(data->zone->apex, KNOT_RRTYPE_NSEC3PARAM); - knot_rdata_t *rrd = knot_rdataset_at(nsec3param, 0); - dnssec_binary_t rdata = { .size = rrd->len, .data = rrd->data }; + dnssec_binary_t rdata = { + .size = nsec3param->rdata->len, + .data = nsec3param->rdata->data + }; ret = dnssec_nsec3_params_from_rdata(¶ms_apex, &rdata); if (ret != DNSSEC_EOK) { ret = knot_error_from_libdnssec(ret); goto nsec3_cleanup; } - if (knot_nsec3_flags(&nsec3_rrs.rrs, 0) > 1) { + if (knot_nsec3_flags(nsec3_rrs.rrs.rdata) > 1) { data->handler->cb(data->handler, data->zone, node, SEM_ERR_NSEC3_RDATA_FLAGS, info); } dnssec_binary_t salt = { - .size = knot_nsec3_salt_length(&nsec3_rrs.rrs, 0), - .data = (uint8_t *)knot_nsec3_salt(&nsec3_rrs.rrs, 0), + .size = knot_nsec3_salt_len(nsec3_rrs.rrs.rdata), + .data = (uint8_t *)knot_nsec3_salt(nsec3_rrs.rrs.rdata), }; if (dnssec_binary_cmp(&salt, ¶ms_apex.salt)) { @@ -927,21 +932,20 @@ static int check_nsec3(const zone_node_t *node, semchecks_data_t *data) SEM_ERR_NSEC3_RDATA_SALT, info); } - if (knot_nsec3_algorithm(&nsec3_rrs.rrs, 0) != params_apex.algorithm) { + if (knot_nsec3_alg(nsec3_rrs.rrs.rdata) != params_apex.algorithm) { data->handler->cb(data->handler, data->zone, node, SEM_ERR_NSEC3_RDATA_ALG, info); } - if (knot_nsec3_iterations(&nsec3_rrs.rrs, 0) != params_apex.iterations) { + if (knot_nsec3_iters(nsec3_rrs.rrs.rdata) != params_apex.iterations) { data->handler->cb(data->handler, data->zone, node, SEM_ERR_NSEC3_RDATA_ITERS, info); } // Get next nsec3 node. const zone_node_t *apex = data->zone->apex; - uint8_t *next_dname_str = NULL; - uint8_t next_dname_str_size = 0; - knot_nsec3_next_hashed(&nsec3_rrs.rrs, 0, &next_dname_str, &next_dname_str_size); + const uint8_t *next_dname_str = knot_nsec3_next(nsec3_rrs.rrs.rdata); + uint8_t next_dname_str_size = knot_nsec3_next_len(nsec3_rrs.rrs.rdata); uint8_t next_dname[KNOT_DNAME_MAXLEN]; ret = knot_nsec3_hash_to_dname(next_dname, sizeof(next_dname), next_dname_str, next_dname_str_size, @@ -1093,13 +1097,13 @@ static void check_nsec3param(knot_rdataset_t *nsec3param, zone_contents_t *zone, assert(nsec3param); data->level |= NSEC3; - uint8_t param = knot_nsec3param_flags(nsec3param, 0); + uint8_t param = knot_nsec3param_flags(nsec3param->rdata); if ((param & ~1) != 0) { handler->cb(handler, zone, zone->apex, SEM_ERR_NSEC3PARAM_RDATA_FLAGS, NULL); } - param = knot_nsec3param_algorithm(nsec3param, 0); + param = knot_nsec3param_alg(nsec3param->rdata); if (param != DNSSEC_NSEC3_ALGORITHM_SHA1) { handler->cb(handler, zone, zone->apex, SEM_ERR_NSEC3PARAM_RDATA_ALG, NULL); @@ -1125,12 +1129,12 @@ static void check_dnskey(zone_contents_t *zone, sem_handler_t *handler) handler->cb(handler, zone, zone->apex, SEM_ERR_DNSKEY_INVALID, NULL); } - if (knot_dnskey_proto(dnskeys, i) != 3) { + if (knot_dnskey_proto(dnskey) != 3) { handler->cb(handler, zone, zone->apex, SEM_ERR_DNSKEY_RDATA_PROTOCOL, NULL); } - dnssec_key_algorithm_t alg = knot_dnskey_alg(dnskeys, i); + dnssec_key_algorithm_t alg = knot_dnskey_alg(dnskey); if (!dnssec_algorithm_key_support(alg)) { char *info = sprintf_alloc("(unsupported algorithm %d)", alg); handler->cb(handler, zone, zone->apex, SEM_ERR_DNSKEY_INVALID, info); diff --git a/src/knot/zone/zone-diff.c b/src/knot/zone/zone-diff.c index d9e1cb6f5d..7cf642fec1 100644 --- a/src/knot/zone/zone-diff.c +++ b/src/knot/zone/zone-diff.c @@ -51,8 +51,8 @@ static int load_soas(const zone_contents_t *zone1, const zone_contents_t *zone2, return KNOT_EINVAL; } - uint32_t soa_serial1 = knot_soa_serial(&soa_rrset1.rrs); - uint32_t soa_serial2 = knot_soa_serial(&soa_rrset2.rrs); + uint32_t soa_serial1 = knot_soa_serial(soa_rrset1.rrs.rdata); + uint32_t soa_serial2 = knot_soa_serial(soa_rrset2.rrs.rdata); if (serial_compare(soa_serial1, soa_serial2) == SERIAL_EQUAL) { return KNOT_ENODIFF; @@ -103,13 +103,6 @@ static int remove_node(const zone_node_t *node, changeset_t *changeset) return KNOT_EOK; } -static bool rr_exists(const knot_rrset_t *in, const knot_rrset_t *ref, - size_t ref_pos) -{ - knot_rdata_t *to_check = knot_rdataset_at(&ref->rrs, ref_pos); - return knot_rdataset_member(&in->rrs, to_check); -} - static int rdata_return_changes(const knot_rrset_t *rrset1, const knot_rrset_t *rrset2, knot_rrset_t *changes) @@ -129,20 +122,20 @@ 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.count; - for (uint16_t i = 0; i < rr1_count; ++i) { - if (ttl_differ || !rr_exists(rrset2, rrset1, i)) { + knot_rdata_t *rr1 = rrset1->rrs.rdata; + for (uint16_t i = 0; i < rrset1->rrs.count; ++i) { + if (ttl_differ || !knot_rdataset_member(&rrset2->rrs, rr1)) { /* * No such RR is present in 'rrset2'. We'll copy * index 'i' into 'changes' RRSet. */ - knot_rdata_t *add_rr = knot_rdataset_at(&rrset1->rrs, i); - int ret = knot_rdataset_add(&changes->rrs, add_rr, NULL); + int ret = knot_rdataset_add(&changes->rrs, rr1, NULL); if (ret != KNOT_EOK) { knot_rdataset_clear(&changes->rrs, NULL); return ret; } } + rr1 = knot_rdataset_next(rr1); } return KNOT_EOK; diff --git a/src/knot/zone/zonedb-load.c b/src/knot/zone/zonedb-load.c index 97383dc170..a6e98341e1 100644 --- a/src/knot/zone/zonedb-load.c +++ b/src/knot/zone/zonedb-load.c @@ -87,7 +87,7 @@ static void timers_sanitize(conf_t *conf, zone_t *zone) // replace SOA expire if we have better knowledge if (!zone_contents_is_empty(zone->contents)) { const knot_rdataset_t *soa = zone_soa(zone); - zone->timers.soa_expire = knot_soa_expire(soa); + zone->timers.soa_expire = knot_soa_expire(soa->rdata); } // assume now if we don't know when we flushed diff --git a/src/libknot/packet/rrset-wire.c b/src/libknot/packet/rrset-wire.c index b2cd5af290..523aac45c2 100644 --- a/src/libknot/packet/rrset-wire.c +++ b/src/libknot/packet/rrset-wire.c @@ -327,7 +327,8 @@ static int write_fixed_header(const knot_rrset_t *rrset, uint16_t rrset_index, wire_ctx_write_u16(&write, rrset->rclass); if (rrset->type == KNOT_RRTYPE_RRSIG) { - wire_ctx_write_u32(&write, knot_rrsig_original_ttl(&rrset->rrs, rrset_index)); + const knot_rdata_t *rdata = knot_rdataset_at(&rrset->rrs, rrset_index); + wire_ctx_write_u32(&write, knot_rrsig_original_ttl(rdata)); } else { wire_ctx_write_u32(&write, rrset->ttl); } diff --git a/src/libknot/rdataset.c b/src/libknot/rdataset.c index 29a9f29587..4767bf9aba 100644 --- a/src/libknot/rdataset.c +++ b/src/libknot/rdataset.c @@ -39,11 +39,12 @@ 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) { + knot_rdata_t *search_rr = rrs->rdata; 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; } + search_rr = knot_rdataset_next(search_rr); } return KNOT_ENOENT; @@ -256,12 +257,14 @@ bool knot_rdataset_eq(const knot_rdataset_t *rrs1, const knot_rdataset_t *rrs2) return false; } + knot_rdata_t *rr1 = rrs1->rdata; + knot_rdata_t *rr2 = rrs2->rdata; 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) { return false; } + rr1 = knot_rdataset_next(rr1); + rr2 = knot_rdataset_next(rr2); } return true; @@ -274,8 +277,8 @@ bool knot_rdataset_member(const knot_rdataset_t *rrs, const knot_rdata_t *rr) return false; } + knot_rdata_t *cmp_rr = rrs->rdata; 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) { // Match. @@ -284,6 +287,7 @@ bool knot_rdataset_member(const knot_rdataset_t *rrs, const knot_rdata_t *rr) // 'Greater' RR present, no need to continue. return false; } + cmp_rr = knot_rdataset_next(cmp_rr); } return false; @@ -297,12 +301,13 @@ int knot_rdataset_merge(knot_rdataset_t *rrs1, const knot_rdataset_t *rrs2, return KNOT_EINVAL; } + knot_rdata_t *rr2 = rrs2->rdata; 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); + int ret = knot_rdataset_add(rrs1, rr2, mm); if (ret != KNOT_EOK) { return ret; } + rr2 = knot_rdataset_next(rr2); } return KNOT_EOK; @@ -317,16 +322,17 @@ int knot_rdataset_intersect(const knot_rdataset_t *rrs1, const knot_rdataset_t * } knot_rdataset_init(out); + knot_rdata_t *rr1 = rrs1->rdata; for (uint16_t i = 0; i < rrs1->count; ++i) { - const knot_rdata_t *rr = rr_seek(rrs1, i); - if (knot_rdataset_member(rrs2, rr)) { + if (knot_rdataset_member(rrs2, rr1)) { // Add RR into output intersection RRSet. - int ret = knot_rdataset_add(out, rr, mm); + int ret = knot_rdataset_add(out, rr1, mm); if (ret != KNOT_EOK) { knot_rdataset_clear(out, mm); return ret; } } + rr1 = knot_rdataset_next(rr1); } return KNOT_EOK; @@ -346,8 +352,8 @@ int knot_rdataset_subtract(knot_rdataset_t *from, const knot_rdataset_t *what, return KNOT_EOK; } + knot_rdata_t *to_remove = what->rdata; 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) { int ret = remove_rr_at(from, pos_to_remove, mm); @@ -355,6 +361,7 @@ int knot_rdataset_subtract(knot_rdataset_t *from, const knot_rdataset_t *what, return ret; } } + to_remove = knot_rdataset_next(to_remove); } return KNOT_EOK; diff --git a/src/libknot/rrset-dump.c b/src/libknot/rrset-dump.c index 4659244649..a1c410a52b 100644 --- a/src/libknot/rrset-dump.c +++ b/src/libknot/rrset-dump.c @@ -1947,10 +1947,11 @@ static int rrset_txt_dump(const knot_rrset_t *rrset, // Loop over rdata in rrset. uint16_t rr_count = rrset->rrs.count; + knot_rdata_t *rr = rrset->rrs.rdata; 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) ? - knot_rrsig_original_ttl(&rrset->rrs, i) : rrset->ttl); + knot_rrsig_original_ttl(rr) : rrset->ttl); int ret = knot_rrset_txt_dump_header(rrset, ttl, dst + len, maxlen - len, style); @@ -1973,6 +1974,8 @@ static int rrset_txt_dump(const knot_rrset_t *rrset, } dst[len++] = '\n'; dst[len] = '\0'; + + rr = knot_rdataset_next(rr); } return len; diff --git a/src/libknot/rrset.c b/src/libknot/rrset.c index a7484453ec..67d7aed85c 100644 --- a/src/libknot/rrset.c +++ b/src/libknot/rrset.c @@ -143,7 +143,7 @@ bool knot_rrset_is_nsec3rel(const knot_rrset_t *rr) /* Is NSEC3 or non-empty RRSIG covering NSEC3. */ return ((rr->type == KNOT_RRTYPE_NSEC3) || (rr->type == KNOT_RRTYPE_RRSIG - && knot_rrsig_type_covered(&rr->rrs, 0) == KNOT_RRTYPE_NSEC3)); + && knot_rrsig_type_covered(rr->rrs.rdata) == KNOT_RRTYPE_NSEC3)); } _public_ @@ -166,10 +166,8 @@ int knot_rrset_rr_to_canonical(knot_rrset_t *rrset) desc = knot_get_obsolete_rdata_descriptor(rrset->type); } - knot_rdata_t *rdata = knot_rdataset_at(&rrset->rrs, 0); - assert(rdata); - uint16_t rdlen = rdata->len; - uint8_t *pos = rdata->data; + uint16_t rdlen = rrset->rrs.rdata->len; + uint8_t *pos = rrset->rrs.rdata->data; uint8_t *endpos = pos + rdlen; /* No RDATA */ @@ -218,11 +216,11 @@ size_t knot_rrset_size(const knot_rrset_t *rrset) size_t total_size = knot_dname_size(rrset->owner) * rr_count; + knot_rdata_t *rr = rrset->rrs.rdata; for (size_t i = 0; i < rr_count; ++i) { - const knot_rdata_t *rr = knot_rdataset_at(&rrset->rrs, i); - assert(rr); /* 10B = TYPE + CLASS + TTL + RDLENGTH */ total_size += rr->len + 10; + rr = knot_rdataset_next(rr); } return total_size; diff --git a/src/utils/common/exec.c b/src/utils/common/exec.c index 402d9aa003..9b97fba681 100644 --- a/src/utils/common/exec.c +++ b/src/utils/common/exec.c @@ -253,7 +253,8 @@ static void print_section_opt(const knot_pkt_t *packet) knot_edns_get_payload(packet->opt_rr), ercode_str); - knot_rdata_t *rdata = knot_rdataset_at(&packet->opt_rr->rrs, 0); + assert(packet->opt_rr->rrs.count > 0); + knot_rdata_t *rdata = packet->opt_rr->rrs.rdata; wire_ctx_t wire = wire_ctx_init_const(rdata->data, rdata->len); while (wire_ctx_available(&wire) >= KNOT_EDNS_OPTION_HDRLEN) { diff --git a/src/utils/kdig/kdig_exec.c b/src/utils/kdig/kdig_exec.c index 03e6d1e474..03908e2293 100644 --- a/src/utils/kdig/kdig_exec.c +++ b/src/utils/kdig/kdig_exec.c @@ -453,7 +453,7 @@ static knot_pkt_t *create_query_packet(const query_t *query) } // Set SOA serial. - knot_soa_serial_set(&soa->rrs, query->serial); + knot_soa_serial_set(soa->rrs.rdata, query->serial); ret = knot_pkt_put(packet, KNOT_COMPR_HINT_NONE, soa, KNOT_PF_FREE); if (ret != KNOT_EOK) { @@ -534,7 +534,7 @@ static int64_t first_serial_check(const knot_pkt_t *reply) if (first->type != KNOT_RRTYPE_SOA) { return -1; } else { - return knot_soa_serial(&first->rrs); + return knot_soa_serial(first->rrs.rdata); } } @@ -554,7 +554,7 @@ static bool finished_xfr(const uint32_t serial, const knot_pkt_t *reply, } else if (answer->count == 1 && msg_count == 1) { return is_ixfr; } else { - return knot_soa_serial(&last->rrs) == serial; + return knot_soa_serial(last->rrs.rdata) == serial; } } diff --git a/src/utils/kjournalprint/main.c b/src/utils/kjournalprint/main.c index 9cbcf81624..7a0388488a 100644 --- a/src/utils/kjournalprint/main.c +++ b/src/utils/kjournalprint/main.c @@ -73,11 +73,11 @@ static void print_changeset(const changeset_t *chs, bool color) printf(color ? YLW : ""); if (chs->soa_from == NULL) { printf(";; Zone-in-journal, serial: %u\n", - knot_soa_serial(&chs->soa_to->rrs)); + knot_soa_serial(chs->soa_to->rrs.rdata)); } else { printf(";; Changes between zone versions: %u -> %u\n", - knot_soa_serial(&chs->soa_from->rrs), - knot_soa_serial(&chs->soa_to->rrs)); + knot_soa_serial(chs->soa_from->rrs.rdata), + knot_soa_serial(chs->soa_to->rrs.rdata)); } changeset_print(chs, stdout, color); } @@ -127,11 +127,11 @@ static void print_changeset_debugmode(const changeset_t *chs) (void)zone_contents_nsec3_apply(chs->add, rrtypelist_callback, &ctx_plus); if (chs->soa_from == NULL) { - printf("Zone-in-journal %u +++: %zu\t size: %zu\t", knot_soa_serial(&chs->soa_to->rrs), + printf("Zone-in-journal %u +++: %zu\t size: %zu\t", knot_soa_serial(chs->soa_to->rrs.rdata), count_plus, changeset_serialized_size(chs)); } else { - printf("%u -> %u ---: %zu\t +++: %zu\t size: %zu\t", knot_soa_serial(&chs->soa_from->rrs), - knot_soa_serial(&chs->soa_to->rrs), count_minus, count_plus, changeset_serialized_size(chs)); + printf("%u -> %u ---: %zu\t +++: %zu\t size: %zu\t", knot_soa_serial(chs->soa_from->rrs.rdata), + knot_soa_serial(chs->soa_to->rrs.rdata), count_minus, count_plus, changeset_serialized_size(chs)); } char temp[100]; @@ -241,7 +241,8 @@ int print_journal(char *path, knot_dname_t *name, uint32_t limit, bool color, bo } WALK_LIST(chs, db) { print_changeset_debugmode(chs); - if (last_flushed.valid && serial_equal(knot_soa_serial(&chs->soa_from->rrs), last_flushed.serial)) { + if (last_flushed.valid && + serial_equal(knot_soa_serial(chs->soa_from->rrs.rdata), last_flushed.serial)) { break; } } diff --git a/tests/knot/test_journal.c b/tests/knot/test_journal.c index c12a460481..457cde09e8 100644 --- a/tests/knot/test_journal.c +++ b/tests/knot/test_journal.c @@ -78,7 +78,7 @@ static void init_soa(knot_rrset_t *rr, const uint32_t serial, const knot_dname_t uint8_t soa_data[MIN_SOA_SIZE] = { 0 }; int ret = knot_rrset_add_rdata(rr, soa_data, sizeof(soa_data), NULL); - knot_soa_serial_set(&rr->rrs, serial); + knot_soa_serial_set(rr->rrs.rdata, serial); (void)ret; assert(ret == KNOT_EOK); } @@ -232,8 +232,8 @@ static bool test_continuity(list_t *l) } changeset_t *ch1 = (changeset_t *) n; changeset_t *ch2 = (changeset_t *) n->next; - key1 = knot_soa_serial(&ch1->soa_to->rrs); - key2 = knot_soa_serial(&ch2->soa_from->rrs); + key1 = knot_soa_serial(ch1->soa_to->rrs.rdata); + key2 = knot_soa_serial(ch2->soa_from->rrs.rdata); if (key1 != key2) { return KNOT_EINVAL; } @@ -404,7 +404,7 @@ static void test_store_load(void) /* Load all previous changesets. */ ret = journal_load_changesets(j, &l, 1); - ok(ret == KNOT_EOK && knot_soa_serial(&((changeset_t *)TAIL(l))->soa_to->rrs) == m_serial, + ok(ret == KNOT_EOK && knot_soa_serial(((changeset_t *)TAIL(l))->soa_to->rrs.rdata) == m_serial, "journal: load all changesets"); /* Check for changeset ordering. */ diff --git a/tests/knot/test_zone-update.c b/tests/knot/test_zone-update.c index 8ba84face2..5e528dda18 100644 --- a/tests/knot/test_zone-update.c +++ b/tests/knot/test_zone-update.c @@ -37,14 +37,16 @@ knot_rrset_t rrset; /*!< \brief Returns true if node contains given RR in its RRSets. */ static bool node_contains_rr(const zone_node_t *node, - const knot_rrset_t *rr) + const knot_rrset_t *rrset) { - const knot_rdataset_t *zone_rrs = node_rdataset(node, rr->type); - if (zone_rrs) { - for (size_t i = 0; i < rr->rrs.count; ++i) { - if (!knot_rdataset_member(zone_rrs, knot_rdataset_at(&rr->rrs, i))) { + const knot_rdataset_t *zone_rrs = node_rdataset(node, rrset->type); + if (zone_rrs != NULL) { + knot_rdata_t *rr = rrset->rrs.rdata; + for (size_t i = 0; i < rrset->rrs.count; ++i) { + if (!knot_rdataset_member(zone_rrs, rr)) { return false; } + rr = knot_rdataset_next(rr); } return true; diff --git a/tests/libknot/test_edns.c b/tests/libknot/test_edns.c index e97faee992..0da882cb5e 100644 --- a/tests/libknot/test_edns.c +++ b/tests/libknot/test_edns.c @@ -146,7 +146,7 @@ static void check_header(knot_rrset_t *opt_rr, uint16_t payload, uint8_t ver, check = (opt_rr->rrs.count == 1); ok(check, "%s: RR count == 1", msg); - knot_rdata_t *rdata = knot_rdataset_at(&opt_rr->rrs, 0); + knot_rdata_t *rdata = opt_rr->rrs.rdata; check = (rdata != NULL); ok(check, "%s: RDATA exists", msg); @@ -251,7 +251,7 @@ static void test_setters(knot_rrset_t *opt_rr) is_int(KNOT_EOK, ret, "OPT RR setters: add empty option 2 (ret = %s)", knot_strerror(ret)); - knot_rdata_t *rdata = knot_rdataset_at(&opt_rr->rrs, 0); + knot_rdata_t *rdata = opt_rr->rrs.rdata; ok(rdata != NULL, "OPT RR setters: non-empty RDATA"); /* Check proper option */ diff --git a/tests/libknot/test_rrset-wire.c b/tests/libknot/test_rrset-wire.c index 1e59a91d05..ea1d3c2a0a 100644 --- a/tests/libknot/test_rrset-wire.c +++ b/tests/libknot/test_rrset-wire.c @@ -214,7 +214,7 @@ static void check_canon(uint8_t *wire, size_t size, size_t pos, bool canon, is_int(KNOT_EOK, ret, "OK %s canonization", canon ? "with" : "without"); ok(memcmp(rrset.owner, qname, knot_dname_size(qname)) == 0, "compare owner"); - uint8_t *rdata = knot_rdataset_at(&rrset.rrs, 0)->data; + uint8_t *rdata = rrset.rrs.rdata->data; ok(memcmp(rdata, dname, knot_dname_size(dname)) == 0, "compare rdata dname"); knot_rrset_clear(&rrset, NULL);