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");
}
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;
}
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;
}
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);
}
}
// 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;
-/* 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
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)
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;
/*!
* \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;
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;
}
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;
}
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)) {
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 };
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;
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;
}
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) {
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);
}
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) {
(*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) {
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;
}
}
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;
}
return ret;
}
}
+ rdata = knot_rdataset_next(rdata);
}
return KNOT_EOK;
// 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
-/* 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
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));
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;
}
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;
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);
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);
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);
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);
}
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,
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);
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,
// 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 */) {
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) {
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;
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;
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);
}
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) {
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);
}
}
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);
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)) {
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;
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);
}
/*!
-/* 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
}
// 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)
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;
}
/* 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) {
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;
}
/* 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;
}
/* 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;
}
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);
}
/*! \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.
// 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;
}
}
}
-/*!< \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. */
/*!< \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;
}
{
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;
}
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);
{
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;
}
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 "
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);
}
/* 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. */
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);
}
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 };
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);
}
}
}
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;
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;
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;
}
* \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.
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,
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) {
}
/* 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);
}
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,
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;
}
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) {
// 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;
}
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);
}
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);
// 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,
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 ||
* 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) {
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);
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);
// 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)) {
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,
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);
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);
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;
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)
* 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;
// 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
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);
}
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;
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;
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.
// 'Greater' RR present, no need to continue.
return false;
}
+ cmp_rr = knot_rdataset_next(cmp_rr);
}
return false;
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;
}
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;
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);
return ret;
}
}
+ to_remove = knot_rdataset_next(to_remove);
}
return KNOT_EOK;
// 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);
}
dst[len++] = '\n';
dst[len] = '\0';
+
+ rr = knot_rdataset_next(rr);
}
return len;
/* 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_
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 */
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;
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) {
}
// 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) {
if (first->type != KNOT_RRTYPE_SOA) {
return -1;
} else {
- return knot_soa_serial(&first->rrs);
+ return knot_soa_serial(first->rrs.rdata);
}
}
} 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;
}
}
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);
}
(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];
}
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;
}
}
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);
}
}
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;
}
/* 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. */
/*!< \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;
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);
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 */
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);
projects / thirdparty / knot-dns.git / commitdiff
