upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-06-11 04:50:01 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Fix formatting

Browse source
This commit is contained in:
Alessio Podda 2025-12-09 22:49:16 +01:00
parent 852041457e
commit f1d8c3059c
8 changed files with 115 additions and 114 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
lib/dns/include/dns/rdataset.h
View file

@ -51,8 +51,8 @@
#include <isc/stdtime.h>
#include <dns/rdataslab.h>
#include <dns/rdatavec.h>
#include <dns/rdatastruct.h>
#include <dns/rdatavec.h>
#include <dns/types.h>
#define DNS_RDATASET_MAXADDITIONAL 13
@ -208,10 +208,10 @@ struct dns_rdataset {
* methods; see comments in rdatavec.c for details.)
*/
struct {
struct dns_db *db;
dns_dbnode_t *node;
dns_vecheader_t *header;
rdatavec_iter_t iter;
struct dns_db *db;
dns_dbnode_t *node;
dns_vecheader_t *header;
rdatavec_iter_t iter;
} vec;
/*
@ -635,7 +635,6 @@ dns_trust_totext(dns_trust_t trust);
* Display trust in textual form.
*/
isc_stdtime_t
dns_rdataset_minresign(dns_rdataset_t *rdataset);
/*%<

36
lib/dns/include/dns/rdatavec.h
View file

@ -58,15 +58,14 @@
#define DNS_RDATAVEC_OFFLINE 0x01 /* RRSIG is for offline DNSKEY */
typedef struct dns_vectop dns_vectop_t;
typedef struct dns_vectop dns_vectop_t;
typedef struct dns_vecheader dns_vecheader_t;
struct rdatavec_iter {
unsigned char *iter_pos;
unsigned int iter_count;
unsigned char *iter_pos;
unsigned int iter_count;
dns_rdataclass_t iter_rdclass;
dns_rdatatype_t iter_type;
dns_rdatatype_t iter_type;
};
typedef struct rdatavec_iter rdatavec_iter_t;
@ -91,7 +90,8 @@ struct dns_vecheader {
dns_ttl_t ttl;
dns_typepair_t typepair;
/* resigning (zone). The lsb is not adjacent for struct packing reasons */
/* resigning (zone). The lsb is not adjacent for struct packing reasons
*/
isc_stdtime_t resign;
/*%
@ -102,7 +102,7 @@ struct dns_vecheader {
/*%
* The database node objects containing this rdataset, if any.
*/
dns_dbnode_t *node;
dns_dbnode_t *node;
/*%
* Cached glue records for an rdataset of type NS (zone only).
@ -114,16 +114,15 @@ struct dns_vecheader {
* character in the owner name needs to be AND'd with 0x20,
* rendering that character upper case.
*/
unsigned char upper[32];
unsigned char upper[32];
/*%
* Flexible member indicates the address of the raw data
* following this header.
*/
unsigned char raw[];
unsigned char raw[];
};
enum {
DNS_VECHEADERATTR_NONEXISTENT = 1 << 0,
DNS_VECHEADERATTR_IGNORE = 1 << 1,
@ -151,7 +150,7 @@ extern dns_rdatasetmethods_t dns_rdatavec_rdatasetmethods;
isc_result_t
dns_rdatavec_fromrdataset(dns_rdataset_t *rdataset, isc_mem_t *mctx,
isc_region_t *region, uint32_t limit);
isc_region_t *region, uint32_t limit);
/*%<
* Allocate space for a vec to hold the data in rdataset, and copy the
* data into it. The resulting vec will be returned in 'region'.
@ -204,18 +203,18 @@ dns_rdatavec_count(dns_vecheader_t *header);
isc_result_t
dns_rdatavec_merge(dns_vecheader_t *oheader, dns_vecheader_t *nheader,
isc_mem_t *mctx, dns_rdataclass_t rdclass,
dns_rdatatype_t type, unsigned int flags,
uint32_t maxrrperset, dns_vecheader_t **theaderp);
isc_mem_t *mctx, dns_rdataclass_t rdclass,
dns_rdatatype_t type, unsigned int flags,
uint32_t maxrrperset, dns_vecheader_t **theaderp);
/*%<
* Merge the vecs following 'oheader' and 'nheader'.
*/
isc_result_t
dns_rdatavec_subtract(dns_vecheader_t *mheader, dns_vecheader_t *sheader,
isc_mem_t *mctx, dns_rdataclass_t rdclass,
dns_rdatatype_t type, unsigned int flags,
dns_vecheader_t **theaderp);
isc_mem_t *mctx, dns_rdataclass_t rdclass,
dns_rdatatype_t type, unsigned int flags,
dns_vecheader_t **theaderp);
/*%<
* Subtract the vec following 'sheader' from the one following 'mheader'.
* If 'exact' is true then all elements from the 'sheader' vec must exist
@ -225,7 +224,6 @@ dns_rdatavec_subtract(dns_vecheader_t *mheader, dns_vecheader_t *sheader,
* valid flags are DNS_RDATAVEC_EXACT
*/
void
dns_vecheader_setownercase(dns_vecheader_t *header, const dns_name_t *name);
/*%<
@ -236,7 +234,6 @@ dns_vecheader_setownercase(dns_vecheader_t *header, const dns_name_t *name);
* \li 'name' is a valid name.
*/
void
dns_vecheader_reset(dns_vecheader_t *h, dns_dbnode_t *node);
/*%<
@ -257,7 +254,6 @@ dns_vecheader_destroy(dns_vecheader_t **headerp);
* Free all memory associated with '*headerp'.
*/
dns_vectop_t *
dns_vectop_new(isc_mem_t *mctx, dns_typepair_t typepair);
/*%<

64
lib/dns/qpzone.c
View file

@ -32,8 +32,8 @@
#include <isc/refcount.h>
#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/slist.h>
#include <isc/serial.h>
#include <isc/slist.h>
#include <isc/stdio.h>
#include <isc/string.h>
#include <isc/time.h>
@ -54,10 +54,8 @@
#include <dns/rdata.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatavec.h>
#include "rdatavec_p.h"
#include <dns/rdatastruct.h>
#include <dns/rdatavec.h>
#include <dns/stats.h>
#include <dns/time.h>
#include <dns/types.h>
@ -499,7 +497,7 @@ cleanup_gluelists(struct cds_wfs_stack *glue_stack) {
dns_gluelist_t *gluelist =
caa_container_of(node, dns_gluelist_t, wfs_node);
dns_vecheader_t *header = rcu_xchg_pointer(&gluelist->header,
NULL);
NULL);
(void)rcu_cmpxchg_pointer(&header->gluelist, gluelist, NULL);
call_rcu(&gluelist->rcu_head, free_gluelist_rcu);
@ -813,7 +811,6 @@ first_header(dns_vectop_t *top) {
return ISC_SLIST_HEAD(top->headers);
}
static dns_vecheader_t *
first_existing_header(dns_vectop_t *top, uint32_t serial) {
ISC_SLIST_FOREACH(header, top->headers, next_header) {
@ -872,7 +869,8 @@ clean_multiple_versions(dns_vectop_t *top, uint32_t least_serial) {
}
bool multiple = false;
dns_vecheader_t **pointer_to_second_header = &ISC_SLIST_NEXT(ISC_SLIST_HEAD(top->headers), next_header);
dns_vecheader_t **pointer_to_second_header =
&ISC_SLIST_NEXT(ISC_SLIST_HEAD(top->headers), next_header);
ISC_SLIST_FOREACH_PTR(p, pointer_to_second_header) {
dns_vecheader_t *header = *p;
if (header->serial < least_serial) {
@ -922,7 +920,7 @@ clean_zone_node(qpznode_t *node, uint32_t least_serial) {
}
}
/*
/*
* Second pass: remove all empty vectops
*/
ISC_SLIST_FOREACH_PTR(iter, &ISC_SLIST_HEAD(node->next_type)) {
@ -1080,7 +1078,8 @@ setnsec3parameters(dns_db_t *db, qpz_version_t *version) {
dns_rdata_t rdata = DNS_RDATA_INIT;
vecheader_current(&iter, &rdata);
isc_result_t result = dns_rdata_tostruct(&rdata, &nsec3param, NULL);
isc_result_t result =
dns_rdata_tostruct(&rdata, &nsec3param, NULL);
INSIST(result == ISC_R_SUCCESS);
if (nsec3param.hash != DNS_NSEC3_UNKNOWNALG &&
@ -1299,8 +1298,8 @@ rollback_node(qpznode_t *node, uint32_t serial) {
ISC_SLIST_FOREACH(top, node->next_type, next_type) {
ISC_SLIST_FOREACH(header, top->headers, next_header) {
if (header->serial == serial) {
DNS_VECHEADER_SETATTR(
header, DNS_VECHEADERATTR_IGNORE);
DNS_VECHEADER_SETATTR(header,
DNS_VECHEADERATTR_IGNORE);
make_dirty = true;
}
}
@ -1865,8 +1864,8 @@ add(qpzonedb_t *qpdb, qpznode_t *node, const dns_name_t *nodename,
dns_vecheader_destroy(&newheader);
newheader = merged;
dns_vecheader_reset(newheader,
(dns_dbnode_t *)node);
/*
(dns_dbnode_t *)node);
/*
* dns_rdatavec_subtract takes the header from
* the first argument, so it preserves the case
*/
@ -1907,7 +1906,8 @@ add(qpzonedb_t *qpdb, qpznode_t *node, const dns_name_t *nodename,
* loading, we MUST clean up 'header' now.
*/
*header_p = ISC_SLIST_NEXT(header, next_header);
ISC_SLIST_PREPEND(foundtop->headers, newheader, next_header);
ISC_SLIST_PREPEND(foundtop->headers, newheader,
next_header);
maybe_update_recordsandsize(false, version, header,
nodename->length);
@ -1919,7 +1919,8 @@ add(qpzonedb_t *qpdb, qpznode_t *node, const dns_name_t *nodename,
header DNS__DB_FLARG_PASS);
}
ISC_SLIST_PREPEND(foundtop->headers, newheader, next_header);
ISC_SLIST_PREPEND(foundtop->headers, newheader,
next_header);
node->dirty = true;
if (changed != NULL) {
@ -1956,7 +1957,8 @@ add(qpzonedb_t *qpdb, qpznode_t *node, const dns_name_t *nodename,
*/
INSIST(!loading);
ISC_SLIST_PREPEND(foundtop->headers, newheader, next_header);
ISC_SLIST_PREPEND(foundtop->headers, newheader,
next_header);
if (changed != NULL) {
changed->dirty = true;
@ -1974,20 +1976,24 @@ add(qpzonedb_t *qpdb, qpznode_t *node, const dns_name_t *nodename,
return DNS_R_TOOMANYRECORDS;
}
dns_vectop_t *newtop = dns_vectop_new(
node->mctx, newheader->typepair);
dns_vectop_t *newtop =
dns_vectop_new(node->mctx, newheader->typepair);
ISC_SLIST_PREPEND(newtop->headers, newheader, next_header);
ISC_SLIST_PREPEND(newtop->headers, newheader,
next_header);
if (prio_type(newheader->typepair)) {
/* This is a priority type, prepend it */
ISC_SLIST_PREPEND(node->next_type, newtop, next_type);
ISC_SLIST_PREPEND(node->next_type, newtop,
next_type);
} else if (priotop != NULL) {
/* Append after the priority headers */
ISC_SLIST_INSERTAFTER(priotop, newtop, next_type);
ISC_SLIST_INSERTAFTER(priotop, newtop,
next_type);
} else {
/* There were no priority headers */
ISC_SLIST_PREPEND(node->next_type, newtop, next_type);
ISC_SLIST_PREPEND(node->next_type, newtop,
next_type);
}
}
}
@ -2102,7 +2108,7 @@ loading_addrdataset(void *arg, const dns_name_t *name, dns_rdataset_t *rdataset,
loading_addnode(loadctx, name, rdataset->type, rdataset->covers, &node);
result = dns_rdatavec_fromrdataset(rdataset, node->mctx, &region,
qpdb->maxrrperset);
qpdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
if (result == DNS_R_TOOMANYRECORDS) {
dns__db_logtoomanyrecords((dns_db_t *)qpdb, name,
@ -3513,7 +3519,7 @@ found:
* Look for an active, extant rdataset.
*/
dns_vecheader_t *header = first_existing_header(top,
search.serial);
search.serial);
if (header != NULL) {
/*
* We now know that there is at least one active
@ -4689,7 +4695,7 @@ qpzone_addrdataset_inner(dns_db_t *db, dns_dbnode_t *dbnode,
rdataset->covers != dns_rdatatype_nsec3));
result = dns_rdatavec_fromrdataset(rdataset, node->mctx, &region,
qpdb->maxrrperset);
qpdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
if (result == DNS_R_TOOMANYRECORDS) {
dns__db_logtoomanyrecords((dns_db_t *)qpdb, &node->name,
@ -4902,13 +4908,13 @@ qpzone_subtractrdataset(dns_db_t *db, dns_dbnode_t *dbnode,
dns_vecheader_destroy(&newheader);
newheader = subresult;
dns_vecheader_reset(newheader, (dns_dbnode_t *)node);
/*
/*
* dns_rdatavec_subtract takes the header from the first
* argument, so it preserves the case
*/
if (RESIGN(header)) {
DNS_VECHEADER_SETATTR(
newheader, DNS_VECHEADERATTR_RESIGN);
DNS_VECHEADER_SETATTR(newheader,
DNS_VECHEADERATTR_RESIGN);
newheader->resign = header->resign;
newheader->resign_lsb = header->resign_lsb;
resigninsert(newheader);
@ -4933,7 +4939,7 @@ qpzone_subtractrdataset(dns_db_t *db, dns_dbnode_t *dbnode,
*/
dns_vecheader_destroy(&newheader);
newheader = dns_vecheader_new(db->mctx,
(dns_dbnode_t *)node);
(dns_dbnode_t *)node);
newheader->ttl = 0;
newheader->typepair = foundtop->typepair;
atomic_init(&newheader->attributes,

55
lib/dns/rdatavec.c
View file

@ -97,27 +97,27 @@ compare_rdata(const void *p1, const void *p2) {
}
static size_t
header_size(const dns_vecheader_t* header) {
header_size(const dns_vecheader_t *header) {
UNUSED(header);
return sizeof(dns_vecheader_t);
}
static unsigned char*
rdatavec_raw(dns_vecheader_t* header) {
unsigned char *as_char_star = (unsigned char*) header;
unsigned char* raw = as_char_star + header_size(header);
static unsigned char *
rdatavec_raw(dns_vecheader_t *header) {
unsigned char *as_char_star = (unsigned char *)header;
unsigned char *raw = as_char_star + header_size(header);
return raw;
}
static unsigned char*
rdatavec_data(dns_vecheader_t* header) {
static unsigned char *
rdatavec_data(dns_vecheader_t *header) {
return rdatavec_raw(header) + 2;
}
static unsigned int
rdatavec_count(dns_vecheader_t* header) {
unsigned char* raw = rdatavec_raw(header);
static unsigned int
rdatavec_count(dns_vecheader_t *header) {
unsigned char *raw = rdatavec_raw(header);
unsigned int count = get_uint16(raw);
return count;
@ -125,7 +125,7 @@ rdatavec_count(dns_vecheader_t* header) {
static isc_result_t
makevec(dns_rdataset_t *rdataset, isc_mem_t *mctx, isc_region_t *region,
uint32_t maxrrperset) {
uint32_t maxrrperset) {
/*
* Use &removed as a sentinel pointer for duplicate
* rdata as rdata.data == NULL is valid.
@ -318,7 +318,7 @@ free_rdatas:
isc_result_t
dns_rdatavec_fromrdataset(dns_rdataset_t *rdataset, isc_mem_t *mctx,
isc_region_t *region, uint32_t maxrrperset) {
isc_region_t *region, uint32_t maxrrperset) {
isc_result_t result;
if (rdataset->type == dns_rdatatype_none &&
@ -389,7 +389,7 @@ dns_rdatavec_count(dns_vecheader_t *header) {
*/
static void
rdata_from_vecitem(unsigned char **current, dns_rdataclass_t rdclass,
dns_rdatatype_t type, dns_rdata_t *rdata) {
dns_rdatatype_t type, dns_rdata_t *rdata) {
unsigned char *tcurrent = *current;
isc_region_t region;
bool offline = false;
@ -414,7 +414,7 @@ rdata_from_vecitem(unsigned char **current, dns_rdataclass_t rdclass,
static void
rdata_to_vecitem(unsigned char **current, dns_rdatatype_t type,
dns_rdata_t *rdata) {
dns_rdata_t *rdata) {
unsigned int length = rdata->length;
unsigned char *data = rdata->data;
unsigned char *p = *current;
@ -439,9 +439,9 @@ typedef struct vecinfo {
isc_result_t
dns_rdatavec_merge(dns_vecheader_t *oheader, dns_vecheader_t *nheader,
isc_mem_t *mctx, dns_rdataclass_t rdclass,
dns_rdatatype_t type, unsigned int flags,
uint32_t maxrrperset, dns_vecheader_t **theaderp) {
isc_mem_t *mctx, dns_rdataclass_t rdclass,
dns_rdatatype_t type, unsigned int flags,
uint32_t maxrrperset, dns_vecheader_t **theaderp) {
isc_result_t result = ISC_R_SUCCESS;
unsigned char *ocurrent = NULL, *ncurrent = NULL, *tcurrent = NULL;
unsigned int ocount, ncount, tlength, tcount = 0;
@ -561,9 +561,9 @@ dns_rdatavec_merge(dns_vecheader_t *oheader, dns_vecheader_t *nheader,
/* Allocate the target buffer and copy the new vec's header */
unsigned char *tstart = isc_mem_get(mctx, tlength);
dns_vecheader_t *as_header = (dns_vecheader_t*) tstart;
dns_vecheader_t *as_header = (dns_vecheader_t *)tstart;
/*
/*
* Preserve the case of the old header, but the rest from the new
* header
*/
@ -626,9 +626,9 @@ cleanup:
isc_result_t
dns_rdatavec_subtract(dns_vecheader_t *oheader, dns_vecheader_t *sheader,
isc_mem_t *mctx, dns_rdataclass_t rdclass,
dns_rdatatype_t type, unsigned int flags,
dns_vecheader_t **theaderp) {
isc_mem_t *mctx, dns_rdataclass_t rdclass,
dns_rdatatype_t type, unsigned int flags,
dns_vecheader_t **theaderp) {
isc_result_t result = ISC_R_SUCCESS;
unsigned char *ocurrent = NULL, *scurrent = NULL;
unsigned char *tstart = NULL, *tcurrent = NULL;
@ -756,7 +756,6 @@ cleanup:
return result;
}
void
dns_vecheader_setownercase(dns_vecheader_t *header, const dns_name_t *name) {
REQUIRE(!CASESET(header));
@ -775,8 +774,7 @@ dns_vecheader_setownercase(dns_vecheader_t *header, const dns_name_t *name) {
}
}
if (casefullylower) {
DNS_VECHEADER_SETATTR(header,
DNS_VECHEADERATTR_CASEFULLYLOWER);
DNS_VECHEADER_SETATTR(header, DNS_VECHEADERATTR_CASEFULLYLOWER);
}
DNS_VECHEADER_SETATTR(header, DNS_VECHEADERATTR_CASESET);
}
@ -826,7 +824,8 @@ dns_vecheader_destroy(dns_vecheader_t **headerp) {
/* Iterators for already bound rdatavec */
isc_result_t
vecheader_first(rdatavec_iter_t *iter, dns_vecheader_t *header, dns_rdataclass_t rdclass) {
vecheader_first(rdatavec_iter_t *iter, dns_vecheader_t *header,
dns_rdataclass_t rdclass) {
unsigned char *raw = rdatavec_data(header);
uint16_t count = rdatavec_count(header);
if (count == 0) {
@ -899,7 +898,6 @@ vecheader_current(rdatavec_iter_t *iter, dns_rdata_t *rdata) {
rdata->flags |= flags;
}
/* Fixed RRSet helper macros */
static void
@ -911,7 +909,8 @@ rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) {
static isc_result_t
rdataset_first(dns_rdataset_t *rdataset) {
return vecheader_first(&rdataset->vec.iter, rdataset->vec.header, rdataset->rdclass);
return vecheader_first(&rdataset->vec.iter, rdataset->vec.header,
rdataset->rdclass);
}
static isc_result_t

4
lib/dns/rdatavec_p.h
View file

@ -58,9 +58,9 @@ dns_vecheader_getheader(const dns_rdataset_t *rdataset);
* \li 'rdataset' is a valid rdataset using rdatavec methods.
*/
isc_result_t
vecheader_first(rdatavec_iter_t *iter, dns_vecheader_t *header, dns_rdataclass_t rdclass);
vecheader_first(rdatavec_iter_t *iter, dns_vecheader_t *header,
dns_rdataclass_t rdclass);
isc_result_t
vecheader_next(rdatavec_iter_t *iter);

18
lib/isc/include/isc/slist.h
View file

@ -21,9 +21,9 @@
* similar to isc/list.h but optimized for forward-only traversal.
*/
#define ISC_SLIST_INITIALIZER \
{ \
.head = NULL, \
#define ISC_SLIST_INITIALIZER \
{ \
.head = NULL, \
}
#define ISC_SLINK_INITIALIZER \
@ -44,16 +44,16 @@
#define ISC_SLIST_HEAD(list) ((list).head)
#define ISC_SLIST_EMPTY(list) ((list).head == NULL)
#define ISC_SLIST_PREPEND(list, elt, link) \
({ \
#define ISC_SLIST_PREPEND(list, elt, link) \
({ \
(elt)->link.next = (list).head; \
(list).head = (elt); \
})
#define ISC_SLIST_INSERTAFTER(after, elt, link) \
({ \
#define ISC_SLIST_INSERTAFTER(after, elt, link) \
({ \
(elt)->link.next = (after)->link.next; \
(after)->link.next = (elt); \
(after)->link.next = (elt); \
})
#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next)
@ -73,7 +73,7 @@
/* Iteration over pointer-to-pointer for safe operations */
#define ISC_SLIST_FOREACH_PTR(p, head) \
for (typeof(head) p = (head); *p != NULL; )
for (typeof(head) p = (head); *p != NULL;)
#define ISC_SLIST_PTR_REMOVE(p, elt, link_field) \
(*(p) = ISC_SLIST_NEXT(elt, link_field))

2
tests/dns/qpzone_test.c
View file

@ -33,8 +33,8 @@
#include <dns/qp.h>
#include <dns/rdatalist.h>
#include <dns/rdataset.h>
#include <dns/rdatavec.h>
#include <dns/rdatastruct.h>
#include <dns/rdatavec.h>
#define KEEP_BEFORE
#include "rdatavec_p.h"

39
tests/dns/vecheader_test.c
View file

@ -44,9 +44,9 @@
/* Helper function to create a vecheader directly */
static isc_result_t
create_vecheader(isc_mem_t *mctx, dns_rdatatype_t type, dns_rdataclass_t rdclass,
dns_ttl_t ttl, const char *rdata_text, dns_vecheader_t **headerp)
{
create_vecheader(isc_mem_t *mctx, dns_rdatatype_t type,
dns_rdataclass_t rdclass, dns_ttl_t ttl,
const char *rdata_text, dns_vecheader_t **headerp) {
dns_rdataset_t rdataset;
dns_rdatalist_t *rdatalist;
dns_rdata_t *rdata;
@ -68,8 +68,8 @@ create_vecheader(isc_mem_t *mctx, dns_rdatatype_t type, dns_rdataclass_t rdclass
/* Create rdata */
dns_rdata_init(rdata);
CHECK(dns_test_rdatafromstring(rdata, rdclass, type, data,
256, rdata_text, false));
CHECK(dns_test_rdatafromstring(rdata, rdclass, type, data, 256,
rdata_text, false));
ISC_LIST_APPEND(rdatalist->rdata, rdata, link);
dns_rdatalist_tordataset(rdatalist, &rdataset);
@ -92,9 +92,9 @@ cleanup:
/* Helper function to create an rdataset from a vecheader */
static void
create_rdataset_from_vecheader(dns_vecheader_t *header, dns_rdataclass_t rdclass,
dns_rdatatype_t type, dns_rdataset_t *rdataset)
{
create_rdataset_from_vecheader(dns_vecheader_t *header,
dns_rdataclass_t rdclass, dns_rdatatype_t type,
dns_rdataset_t *rdataset) {
dns_rdataset_init(rdataset);
rdataset->methods = &dns_rdatavec_rdatasetmethods;
rdataset->rdclass = rdclass;
@ -112,11 +112,11 @@ ISC_RUN_TEST_IMPL(merge_headers) {
isc_result_t result;
/* Create vecheaders with A records */
CHECK(create_vecheader(mctx, dns_rdatatype_a, dns_rdataclass_in,
300, "192.168.1.1", &header1));
CHECK(create_vecheader(mctx, dns_rdatatype_a, dns_rdataclass_in, 300,
"192.168.1.1", &header1));
CHECK(create_vecheader(mctx, dns_rdatatype_a, dns_rdataclass_in,
300, "192.168.1.2", &header2));
CHECK(create_vecheader(mctx, dns_rdatatype_a, dns_rdataclass_in, 300,
"192.168.1.2", &header2));
/* Get sizes and counts before merging */
size1 = dns_rdatavec_size(header1);
@ -133,7 +133,8 @@ ISC_RUN_TEST_IMPL(merge_headers) {
merged_size = dns_rdatavec_size(merged_header);
merged_count = dns_rdatavec_count(merged_header);
/* Test: merged size should be first_size + second_size - sizeof(header) - count_field_size */
/* Test: merged size should be first_size + second_size - sizeof(header)
* - count_field_size */
expected_size = size1 + size2 - sizeof(dns_vecheader_t) - 2;
assert_int_equal(merged_size, expected_size);
@ -173,11 +174,11 @@ ISC_RUN_TEST_IMPL(merge_case_preservation) {
dns_test_namefromstring("example.com", &fname2);
/* Create vecheaders */
CHECK(create_vecheader(mctx, dns_rdatatype_a, dns_rdataclass_in,
300, "192.168.1.1", &header1));
CHECK(create_vecheader(mctx, dns_rdatatype_a, dns_rdataclass_in, 300,
"192.168.1.1", &header1));
CHECK(create_vecheader(mctx, dns_rdatatype_a, dns_rdataclass_in,
300, "192.168.1.2", &header2));
CHECK(create_vecheader(mctx, dns_rdatatype_a, dns_rdataclass_in, 300,
"192.168.1.2", &header2));
/* Set case on first header */
dns_vecheader_setownercase(header1, name1);
@ -242,8 +243,8 @@ ISC_RUN_TEST_IMPL(setcase_size_consistency) {
dns_test_namefromstring("Example.COM", &fname);
/* Create vecheader */
CHECK(create_vecheader(mctx, dns_rdatatype_a, dns_rdataclass_in,
300, "192.168.1.1", &header));
CHECK(create_vecheader(mctx, dns_rdatatype_a, dns_rdataclass_in, 300,
"192.168.1.1", &header));
/* Get original size */
original_size = dns_rdatavec_size(header);