#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
* 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;
/*
* Display trust in textual form.
*/
-
isc_stdtime_t
dns_rdataset_minresign(dns_rdataset_t *rdataset);
/*%<
#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;
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;
/*%
/*%
* 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).
* 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,
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'.
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
* valid flags are DNS_RDATAVEC_EXACT
*/
-
void
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);
/*%<
* Free all memory associated with '*headerp'.
*/
-
dns_vectop_t *
dns_vectop_new(isc_mem_t *mctx, dns_typepair_t typepair);
/*%<
#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>
#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>
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);
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) {
}
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) {
}
}
- /*
+ /*
* Second pass: remove all empty vectops
*/
ISC_SLIST_FOREACH_PTR(iter, &ISC_SLIST_HEAD(node->next_type)) {
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 &&
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;
}
}
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
*/
* 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);
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) {
*/
INSIST(!loading);
- ISC_SLIST_PREPEND(foundtop->headers, newheader, next_header);
+ ISC_SLIST_PREPEND(foundtop->headers, newheader,
+ next_header);
if (changed != NULL) {
changed->dirty = true;
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);
}
}
}
loading_addnode(loadctx, name, rdataset->type, rdataset->covers, &node);
result = dns_rdatavec_fromrdataset(rdataset, node->mctx, ®ion,
- qpdb->maxrrperset);
+ qpdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
if (result == DNS_R_TOOMANYRECORDS) {
dns__db_logtoomanyrecords((dns_db_t *)qpdb, name,
* 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
rdataset->covers != dns_rdatatype_nsec3));
result = dns_rdatavec_fromrdataset(rdataset, node->mctx, ®ion,
- qpdb->maxrrperset);
+ qpdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
if (result == DNS_R_TOOMANYRECORDS) {
dns__db_logtoomanyrecords((dns_db_t *)qpdb, &node->name,
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);
*/
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,
}
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;
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.
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 &&
*/
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;
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;
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;
/* 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
*/
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;
return result;
}
-
void
dns_vecheader_setownercase(dns_vecheader_t *header, const dns_name_t *name) {
REQUIRE(!CASESET(header));
}
}
if (casefullylower) {
- DNS_VECHEADER_SETATTR(header,
- DNS_VECHEADERATTR_CASEFULLYLOWER);
+ DNS_VECHEADER_SETATTR(header, DNS_VECHEADERATTR_CASEFULLYLOWER);
}
DNS_VECHEADER_SETATTR(header, DNS_VECHEADERATTR_CASESET);
}
/* 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) {
rdata->flags |= flags;
}
-
/* Fixed RRSet helper macros */
static void
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
* \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);
* 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 \
#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)
/* 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))
#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"
/* 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;
/* 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);
/* 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;
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);
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);
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);
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);
projects / thirdparty / bind9.git / commitdiff
