static isc_result_t
builtin_lookup(bdb_t *bdb, const dns_name_t *name, bdbnode_t *node) {
- if (name->labels == 0 && name->length == 0) {
+ if (name->length == 0) {
return bdb->lookup(node);
} else if ((node->bdb->implementation->flags & BDB_DNS64) != 0) {
return dns64_cname(&bdb->common.origin, name, node);
isc_refcount_init(&bdb->common.references, 1);
isc_mem_attach(mctx, &bdb->common.mctx);
dns_name_init(&bdb->common.origin, NULL);
- dns_name_dupwithoffsets(origin, mctx, &bdb->common.origin);
+ dns_name_dup(origin, mctx, &bdb->common.origin);
INSIST(argc >= 1);
if (strcmp(argv[0], "authors") == 0) {
if (usegsstsig) {
dns_name_free(&tmpzonename, gmctx);
dns_name_free(&restart_primary, gmctx);
- dns_name_init(&tmpzonename, 0);
- dns_name_init(&restart_primary, 0);
+ dns_name_init(&tmpzonename, NULL);
+ dns_name_init(&restart_primary, NULL);
}
done_update();
}
isc_mem_attach(mctx, &sampledb->common.mctx);
dns_name_init(&sampledb->common.origin, NULL);
- dns_name_dupwithoffsets(origin, mctx, &sampledb->common.origin);
+ dns_name_dup(origin, mctx, &sampledb->common.origin);
isc_refcount_init(&sampledb->common.references, 1);
a buffer.
- `dns_name_dup()` copies a name into a new name object, dynamically
- allocating buffer space as needed. `dns_name_dupwithoffsets()` does
- the same, but also dynamically allocates space for the copied offset
- table. Targets created by these functions must be freed by calling
- `dns_name_free()`.
+ allocating buffer space as needed. Target created by this function
+ must be freed by calling `dns_name_free()`.
##### Wire format
dns_fixedname_t old_fixed;
dns_name_t *new_name = dns_fixedname_initname(&new_fixed);
dns_name_t *old_name = dns_fixedname_initname(&old_fixed);
- uint8_t *new_offsets;
- uint8_t *old_offsets;
dns_decompress_t dctx = DNS_DECOMPRESS_PERMITTED;
isc_buffer_t new_buf;
isc_buffer_t old_buf;
REQUIRE(new_result == old_result);
REQUIRE(dns_name_equal(new_name, old_name));
- REQUIRE(new_name->labels == old_name->labels);
-
- new_offsets = new_name->offsets;
- old_offsets = old_name->offsets;
- REQUIRE(new_offsets != NULL && old_offsets != NULL);
- REQUIRE(memcmp(new_offsets, old_offsets, old_name->labels) == 0);
REQUIRE(new_fixed.buffer.current == old_fixed.buffer.current);
REQUIRE(new_fixed.buffer.active == old_fixed.buffer.active);
#define VALID_NAME(n) ISC_MAGIC_VALID(n, DNS_NAME_MAGIC)
-#define INIT_OFFSETS(name, var, default_offsets) \
- if ((name)->offsets != NULL) \
- var = (name)->offsets; \
- else \
- var = (default_offsets);
+#define INIT_OFFSETS(name, var, default_offsets) (var) = (default_offsets)
#define MAKE_EMPTY(name) \
do { \
name->ndata = NULL; \
name->length = 0; \
- name->labels = 0; \
name->attributes.absolute = false; \
} while (0)
}
name->ndata = (unsigned char *)target->base + target->used;
- name->labels = labels;
name->length = nused;
name->attributes.absolute = true;
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
+#include <unistd.h>
#include <isc/async.h>
#include <isc/hex.h>
#include <dns/view.h>
#include <dns/zone.h>
+#include "dns/name.h"
+
#define DNS_CATZ_ZONE_MAGIC ISC_MAGIC('c', 'a', 't', 'z')
#define DNS_CATZ_ZONES_MAGIC ISC_MAGIC('c', 'a', 't', 's')
#define DNS_CATZ_ENTRY_MAGIC ISC_MAGIC('c', 'a', 't', 'e')
* record, removed.
* xxxwpk: make it a separate verification phase?
*/
- if (dns_name_countlabels(&nentry->name) == 0) {
+ if (nentry->name.length == 0) {
dns_catz_entry_detach(newcatz, &nentry);
delcur = true;
continue;
REQUIRE(DNS_RDATASET_VALID(value));
REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
- if (name->labels == 0) {
+ uint8_t labels = dns_name_countlabels(name);
+
+ if (labels == 0) {
return ISC_R_FAILURE;
}
- dns_name_getlabel(name, name->labels - 1, &mhash);
+ dns_name_getlabel(name, labels - 1, &mhash);
- if (name->labels == 1) {
+ if (labels == 1) {
return catz_process_zones_entry(catz, value, &mhash);
} else {
dns_name_init(&opt, NULL);
* - label and IN A/IN AAAA
* - label and IN TXT - TSIG key name
*/
- if (name->labels > 0) {
+ if (name->length != 0) {
isc_sockaddr_t sockaddr;
size_t i;
/* rdatastr.length < DNS_NAME_MAXTEXT */
keyname = isc_mem_get(mctx, sizeof(*keyname));
- dns_name_init(keyname, 0);
+ dns_name_init(keyname, NULL);
memmove(keycbuf, rdatastr.data, rdatastr.length);
keycbuf[rdatastr.length] = 0;
dns_rdata_freestruct(&rdata_txt);
REQUIRE(DNS_RDATASET_VALID(value));
REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
- if (name->labels < 1) {
+ uint8_t labels = dns_name_countlabels(name);
+
+ if (labels < 1) {
return ISC_R_FAILURE;
}
- dns_name_getlabel(name, name->labels - 1, &option);
+ dns_name_getlabel(name, labels - 1, &option);
opt = catz_get_option(&option);
/*
* "ext" label.
*/
if (catz->version >= 2 && opt >= CATZ_OPT_CUSTOM_START) {
- if (opt != CATZ_OPT_EXT || name->labels < 2) {
+ if (opt != CATZ_OPT_EXT || labels < 2) {
return ISC_R_FAILURE;
}
suffix_labels++;
- dns_name_getlabel(name, name->labels - 2, &option);
+ dns_name_getlabel(name, labels - 2, &option);
opt = catz_get_option(&option);
}
case CATZ_OPT_PRIMARIES:
return catz_process_primaries(catz, &entry->opts.masters, value,
&prefix);
- case CATZ_OPT_ALLOW_QUERY:
- if (prefix.labels != 0) {
+ case CATZ_OPT_ALLOW_QUERY:;
+ if (prefix.length != 0) {
return ISC_R_FAILURE;
}
return catz_process_apl(catz, &entry->opts.allow_query, value);
case CATZ_OPT_ALLOW_TRANSFER:
- if (prefix.labels != 0) {
+ if (prefix.length != 0) {
return ISC_R_FAILURE;
}
return catz_process_apl(catz, &entry->opts.allow_transfer,
REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
REQUIRE(DNS_RDATASET_VALID(rdataset));
- if (name->labels < 1) {
+ uint8_t labels = dns_name_countlabels(name);
+
+ if (labels < 1) {
return ISC_R_FAILURE;
}
- dns_name_getlabel(name, name->labels - 1, &option);
+ dns_name_getlabel(name, labels - 1, &option);
opt = catz_get_option(&option);
/*
* "ext" label.
*/
if (catz->version >= 2 && opt >= CATZ_OPT_CUSTOM_START) {
- if (opt != CATZ_OPT_EXT || name->labels < 2) {
+ if (opt != CATZ_OPT_EXT || labels < 2) {
return ISC_R_FAILURE;
}
suffix_labels++;
- dns_name_getlabel(name, name->labels - 2, &option);
+ dns_name_getlabel(name, labels - 2, &option);
opt = catz_get_option(&option);
}
return catz_process_primaries(catz, &catz->zoneoptions.masters,
rdataset, &prefix);
case CATZ_OPT_ALLOW_QUERY:
- if (prefix.labels != 0) {
+ if (prefix.length != 0) {
return ISC_R_FAILURE;
}
return catz_process_apl(catz, &catz->zoneoptions.allow_query,
rdataset);
case CATZ_OPT_ALLOW_TRANSFER:
- if (prefix.labels != 0) {
+ if (prefix.length != 0) {
return ISC_R_FAILURE;
}
return catz_process_apl(catz, &catz->zoneoptions.allow_transfer,
rdataset);
case CATZ_OPT_VERSION:
- if (prefix.labels != 0) {
+ if (prefix.length != 0) {
return ISC_R_FAILURE;
}
return catz_process_version(catz, rdataset);
return ISC_R_UNEXPECTED;
}
+ uint8_t labels = dns_name_countlabels(&catz->name);
dns_name_init(&prefix, NULL);
- dns_name_split(src_name, catz->name.labels, &prefix, NULL);
+ dns_name_split(src_name, labels, &prefix, NULL);
result = catz_process_value(catz, &prefix, rdataset);
return result;
}
static bool
-insert_label(dns_compress_t *cctx, isc_buffer_t *buffer, const dns_name_t *name,
- unsigned int label, uint16_t hash, unsigned int probe) {
+insert_label(dns_compress_t *cctx, isc_buffer_t *buffer,
+ const dns_offsets_t offsets, unsigned int label, uint16_t hash,
+ unsigned int probe) {
/*
* hash set entries must have valid compression offsets
* and the hash set must not get too full (75% load)
*/
- unsigned int prefix_len = name->offsets[label];
+ unsigned int prefix_len = offsets[label];
unsigned int coff = isc_buffer_usedlength(buffer) + prefix_len;
if (coff >= 0x4000 || cctx->count > cctx->mask * 3 / 4) {
return false;
*/
static void
insert(dns_compress_t *cctx, isc_buffer_t *buffer, const dns_name_t *name,
- unsigned int label, uint16_t hash, unsigned int probe) {
+ const dns_offsets_t offsets, unsigned int label, uint16_t hash,
+ unsigned int probe) {
bool sensitive = (cctx->flags & DNS_COMPRESS_CASE) != 0;
/*
* this insertion loop continues from the search loop inside
* dns_compress_name() below, iterating over the remaining labels
* of the name and accumulating the hash in the same manner
*/
- while (insert_label(cctx, buffer, name, label, hash, probe) &&
+ while (insert_label(cctx, buffer, offsets, label, hash, probe) &&
label-- > 0)
{
- unsigned int prefix_len = name->offsets[label];
+ unsigned int prefix_len = offsets[label];
uint8_t *suffix_ptr = name->ndata + prefix_len;
hash = hash_label(hash, suffix_ptr, sensitive);
probe = 0;
REQUIRE(CCTX_VALID(cctx));
REQUIRE(ISC_BUFFER_VALID(buffer));
REQUIRE(dns_name_isabsolute(name));
- REQUIRE(name->labels > 0);
- REQUIRE(name->offsets != NULL);
REQUIRE(return_prefix != NULL);
REQUIRE(return_coff != NULL);
REQUIRE(*return_coff == 0);
return;
}
+ dns_offsets_t offsets;
+ size_t labels = dns_name_offsets(name, offsets);
+ INSIST(labels > 0);
+
bool sensitive = (cctx->flags & DNS_COMPRESS_CASE) != 0;
uint16_t hash = HASH_INIT_DJB2;
- unsigned int label = name->labels - 1; /* skip the root label */
+ size_t label = labels - 1; /* skip the root label */
/*
* find out how much of the name's suffix is in the hash set,
* stepping backwards from the end one label at a time
*/
while (label-- > 0) {
- unsigned int prefix_len = name->offsets[label];
+ unsigned int prefix_len = offsets[label];
unsigned int suffix_len = name->length - prefix_len;
uint8_t *suffix_ptr = name->ndata + prefix_len;
hash = hash_label(hash, suffix_ptr, sensitive);
* the rest of the name (its prefix) into the set
*/
if (coff == 0 || probe > probe_distance(cctx, slot)) {
- insert(cctx, buffer, name, label, hash, probe);
+ insert(cctx, buffer, name, offsets, label, hash,
+ probe);
return;
}
void
dns_fixedname_init(dns_fixedname_t *fixed) {
- dns_name_init(&fixed->name, fixed->offsets);
+ dns_name_init(&fixed->name, NULL);
isc_buffer_init(&fixed->buffer, fixed->data, DNS_NAME_MAXWIRE);
dns_name_setbuffer(&fixed->name, &fixed->buffer);
}
isc_mem_attach(mctx, &forwarders->mctx);
isc_refcount_init(&forwarders->references, 1);
- dns_name_dupwithoffsets(name, mctx, &forwarders->name);
+ dns_name_dup(name, mctx, &forwarders->name);
return forwarders;
}
struct dns_fixedname {
dns_name_t name;
- dns_offsets_t offsets;
isc_buffer_t buffer;
unsigned char data[DNS_NAME_MAXWIRE];
};
*
* The same applies to rdatasets.
*
- * On the other hand, offsets, rdatalists and rdatas allocated using
+ * On the other hand, rdatalists and rdatas allocated using
* dns_message_gettemp*() will always be freed automatically
* when the message is reset or destroyed; calling dns_message_puttemp*()
* on rdatalists and rdatas is optional and serves only to enable the item
ISC_LIST(dns_msgblock_t) rdatas;
ISC_LIST(dns_msgblock_t) rdatalists;
- ISC_LIST(dns_msgblock_t) offsets;
ISC_LIST(dns_rdata_t) freerdata;
ISC_LIST(dns_rdatalist_t) freerdatalist;
#include <stdbool.h>
#include <stdio.h>
+#include <isc/attributes.h>
#include <isc/buffer.h>
#include <isc/hashmap.h>
#include <isc/magic.h>
struct dns_name {
unsigned int magic;
uint8_t length;
- uint8_t labels;
struct dns_name_attrs {
bool absolute : 1; /*%< Used by name.c */
bool readonly : 1; /*%< Used by name.c */
bool dynamic : 1; /*%< Used by name.c */
- bool dynoffsets : 1; /*%< Used by name.c */
bool nocompress : 1; /*%< Used by name.c */
bool cache : 1; /*%< Used by resolver. */
bool answer : 1; /*%< Used by resolver. */
bool hasupdaterec : 1; /*%< Used by client. */
} attributes;
unsigned char *ndata;
- unsigned char *offsets;
isc_buffer_t *buffer;
ISC_LINK(dns_name_t) link;
ISC_LIST(dns_rdataset_t) list;
* and sizeof(A) in DNS_NAME_INITABSOLUTE to allow C strings to be used
* to initialize 'ndata'.
*
- * Note[2]: The final value of offsets for DNS_NAME_INITABSOLUTE should
- * match (sizeof(A) - 1) which is the offset of the root label.
- *
* Typical usage:
* unsigned char data[] = "\005value";
- * unsigned char offsets[] = { 0 };
- * dns_name_t value = DNS_NAME_INITNONABSOLUTE(data, offsets);
+ * dns_name_t value = DNS_NAME_INITNONABSOLUTE(data, 1);
*
* unsigned char data[] = "\005value";
- * unsigned char offsets[] = { 0, 6 };
- * dns_name_t value = DNS_NAME_INITABSOLUTE(data, offsets);
+ * dns_name_t value = DNS_NAME_INITABSOLUTE(data, 1);
*/
-#define DNS_NAME_INITNONABSOLUTE(A, B) \
- { \
- .magic = DNS_NAME_MAGIC, \
- .ndata = A, \
- .length = (sizeof(A) - 1), \
- .labels = sizeof(B), \
- .attributes = { .readonly = true }, \
- .offsets = B, \
- .link = ISC_LINK_INITIALIZER, \
- .list = ISC_LIST_INITIALIZER, \
+#define DNS_NAME_INITNONABSOLUTE(__ndata, __labels) \
+ { \
+ .magic = 0 ? sizeof(__labels) : DNS_NAME_MAGIC, \
+ .ndata = (__ndata), \
+ .length = (sizeof(__ndata) - 1), \
+ .attributes = { .readonly = true }, \
+ .link = ISC_LINK_INITIALIZER, \
+ .list = ISC_LIST_INITIALIZER, \
}
-#define DNS_NAME_INITABSOLUTE(A, B) \
+#define DNS_NAME_INITABSOLUTE(__ndata, __labels) \
{ \
- .magic = DNS_NAME_MAGIC, \
- .ndata = A, \
- .length = sizeof(A), \
- .labels = sizeof(B), \
+ .magic = 0 ? sizeof(__labels) : DNS_NAME_MAGIC, \
+ .ndata = (__ndata), \
+ .length = sizeof(__ndata), \
.attributes = { .readonly = true, .absolute = true }, \
- .offsets = B, \
.link = ISC_LINK_INITIALIZER, \
.list = ISC_LIST_INITIALIZER, \
}
#define DNS_NAME_MAXLABELS 128
#define DNS_NAME_LABELLEN 63
-typedef unsigned char dns_offsets_t[DNS_NAME_MAXLABELS];
+typedef uint8_t dns_offsets_t[DNS_NAME_MAXLABELS];
/*
* Text output filter procedure.
***/
static inline void
-dns_name_init(dns_name_t *name, unsigned char *offsets) {
+dns_name_init(dns_name_t *name, unsigned char *offsets ISC_ATTR_UNUSED) {
*name = (dns_name_t){
.magic = DNS_NAME_MAGIC,
- .offsets = (offsets),
.link = ISC_LINK_INITIALIZER,
.list = ISC_LIST_INITIALIZER,
};
/*%<
* Initialize 'name'.
*
- * Notes:
- * \li 'offsets' is never required to be non-NULL, but specifying a
- * dns_offsets_t for 'offsets' will improve the performance of most
- * name operations if the name is used more than once.
- *
* Requires:
* \li 'name' is not NULL and points to a struct dns_name.
*
- * \li offsets == NULL or offsets is a dns_offsets_t.
- *
* Ensures:
* \li 'name' is a valid name.
* \li dns_name_countlabels(name) == 0
name->ndata = NULL;
name->length = 0;
- name->labels = 0;
name->attributes.absolute = false;
if (name->buffer != NULL) {
isc_buffer_clear(name->buffer);
name->magic = 0;
name->ndata = NULL;
name->length = 0;
- name->labels = 0;
name->attributes = (struct dns_name_attrs){};
- name->offsets = NULL;
name->buffer = NULL;
ISC_LINK_INIT(name, link);
}
* \li Because it only needs to test for equality, dns_name_equal() can be
* significantly faster than dns_name_fullcompare() or dns_name_compare().
*
- * \li Offsets tables are not used in the comparison.
- *
* \li It makes no sense for one of the names to be relative and the
* other absolute. If both names are relative, then to be meaningfully
* compared the caller must ensure that they are both relative to the
*** Labels
***/
-static inline unsigned int
+uint8_t
+dns_name_offsets(const dns_name_t *name, uint8_t *offsets);
+/*%<
+ * Returns the number of the labels in the DNS name and optionally fills their
+ * offsets into the table.
+ *
+ * Requires:
+ *\li 'name' is a valid DNS name
+ *
+ * Returns:
+ *\li number of labels in the DNS name
+ *
+ * Note:
+ *\li if the 'offsets' is non-NULL, it will fill the offsets of
+ * individual labels in the name
+ */
+
+static inline uint8_t
dns_name_countlabels(const dns_name_t *name) {
REQUIRE(DNS_NAME_VALID(name));
- REQUIRE(name->labels <= DNS_NAME_MAXLABELS);
- return name->labels;
+ return dns_name_offsets(name, NULL);
}
/*%<
* How many labels does 'name' have?
*
* \li target is a valid buffer.
*
- * \li Any offsets in the compression table are valid for buffer.
- *
* Ensures:
*
* If the result is success:
dns_name_t *prefix, dns_name_t *suffix) {
REQUIRE(DNS_NAME_VALID(name));
REQUIRE(suffixlabels > 0);
- REQUIRE(suffixlabels <= name->labels);
REQUIRE(prefix != NULL || suffix != NULL);
REQUIRE(prefix == NULL ||
(DNS_NAME_VALID(prefix) && DNS_NAME_BINDABLE(prefix)));
REQUIRE(suffix == NULL ||
(DNS_NAME_VALID(suffix) && DNS_NAME_BINDABLE(suffix)));
+ uint8_t labels = dns_name_countlabels(name);
+ INSIST(suffixlabels <= labels);
+
if (prefix != NULL) {
- dns_name_getlabelsequence(name, 0, name->labels - suffixlabels,
+ dns_name_getlabelsequence(name, 0, labels - suffixlabels,
prefix);
}
if (suffix != NULL) {
- dns_name_getlabelsequence(name, name->labels - suffixlabels,
+ dns_name_getlabelsequence(name, labels - suffixlabels,
suffixlabels, suffix);
}
}
*\li 'mctx' is a valid memory context.
*/
-void
-dns_name_dupwithoffsets(const dns_name_t *source, isc_mem_t *mctx,
- dns_name_t *target);
-/*%<
- * Make 'target' a read-only dynamically allocated copy of 'source'.
- * 'target' will also have a dynamically allocated offsets table.
- *
- * Requires:
- *
- *\li 'source' is a valid non-empty name.
- *
- *\li 'target' is a valid name that is not read-only.
- *
- *\li 'target' has no offsets table.
- *
- *\li 'mctx' is a valid memory context.
- */
-
void
dns_name_free(dns_name_t *name, isc_mem_t *mctx);
/*%<
isc_refcount_init(&knode->references, 1);
isc_rwlock_init(&knode->rwlock);
- dns_name_dupwithoffsets(name, keytable->mctx, &knode->name);
+ dns_name_dup(name, keytable->mctx, &knode->name);
/*
* If a DS was supplied, initialize an rdatalist.
source, line, isc_result_totext(result))
static unsigned char in_addr_arpa_data[] = "\007IN-ADDR\004ARPA";
-static unsigned char in_addr_arpa_offsets[] = { 0, 8, 13 };
-static dns_name_t const in_addr_arpa =
- DNS_NAME_INITABSOLUTE(in_addr_arpa_data, in_addr_arpa_offsets);
+static dns_name_t const in_addr_arpa = DNS_NAME_INITABSOLUTE(in_addr_arpa_data,
+ NULL);
static unsigned char ip6_int_data[] = "\003IP6\003INT";
-static unsigned char ip6_int_offsets[] = { 0, 4, 8 };
-static dns_name_t const ip6_int = DNS_NAME_INITABSOLUTE(ip6_int_data,
- ip6_int_offsets);
+static dns_name_t const ip6_int = DNS_NAME_INITABSOLUTE(ip6_int_data, NULL);
static unsigned char ip6_arpa_data[] = "\003IP6\004ARPA";
-static unsigned char ip6_arpa_offsets[] = { 0, 4, 9 };
-static dns_name_t const ip6_arpa = DNS_NAME_INITABSOLUTE(ip6_arpa_data,
- ip6_arpa_offsets);
+static dns_name_t const ip6_arpa = DNS_NAME_INITABSOLUTE(ip6_arpa_data, NULL);
static bool
dns_master_isprimary(dns_loadctx_t *lctx) {
return rdatalist;
}
-static dns_offsets_t *
-newoffsets(dns_message_t *msg) {
- dns_msgblock_t *msgblock;
- dns_offsets_t *offsets;
-
- msgblock = ISC_LIST_TAIL(msg->offsets);
- offsets = msgblock_get(msgblock, dns_offsets_t);
- if (offsets == NULL) {
- msgblock = msgblock_allocate(msg->mctx, sizeof(dns_offsets_t),
- OFFSET_COUNT);
- ISC_LIST_APPEND(msg->offsets, msgblock, link);
-
- offsets = msgblock_get(msgblock, dns_offsets_t);
- }
-
- return offsets;
-}
-
static void
msginitheader(dns_message_t *m) {
m->id = 0;
msgblock = next_msgblock;
}
- msgblock = ISC_LIST_HEAD(msg->offsets);
- if (!everything && msgblock != NULL) {
- msgblock_reset(msgblock);
- msgblock = ISC_LIST_NEXT(msgblock, link);
- }
- while (msgblock != NULL) {
- next_msgblock = ISC_LIST_NEXT(msgblock, link);
- ISC_LIST_UNLINK(msg->offsets, msgblock, link);
- msgblock_free(msg->mctx, msgblock, sizeof(dns_offsets_t));
- msgblock = next_msgblock;
- }
-
if (msg->tsigkey != NULL) {
dns_tsigkey_detach(&msg->tsigkey);
msg->tsigkey = NULL;
.cleanup = ISC_LIST_INITIALIZER,
.rdatas = ISC_LIST_INITIALIZER,
.rdatalists = ISC_LIST_INITIALIZER,
- .offsets = ISC_LIST_INITIALIZER,
.freerdata = ISC_LIST_INITIALIZER,
.freerdatalist = ISC_LIST_INITIALIZER,
.magic = DNS_MESSAGE_MAGIC,
for (count = 0; count < msg->counts[DNS_SECTION_QUESTION]; count++) {
name = NULL;
dns_message_gettempname(msg, &name);
- name->offsets = (unsigned char *)newoffsets(msg);
free_name = true;
/*
name = NULL;
dns_message_gettempname(msg, &name);
- name->offsets = (unsigned char *)newoffsets(msg);
free_name = true;
/*
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h>
+#include <unistd.h>
#include <isc/ascii.h>
+#include <isc/attributes.h>
#include <isc/buffer.h>
#include <isc/hash.h>
#include <isc/hex.h>
} ft_state;
#define INIT_OFFSETS(name, var, default_offsets) \
- if ((name)->offsets != NULL) \
- var = (name)->offsets; \
- else \
- var = (default_offsets);
+ { \
+ (var) = (default_offsets); \
+ }
#define SETUP_OFFSETS(name, var, default_offsets) \
- if ((name)->offsets != NULL) { \
- var = (name)->offsets; \
- } else { \
- var = (default_offsets); \
+ ({ \
+ (var) = (default_offsets); \
set_offsets(name, var, NULL); \
- }
+ })
/*%
* Note: If additional attributes are added that should not be set for
* empty names, MAKE_EMPTY() must be changed so it clears them.
*/
#define MAKE_EMPTY(name) \
- do { \
+ { \
name->ndata = NULL; \
name->length = 0; \
- name->labels = 0; \
name->attributes.absolute = false; \
- } while (0);
+ }
/*%
* Note that the name data must be a char array, not a string
* the const attribute of a string.
*/
static unsigned char root_ndata[] = { "" };
-static unsigned char root_offsets[] = { 0 };
-
-static dns_name_t root = DNS_NAME_INITABSOLUTE(root_ndata, root_offsets);
+static dns_name_t root = DNS_NAME_INITABSOLUTE(root_ndata, NULL);
const dns_name_t *dns_rootname = &root;
static unsigned char wild_ndata[] = { "\001*" };
-static unsigned char wild_offsets[] = { 0 };
-
-static dns_name_t const wild = DNS_NAME_INITNONABSOLUTE(wild_ndata,
- wild_offsets);
+static dns_name_t const wild = DNS_NAME_INITNONABSOLUTE(wild_ndata, NULL);
const dns_name_t *dns_wildcardname = &wild;
/*
*/
static thread_local dns_name_totextfilter_t *totext_filter_proc = NULL;
-static void
+static uint8_t
set_offsets(const dns_name_t *name, unsigned char *offsets,
dns_name_t *set_name);
bool
dns_name_isvalid(const dns_name_t *name) {
- unsigned char *ndata, *offsets;
+ unsigned char *ndata;
unsigned int offset, count, length, nlabels;
if (!DNS_NAME_VALID(name)) {
return false;
}
- if (name->labels > DNS_NAME_MAXLABELS) {
- return false;
- }
-
ndata = name->ndata;
length = name->length;
- offsets = name->offsets;
offset = 0;
nlabels = 0;
if (count > DNS_NAME_LABELLEN) {
return false;
}
- if (offsets != NULL && offsets[nlabels] != offset) {
- return false;
- }
nlabels++;
offset += count + 1;
}
}
- if (nlabels != name->labels || offset != name->length) {
+ if (nlabels > DNS_NAME_MAXLABELS || offset != name->length) {
return false;
}
bool first;
REQUIRE(DNS_NAME_VALID(name));
- REQUIRE(name->labels > 0);
+ REQUIRE(name->length > 0);
REQUIRE(name->attributes.absolute);
/*
bool first;
REQUIRE(DNS_NAME_VALID(name));
- REQUIRE(name->labels > 0);
+ REQUIRE(name->length > 0);
REQUIRE(name->attributes.absolute);
/*
*/
REQUIRE(DNS_NAME_VALID(name));
- REQUIRE(name->labels > 0);
+ REQUIRE(name->length > 0);
if (name->length >= 2) {
ndata = name->ndata;
*/
REQUIRE(DNS_NAME_VALID(name));
- REQUIRE(name->labels > 0);
/*
* Skip first label.
INSIST(count <= DNS_NAME_LABELLEN);
ndata += count;
label = 1;
- /*
- * Check all but the last of the remaining labels.
- */
- while (label + 1 < name->labels) {
+
+ uint8_t labels = dns_name_countlabels(name);
+ while (label + 1 < labels) {
count = *ndata++;
INSIST(count <= DNS_NAME_LABELLEN);
+
if (count == 1 && *ndata == '*') {
return true;
}
if (name1 == name2) {
*orderp = 0;
- *nlabelsp = name1->labels;
+ *nlabelsp = dns_name_countlabels(name1);
+
return dns_namereln_equal;
}
- SETUP_OFFSETS(name1, offsets1, odata1);
- SETUP_OFFSETS(name2, offsets2, odata2);
+ l1 = SETUP_OFFSETS(name1, offsets1, odata1);
+ l2 = SETUP_OFFSETS(name2, offsets2, odata2);
nlabels = 0;
- l1 = name1->labels;
- l2 = name2->labels;
if (l2 > l1) {
l = l1;
ldiff = 0 - (l2 - l1);
*/
REQUIRE(DNS_NAME_VALID(name1));
- REQUIRE(name1->labels > 0);
+ REQUIRE(name1->length > 0);
REQUIRE(name1->attributes.absolute);
REQUIRE(DNS_NAME_VALID(name2));
- REQUIRE(name2->labels > 0);
+ REQUIRE(name2->length > 0);
REQUIRE(name2->attributes.absolute);
/* label lengths are < 64 so tolower() does not affect them */
dns_name_t tname;
REQUIRE(DNS_NAME_VALID(name));
- REQUIRE(name->labels > 0);
+ REQUIRE(name->length > 0);
REQUIRE(DNS_NAME_VALID(wname));
- labels = wname->labels;
+ labels = dns_name_countlabels(wname);
REQUIRE(labels > 0);
REQUIRE(dns_name_iswildcard(wname));
*/
REQUIRE(DNS_NAME_VALID(name));
- REQUIRE(name->labels > 0);
- REQUIRE(n < name->labels);
REQUIRE(label != NULL);
- SETUP_OFFSETS(name, offsets, odata);
+ uint8_t labels = SETUP_OFFSETS(name, offsets, odata);
+
+ REQUIRE(labels > 0);
+ REQUIRE(n < labels);
label->base = &name->ndata[offsets[n]];
- if (n == (unsigned int)name->labels - 1) {
+ if (n == (unsigned int)labels - 1) {
label->length = name->length - offsets[n];
} else {
label->length = offsets[n + 1] - offsets[n];
REQUIRE(DNS_NAME_VALID(source));
REQUIRE(DNS_NAME_VALID(target));
- REQUIRE(first <= source->labels);
- REQUIRE(n <= source->labels - first); /* note first+n could overflow */
REQUIRE(DNS_NAME_BINDABLE(target));
+ uint8_t labels = dns_name_countlabels(source);
+ REQUIRE(first <= labels && n <= labels - first);
+
p = source->ndata;
- if (first == source->labels) {
+ if (first == labels) {
firstoffset = source->length;
} else {
for (i = 0; i < first; i++) {
firstoffset = (unsigned int)(p - source->ndata);
}
- if (first + n == source->labels) {
+ if (first + n == labels) {
endoffset = source->length;
} else {
for (i = 0; i < n; i++) {
target->ndata = &source->ndata[firstoffset];
target->length = endoffset - firstoffset;
- if (first + n == source->labels && n > 0 && source->attributes.absolute)
- {
+ if (first + n == labels && n > 0 && source->attributes.absolute) {
target->attributes.absolute = true;
} else {
target->attributes.absolute = false;
}
-
- target->labels = n;
-
- /*
- * If source and target are the same, and we're making target
- * a prefix of source, the offsets table is correct already
- * so we don't need to call set_offsets().
- */
- if (target->offsets != NULL && (target != source || first != 0)) {
- set_offsets(target, target->offsets, NULL);
- }
}
void
target->ndata = source->ndata;
target->length = source->length;
- target->labels = source->labels;
target->attributes = source->attributes;
target->attributes.readonly = false;
target->attributes.dynamic = false;
- target->attributes.dynoffsets = false;
- if (target->offsets != NULL && source->labels > 0) {
- if (source->offsets != NULL) {
- memmove(target->offsets, source->offsets,
- source->labels);
- } else {
- set_offsets(target, target->offsets, NULL);
- }
- }
}
void
if (r->length > 0) {
set_offsets(name, offsets, name);
} else {
- name->labels = 0;
name->attributes.absolute = false;
}
}
name->ndata = (unsigned char *)target->base + target->used;
- name->labels = labels;
name->length = nused;
isc_buffer_forward(source, tused);
ndata = name->ndata;
nlen = name->length;
- labels = name->labels;
+ labels = dns_name_countlabels(name);
tdata = isc_buffer_used(target);
tlen = isc_buffer_availablelength(target);
ndata = name->ndata;
nlen = name->length;
- labels = name->labels;
+ labels = dns_name_countlabels(name);
tdata = isc_buffer_used(target);
tlen = isc_buffer_availablelength(target);
isc_ascii_lowercopy(ndata, source->ndata, source->length);
if (source != name) {
- name->labels = source->labels;
name->length = source->length;
name->attributes = (struct dns_name_attrs){
.absolute = source->attributes.absolute
};
- if (name->labels > 0 && name->offsets != NULL) {
- set_offsets(name, name->offsets, NULL);
- }
}
isc_buffer_add(target, name->length);
return ISC_R_SUCCESS;
}
-static void
+static uint8_t
set_offsets(const dns_name_t *name, unsigned char *offsets,
dns_name_t *set_name) {
unsigned int offset, count, length, nlabels;
absolute = false;
while (offset != length) {
INSIST(nlabels < DNS_NAME_MAXLABELS);
- offsets[nlabels++] = offset;
+ if (offsets != NULL) {
+ offsets[nlabels] = offset;
+ }
+ nlabels++;
count = *ndata;
INSIST(count <= DNS_NAME_LABELLEN);
offset += count + 1;
if (set_name != NULL) {
INSIST(set_name == name);
- set_name->labels = nlabels;
set_name->length = offset;
set_name->attributes.absolute = absolute;
}
- INSIST(nlabels == name->labels);
INSIST(offset == name->length);
+
+ return nlabels;
}
isc_result_t
name->attributes.absolute = true;
name->ndata = name_buf;
- name->labels = labels;
name->length = name_len;
isc_buffer_add(target, name_len);
dns_name_towire(const dns_name_t *name, dns_compress_t *cctx,
isc_buffer_t *target, uint16_t *name_coff) {
bool compress;
- dns_offsets_t clo;
- dns_name_t clname;
unsigned int here;
unsigned int prefix_length;
unsigned int suffix_coff;
return ISC_R_SUCCESS;
}
- if (name->offsets == NULL) {
- dns_name_init(&clname, clo);
- dns_name_clone(name, &clname);
- name = &clname;
- }
-
/*
* Always add the name to the compression context; if compression
* is off, reset the return values before writing the name.
isc_result_t
dns_name_concatenate(const dns_name_t *prefix, const dns_name_t *suffix,
dns_name_t *name, isc_buffer_t *target) {
- unsigned char *ndata, *offsets;
- unsigned int nrem, labels, prefix_length, length;
+ unsigned char *ndata;
+ unsigned int nrem, prefix_length, length;
bool copy_prefix = true;
bool copy_suffix = true;
bool absolute = false;
dns_name_t tmp_name;
- dns_offsets_t odata;
/*
* Concatenate 'prefix' and 'suffix'.
REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) ||
(target == NULL && name != NULL &&
ISC_BUFFER_VALID(name->buffer)));
- if (prefix == NULL || prefix->labels == 0) {
+ if (prefix == NULL || prefix->length == 0) {
copy_prefix = false;
}
- if (suffix == NULL || suffix->labels == 0) {
+ if (suffix == NULL || suffix->length == 0) {
copy_suffix = false;
}
if (copy_prefix && prefix->attributes.absolute) {
REQUIRE(!copy_suffix);
}
if (name == NULL) {
- dns_name_init(&tmp_name, odata);
+ dns_name_init(&tmp_name, NULL);
name = &tmp_name;
}
if (target == NULL) {
}
length = 0;
prefix_length = 0;
- labels = 0;
if (copy_prefix) {
prefix_length = prefix->length;
length += prefix_length;
- labels += prefix->labels;
}
if (copy_suffix) {
length += suffix->length;
- labels += suffix->labels;
}
if (length > DNS_NAME_MAXWIRE) {
MAKE_EMPTY(name);
}
name->ndata = ndata;
- name->labels = labels;
name->length = length;
name->attributes.absolute = absolute;
- if (name->labels > 0 && name->offsets != NULL) {
- INIT_OFFSETS(name, offsets, odata);
- set_offsets(name, offsets, NULL);
- }
-
isc_buffer_add(target, name->length);
return ISC_R_SUCCESS;
memmove(target->ndata, source->ndata, source->length);
target->length = source->length;
- target->labels = source->labels;
target->attributes = (struct dns_name_attrs){ .dynamic = true };
target->attributes.absolute = source->attributes.absolute;
- if (target->offsets != NULL) {
- if (source->offsets != NULL) {
- memmove(target->offsets, source->offsets,
- source->labels);
- } else {
- set_offsets(target, target->offsets, NULL);
- }
- }
-}
-
-void
-dns_name_dupwithoffsets(const dns_name_t *source, isc_mem_t *mctx,
- dns_name_t *target) {
- /*
- * Make 'target' a read-only dynamically allocated copy of 'source'.
- * 'target' will also have a dynamically allocated offsets table.
- */
-
- REQUIRE(DNS_NAME_VALID(source));
- REQUIRE(source->length > 0);
- REQUIRE(DNS_NAME_VALID(target));
- REQUIRE(DNS_NAME_BINDABLE(target));
- REQUIRE(target->offsets == NULL);
-
- /*
- * Make 'target' empty in case of failure.
- */
- MAKE_EMPTY(target);
-
- target->ndata = isc_mem_get(mctx, source->length + source->labels);
-
- memmove(target->ndata, source->ndata, source->length);
-
- target->length = source->length;
- target->labels = source->labels;
- target->attributes = (struct dns_name_attrs){ .dynamic = true,
- .dynoffsets = true,
- .readonly = true };
- target->attributes.absolute = source->attributes.absolute;
- target->offsets = target->ndata + source->length;
- if (source->offsets != NULL) {
- memmove(target->offsets, source->offsets, source->labels);
- } else {
- set_offsets(target, target->offsets, NULL);
- }
}
void
REQUIRE(name->attributes.dynamic);
size = name->length;
- if (name->attributes.dynoffsets) {
- size += name->labels;
- }
isc_mem_put(mctx, name->ndata, size);
dns_name_invalidate(name);
}
}
size = name->length;
- if (name->attributes.dynoffsets) {
- size += name->labels;
- }
return size;
}
}
if (name != target) {
- dns_name_dupwithoffsets(name, mctx, target);
+ dns_name_dup(name, mctx, target);
}
return result;
}
}
dest->ndata = ndata;
- dest->labels = source->labels;
dest->length = source->length;
dest->attributes.absolute = source->attributes.absolute;
- if (dest->labels > 0 && dest->offsets != NULL) {
- if (source->offsets != NULL && source->labels != 0) {
- memmove(dest->offsets, source->offsets, source->labels);
- } else {
- set_offsets(dest, dest->offsets, NULL);
- }
- }
-
isc_buffer_add(target, dest->length);
}
* Service Discovery Prefixes RFC 6763.
*/
static unsigned char b_dns_sd_udp_data[] = "\001b\007_dns-sd\004_udp";
-static unsigned char b_dns_sd_udp_offsets[] = { 0, 2, 10 };
static unsigned char db_dns_sd_udp_data[] = "\002db\007_dns-sd\004_udp";
-static unsigned char db_dns_sd_udp_offsets[] = { 0, 3, 11 };
static unsigned char r_dns_sd_udp_data[] = "\001r\007_dns-sd\004_udp";
-static unsigned char r_dns_sd_udp_offsets[] = { 0, 2, 10 };
static unsigned char dr_dns_sd_udp_data[] = "\002dr\007_dns-sd\004_udp";
-static unsigned char dr_dns_sd_udp_offsets[] = { 0, 3, 11 };
static unsigned char lb_dns_sd_udp_data[] = "\002lb\007_dns-sd\004_udp";
-static unsigned char lb_dns_sd_udp_offsets[] = { 0, 3, 11 };
static dns_name_t const dns_sd[] = {
- DNS_NAME_INITNONABSOLUTE(b_dns_sd_udp_data, b_dns_sd_udp_offsets),
- DNS_NAME_INITNONABSOLUTE(db_dns_sd_udp_data, db_dns_sd_udp_offsets),
- DNS_NAME_INITNONABSOLUTE(r_dns_sd_udp_data, r_dns_sd_udp_offsets),
- DNS_NAME_INITNONABSOLUTE(dr_dns_sd_udp_data, dr_dns_sd_udp_offsets),
- DNS_NAME_INITNONABSOLUTE(lb_dns_sd_udp_data, lb_dns_sd_udp_offsets)
+ DNS_NAME_INITNONABSOLUTE(b_dns_sd_udp_data, NULL),
+ DNS_NAME_INITNONABSOLUTE(db_dns_sd_udp_data, NULL),
+ DNS_NAME_INITNONABSOLUTE(r_dns_sd_udp_data, NULL),
+ DNS_NAME_INITNONABSOLUTE(dr_dns_sd_udp_data, NULL),
+ DNS_NAME_INITNONABSOLUTE(lb_dns_sd_udp_data, NULL)
};
bool
return false;
}
-static unsigned char inaddr10_offsets[] = { 0, 3, 11, 16 };
-static unsigned char inaddr172_offsets[] = { 0, 3, 7, 15, 20 };
-static unsigned char inaddr192_offsets[] = { 0, 4, 8, 16, 21 };
-
static unsigned char inaddr10[] = "\00210\007IN-ADDR\004ARPA";
static unsigned char inaddr16172[] = "\00216\003172\007IN-ADDR\004ARPA";
static unsigned char inaddr168192[] = "\003168\003192\007IN-ADDR\004ARPA";
static dns_name_t const rfc1918names[] = {
- DNS_NAME_INITABSOLUTE(inaddr10, inaddr10_offsets),
- DNS_NAME_INITABSOLUTE(inaddr16172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr17172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr18172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr19172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr20172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr21172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr22172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr23172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr24172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr25172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr26172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr27172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr28172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr29172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr30172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr31172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr168192, inaddr192_offsets)
+ DNS_NAME_INITABSOLUTE(inaddr10, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr16172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr17172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr18172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr19172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr20172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr21172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr22172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr23172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr24172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr25172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr26172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr27172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr28172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr29172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr30172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr31172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr168192, NULL)
};
bool
return false;
}
-static unsigned char ulaoffsets[] = { 0, 2, 4, 8, 13 };
+static unsigned char
+ __attribute((__unused__)) ulaoffsets[] = { 0, 2, 4, 8, 13 };
static unsigned char ip6fc[] = "\001c\001f\003ip6\004ARPA";
static unsigned char ip6fd[] = "\001d\001f\003ip6\004ARPA";
REQUIRE(DNS_NAME_VALID(name));
- if (name->labels < 1) {
+ if (name->length == 0) {
return false;
}
REQUIRE(DNS_NAME_VALID(name));
- if (name->labels < 1 || name->length < 5) {
+ if (name->length < 5) {
return false;
}
if (len < 2 || ndata[0] != '_') {
return false;
}
- if (isdigit(ndata[1]) && name->labels > 1) {
+ if (isdigit(ndata[1]) && name->length > len + 1) {
char buf[sizeof("65000")];
long port;
char *endp;
bool
dns_name_israd(const dns_name_t *name, const dns_name_t *rad) {
dns_name_t suffix;
- dns_offsets_t offsets;
char labelbuf[64];
unsigned long v, last = ULONG_MAX;
char *end, *l;
REQUIRE(DNS_NAME_VALID(name));
REQUIRE(DNS_NAME_VALID(rad));
- if (name->labels < rad->labels + 4U || name->length < 4U) {
+ uint8_t name_labels = dns_name_countlabels(name);
+ uint8_t rad_labels = dns_name_countlabels(rad);
+
+ if (name_labels < rad_labels + 4U || name->length < 4U) {
return false;
}
return false;
}
- dns_name_init(&suffix, offsets);
- dns_name_split(name, rad->labels + 1, NULL, &suffix);
+ dns_name_init(&suffix, NULL);
+ dns_name_split(name, rad_labels + 1, NULL, &suffix);
if (suffix.ndata[0] != 3 || suffix.ndata[1] != '_' ||
tolower(suffix.ndata[2]) != 'e' || tolower(suffix.ndata[3]) != 'r')
}
/* type list */
- dns_name_split(name, name->labels - 1, NULL, &suffix);
+ dns_name_split(name, name_labels - 1, NULL, &suffix);
INSIST(*suffix.ndata < sizeof(labelbuf));
memmove(labelbuf, suffix.ndata + 1, *suffix.ndata);
labelbuf[*suffix.ndata] = 0;
} while (*end != 0);
/* extended error code */
- dns_name_split(name, rad->labels + 2, NULL, &suffix);
+ dns_name_split(name, rad_labels + 2, NULL, &suffix);
INSIST(*suffix.ndata < sizeof(labelbuf));
memmove(labelbuf, suffix.ndata + 1, *suffix.ndata);
labelbuf[*suffix.ndata] = 0;
return dns_name_issubdomain(name, rad);
}
+
+uint8_t
+dns_name_offsets(const dns_name_t *name, uint8_t *offsets) {
+ REQUIRE(DNS_NAME_VALID(name));
+ return set_offsets(name, offsets, NULL);
+}
isc_mem_attach(mctx, &node->mctx);
isc_refcount_init(&node->references, 1);
- dns_name_dupwithoffsets(name, mctx, &node->name);
+ dns_name_dup(name, mctx, &node->name);
return node;
}
isc_refcount_init(&nta->references, 1);
- dns_name_dupwithoffsets(name, nta->mctx, &nta->name);
+ dns_name_dup(name, nta->mctx, &nta->name);
*target = nta;
}
*/
size_t
dns_qpkey_fromname(dns_qpkey_t key, const dns_name_t *name) {
- size_t len, label;
- dns_fixedname_t fixed;
-
REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
- if (name->labels == 0) {
+ dns_offsets_t offsets;
+ size_t labels = dns_name_offsets(name, offsets);
+
+ if (labels == 0) {
key[0] = SHIFT_NOBYTE;
return 0;
}
- if (name->offsets == NULL) {
- dns_name_t *clone = dns_fixedname_initname(&fixed);
- dns_name_clone(name, clone);
- name = clone;
- }
-
- len = 0;
- label = name->labels;
+ size_t len = 0;
+ size_t label = labels;
while (label-- > 0) {
- const uint8_t *ldata = name->ndata + name->offsets[label];
+ const uint8_t *ldata = name->ndata + offsets[label];
size_t label_len = *ldata++;
while (label_len-- > 0) {
uint16_t bits = dns_qp_bits_for_byte[*ldata++];
void
dns_qpkey_toname(const dns_qpkey_t key, size_t keylen, dns_name_t *name) {
size_t locs[DNS_NAME_MAXLABELS];
- size_t loc = 0, opos = 0;
+ size_t loc = 0;
size_t offset;
REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
REQUIRE(name->buffer != NULL);
- REQUIRE(name->offsets != NULL);
dns_name_reset(name);
* we step backward through the label boundaries, then forward
* through the labels, to create the DNS wire format data.
*/
- name->labels = loc;
while (loc-- > 0) {
uint8_t len = 0, *lenp = NULL;
- /* Add a length byte to the name data and set an offset */
+ /* Store the location of the length byte */
lenp = isc_buffer_used(name->buffer);
+
+ /* Add a length byte to the name data */
isc_buffer_putuint8(name->buffer, 0);
- name->offsets[opos++] = name->length++;
+ name->length++;
/* Convert from escaped byte ranges to ASCII */
for (offset = locs[loc]; offset < locs[loc + 1] - 1; offset++) {
}
name->length += len;
+
+ /* Write the final label length to the length byte */
*lenp = len;
}
if (key[0] == SHIFT_NOBYTE) {
name->attributes.absolute = true;
isc_buffer_putuint8(name->buffer, 0);
- name->offsets[opos++] = name->length++;
- name->labels++;
+ name->length++;
}
name->ndata = isc_buffer_base(name->buffer);
};
isc_mem_attach(qpdb->common.mctx, &newdata->mctx);
- dns_name_dupwithoffsets(name, newdata->mctx, &newdata->name);
+ dns_name_dup(name, newdata->mctx, &newdata->name);
#ifdef DNS_DB_NODETRACE
fprintf(stderr, "new_qpcnode:%s:%s:%d:%p->references = 1\n", __func__,
/*
* Make a copy of the origin name.
*/
- dns_name_dupwithoffsets(origin, mctx, &qpdb->common.origin);
+ dns_name_dup(origin, mctx, &qpdb->common.origin);
/*
* Make the qp tries.
};
isc_mem_attach(qpdb->common.mctx, &newdata->mctx);
- dns_name_dupwithoffsets(name, qpdb->common.mctx, &newdata->name);
+ dns_name_dup(name, qpdb->common.mctx, &newdata->name);
#if DNS_DB_NODETRACE
fprintf(stderr, "new_qpznode:%s:%s:%d:%p->references = 1\n", __func__,
/*
* Make a copy of the origin name.
*/
- dns_name_dupwithoffsets(origin, mctx, &qpdb->common.origin);
+ dns_name_dup(origin, mctx, &qpdb->common.origin);
dns_qpmulti_create(mctx, &qpmethods, qpdb, &qpdb->tree);
dns_qpmulti_create(mctx, &qpmethods, qpdb, &qpdb->nsec);
wildcardmagic(qpzonedb_t *qpdb, dns_qp_t *qp, const dns_name_t *name) {
isc_result_t result;
dns_name_t foundname;
- dns_offsets_t offsets;
unsigned int n;
qpznode_t *node = NULL;
- dns_name_init(&foundname, offsets);
+ dns_name_init(&foundname, NULL);
n = dns_name_countlabels(name);
INSIST(n >= 2);
n--;
static void
addwildcards(qpzonedb_t *qpdb, dns_qp_t *qp, const dns_name_t *name) {
dns_name_t foundname;
- dns_offsets_t offsets;
unsigned int n, l, i;
- dns_name_init(&foundname, offsets);
+ dns_name_init(&foundname, NULL);
n = dns_name_countlabels(name);
l = dns_name_countlabels(&qpdb->common.origin);
i = l + 1;
* Active Directory gc._msdcs.<forest> prefix.
*/
static unsigned char gc_msdcs_data[] = "\002gc\006_msdcs";
-static unsigned char gc_msdcs_offset[] = { 0, 3 };
static dns_name_t const gc_msdcs = DNS_NAME_INITNONABSOLUTE(gc_msdcs_data,
- gc_msdcs_offset);
+ NULL);
/*%
* convert presentation level address to network order binary form.
towire_any_tsig(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
- dns_offsets_t offsets;
REQUIRE(rdata->type == dns_rdatatype_tsig);
REQUIRE(rdata->rdclass == dns_rdataclass_any);
dns_compress_setpermitted(cctx, false);
dns_rdata_toregion(rdata, &sr);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, &sr);
RETERR(dns_name_towire(&name, cctx, target, NULL));
isc_region_consume(&sr, name_length(&name));
static isc_result_t
towire_ch_a(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t sregion;
isc_region_t tregion;
dns_compress_setpermitted(cctx, true);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, &sregion);
isc_region_t tr;
isc_region_t sr;
dns_name_t name;
- dns_offsets_t offsets;
REQUIRE(rdata->type == dns_rdatatype_afsdb);
REQUIRE(rdata->length != 0);
isc_region_consume(&sr, 2);
isc_buffer_add(target, 2);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, &sr);
return dns_name_towire(&name, cctx, target, NULL);
static isc_result_t
additionaldata_afsdb(ARGS_ADDLDATA) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_afsdb);
UNUSED(owner);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
isc_region_consume(®ion, 2);
dns_name_fromregion(&name, ®ion);
static isc_result_t
towire_cname(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_cname);
dns_compress_setpermitted(cctx, true);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
static isc_result_t
towire_dname(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_dname);
REQUIRE(rdata->length != 0);
dns_compress_setpermitted(cctx, false);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
static isc_result_t
additionaldata_lp(ARGS_ADDLDATA) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
isc_result_t result;
UNUSED(owner);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
isc_region_consume(®ion, 2);
dns_name_fromregion(&name, ®ion);
static isc_result_t
towire_mb(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_mb);
dns_compress_setpermitted(cctx, true);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
static isc_result_t
additionaldata_mb(ARGS_ADDLDATA) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_mb);
UNUSED(owner);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
static isc_result_t
towire_md(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_md);
dns_compress_setpermitted(cctx, true);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
static isc_result_t
additionaldata_md(ARGS_ADDLDATA) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_md);
UNUSED(owner);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
static isc_result_t
towire_mf(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_mf);
dns_compress_setpermitted(cctx, true);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
static isc_result_t
additionaldata_mf(ARGS_ADDLDATA) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_mf);
UNUSED(owner);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
static isc_result_t
towire_mg(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_mg);
dns_compress_setpermitted(cctx, true);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
isc_region_t region;
dns_name_t rmail;
dns_name_t email;
- dns_offsets_t roffsets;
- dns_offsets_t eoffsets;
REQUIRE(rdata->type == dns_rdatatype_minfo);
REQUIRE(rdata->length != 0);
dns_compress_setpermitted(cctx, true);
- dns_name_init(&rmail, roffsets);
- dns_name_init(&email, eoffsets);
+ dns_name_init(&rmail, NULL);
+ dns_name_init(&email, NULL);
dns_rdata_toregion(rdata, ®ion);
static isc_result_t
towire_mr(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_mr);
dns_compress_setpermitted(cctx, true);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
static isc_result_t
towire_mx(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_mx);
RETERR(mem_tobuffer(target, region.base, 2));
isc_region_consume(®ion, 2);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, ®ion);
return dns_name_towire(&name, cctx, target, NULL);
mx->mctx = NULL;
}
-static unsigned char port25_offset[] = { 0, 3 };
static unsigned char port25_ndata[] = "\003_25\004_tcp";
-static dns_name_t port25 = DNS_NAME_INITNONABSOLUTE(port25_ndata,
- port25_offset);
+static dns_name_t port25 = DNS_NAME_INITNONABSOLUTE(port25_ndata, NULL);
static isc_result_t
additionaldata_mx(ARGS_ADDLDATA) {
isc_result_t result;
dns_fixedname_t fixed;
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_mx);
UNUSED(owner);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
isc_region_consume(®ion, 2);
dns_name_fromregion(&name, ®ion);
static isc_result_t
towire_naptr(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t sr;
REQUIRE(rdata->type == dns_rdatatype_naptr);
/*
* Replacement.
*/
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, &sr);
return dns_name_towire(&name, cctx, target, NULL);
}
static isc_result_t
additionaldata_naptr(ARGS_ADDLDATA) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t sr;
dns_rdatatype_t atype;
unsigned int i, flagslen;
/*
* Replacement.
*/
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, &sr);
if (atype != 0) {
static isc_result_t
towire_ns(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_ns);
dns_compress_setpermitted(cctx, true);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
static isc_result_t
additionaldata_ns(ARGS_ADDLDATA) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_ns);
UNUSED(owner);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
towire_nsec(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
- dns_offsets_t offsets;
REQUIRE(rdata->type == dns_rdatatype_nsec);
REQUIRE(rdata->length != 0);
dns_compress_setpermitted(cctx, false);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, &sr);
dns_name_fromregion(&name, &sr);
isc_region_consume(&sr, name_length(&name));
towire_nxt(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
- dns_offsets_t offsets;
REQUIRE(rdata->type == dns_rdatatype_nxt);
REQUIRE(rdata->length != 0);
dns_compress_setpermitted(cctx, false);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, &sr);
dns_name_fromregion(&name, &sr);
isc_region_consume(&sr, name_length(&name));
static isc_result_t
towire_ptr(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_ptr);
dns_compress_setpermitted(cctx, true);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
}
static unsigned char ip6_arpa_data[] = "\003IP6\004ARPA";
-static unsigned char ip6_arpa_offsets[] = { 0, 4, 9 };
-static const dns_name_t ip6_arpa = DNS_NAME_INITABSOLUTE(ip6_arpa_data,
- ip6_arpa_offsets);
+static const dns_name_t ip6_arpa = DNS_NAME_INITABSOLUTE(ip6_arpa_data, NULL);
static unsigned char ip6_int_data[] = "\003IP6\003INT";
-static unsigned char ip6_int_offsets[] = { 0, 4, 8 };
-static const dns_name_t ip6_int = DNS_NAME_INITABSOLUTE(ip6_int_data,
- ip6_int_offsets);
+static const dns_name_t ip6_int = DNS_NAME_INITABSOLUTE(ip6_int_data, NULL);
static unsigned char in_addr_arpa_data[] = "\007IN-ADDR\004ARPA";
-static unsigned char in_addr_arpa_offsets[] = { 0, 8, 13 };
-static const dns_name_t in_addr_arpa =
- DNS_NAME_INITABSOLUTE(in_addr_arpa_data, in_addr_arpa_offsets);
+static const dns_name_t in_addr_arpa = DNS_NAME_INITABSOLUTE(in_addr_arpa_data,
+ NULL);
static bool
checknames_ptr(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t rmail;
dns_name_t email;
- dns_offsets_t roffsets;
- dns_offsets_t eoffsets;
REQUIRE(rdata->type == dns_rdatatype_rp);
REQUIRE(rdata->length != 0);
dns_compress_setpermitted(cctx, false);
- dns_name_init(&rmail, roffsets);
- dns_name_init(&email, eoffsets);
+ dns_name_init(&rmail, NULL);
+ dns_name_init(&email, NULL);
dns_rdata_toregion(rdata, ®ion);
towire_rrsig(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
- dns_offsets_t offsets;
REQUIRE(rdata->type == dns_rdatatype_rrsig);
REQUIRE(rdata->length != 0);
/*
* Signer.
*/
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, &sr);
isc_region_consume(&sr, name_length(&name));
RETERR(dns_name_towire(&name, cctx, target, NULL));
static isc_result_t
towire_rt(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
isc_region_t tr;
isc_region_consume(®ion, 2);
isc_buffer_add(target, 2);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, ®ion);
return dns_name_towire(&name, cctx, target, NULL);
static isc_result_t
additionaldata_rt(ARGS_ADDLDATA) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
isc_result_t result;
UNUSED(owner);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
isc_region_consume(®ion, 2);
dns_name_fromregion(&name, ®ion);
towire_sig(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
- dns_offsets_t offsets;
REQUIRE(rdata->type == dns_rdatatype_sig);
REQUIRE(rdata->length != 0);
/*
* Signer.
*/
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, &sr);
isc_region_consume(&sr, name_length(&name));
RETERR(dns_name_towire(&name, cctx, target, NULL));
isc_region_t tregion;
dns_name_t mname;
dns_name_t rname;
- dns_offsets_t moffsets;
- dns_offsets_t roffsets;
REQUIRE(rdata->type == dns_rdatatype_soa);
REQUIRE(rdata->length != 0);
dns_compress_setpermitted(cctx, true);
- dns_name_init(&mname, moffsets);
- dns_name_init(&rname, roffsets);
+ dns_name_init(&mname, NULL);
+ dns_name_init(&rname, NULL);
dns_rdata_toregion(rdata, &sregion);
isc_region_t sregion;
dns_name_t prev;
dns_name_t next;
- dns_offsets_t moffsets;
- dns_offsets_t roffsets;
REQUIRE(rdata->type == dns_rdatatype_talink);
REQUIRE(rdata->length != 0);
dns_compress_setpermitted(cctx, false);
- dns_name_init(&prev, moffsets);
- dns_name_init(&next, roffsets);
+ dns_name_init(&prev, NULL);
+ dns_name_init(&next, NULL);
dns_rdata_toregion(rdata, &sregion);
towire_tkey(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
- dns_offsets_t offsets;
REQUIRE(rdata->type == dns_rdatatype_tkey);
REQUIRE(rdata->length != 0);
* Algorithm.
*/
dns_rdata_toregion(rdata, &sr);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, &sr);
RETERR(dns_name_towire(&name, cctx, target, NULL));
isc_region_consume(&sr, name_length(&name));
towire_in_a6(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
- dns_offsets_t offsets;
unsigned char prefixlen;
unsigned char octets;
return ISC_R_SUCCESS;
}
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, &sr);
return dns_name_towire(&name, cctx, target, NULL);
}
static isc_result_t
towire_in_kx(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_kx);
RETERR(mem_tobuffer(target, region.base, 2));
isc_region_consume(®ion, 2);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, ®ion);
return dns_name_towire(&name, cctx, target, NULL);
static isc_result_t
additionaldata_in_kx(ARGS_ADDLDATA) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_kx);
UNUSED(owner);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
isc_region_consume(®ion, 2);
dns_name_fromregion(&name, ®ion);
static isc_result_t
towire_in_nsap_ptr(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_nsap_ptr);
REQUIRE(rdata->length != 0);
dns_compress_setpermitted(cctx, false);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
static isc_result_t
towire_in_px(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_px);
/*
* MAP822.
*/
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, ®ion);
RETERR(dns_name_towire(&name, cctx, target, NULL));
isc_region_consume(®ion, name_length(&name));
/*
* MAPX400.
*/
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, ®ion);
return dns_name_towire(&name, cctx, target, NULL);
}
static isc_result_t
towire_in_srv(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t sr;
REQUIRE(rdata->type == dns_rdatatype_srv);
/*
* Target.
*/
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, &sr);
return dns_name_towire(&name, cctx, target, NULL);
}
char buf[sizeof("_65000._tcp")];
dns_fixedname_t fixed;
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
uint16_t port;
isc_result_t result;
UNUSED(owner);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
isc_region_consume(®ion, 4);
port = uint16_fromregion(®ion);
static isc_result_t
generic_towire_in_svcb(ARGS_TOWIRE) {
dns_name_t name;
- dns_offsets_t offsets;
isc_region_t region;
REQUIRE(rdata->length != 0);
/*
* TargetName.
*/
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_fromregion(&name, ®ion);
RETERR(dns_name_towire(&name, cctx, target, NULL));
isc_region_consume(®ion, name_length(&name));
bool alias, done = false;
dns_fixedname_t fixed;
dns_name_t name, *fname = NULL;
- dns_offsets_t offsets;
dns_rdataset_t rdataset;
isc_region_t region;
unsigned int cnames = 0;
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
alias = uint16_fromregion(®ion) == 0;
isc_region_consume(®ion, 2);
#endif /* ifdef ENABLE_AFL */
static unsigned char ip6_arpa_data[] = "\003IP6\004ARPA";
-static unsigned char ip6_arpa_offsets[] = { 0, 4, 9 };
-static const dns_name_t ip6_arpa = DNS_NAME_INITABSOLUTE(ip6_arpa_data,
- ip6_arpa_offsets);
+static const dns_name_t ip6_arpa = DNS_NAME_INITABSOLUTE(ip6_arpa_data, NULL);
static void
dns_resolver__destroy(dns_resolver_t *res);
"M.ROOT-SERVERS.NET. 3600000 IN AAAA 2001:DC3::35\n";
static unsigned char b_data[] = "\001b\014root-servers\003net";
-static unsigned char b_offsets[] = { 0, 2, 15, 19 };
static struct upcoming {
const dns_name_t name;
dns_rdatatype_t type;
isc_stdtime_t time;
} upcoming[] = { {
- .name = DNS_NAME_INITABSOLUTE(b_data, b_offsets),
+ .name = DNS_NAME_INITABSOLUTE(b_data, NULL),
.type = dns_rdatatype_a,
.time = 1701086400 /* November 27 2023, 12:00 UTC */
},
{
- .name = DNS_NAME_INITABSOLUTE(b_data, b_offsets),
+ .name = DNS_NAME_INITABSOLUTE(b_data, NULL),
.type = dns_rdatatype_aaaa,
.time = 1701086400 /* November 27 2023, 12:00 UTC */
} };
const dns_name_t *src_name, dns_rpz_cidr_key_t *tgt_ip,
dns_rpz_prefix_t *tgt_prefix, dns_rpz_addr_zbits_t *new_set) {
char ip_str[DNS_NAME_FORMATSIZE];
- dns_offsets_t ip_name_offsets;
dns_fixedname_t ip_name2f;
dns_name_t ip_name;
const char *prefix_str = NULL, *cp = NULL, *end = NULL;
badname(log_level, src_name, "; too short", "");
return ISC_R_FAILURE;
}
- dns_name_init(&ip_name, ip_name_offsets);
+ dns_name_init(&ip_name, NULL);
dns_name_getlabelsequence(src_name, 0, ip_labels, &ip_name);
/*
name2data(dns_rpz_zone_t *rpz, dns_rpz_type_t rpz_type,
const dns_name_t *src_name, dns_name_t *trig_name,
nmdata_t *new_data) {
- dns_offsets_t tmp_name_offsets;
dns_name_t tmp_name;
unsigned int prefix_len, n;
memset(&new_data->wild, 0, sizeof(new_data->wild));
}
- dns_name_init(&tmp_name, tmp_name_offsets);
+ dns_name_init(&tmp_name, NULL);
n = dns_name_countlabels(src_name);
n -= prefix_len;
if (rpz_type == DNS_RPZ_TYPE_QNAME) {
.name = DNS_NAME_INITEMPTY,
.references = ISC_REFCOUNT_INITIALIZER(1),
};
- dns_name_dupwithoffsets(name, mctx, &newdata->name);
+ dns_name_dup(name, mctx, &newdata->name);
isc_mem_attach(mctx, &newdata->mctx);
#ifdef DNS_RPZ_TRACE
key->s.qclass = qclass & 0xff;
}
- if (qname != NULL && qname->labels != 0) {
+ if (qname != NULL && qname->length != 0) {
dns_name_t *origin = NULL;
if (qname->attributes.wildcard && zone != NULL &&
/* initialize and set origin */
dns_name_init(&sdlzdb->common.origin, NULL);
- dns_name_dupwithoffsets(name, mctx, &sdlzdb->common.origin);
+ dns_name_dup(name, mctx, &sdlzdb->common.origin);
isc_refcount_init(&sdlzdb->common.references, 1);
#define BADTIMELEN 6
static unsigned char hmacmd5_ndata[] = "\010hmac-md5\007sig-alg\003reg\003int";
-static unsigned char hmacmd5_offsets[] = { 0, 9, 17, 21, 25 };
-static dns_name_t const hmacmd5 = DNS_NAME_INITABSOLUTE(hmacmd5_ndata,
- hmacmd5_offsets);
+static dns_name_t const hmacmd5 = DNS_NAME_INITABSOLUTE(hmacmd5_ndata, NULL);
const dns_name_t *dns_tsig_hmacmd5_name = &hmacmd5;
static unsigned char gsstsig_ndata[] = "\010gss-tsig";
-static unsigned char gsstsig_offsets[] = { 0, 9 };
-static dns_name_t const gsstsig = DNS_NAME_INITABSOLUTE(gsstsig_ndata,
- gsstsig_offsets);
+static dns_name_t const gsstsig = DNS_NAME_INITABSOLUTE(gsstsig_ndata, NULL);
const dns_name_t *dns_tsig_gssapi_name = &gsstsig;
static unsigned char hmacsha1_ndata[] = "\011hmac-sha1";
-static unsigned char hmacsha1_offsets[] = { 0, 10 };
-static dns_name_t const hmacsha1 = DNS_NAME_INITABSOLUTE(hmacsha1_ndata,
- hmacsha1_offsets);
+static dns_name_t const hmacsha1 = DNS_NAME_INITABSOLUTE(hmacsha1_ndata, NULL);
const dns_name_t *dns_tsig_hmacsha1_name = &hmacsha1;
static unsigned char hmacsha224_ndata[] = "\013hmac-sha224";
-static unsigned char hmacsha224_offsets[] = { 0, 12 };
static dns_name_t const hmacsha224 = DNS_NAME_INITABSOLUTE(hmacsha224_ndata,
- hmacsha224_offsets);
+ NULL);
const dns_name_t *dns_tsig_hmacsha224_name = &hmacsha224;
static unsigned char hmacsha256_ndata[] = "\013hmac-sha256";
-static unsigned char hmacsha256_offsets[] = { 0, 12 };
static dns_name_t const hmacsha256 = DNS_NAME_INITABSOLUTE(hmacsha256_ndata,
- hmacsha256_offsets);
+ NULL);
const dns_name_t *dns_tsig_hmacsha256_name = &hmacsha256;
static unsigned char hmacsha384_ndata[] = "\013hmac-sha384";
-static unsigned char hmacsha384_offsets[] = { 0, 12 };
static dns_name_t const hmacsha384 = DNS_NAME_INITABSOLUTE(hmacsha384_ndata,
- hmacsha384_offsets);
+ NULL);
const dns_name_t *dns_tsig_hmacsha384_name = &hmacsha384;
static unsigned char hmacsha512_ndata[] = "\013hmac-sha512";
-static unsigned char hmacsha512_offsets[] = { 0, 12 };
static dns_name_t const hmacsha512 = DNS_NAME_INITABSOLUTE(hmacsha512_ndata,
- hmacsha512_offsets);
+ NULL);
const dns_name_t *dns_tsig_hmacsha512_name = &hmacsha512;
static const struct {
}
}
-static unsigned char er_offset[] = { 0, 1 };
static unsigned char er_ndata[] = "\001*\003_er";
-static dns_name_t er = DNS_NAME_INITNONABSOLUTE(er_ndata, er_offset);
+static dns_name_t er = DNS_NAME_INITNONABSOLUTE(er_ndata, NULL);
static isc_result_t
check_reportchannel(dns_zone_t *zone, dns_db_t *db) {
static isc_result_t
rpz_get_p_name(ns_client_t *client, dns_name_t *p_name, dns_rpz_zone_t *rpz,
dns_rpz_type_t rpz_type, dns_name_t *trig_name) {
- dns_offsets_t prefix_offsets;
dns_name_t prefix, *suffix;
unsigned int first, labels;
isc_result_t result;
* Start with relative version of the full trigger name,
* and trim enough allow the addition of the suffix.
*/
- dns_name_init(&prefix, prefix_offsets);
+ dns_name_init(&prefix, NULL);
labels = dns_name_countlabels(trig_name);
first = 0;
for (;;) {
return true;
}
-static unsigned char inaddr10_offsets[] = { 0, 3, 11, 16 };
-static unsigned char inaddr172_offsets[] = { 0, 3, 7, 15, 20 };
-static unsigned char inaddr192_offsets[] = { 0, 4, 8, 16, 21 };
-
static unsigned char inaddr10[] = "\00210\007IN-ADDR\004ARPA";
static unsigned char inaddr16172[] = "\00216\003172\007IN-ADDR\004ARPA";
static unsigned char inaddr168192[] = "\003168\003192\007IN-ADDR\004ARPA";
-static dns_name_t rfc1918names[] = {
- DNS_NAME_INITABSOLUTE(inaddr10, inaddr10_offsets),
- DNS_NAME_INITABSOLUTE(inaddr16172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr17172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr18172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr19172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr20172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr21172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr22172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr23172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr24172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr25172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr26172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr27172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr28172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr29172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr30172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr31172, inaddr172_offsets),
- DNS_NAME_INITABSOLUTE(inaddr168192, inaddr192_offsets)
-};
+static dns_name_t rfc1918names[] = { DNS_NAME_INITABSOLUTE(inaddr10, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr16172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr17172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr18172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr19172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr20172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr21172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr22172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr23172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr24172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr25172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr26172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr27172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr28172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr29172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr30172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr31172, NULL),
+ DNS_NAME_INITABSOLUTE(inaddr168192,
+ NULL) };
static unsigned char prisoner_data[] = "\010prisoner\004iana\003org";
static unsigned char hostmaster_data[] = "\012hostmaster\014root-"
"servers\003org";
-static unsigned char prisoner_offsets[] = { 0, 9, 14, 18 };
-static unsigned char hostmaster_offsets[] = { 0, 11, 24, 28 };
-
-static dns_name_t const prisoner = DNS_NAME_INITABSOLUTE(prisoner_data,
- prisoner_offsets);
+static dns_name_t const prisoner = DNS_NAME_INITABSOLUTE(prisoner_data, NULL);
static dns_name_t const hostmaster = DNS_NAME_INITABSOLUTE(hostmaster_data,
- hostmaster_offsets);
+ NULL);
static void
warn_rfc1918(ns_client_t *client, dns_name_t *fname, dns_rdataset_t *rdataset) {
#include <dns/qp.h>
#include <dns/types.h>
+#include "dns/name.h"
#include "qp_p.h"
#include <tests/dns.h>
FILE_CHECK(result == ISC_R_SUCCESS, isc_result_totext(result));
wirebytes += name->length;
- labels += name->labels;
+ labels += dns_name_countlabels(name);
lines++;
}
#include <dns/qp.h>
#include <dns/types.h>
+#include "dns/name.h"
+
#include <tests/dns.h>
#include <tests/qp.h>
return (uint8_t *)(smallname_refcount(pval, ival) + 1);
}
-static inline uint8_t *
-smallname_offsets(void *pval, uint32_t ival) {
- return smallname_ndata(pval, ival) + smallname_length(pval, ival);
-}
-
static void
smallname_from_name(const dns_name_t *name, void **valp, uint32_t *ctxp) {
- size_t size = sizeof(isc_refcount_t) + name->length + name->labels;
+ uint8_t labels = dns_name_countlabels(name);
+ size_t size = sizeof(isc_refcount_t) + name->length + labels;
*valp = isc_mem_get(mctx, size);
- *ctxp = name->labels << 8 | name->length;
+ *ctxp = labels << 8 | name->length;
isc_refcount_init(smallname_refcount(*valp, *ctxp), 0);
memmove(smallname_ndata(*valp, *ctxp), name->ndata, name->length);
- memmove(smallname_offsets(*valp, *ctxp), name->offsets, name->labels);
}
static void
dns_name_reset(name);
name->ndata = smallname_ndata(pval, ival);
name->length = smallname_length(pval, ival);
- name->labels = smallname_labels(pval, ival);
- name->offsets = smallname_offsets(pval, ival);
name->attributes.readonly = true;
- if (name->ndata[name->offsets[name->labels - 1]] == '\0') {
+ if (name->ndata[name->length - 1] == '\0') {
name->attributes.absolute = true;
}
}
}
wirebytes += name->length;
- labels += name->labels;
+ labels += dns_name_countlabels(name);
names += 1;
}
dns_qp_compact(qp, DNS_QPGC_ALL);
#include <dns/qp.h>
#include <dns/types.h>
+#include "dns/name.h"
+
#include <tests/dns.h>
#include <tests/qp.h>
static inline size_t
smallname_length(void *pval, uint32_t ival) {
UNUSED(pval);
- return ival & 0xff;
-}
-
-static inline size_t
-smallname_labels(void *pval, uint32_t ival) {
- UNUSED(pval);
- return ival >> 8;
+ return ival;
}
static inline isc_refcount_t *
return (uint8_t *)(smallname_refcount(pval, ival) + 1);
}
-static inline uint8_t *
-smallname_offsets(void *pval, uint32_t ival) {
- return smallname_ndata(pval, ival) + smallname_length(pval, ival);
-}
-
static void
smallname_from_name(const dns_name_t *name, void **valp, uint32_t *ctxp) {
- size_t size = sizeof(isc_refcount_t) + name->length + name->labels;
+ size_t size = sizeof(isc_refcount_t) + name->length;
*valp = isc_mem_get(mctx, size);
- *ctxp = name->labels << 8 | name->length;
+ *ctxp = name->length;
isc_refcount_init(smallname_refcount(*valp, *ctxp), 0);
memmove(smallname_ndata(*valp, *ctxp), name->ndata, name->length);
- memmove(smallname_offsets(*valp, *ctxp), name->offsets, name->labels);
}
static void
smallname_free(void *pval, uint32_t ival) {
size_t size = sizeof(isc_refcount_t);
- size += smallname_length(pval, ival) + smallname_labels(pval, ival);
+ size += smallname_length(pval, ival);
isc_mem_put(mctx, pval, size);
}
dns_name_reset(name);
name->ndata = smallname_ndata(pval, ival);
name->length = smallname_length(pval, ival);
- name->labels = smallname_labels(pval, ival);
- name->offsets = smallname_offsets(pval, ival);
name->attributes.readonly = true;
- if (name->ndata[name->offsets[name->labels - 1]] == '\0') {
+ if (name->ndata[name->length - 1] == '\0') {
name->attributes.absolute = true;
}
}
#include <tests/dns.h>
unsigned char data_1[] = "\006name_1";
-unsigned char offsets_1[] = { 0, 7 };
-dns_name_t name_1 = DNS_NAME_INITABSOLUTE(data_1, offsets_1);
+dns_name_t name_1 = DNS_NAME_INITABSOLUTE(data_1, NULL);
unsigned char data_2[] = "\006name_2";
-unsigned char offsets_2[] = { 0, 7 };
-dns_name_t name_2 = DNS_NAME_INITABSOLUTE(data_2, offsets_2);
+dns_name_t name_2 = DNS_NAME_INITABSOLUTE(data_2, NULL);
unsigned char data_3[] = "\006name_3";
-unsigned char offsets_3[] = { 0, 7 };
-dns_name_t name_3 = DNS_NAME_INITABSOLUTE(data_3, offsets_3);
+dns_name_t name_3 = DNS_NAME_INITABSOLUTE(data_3, NULL);
unsigned char data_dup[] = "\006name_1";
-unsigned char offsets_dup[] = { 0, 7 };
-dns_name_t name_dup = DNS_NAME_INITABSOLUTE(data_dup, offsets_dup);
+dns_name_t name_dup = DNS_NAME_INITABSOLUTE(data_dup, NULL);
unsigned char data_nodup[] = "\006name_1";
-unsigned char offsets_nodup[] = { 0, 7 };
-dns_name_t name_nodup = DNS_NAME_INITABSOLUTE(data_nodup, offsets_nodup);
+dns_name_t name_nodup = DNS_NAME_INITABSOLUTE(data_nodup, NULL);
static size_t
count_elements(const dns_diff_t *diff) {
relation = dns_name_fullcompare(name1, name1, &order, &nlabels);
assert_int_equal(relation, dns_namereln_equal);
assert_int_equal(order, 0);
- assert_int_equal(nlabels, name1->labels);
+
+ uint8_t labels = dns_name_countlabels(name1);
+ assert_int_equal(nlabels, labels);
/* Some random initializer */
order = 3001;
uint8_t msgbuf[65536];
dns_name_t name;
char namebuf[256];
- uint8_t offsets[128];
dns_compress_init(&cctx, mctx, DNS_COMPRESS_LARGE);
isc_buffer_init(&message, msgbuf, sizeof(msgbuf));
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
/*
* compression offsets are not allowed to be zero so our
static bool
name_attr_zero(struct dns_name_attrs attributes) {
return !(attributes.absolute | attributes.readonly |
- attributes.dynamic | attributes.dynoffsets |
- attributes.nocompress | attributes.cache | attributes.answer |
- attributes.ncache | attributes.chaining | attributes.chase |
- attributes.wildcard | attributes.prerequisite |
- attributes.update | attributes.hasupdaterec);
+ attributes.dynamic | attributes.nocompress | attributes.cache |
+ attributes.answer | attributes.ncache | attributes.chaining |
+ attributes.chase | attributes.wildcard |
+ attributes.prerequisite | attributes.update |
+ attributes.hasupdaterec);
}
/* dns_name_init */
ISC_RUN_TEST_IMPL(init) {
dns_name_t name;
- unsigned char offsets[1];
-
- UNUSED(state);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
assert_null(name.ndata);
assert_int_equal(name.length, 0);
- assert_int_equal(name.labels, 0);
- assert_ptr_equal(name.offsets, offsets);
assert_null(name.buffer);
assert_true(name_attr_zero(name.attributes));
}
/* dns_name_invalidate */
ISC_RUN_TEST_IMPL(invalidate) {
dns_name_t name;
- unsigned char offsets[1];
-
- UNUSED(state);
- dns_name_init(&name, offsets);
+ dns_name_init(&name, NULL);
dns_name_invalidate(&name);
assert_null(name.ndata);
assert_int_equal(name.length, 0);
- assert_int_equal(name.labels, 0);
- assert_null(name.offsets);
assert_null(name.buffer);
assert_true(name_attr_zero(name.attributes));
}
projects / thirdparty / bind9.git / commitdiff
