dns_rdataset_t rdataset;
dns_fixedname_t fname;
dns_name_t *name;
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
dns_rdataset_init(&rdataset);
CHECK(dns_zone_getdb(zone, &db));
isc_buffer_constinit(&buffer, zonename, strlen(zonename));
isc_buffer_add(&buffer, strlen(zonename));
- dns_fixedname_init(&fixorigin);
- origin = dns_fixedname_name(&fixorigin);
+ origin = dns_fixedname_initname(&fixorigin);
CHECK(dns_name_fromtext(origin, &buffer, dns_rootname, 0, NULL));
CHECK(dns_zone_setorigin(zone, origin));
CHECK(dns_zone_setdbtype(zone, 1, (const char * const *) dbtype));
isc_buffer_constinit(&b, text, len);
isc_buffer_add(&b, len);
- dns_fixedname_init(fn);
- n = dns_fixedname_name(fn);
+ n = dns_fixedname_initname(fn);
result = dns_name_fromtext(n, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
dns_name_t *name;
unsigned int options = 0;
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
result = dns_byaddr_createptrname(&addr, options, name);
if (result != ISC_R_SUCCESS)
return (result);
if (ip6_int)
options |= DNS_BYADDROPT_IPV6INT;
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
result = dns_byaddr_createptrname(&addr, options, name);
if (result != ISC_R_SUCCESS)
return (result);
/*
* Check for a absolute name or ndots being met.
*/
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_name_fromstring2(name, oldlookup->textname, NULL,
0, NULL);
if (result == ISC_R_SUCCESS &&
dns_fixedname_t fixed;
dns_name_t *name;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
len = (unsigned int) strlen(textname);
isc_buffer_init(&b, textname, len);
isc_buffer_add(&b, len);
dns_name_t *name;
/* Add AAAA and MX lookups. */
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
dns_name_copy(query->lookup->name, name, NULL);
chase_cnamechain(msg, name);
dns_name_format(name, namestr, sizeof(namestr));
dns_name_t *name;
/* Add AAAA lookup. */
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
dns_name_copy(query->lookup->name, name, NULL);
chase_cnamechain(msg, name);
dns_name_format(name, namestr, sizeof(namestr));
isc_result_t result;
isc_buffer_t buf;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
namestr = setname;
isc_buffer_init(&buf, setname, strlen(setname));
isc_result_t result;
isc_buffer_t buf;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
isc_buffer_init(&buf, setname, strlen(setname));
isc_buffer_add(&buf, strlen(setname));
rdclass = dst_key_class(key);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_name_copy(dst_key_name(key), name, NULL);
if (result != ISC_R_SUCCESS)
fatal("can't copy name");
isc_result_t result;
isc_buffer_t buf;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
isc_buffer_init(&buf, setname, strlen(setname));
isc_buffer_add(&buf, strlen(setname));
rdclass = dst_key_class(key);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_name_copy(dst_key_name(key), name, NULL);
if (result != ISC_R_SUCCESS)
fatal("can't copy name");
if (argc > isc_commandline_index + 1)
fatal("extraneous arguments");
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
isc_buffer_init(&buf, argv[isc_commandline_index],
strlen(argv[isc_commandline_index]));
isc_buffer_add(&buf, strlen(argv[isc_commandline_index]));
if (argc > isc_commandline_index + 1)
fatal("extraneous arguments");
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
isc_buffer_init(&buf, argv[isc_commandline_index],
strlen(argv[isc_commandline_index]));
isc_buffer_add(&buf, strlen(argv[isc_commandline_index]));
isc_result_t result;
char namestr[DNS_NAME_FORMATSIZE];
- dns_fixedname_init(&fixed);
- wild = dns_fixedname_name(&fixed);
+ wild = dns_fixedname_initname(&fixed);
result = dns_name_concatenate(dns_wildcardname, name, wild, NULL);
if (result == ISC_R_NOSPACE)
isc_result_t result;
dns_rdata_t rdata = DNS_RDATA_INIT;
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
dns_rdataset_init(&soaset);
result = dns_db_find(gdb, gorigin, gversion, dns_rdatatype_soa,
0, 0, NULL, name, &soaset, NULL);
dns_name_t *name;
isc_result_t result;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_dbiterator_seek(gdbiter, gorigin);
check_result(result, "dns_dbiterator_seek()");
result = dns_dbiterator_current(gdbiter, &node, name);
fname = isc_mem_get(mctx, sizeof(dns_fixedname_t));
if (fname == NULL)
fatal("out of memory");
- dns_fixedname_init(fname);
- name = dns_fixedname_name(fname);
+ name = dns_fixedname_initname(fname);
node = NULL;
found = ISC_FALSE;
while (!found) {
(zonecut == NULL ||
!dns_name_issubdomain(name, zonecut))) {
if (is_delegation(gdb, gversion, gorigin, name, node, NULL)) {
- dns_fixedname_init(&fzonecut);
- zonecut = dns_fixedname_name(&fzonecut);
+ zonecut = dns_fixedname_initname(&fzonecut);
dns_name_copy(name, zonecut, NULL);
if (!OPTOUT(nsec3flags) ||
secure(name, node))
isc_uint32_t nsttl = 0;
dns_rdataset_init(&rdataset);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
- dns_fixedname_init(&fnextname);
- nextname = dns_fixedname_name(&fnextname);
+ name = dns_fixedname_initname(&fname);
+ nextname = dns_fixedname_initname(&fnextname);
dns_fixedname_init(&fzonecut);
zonecut = NULL;
dns_diff_init(mctx, &add);
dns_diff_init(mctx, &del);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
dns_rdataset_init(&rdataset);
result = dns_db_createiterator(gdb, 0, &dbiter);
unsigned int count, nlabels;
dns_rdataset_init(&rdataset);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
- dns_fixedname_init(&fnextname);
- nextname = dns_fixedname_name(&fnextname);
+ name = dns_fixedname_initname(&fname);
+ nextname = dns_fixedname_initname(&fnextname);
dns_fixedname_init(&fzonecut);
zonecut = NULL;
isc_buffer_init(&b, origin, len);
isc_buffer_add(&b, len);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS)
fatal("failed converting name '%s' to dns format: %s",
* (This assumes all NSEC3 records agree.)
*/
- dns_fixedname_init(&fname);
- hashname = dns_fixedname_name(&fname);
+ hashname = dns_fixedname_initname(&fname);
result = dns_nsec3_hashname(&fname, NULL, NULL,
gorigin, gorigin, dns_hash_sha1,
orig_iter, orig_salt, orig_saltlen);
unsigned int labels;
dns_name_init(&tname, NULL);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
labels = dns_name_countlabels(gorigin);
dns_name_getlabelsequence(gorigin, 0, labels - 1, &tname);
result = dns_name_concatenate(&tname, dlv, name, NULL);
isc_buffer_init(&b, isc_commandline_argument, len);
isc_buffer_add(&b, len);
- dns_fixedname_init(&dlv_fixed);
- dlv = dns_fixedname_name(&dlv_fixed);
+ dlv = dns_fixedname_initname(&dlv_fixed);
result = dns_name_fromtext(dlv, &b, dns_rootname, 0,
NULL);
check_result(result, "dns_name_fromtext(dlv)");
isc_buffer_init(&b, origin, len);
isc_buffer_add(&b, len);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS)
fatal("failed converting name '%s' to dns format: %s",
* present in the DNSKEY RRSET.
*/
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
- dns_fixedname_init(&fnextname);
- nextname = dns_fixedname_name(&fnextname);
+ name = dns_fixedname_initname(&fname);
+ nextname = dns_fixedname_initname(&fnextname);
dns_fixedname_init(&fprevname);
prevname = NULL;
dns_fixedname_init(&fzonecut);
if (result != ISC_R_SUCCESS)
return (result);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
for (element = cfg_list_first(obj);
element != NULL;
element = cfg_list_next(element)) {
isc_result_t result;
isc_buffer_t b;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
for (element = cfg_list_first(mbs);
element != NULL;
element = cfg_list_next(element))
dns_name_t *name;
isc_buffer_t b;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
str = cfg_obj_asstring(cfg_tuple_get(disabled, "name"));
isc_buffer_constinit(&b, str, strlen(str));
isc_buffer_add(&b, strlen(str));
dns_name_t *name;
isc_buffer_t b;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
str = cfg_obj_asstring(cfg_tuple_get(disabled, "name"));
isc_buffer_constinit(&b, str, strlen(str));
isc_buffer_add(&b, strlen(str));
const char *str;
isc_buffer_t b;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
for (element = cfg_list_first(disablelist);
element != NULL;
dns64_dbtype[2] = server;
if (contact != NULL)
dns64_dbtype[3] = contact;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
isc_buffer_constinit(&b, reverse, strlen(reverse));
isc_buffer_add(&b, strlen(reverse));
CHECK(dns_name_fromtext(name, &b, dns_rootname, 0, NULL));
int order;
unsigned int nlabels;
- dns_fixedname_init(&fixed);
- zname = dns_fixedname_name(&fixed);
- dns_fixedname_init(&nsfixed);
- ns = dns_fixedname_name(&nsfixed);
- dns_fixedname_init(&cfixed);
- contact = dns_fixedname_name(&cfixed);
+ zname = dns_fixedname_initname(&fixed);
+ ns = dns_fixedname_initname(&nsfixed);
+ contact = dns_fixedname_initname(&cfixed);
/*
* Look for forward "zones" beneath this empty zone and if so
if (result == ISC_R_SUCCESS) {
dns_name_t *dlv, *iscdlv;
dns_fixedname_t f;
- dns_fixedname_init(&f);
/* Also log a warning if manually configured to dlv.isc.org */
- iscdlv = dns_fixedname_name(&f);
+ iscdlv = dns_fixedname_initname(&f);
CHECK(dns_name_fromstring(iscdlv, "dlv.isc.org", 0, NULL));
for (element = cfg_list_first(obj);
dns_fixedname_t fixed;
dns_name_t *name;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
for (element = cfg_list_first(obj);
element != NULL;
element = cfg_list_next(element))
int empty_dbtypec = 4;
dns_zonestat_level_t statlevel;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
obj = NULL;
result = named_config_get(maps, "empty-server", &obj);
isc_buffer_constinit(&buffer, str, strlen(str));
isc_buffer_add(&buffer, strlen(str));
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
CHECK(dns_name_fromtext(name, &buffer, dns_rootname, 0,
NULL));
}
isc_textregion_consume(&r, m);
}
- dns_fixedname_init(&fixed);
- tatname = dns_fixedname_name(&fixed);
+ tatname = dns_fixedname_initname(&fixed);
result = dns_name_fromstring2(tatname, label, name, 0, NULL);
if (result != ISC_R_SUCCESS) {
return;
result = named_config_get(maps, "session-keyname", &obj);
INSIST(result == ISC_R_SUCCESS);
keynamestr = cfg_obj_asstring(obj);
- dns_fixedname_init(&fname);
isc_buffer_constinit(&buffer, keynamestr, strlen(keynamestr));
isc_buffer_add(&buffer, strlen(keynamestr));
- keyname = dns_fixedname_name(&fname);
+ keyname = dns_fixedname_initname(&fname);
result = dns_name_fromtext(keyname, &buffer, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS)
return (result);
dns_zone_t *raw = NULL;
zname = cfg_obj_asstring(cfg_tuple_get(zconfig, "name"));
- dns_fixedname_init(&fixorigin);
- origin = dns_fixedname_name(&fixorigin);
+ origin = dns_fixedname_initname(&fixorigin);
result2 = dns_name_fromstring(origin, zname, 0, NULL);
if (result2 != ISC_R_SUCCESS) {
/* Normalize zone name */
isc_buffer_constinit(&b, zonename, strlen(zonename));
isc_buffer_add(&b, strlen(zonename));
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
CHECK(dns_name_fromtext(name, &b, dns_rootname,
DNS_NAME_DOWNCASE, NULL));
dns_name_format(name, zname, sizeof(zname));
strlcpy(zonename, redirect ? "." : zonetxt,
DNS_NAME_FORMATSIZE);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
CHECK(dns_name_fromstring(name, zonebuf, 0, NULL));
/* Look for the optional class name. */
strlcpy(target, ptr, DNS_NAME_FORMATSIZE);
isc_buffer_constinit(&b, target, strlen(target));
isc_buffer_add(&b, strlen(target));
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS)
return (result);
dns_tsigkey_t *tkey;
dns_name_init(&foundname, NULL);
- dns_fixedname_init(&fixedorigin);
- origin = dns_fixedname_name(&fixedorigin);
+ origin = dns_fixedname_initname(&fixedorigin);
again:
dns_rbtnodechain_init(&chain, ring->mctx);
viewname = "(global)";
dns_name_init(&foundname, NULL);
- dns_fixedname_init(&fixedorigin);
- origin = dns_fixedname_name(&fixedorigin);
+ origin = dns_fixedname_initname(&fixedorigin);
dns_rbtnodechain_init(&chain, ring->mctx);
result = dns_rbtnodechain_first(&chain, ring->keys, &foundname,
origin);
/* Normalize zone name */
isc_buffer_constinit(&b, origin, strlen(origin));
isc_buffer_add(&b, strlen(origin));
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
CHECK(dns_name_fromtext(name, &b, dns_rootname,
DNS_NAME_DOWNCASE, NULL));
dns_name_format(name, zname, sizeof(zname));
DE_CONST(&zl->value.list, list);
- dns_fixedname_init(&myfixed);
- myname = dns_fixedname_name(&myfixed);
+ myname = dns_fixedname_initname(&myfixed);
for (elt = ISC_LIST_HEAD(*list);
elt != NULL;
isc_buffer_constinit(&buf, zonename, strlen(zonename));
isc_buffer_add(&buf, strlen(zonename));
- dns_fixedname_init(&fname);
- dnsname = dns_fixedname_name(&fname);
+ dnsname = dns_fixedname_initname(&fname);
CHECK(dns_name_fromtext(dnsname, &buf, dns_rootname, 0, NULL));
if (redirect) {
isc_result_t result;
if (strcmp(map_key_for_list, "zone") == 0) {
- dns_fixedname_init(&fixed1);
- dns_fixedname_init(&fixed2);
- name1 = dns_fixedname_name(&fixed1);
- name2 = dns_fixedname_name(&fixed2);
+ name1 = dns_fixedname_initname(&fixed1);
+ name2 = dns_fixedname_initname(&fixed2);
result = dns_name_fromstring(name1, name, 0, NULL);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
dns_rdataset_t next;
dns_rdataset_init(&next);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_db_getsigningtime(db, &next, name);
if (result == ISC_R_SUCCESS) {
UNUSED(force);
- dns_fixedname_init(&fn);
- fname = dns_fixedname_name(&fn);
+ fname = dns_fixedname_initname(&fn);
/* Skip the command name. */
ptr = next_token(lex, text);
n = cfg_obj_asuint32(cfg_tuple_get(obj, "keyid"));
isc_buffer_constinit(&b, s, strlen(s));
isc_buffer_add(&b, strlen(s));
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
RETERR(dns_name_fromtext(name, &b, dns_rootname, 0, NULL));
type = DST_TYPE_PUBLIC|DST_TYPE_PRIVATE|DST_TYPE_KEY;
RETERR(dst_key_fromfile(name, (dns_keytag_t) n, DNS_KEYALG_DH,
s = cfg_obj_asstring(obj);
isc_buffer_constinit(&b, s, strlen(s));
isc_buffer_add(&b, strlen(s));
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
RETERR(dns_name_fromtext(name, &b, dns_rootname, 0, NULL));
tctx->domain = isc_mem_get(mctx, sizeof(dns_name_t));
if (tctx->domain == NULL) {
isc_buffer_constinit(&b, s, strlen(s));
isc_buffer_add(&b, strlen(s));
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
RETERR(dns_name_fromtext(name, &b, dns_rootname, 0, NULL));
RETERR(dst_gssapi_acquirecred(name, ISC_FALSE, &tctx->gsscred));
}
obj = cfg_listelt_value(element);
str = cfg_obj_asstring(obj);
- dns_fixedname_init(&fixed_name);
- nsname = dns_fixedname_name(&fixed_name);
+ nsname = dns_fixedname_initname(&fixed_name);
isc_buffer_constinit(&b, str, strlen(str));
isc_buffer_add(&b, strlen(str));
const dns_name_t *hmacname = NULL;
isc_uint16_t digestbits = 0;
- dns_fixedname_init(&fkeyname);
- mykeyname = dns_fixedname_name(&fkeyname);
+ mykeyname = dns_fixedname_initname(&fkeyname);
debug("Creating key...");
return (STATUS_SYNTAX);
}
- dns_fixedname_init(&fkeyname);
- mykeyname = dns_fixedname_name(&fkeyname);
+ mykeyname = dns_fixedname_initname(&fkeyname);
n = strchr(namestr, ':');
if (n != NULL) {
return (STATUS_SYNTAX);
}
- dns_fixedname_init(&fuserzone);
- userzone = dns_fixedname_name(&fuserzone);
+ userzone = dns_fixedname_initname(&fuserzone);
isc_buffer_init(&b, word, strlen(word));
isc_buffer_add(&b, strlen(word));
result = dns_name_fromtext(userzone, &b, dns_rootname, 0, NULL);
goto failure;
}
- dns_fixedname_init(&fixed);
- bad = dns_fixedname_name(&fixed);
+ bad = dns_fixedname_initname(&fixed);
if (!dns_rdata_checknames(rdata, name, bad)) {
char namebuf[DNS_NAME_FORMATSIZE];
* Save the zone name in case we need to try a second
* address.
*/
- dns_fixedname_init(&fzname);
- zname = dns_fixedname_name(&fzname);
+ zname = dns_fixedname_initname(&fzname);
dns_name_copy(name, zname, NULL);
}
memmove(kserver, &master_servers[master_inuse], sizeof(isc_sockaddr_t));
- dns_fixedname_init(&fname);
- servname = dns_fixedname_name(&fname);
+ servname = dns_fixedname_initname(&fname);
if (realm == NULL)
get_ticket_realm(gmctx);
fatal("dns_name_fromtext(servname) failed: %s",
isc_result_totext(result));
- dns_fixedname_init(&fkname);
- keyname = dns_fixedname_name(&fkname);
+ keyname = dns_fixedname_initname(&fkname);
isc_random_get(&val);
result = isc_string_printf(mykeystr, sizeof(mykeystr), "%u.sig-%s",
fatal("response to GSS-TSIG query was unsuccessful");
- dns_fixedname_init(&fname);
- servname = dns_fixedname_name(&fname);
+ servname = dns_fixedname_initname(&fname);
isc_buffer_init(&buf, servicename, strlen(servicename));
isc_buffer_add(&buf, strlen(servicename));
result = dns_name_fromtext(servname, &buf, dns_rootname, 0, NULL);
dns_fixedname_t fixed;
dns_name_t *name;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_name_fromstring(name, origin, 0, NULL);
if (result != ISC_R_SUCCESS)
len = strlen(origintext);
isc_buffer_init(&source, origintext, len);
isc_buffer_add(&source, len);
- dns_fixedname_init(&forigin);
- origin = dns_fixedname_name(&forigin);
+ origin = dns_fixedname_initname(&forigin);
result = dns_name_fromtext(origin, &source, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
print_result("bad name", result);
dns_name_t *seekname;
isc_buffer_t source;
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
if (dbi->dbiterator == NULL) {
INSIST(dbi->iversion == NULL);
len = strlen(seektext);
isc_buffer_init(&source, seektext, len);
isc_buffer_add(&source, len);
- dns_fixedname_init(&fseekname);
- seekname = dns_fixedname_name(&fseekname);
+ seekname = dns_fixedname_initname(&fseekname);
result = dns_name_fromtext(seekname, &source,
dns_db_origin(
dbi->db),
len = strlen(origintext);
isc_buffer_constinit(&source, origintext, len);
isc_buffer_add(&source, len);
- dns_fixedname_init(&forigin);
- origin = dns_fixedname_name(&forigin);
+ origin = dns_fixedname_initname(&forigin);
result = dns_name_fromtext(origin, &source, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, dbi, sizeof(*dbi));
/*
* Some final initialization...
*/
- dns_fixedname_init(&foundname);
- fname = dns_fixedname_name(&foundname);
+ fname = dns_fixedname_initname(&foundname);
dbi = NULL;
origin = dns_rootname;
version = NULL;
dst_lib_init(mctx, ectx, NULL,
ISC_ENTROPY_BLOCKING|ISC_ENTROPY_GOODONLY);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
isc_buffer_constinit(&b, "test.", 5);
isc_buffer_add(&b, 5);
result = dns_name_fromtext(name, &b, NULL, 0, NULL);
} else
comp = NULL;
- dns_fixedname_init(&wname);
- name = dns_fixedname_name(&wname);
+ name = dns_fixedname_initname(&wname);
dns_fixedname_init(&wname2);
while (fgets(s, sizeof(s), stdin) != NULL) {
len = strlen(s);
if (inplace) {
down = name;
} else {
- dns_fixedname_init(&downname);
- down = dns_fixedname_name(&downname);
+ down = dns_fixedname_initname(&downname);
}
result = dns_name_downcase(name, down, NULL);
INSIST(result == ISC_R_SUCCESS);
labels = dns_name_countlabels(name);
if (want_split && split_label < labels) {
- dns_fixedname_init(&fprefix);
- prefix = dns_fixedname_name(&fprefix);
- dns_fixedname_init(&fsuffix);
- suffix = dns_fixedname_name(&fsuffix);
+ prefix = dns_fixedname_initname(&fprefix);
+ suffix = dns_fixedname_initname(&fsuffix);
printf("splitting at label %u: ", split_label);
dns_name_split(name, split_label, prefix, suffix);
printf("\n prefix = ");
dns_dbiterator_t *dbiter;
char newfilename[1024];
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
- dns_fixedname_init(&fnextname);
- nextname = dns_fixedname_name(&fnextname);
+ name = dns_fixedname_initname(&fname);
+ nextname = dns_fixedname_initname(&fnextname);
origintext = strrchr(filename, '/');
if (origintext == NULL)
dns_rbtnodechain_init(&chain, mctx);
- dns_fixedname_init(&fixedorigin);
- dns_fixedname_init(&fixedfullname);
- dns_fixedname_init(&fixedfoundname);
-
- origin = dns_fixedname_name(&fixedorigin);
- fullname = dns_fixedname_name(&fixedfullname);
- foundname = dns_fixedname_name(&fixedfoundname);
+ origin = dns_fixedname_initname(&fixedorigin);
+ fullname = dns_fixedname_initname(&fixedfullname);
+ foundname = dns_fixedname_initname(&fixedfoundname);
node1 = node2 = NULL;
dns_rbtnodechain_init(&chain, mctx);
dns_name_init(&foundname, NULL);
- dns_fixedname_init(&fixedorigin);
- origin = dns_fixedname_name(&fixedorigin);
+ origin = dns_fixedname_initname(&fixedorigin);
if (forward) {
printf("iterating forward\n" );
printf("searching for name %s ... ",
arg);
- dns_fixedname_init(&fixedname);
foundname =
- dns_fixedname_name(&fixedname);
+ dns_fixedname_initname(&fixedname);
data = NULL;
result = dns_rbt_findname(rbt, name, 0,
inaddr.s_addr = htonl(INADDR_LOOPBACK);
isc_sockaddr_fromin(&address, &inaddr, port);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
isc_buffer_constinit(&b, "child.example.", strlen("child.example."));
isc_buffer_add(&b, strlen("child.example."));
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
goto cleanup;
}
- dns_fixedname_init(&inst->zone1_fn);
- inst->zone1_name = dns_fixedname_name(&inst->zone1_fn);
-
- dns_fixedname_init(&inst->zone2_fn);
- inst->zone2_name = dns_fixedname_name(&inst->zone2_fn);
+ inst->zone1_name = dns_fixedname_initname(&inst->zone1_fn);
+ inst->zone2_name = dns_fixedname_initname(&inst->zone2_fn);
CHECK(parse_params(mctx, argc, argv,
inst->zone1_name, inst->zone2_name));
"isc_log_createchannel()");
CHECK(isc_log_usechannel(logconfig, "stderr", NULL, NULL),
"isc_log_usechannel()");
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
isc_buffer_constinit(&buf, "example.", strlen("example."));
isc_buffer_add(&buf, strlen("example."));
CHECK(dns_name_fromtext(name, &buf, dns_rootname, 0, NULL),
isc_buffer_t b;
dns_decompress_t dctx;
- dns_fixedname_init(&fn);
- name = dns_fixedname_name(&fn);
+ name = dns_fixedname_initname(&fn);
isc_buffer_init(&b, m->query_zone.data, m->query_zone.len);
isc_buffer_add(&b, m->query_zone.len);
if (ip6_int)
options |= DNS_BYADDROPT_IPV6INT;
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
result = dns_byaddr_createptrname(&addr, options, name);
CHECK("dns_byaddr_createptrname2", result);
dns_name_format(name, reverse, (unsigned int)len);
RUNTIME_CHECK(isc_lex_openstream(lex, stdin) == ISC_R_SUCCESS);
if (origin != NULL) {
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_name_fromstring(name, origin, 0, NULL);
if (result != ISC_R_SUCCESS) {
fatal("dns_name_fromstring: %s",
if (iterations > 0xffffU)
fatal("iterations to large");
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
isc_buffer_constinit(&buffer, domain, strlen(domain));
isc_buffer_add(&buffer, strlen(domain));
result = dns_name_fromtext(name, &buffer, dns_rootname, 0, NULL);
/* Name */
- dns_fixedname_init(&tsigkey->fname);
- tsigkey->name = dns_fixedname_name(&tsigkey->fname);
+ tsigkey->name = dns_fixedname_initname(&tsigkey->fname);
result = name_fromstring(tsigkey->name, dns_rootname, name, namelen,
NULL, "TSIG key");
if (result != ISC_R_SUCCESS) {
/* Initialize */
- dns_fixedname_init(&foname);
- oname = dns_fixedname_name(&foname);
+ oname = dns_fixedname_initname(&foname);
/* Parse zone name */
- dns_fixedname_init(&fzname);
- zname = dns_fixedname_name(&fzname);
+ zname = dns_fixedname_initname(&fzname);
result = name_fromstring(zname, dns_rootname,
input.base, strlen(input.base),
NULL, "zone");
isc_buffer_init (&buff, argzone, strlen (argzone));
isc_buffer_add (&buff, strlen (argzone));
- dns_fixedname_init (&fixedzone);
- zone = dns_fixedname_name (&fixedzone);
+ zone = dns_fixedname_initname(&fixedzone);
result = dns_name_fromtext (zone, &buff, dns_rootname, 0, NULL);
isc_result_check (result, "dns_name_fromtext");
result = dns_dbiterator_first (dbit);
isc_result_check (result, "dns_dbiterator_first");
- dns_fixedname_init (&fixedname);
- name = dns_fixedname_name (&fixedname);
+ name = dns_fixedname_initname(&fixedname);
dns_rdataset_init (&rdataset);
dns_rdata_init (&rdata);
isc_buffer_init(&b, porigin, strlen(porigin));
isc_buffer_add(&b, strlen(porigin));
- dns_fixedname_init(&forigin);
- origin = dns_fixedname_name(&forigin);
+ origin = dns_fixedname_initname(&forigin);
result = dns_name_fromtext(origin, &b, dns_rootname, 0, NULL);
check_result(result, "dns_name_fromtext");
result = dns_dbiterator_first(dbiter);
check_result(result, "dns_dbiterator_first");
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
dns_rdataset_init(&rdataset);
dns_rdata_init(&rdata);
isc_buffer_init(&b, porigin, strlen(porigin));
isc_buffer_add(&b, strlen(porigin));
- dns_fixedname_init(&forigin);
- origin = dns_fixedname_name(&forigin);
+ origin = dns_fixedname_initname(&forigin);
result = dns_name_fromtext(origin, &b, dns_rootname, 0, NULL);
check_result(result, "dns_name_fromtext");
result = dns_dbiterator_first(dbiter);
check_result(result, "dns_dbiterator_first");
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
dns_rdataset_init(&rdataset);
dns_rdata_init(&rdata);
dns_fixedname_t fn;
dns_name_t *name;
- dns_fixedname_init(&fn)
- name = dns_fixedname_name(&fn);
+ name = dns_fixedname_initname(&fn);
`name` is now a pointer to a `dns_name` object in which a name can be
stored for the duration of this function; there is no need to initialize,
str = cfg_obj_asstring(obj);
isc_buffer_constinit(&buffer, str, strlen(str));
isc_buffer_add(&buffer, strlen(str));
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
tresult = dns_name_fromtext(name, &buffer, dns_rootname,
0, NULL);
if (tresult != ISC_R_SUCCESS) {
dns_name_t *name;
const cfg_obj_t *obj;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
obj = cfg_tuple_get(disabled, "name");
str = cfg_obj_asstring(obj);
isc_buffer_constinit(&b, str, strlen(str));
dns_name_t *name;
const cfg_obj_t *obj;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
obj = cfg_tuple_get(disabled, "name");
str = cfg_obj_asstring(obj);
isc_buffer_constinit(&b, str, strlen(str));
isc_buffer_t b;
isc_result_t result = ISC_R_SUCCESS;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
obj = cfg_tuple_get(secure, "name");
str = cfg_obj_asstring(obj);
isc_buffer_constinit(&b, str, strlen(str));
}
}
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
/*
* Check the DLV zone name.
const cfg_obj_t *typelist = cfg_tuple_get(stmt, "types");
dns_ssumatchtype_t mtype;
- dns_fixedname_init(&fixed_id);
- dns_fixedname_init(&fixed_name);
- id = dns_fixedname_name(&fixed_id);
- name = dns_fixedname_name(&fixed_name);
+ id = dns_fixedname_initname(&fixed_id);
+ name = dns_fixedname_initname(&fixed_name);
tresult = dns_ssu_mtypefromstring(cfg_obj_asstring(matchtype),
&mtype);
obj = cfg_listelt_value(element);
snamestr = cfg_obj_asstring(obj);
- dns_fixedname_init(&fixed_sname);
isc_buffer_constinit(&b2, snamestr, strlen(snamestr));
isc_buffer_add(&b2, strlen(snamestr));
- sname = dns_fixedname_name(&fixed_sname);
+ sname = dns_fixedname_initname(&fixed_sname);
tresult = dns_name_fromtext(sname, &b2, dns_rootname,
0, NULL);
if (tresult != ISC_R_SUCCESS) {
isc_result_t tresult;
const cfg_listelt_t *element;
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
for (element = cfg_list_first(keys);
element != NULL;
element = cfg_list_next(element))
* Normalize key name.
*/
keyval = cfg_obj_asstring(keys);
- dns_fixedname_init(&fname);
isc_buffer_constinit(&b, keyval, strlen(keyval));
isc_buffer_add(&b, strlen(keyval));
- keyname = dns_fixedname_name(&fname);
+ keyname = dns_fixedname_initname(&fname);
tresult = dns_name_fromtext(keyname, &b, dns_rootname,
0, NULL);
if (tresult != ISC_R_SUCCESS) {
proto = cfg_obj_asuint32(cfg_tuple_get(key, "protocol"));
alg = cfg_obj_asuint32(cfg_tuple_get(key, "algorithm"));
- dns_fixedname_init(&fkeyname);
- keyname = dns_fixedname_name(&fkeyname);
+ keyname = dns_fixedname_initname(&fkeyname);
keynamestr = cfg_obj_asstring(cfg_tuple_get(key, "name"));
isc_buffer_constinit(&b, keynamestr, strlen(keynamestr));
}
result = ISC_R_SUCCESS;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
obj = cfg_tuple_get(rpz_obj, "zone list");
for (element = cfg_list_first(obj);
/*
* Construct the new target name.
*/
- dns_fixedname_init(&fixed1);
- prefix = dns_fixedname_name(&fixed1);
- dns_fixedname_init(&fixed2);
- new_target = dns_fixedname_name(&fixed2);
+ prefix = dns_fixedname_initname(&fixed1);
+ new_target = dns_fixedname_initname(&fixed2);
dns_name_split(name, nlabels, prefix, NULL);
result = dns_name_concatenate(prefix, &dname.dname, new_target,
NULL);
INSIST(DNS_ADB_VALID(adb));
INSIST(rdtype == dns_rdatatype_a || rdtype == dns_rdatatype_aaaa);
- dns_fixedname_init(&foundname);
- fname = dns_fixedname_name(&foundname);
+ fname = dns_fixedname_initname(&foundname);
dns_rdataset_init(&rdataset);
if (rdtype == dns_rdatatype_a)
DP(ENTER_LEVEL,
"fetch_name: starting at zone for name %p",
adbname);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_view_findzonecut(adb->view, &adbname->name, name,
0, 0, ISC_TRUE, ISC_FALSE,
&rdataset, NULL);
*/
(void)dns_db_findnode(db, name, ISC_TRUE, &top);
- dns_fixedname_init(&fnodename);
- nodename = dns_fixedname_name(&fnodename);
+ nodename = dns_fixedname_initname(&fnodename);
result = dns_db_createiterator(db, 0, &iter);
if (result != ISC_R_SUCCESS)
return;
}
- dns_fixedname_init(&fixname);
- name = dns_fixedname_name(&fixname);
+ name = dns_fixedname_initname(&fixname);
/*
* Iterate over database to fill the new zone.
want_restart = ISC_FALSE;
if (event == NULL && !rctx->canceled) {
- dns_fixedname_init(&foundname);
- fname = dns_fixedname_name(&foundname);
+ fname = dns_fixedname_initname(&foundname);
INSIST(!dns_rdataset_isassociated(rctx->rdataset));
INSIST(rctx->sigrdataset == NULL ||
!dns_rdataset_isassociated(rctx->sigrdataset));
/*
* Construct the new query name and start over.
*/
- dns_fixedname_init(&fixed);
- prefix = dns_fixedname_name(&fixed);
+ prefix = dns_fixedname_initname(&fixed);
dns_name_split(name, nlabels, prefix, NULL);
tresult = dns_name_concatenate(prefix, &dname.dname,
name, NULL);
if (!dst_ds_digest_supported(digest_type))
return (ISC_R_NOTIMPLEMENTED);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
(void)dns_name_downcase(owner, name, NULL);
memset(buffer, 0, DNS_DS_BUFFERSIZE);
dns_fixedname_t fixed;
dns_name_t *zonename;
- dns_fixedname_init(&fixed);
- zonename = dns_fixedname_name(&fixed);
+ zonename = dns_fixedname_initname(&fixed);
dns_name_copy(dns_db_origin(db), zonename, NULL);
node = NULL;
send_event = ISC_TRUE;
if (event == NULL && !lookup->canceled) {
- dns_fixedname_init(&foundname);
- fname = dns_fixedname_name(&foundname);
+ fname = dns_fixedname_initname(&foundname);
INSIST(!dns_rdataset_isassociated(&lookup->rdataset));
INSIST(!dns_rdataset_isassociated
(&lookup->sigrdataset));
/*
* Construct the new query name and start over.
*/
- dns_fixedname_init(&fixed);
- prefix = dns_fixedname_name(&fixed);
+ prefix = dns_fixedname_initname(&fixed);
dns_name_split(name, nlabels, prefix, NULL);
result = dns_name_concatenate(prefix, &dname.dname,
name, NULL);
lctx->include_arg = include_arg;
isc_stdtime_get(&lctx->now);
- dns_fixedname_init(&lctx->fixed_top);
- lctx->top = dns_fixedname_name(&lctx->fixed_top);
+ lctx->top = dns_fixedname_initname(&lctx->fixed_top);
dns_name_toregion(top, &r);
dns_name_fromregion(lctx->top, &r);
ictx = lctx->inc;
callbacks = lctx->callbacks;
- dns_fixedname_init(&ownerfixed);
- owner = dns_fixedname_name(&ownerfixed);
+ owner = dns_fixedname_initname(&ownerfixed);
ISC_LIST_INIT(head);
target_mem = isc_mem_get(lctx->mctx, target_size);
if (!ictx->in_use[new_in_use])
break;
INSIST(new_in_use < NBUFS);
- dns_fixedname_init(&ictx->fixed[new_in_use]);
- new_name = dns_fixedname_name(&ictx->fixed[new_in_use]);
+ new_name =
+ dns_fixedname_initname(&ictx->fixed[new_in_use]);
isc_buffer_init(&buffer, token.value.as_region.base,
token.value.as_region.length);
isc_buffer_add(&buffer, token.value.as_region.length);
}
isc_buffer_init(&target, target_mem, target_size);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
/*
* In the following loop, we regard any error fatal regardless of
current_ttl_valid = ctx->current_ttl_valid;
if (owner_name != NULL) {
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
dns_name_copy(owner_name, name, NULL);
dns_rdataset_getownercase(rdataset, name);
}
isc_buffer_init(&buffer, bufmem, initial_buffer_length);
- dns_fixedname_init(&fixname);
- name = dns_fixedname_name(&fixname);
+ name = dns_fixedname_initname(&fixname);
if (dctx->first) {
CHECK(writeheader(dctx));
if (BINDABLE(target) && target->buffer != NULL)
name = target;
else {
- dns_fixedname_init(&fn);
- name = dns_fixedname_name(&fn);
+ name = dns_fixedname_initname(&fn);
}
result = dns_name_fromtext(name, &buf, origin, options, NULL);
memset(rethash, 0, NSEC3_MAX_HASH_LENGTH);
- dns_fixedname_init(&fixed);
- downcased = dns_fixedname_name(&fixed);
+ downcased = dns_fixedname_initname(&fixed);
dns_name_downcase(name, downcased, NULL);
/* hash the node name */
unsigned int old_length;
unsigned int salt_length;
- dns_fixedname_init(&fixed);
- hashname = dns_fixedname_name(&fixed);
- dns_fixedname_init(&fprev);
- prev = dns_fixedname_name(&fprev);
+ hashname = dns_fixedname_initname(&fixed);
+ prev = dns_fixedname_initname(&fprev);
dns_rdataset_init(&rdataset);
size_t next_length;
unsigned int salt_length;
- dns_fixedname_init(&fixed);
- hashname = dns_fixedname_name(&fixed);
- dns_fixedname_init(&fprev);
- prev = dns_fixedname_name(&fprev);
+ hashname = dns_fixedname_initname(&fixed);
+ prev = dns_fixedname_initname(&fprev);
dns_rdataset_init(&rdataset);
(*logit)(arg, ISC_LOG_DEBUG(3), "looking for relevant NSEC3");
- dns_fixedname_init(&fzone);
- zone = dns_fixedname_name(&fzone);
+ zone = dns_fixedname_initname(&fzone);
zlabels = dns_name_countlabels(nsec3name);
/*
/*
* Prepare to compute all the hashes.
*/
- dns_fixedname_init(&qfixed);
- qname = dns_fixedname_name(&qfixed);
+ qname = dns_fixedname_initname(&qfixed);
dns_name_downcase(name, qname, NULL);
qlabels = dns_name_countlabels(qname);
first = ISC_TRUE;
return (result);
}
- dns_fixedname_init(&nta->fn);
- nta->name = dns_fixedname_name(&nta->fn);
+ nta->name = dns_fixedname_initname(&nta->fn);
dns_name_copy(name, nta->name, NULL);
nta->magic = NTA_MAGIC;
if (ntatable == NULL)
return (ISC_FALSE);
- dns_fixedname_init(&fn);
- foundname = dns_fixedname_name(&fn);
+ foundname = dns_fixedname_initname(&fn);
relock:
RWLOCK(&ntatable->rwlock, locktype);
dns_name_t *name;
isc_time_t t;
- dns_fixedname_init(&fn);
- name = dns_fixedname_name(&fn);
+ name = dns_fixedname_initname(&fn);
dns_rbt_fullnamefromnode(node, name);
dns_name_format(name, nbuf, sizeof(nbuf));
isc_time_set(&t, n->expiry, 0);
dns_name_t *name;
isc_time_t t;
- dns_fixedname_init(&fn);
- name = dns_fixedname_name(&fn);
+ name = dns_fixedname_initname(&fn);
dns_rbt_fullnamefromnode(node, name);
dns_name_format(name, nbuf, sizeof(nbuf));
isc_time_set(&t, n->expiry, 0);
dns_fixedname_t fn;
dns_name_t *name;
- dns_fixedname_init(&fn);
- name = dns_fixedname_name(&fn);
+ name = dns_fixedname_initname(&fn);
dns_rbt_fullnamefromnode(node, name);
isc_buffer_init(&b, nbuf, sizeof(nbuf));
CONFIRM(dns_name_isvalid(fullname));
if (!dns_name_isabsolute(&nodename)) {
- dns_fixedname_init(&fixed);
- fullname = dns_fixedname_name(&fixed);
+ fullname = dns_fixedname_initname(&fixed);
CHECK(dns_name_concatenate(&nodename, name, fullname, NULL));
}
* Create a copy of the name so the original name structure is
* not modified.
*/
- dns_fixedname_init(&fixedcopy);
- add_name = dns_fixedname_name(&fixedcopy);
+ add_name = dns_fixedname_initname(&fixedcopy);
dns_name_clone(name, add_name);
if (ISC_UNLIKELY(rbt->root == NULL)) {
level_count = 0;
- dns_fixedname_init(&fixedprefix);
- dns_fixedname_init(&fixedsuffix);
- prefix = dns_fixedname_name(&fixedprefix);
- suffix = dns_fixedname_name(&fixedsuffix);
+ prefix = dns_fixedname_initname(&fixedprefix);
+ suffix = dns_fixedname_initname(&fixedsuffix);
root = &rbt->root;
INSIST(IS_ROOT(*root));
current = NULL;
child = *root;
dns_name_init(¤t_name, current_offsets);
- dns_fixedname_init(&fnewname);
- new_name = dns_fixedname_name(&fnewname);
+ new_name = dns_fixedname_initname(&fnewname);
nlabels = dns_name_countlabels(name);
hlabels = 0;
last_compared = NULL;
order = 0;
- dns_fixedname_init(&fixedcallbackname);
- callback_name = dns_fixedname_name(&fixedcallbackname);
+ callback_name = dns_fixedname_initname(&fixedcallbackname);
/*
* search_name is the name segment being sought in each tree level.
* By using dns_name_clone, no name data should be copied thanks to
* the lack of bitstring labels.
*/
- dns_fixedname_init(&fixedsearchname);
- search_name = dns_fixedname_name(&fixedsearchname);
+ search_name = dns_fixedname_initname(&fixedsearchname);
dns_name_clone(name, search_name);
dns_name_init(¤t_name, NULL);
REQUIRE(DNS_RBTNODE_VALID(node));
REQUIRE(printname != NULL);
- dns_fixedname_init(&fixedname);
- name = dns_fixedname_name(&fixedname);
+ name = dns_fixedname_initname(&fixedname);
result = dns_rbt_fullnamefromnode(node, name);
if (result == ISC_R_SUCCESS)
dns_name_format(name, printname, size);
* Though this may be wasteful, it has to be done before
* node is deleted.
*/
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
dns_rbt_fullnamefromnode(node, name);
result = dns_rbt_deletenode(rbtdb->tree, node, ISC_FALSE);
break;
case DNS_RBT_NSEC_HAS_NSEC:
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
dns_rbt_fullnamefromnode(node, name);
/*
* Delete the corresponding node from the auxiliary NSEC
rbtdb = search->rbtdb;
dns_name_init(&prefix, NULL);
- dns_fixedname_init(&fnext);
- next = dns_fixedname_name(&fnext);
- dns_fixedname_init(&forigin);
- origin = dns_fixedname_name(&forigin);
+ next = dns_fixedname_initname(&fnext);
+ origin = dns_fixedname_initname(&forigin);
result = dns_rbtnodechain_next(chain, NULL, NULL);
while (result == ISC_R_SUCCESS || result == DNS_R_NEWORIGIN) {
dns_name_init(&name, NULL);
dns_name_init(&tname, NULL);
dns_name_init(&rname, NULL);
- dns_fixedname_init(&fnext);
- next = dns_fixedname_name(&fnext);
- dns_fixedname_init(&fprev);
- prev = dns_fixedname_name(&fprev);
- dns_fixedname_init(&forigin);
- origin = dns_fixedname_name(&forigin);
+ next = dns_fixedname_initname(&fnext);
+ prev = dns_fixedname_initname(&fprev);
+ origin = dns_fixedname_initname(&forigin);
/*
* Find if qname is at or below a empty node.
*/
dns_name_init(&name, NULL);
dns_rbt_namefromnode(node, &name);
- dns_fixedname_init(&fwname);
- wname = dns_fixedname_name(&fwname);
+ wname = dns_fixedname_initname(&fwname);
result = dns_name_concatenate(dns_wildcardname, &name,
wname, NULL);
j = i;
return (result);
}
- dns_fixedname_init(&ftarget);
- target = dns_fixedname_name(&ftarget);
+ target = dns_fixedname_initname(&ftarget);
for (;;) {
if (*firstp) {
* Use the auxiliary tree only starting with the second node in the
* hope that the original node will be right much of the time.
*/
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
- dns_fixedname_init(&forigin);
- origin = dns_fixedname_name(&forigin);
+ name = dns_fixedname_initname(&fname);
+ origin = dns_fixedname_initname(&forigin);
again:
node = NULL;
prevnode = NULL;
do {
node = NULL;
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
- dns_fixedname_init(&forigin);
- origin = dns_fixedname_name(&forigin);
+ name = dns_fixedname_initname(&fname);
+ origin = dns_fixedname_initname(&forigin);
result = dns_rbtnodechain_current(&chain, name, origin, &node);
if (result != ISC_R_SUCCESS)
return (result);
if (result != ISC_R_SUCCESS)
return (result);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
dns_rbt_fullnamefromnode(node, name);
RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
ctx = (rbtdb_glue_additionaldata_ctx_t *) arg;
- dns_fixedname_init(&fixedname_a);
- name_a = dns_fixedname_name(&fixedname_a);
+ name_a = dns_fixedname_initname(&fixedname_a);
dns_rdataset_init(&rdataset_a);
dns_rdataset_init(&sigrdataset_a);
- dns_fixedname_init(&fixedname_aaaa);
- name_aaaa = dns_fixedname_name(&fixedname_aaaa);
+ name_aaaa = dns_fixedname_initname(&fixedname_aaaa);
dns_rdataset_init(&rdataset_aaaa);
dns_rdataset_init(&sigrdataset_aaaa);
goto out;
}
- dns_fixedname_init(&glue->fixedname);
- gluename = dns_fixedname_name(&glue->fixedname);
+ gluename = dns_fixedname_initname(&glue->fixedname);
dns_name_copy(name_a, gluename, NULL);
dns_rdataset_init(&glue->rdataset_a);
goto out;
}
- dns_fixedname_init(&glue->fixedname);
- gluename = dns_fixedname_name(&glue->fixedname);
+ gluename = dns_fixedname_initname(&glue->fixedname);
dns_name_copy(name_aaaa, gluename, NULL);
dns_rdataset_init(&glue->rdataset_a);
i = 0;
added = 0;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
dns_name_copy(owner_name, name, NULL);
dns_rdataset_getownercase(rdataset, name);
offset = 0xffff;
counter->logged = 0;
counter->allowed = 1;
counter->dropped = 0;
- dns_fixedname_init(&counter->fdname);
- counter->domain = dns_fixedname_name(&counter->fdname);
+ counter->domain =
+ dns_fixedname_initname(&counter->fdname);
dns_name_copy(&fctx->domain, counter->domain, NULL);
ISC_LIST_APPEND(dbucket->list, counter, link);
}
name = &suffix;
}
- dns_fixedname_init(&fixed);
- domain = dns_fixedname_name(&fixed);
+ domain = dns_fixedname_initname(&fixed);
result = dns_fwdtable_find(res->view->fwdtable, name,
domain, &forwarders);
if (result == ISC_R_SUCCESS) {
}
/* Find the forwarder for this name. */
- dns_fixedname_init(&fixed);
- fname = dns_fixedname_name(&fixed);
+ fname = dns_fixedname_initname(&fixed);
result = dns_fwdtable_find(fctx->res->view->fwdtable, fwdname,
fname, &forwarders);
if (result == ISC_R_SUCCESS)
* destroy the fctx if necessary. Save the wildcard name.
*/
if (vevent->proofs[DNS_VALIDATOR_NOQNAMEPROOF] != NULL) {
- dns_fixedname_init(&fwild);
- wild = dns_fixedname_name(&fwild);
+ wild = dns_fixedname_initname(&fwild);
dns_name_copy(dns_fixedname_name(&vevent->validator->wild),
wild, NULL);
}
if (result != ISC_R_SUCCESS)
return (result);
- dns_fixedname_init(&fzonename);
- zonename = dns_fixedname_name(&fzonename);
- dns_fixedname_init(&fclosest);
- closest = dns_fixedname_name(&fclosest);
- dns_fixedname_init(&fnearest);
- nearest = dns_fixedname_name(&fnearest);
+ zonename = dns_fixedname_initname(&fzonename);
+ closest = dns_fixedname_initname(&fclosest);
+ nearest = dns_fixedname_initname(&fnearest);
#define NXND(x) ((x) == ISC_R_SUCCESS)
result = dns_rdata_tostruct(&rdata, &dname, NULL);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
dns_name_init(&prefix, NULL);
- dns_fixedname_init(&fixed);
- tname = dns_fixedname_name(&fixed);
+ tname = dns_fixedname_initname(&fixed);
nlabels = dns_name_countlabels(qname) -
dns_name_countlabels(rname);
dns_name_split(qname, nlabels, &prefix, NULL);
/*
* Retrieve state from fctx->nsfetch before we destroy it.
*/
- dns_fixedname_init(&fixed);
- domain = dns_fixedname_name(&fixed);
+ domain = dns_fixedname_initname(&fixed);
dns_name_copy(&fctx->nsfetch->private->domain, domain, NULL);
if (dns_name_equal(&fctx->nsname, domain)) {
if (dns_rdataset_isassociated(fevent->rdataset)) {
dns_name_t *name, *fname;
unsigned int findoptions = 0;
- dns_fixedname_init(&foundname);
- fname = dns_fixedname_name(&foundname);
+ fname = dns_fixedname_initname(&foundname);
if (result != ISC_R_SUCCESS) {
fctx_done(fctx, DNS_R_SERVFAIL, __LINE__);
isc_stdtime_get(&now);
- dns_fixedname_init(&fixname);
- name = dns_fixedname_name(&fixname);
+ name = dns_fixedname_initname(&fixname);
dns_rdataset_init(&rootns);
(void)dns_db_find(db, dns_rootname, NULL, dns_rdatatype_ns, 0,
dns_rdataset_init(&hintrrset);
dns_rdataset_init(&rootrrset);
- dns_fixedname_init(&fixed);
- foundname = dns_fixedname_name(&fixed);
+ foundname = dns_fixedname_initname(&fixed);
hresult = dns_db_find(hints, name, NULL, dns_rdatatype_a, 0,
now, NULL, foundname, &hintrrset, NULL);
dns_rdataset_init(&hintns);
dns_rdataset_init(&rootns);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_db_find(hints, dns_rootname, NULL, dns_rdatatype_ns, 0,
now, NULL, name, &hintns, NULL);
dns_fixedname_t tgt_namef;
dns_name_t *tgt_name;
- dns_fixedname_init(&tgt_namef);
- tgt_name = dns_fixedname_name(&tgt_namef);
+ tgt_name = dns_fixedname_initname(&tgt_namef);
dns_name_fromstring(tgt_name, tgt, DNS_NAME_DOWNCASE, NULL);
if (dns_name_equal(src_name, tgt_name)) {
isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
* Convert the address back to a canonical domain name
* to ensure that the original name is in canonical form.
*/
- dns_fixedname_init(&ip_name2f);
- ip_name2 = dns_fixedname_name(&ip_name2f);
+ ip_name2 = dns_fixedname_initname(&ip_name2f);
result = ip2name(tgt_ip, (dns_rpz_prefix_t)prefix_num,
NULL, ip_name2);
if (result != ISC_R_SUCCESS ||
* because wildcard triggers are handled differently.
*/
- dns_fixedname_init(&trig_namef);
- trig_name = dns_fixedname_name(&trig_namef);
+ trig_name = dns_fixedname_initname(&trig_namef);
name2data(rpzs, rpz_num, rpz_type, src_name, trig_name, &new_data);
result = add_nm(rpzs, trig_name, &new_data);
goto cleanup;
}
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
for (result = isc_ht_iter_first(iter);
result == ISC_R_SUCCESS;
REQUIRE(rpz->updbit != NULL);
REQUIRE(rpz->newnodes != NULL);
- dns_fixedname_init(&fixname);
- name = dns_fixedname_name(&fixname);
+ name = dns_fixedname_initname(&fixname);
dns_name_format(&rpz->origin, domain, DNS_NAME_FORMATSIZE);
* because wildcard triggers are handled differently.
*/
- dns_fixedname_init(&trig_namef);
- trig_name = dns_fixedname_name(&trig_namef);
+ trig_name = dns_fixedname_initname(&trig_namef);
name2data(rpzs, rpz_num, rpz_type, src_name, trig_name, &del_data);
nmnode = NULL;
isc_buffer_t b;
isc_result_t result;
- dns_fixedname_init(&fnewname);
- newname = dns_fixedname_name(&fnewname);
+ newname = dns_fixedname_initname(&fnewname);
if ((imp->flags & DNS_SDBFLAG_RELATIVERDATA) != 0)
origin = &sdb->common.origin;
olabels = dns_name_countlabels(&db->origin);
nlabels = dns_name_countlabels(name);
- dns_fixedname_init(&fname);
- xname = dns_fixedname_name(&fname);
+ xname = dns_fixedname_initname(&fname);
if (rdataset == NULL) {
dns_rdataset_init(&xrdataset);
olabels = dns_name_countlabels(&db->origin);
nlabels = dns_name_countlabels(name);
- dns_fixedname_init(&fname);
- xname = dns_fixedname_name(&fname);
+ xname = dns_fixedname_initname(&fname);
if (rdataset == NULL) {
dns_rdataset_init(&xrdataset);
isc_buffer_t b;
isc_result_t result;
- dns_fixedname_init(&fnewname);
- newname = dns_fixedname_name(&fnewname);
+ newname = dns_fixedname_initname(&fnewname);
if ((sdlz->dlzimp->flags & DNS_SDLZFLAG_RELATIVERDATA) != 0)
origin = &sdlz->common.origin;
continue;
break;
case dns_ssumatchtype_selfwild:
- dns_fixedname_init(&fixed);
- wildcard = dns_fixedname_name(&fixed);
+ wildcard = dns_fixedname_initname(&fixed);
result = dns_name_concatenate(dns_wildcardname, signer,
wildcard, NULL);
if (result != ISC_R_SUCCESS)
continue;
break;
case dns_ssumatchtype_tcpself:
- dns_fixedname_init(&fixed);
- tcpself = dns_fixedname_name(&fixed);
+ tcpself = dns_fixedname_initname(&fixed);
reverse_from_address(tcpself, addr);
if (dns_name_iswildcard(rule->identity)) {
if (!dns_name_matcheswildcard(tcpself,
continue;
break;
case dns_ssumatchtype_6to4self:
- dns_fixedname_init(&fixed);
- stfself = dns_fixedname_name(&fixed);
+ stfself = dns_fixedname_initname(&fixed);
stf_from_address(stfself, addr);
if (dns_name_iswildcard(rule->identity)) {
if (!dns_name_matcheswildcard(stfself,
dns_rdataclass_in, 0, NULL, &db);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
- dns_fixedname_init(&example_fixed);
- example = dns_fixedname_name(&example_fixed);
-
- dns_fixedname_init(&found_fixed);
- found = dns_fixedname_name(&found_fixed);
+ example = dns_fixedname_initname(&example_fixed);
+ found = dns_fixedname_initname(&found_fixed);
result = dns_name_fromstring(example, "example", 0, NULL);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
dns_db_currentversion(db, &ver);
dns_test_namefromstring("b.test.test", &fname);
name = dns_fixedname_name(&fname);
- dns_fixedname_init(&ffound);
- foundname = dns_fixedname_name(&ffound);
+ foundname = dns_fixedname_initname(&ffound);
dns_rdataset_init(&rdataset);
result = dns_db_find(db, name , ver, dns_rdatatype_a, 0, 0, &node,
foundname, &rdataset, NULL);
dns_db_currentversion(db, &ver);
dns_test_namefromstring("b.test.test", &fname);
name = dns_fixedname_name(&fname);
- dns_fixedname_init(&ffound);
- foundname = dns_fixedname_name(&ffound);
+ foundname = dns_fixedname_initname(&ffound);
dns_rdataset_init(&rdataset);
result = dns_db_find(db, name , ver, dns_rdatatype_a, 0, 0, &node,
foundname, &rdataset, NULL);
UNUSED(tc);
- dns_fixedname_init(&f);
- name = dns_fixedname_name(&f);
+ name = dns_fixedname_initname(&f);
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
UNUSED(tc);
- dns_fixedname_init(&f);
- name = dns_fixedname_name(&f);
+ name = dns_fixedname_initname(&f);
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
UNUSED(tc);
- dns_fixedname_init(&f1);
- name = dns_fixedname_name(&f1);
- dns_fixedname_init(&f2);
- seekname = dns_fixedname_name(&f2);
+ name = dns_fixedname_initname(&f1);
+ seekname = dns_fixedname_initname(&f2);
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
UNUSED(tc);
- dns_fixedname_init(&f1);
- seekname = dns_fixedname_name(&f1);
+ seekname = dns_fixedname_initname(&f1);
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
UNUSED(tc);
- dns_fixedname_init(&f1);
- seekname = dns_fixedname_name(&f1);
+ seekname = dns_fixedname_initname(&f1);
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
ret = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(ret, ISC_R_SUCCESS);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
isc_buffer_constinit(&buf, "dh.", 3);
isc_buffer_add(&buf, 3);
ret = dns_name_fromtext(name, &buf, NULL, 0, NULL);
/*
* Set up some test data
*/
- dns_fixedname_init(&zfname);
- zname = dns_fixedname_name(&zfname);
+ zname = dns_fixedname_initname(&zfname);
isc_buffer_constinit(&zb, "example.com.", 12);
isc_buffer_add(&zb, 12);
result = dns_name_fromtext(zname, &zb, NULL, 0, NULL);
isc_buffer_constinit(&buffer, name, strlen(name));
isc_buffer_add(&buffer, strlen(name));
- dns_fixedname_init(&fixorigin);
- origin = dns_fixedname_name(&fixorigin);
+ origin = dns_fixedname_initname(&fixorigin);
CHECK(dns_name_fromtext(origin, &buffer, dns_rootname, 0, NULL));
CHECK(dns_zone_setorigin(zone, origin));
dns_zone_setview(zone, view);
dns_fixedname_t fixed;
dns_name_t *name;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_name_fromstring(name, origin, 0, NULL);
if (result != ISC_R_SUCCESS)
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_buffer_putmem(b, (const unsigned char *) namestr, length);
- dns_fixedname_init(fname);
- name = dns_fixedname_name(fname);
+ name = dns_fixedname_initname(fname);
ATF_REQUIRE(name != NULL);
result = dns_name_fromtext(name, b, dns_rootname, 0, NULL);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
/*
* Read key from file in a form usable by dst_verify.
*/
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
isc_buffer_constinit(&b, keyname, strlen(keyname));
isc_buffer_add(&b, strlen(keyname));
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
static isc_buffer_t namebuf;
void *deconst_namestr;
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
DE_CONST(namestr, deconst_namestr); /* OK, since we don't modify it */
isc_buffer_init(&namebuf, deconst_namestr, strlen(deconst_namestr));
isc_buffer_add(&namebuf, strlen(namestr));
* dns_keytable_finddeepestmatch() allows partial match. Also match
* nodes with a null key.
*/
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
ATF_REQUIRE_EQ(dns_keytable_finddeepestmatch(keytable,
str2name("example.com"),
name), ISC_R_SUCCESS);
UNUSED(tc);
- dns_fixedname_init(&fixed1);
- name1 = dns_fixedname_name(&fixed1);
- dns_fixedname_init(&fixed2);
- name2 = dns_fixedname_name(&fixed2);
+ name1 = dns_fixedname_initname(&fixed1);
+ name2 = dns_fixedname_initname(&fixed2);
for (i = 0; data[i].name1 != NULL; i++) {
int order = 3000;
unsigned int nlabels = 3000;
{ "_ta-1234-abcf-EcD89.example", ISC_FALSE }
};
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
for (i = 0; i < sizeof(data)/sizeof(data[0]); i++) {
result = dns_name_fromstring(name, data[i].name, 0, NULL);
dns_name_t *n1, *n2;
unsigned int h1, h2;
- dns_fixedname_init(&f1);
- n1 = dns_fixedname_name(&f1);
- dns_fixedname_init(&f2);
- n2 = dns_fixedname_name(&f2);
+ n1 = dns_fixedname_initname(&f1);
+ n2 = dns_fixedname_initname(&f2);
result = dns_name_fromstring2(n1, testcases[i].name1,
NULL, 0, NULL);
dns_fixedname_t f1, f2;
dns_name_t *n1, *n2;
- dns_fixedname_init(&f1);
- n1 = dns_fixedname_name(&f1);
- dns_fixedname_init(&f2);
- n2 = dns_fixedname_name(&f2);
+ n1 = dns_fixedname_initname(&f1);
+ n2 = dns_fixedname_initname(&f2);
result = dns_name_fromstring2(n1, testcases[i].name1,
NULL, 0, NULL);
dns_fixedname_t fname;
dns_name_t *name;
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
result = dns_name_fromstring2(name, testcases[i].namestr,
NULL, 0, NULL);
unsigned char *p1, *p2;
unsigned int j;
- dns_fixedname_init(&f1);
- n1 = dns_fixedname_name(&f1);
- dns_fixedname_init(&f2);
- n2 = dns_fixedname_name(&f2);
+ n1 = dns_fixedname_initname(&f1);
+ n2 = dns_fixedname_initname(&f2);
result = dns_name_fromstring2(n1, testcases[i].name1,
NULL, 0, NULL);
dns_name_init(&t2, NULL);
/* source names */
- dns_fixedname_init(&f1);
- n1 = dns_fixedname_name(&f1);
- dns_fixedname_init(&f2);
- n2 = dns_fixedname_name(&f2);
+ n1 = dns_fixedname_initname(&f1);
+ n2 = dns_fixedname_initname(&f2);
result = dns_name_fromstring2(n1, testcases[i].name1,
NULL, 0, NULL);
isc_buffer_init(&b, buffer, testdatap->name_len);
isc_buffer_add(&b, testdatap->name_len);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
testdatap++;
dns_name_t *foundname;
rbt_testdata_t *testdatap = testdata;
- dns_fixedname_init(&fixed);
- foundname = dns_fixedname_name(&fixed);
+ foundname = dns_fixedname_initname(&fixed);
while (testdatap->name != NULL && testdatap->data.data != NULL) {
memmove(buffer, testdatap->name, testdatap->name_len + 1);
isc_buffer_init(&b, arg, testdatap->name_len);
isc_buffer_add(&b, testdatap->name_len);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
testdatap++;
dns_name_t *foundname;
size_t i;
- dns_fixedname_init(&fixed);
- foundname = dns_fixedname_name(&fixed);
+ foundname = dns_fixedname_initname(&fixed);
for (i = 0; i < domain_names_count; i++) {
dns_fixedname_t fname;
dns_test_namefromstring("d.e.f", &fname);
name = dns_fixedname_name(&fname);
- dns_fixedname_init(&found);
- foundname = dns_fixedname_name(&found);
+ foundname = dns_fixedname_initname(&found);
result = dns_rbt_findname(ctx->rbt, name,
DNS_RBTFIND_EMPTYDATA,
&node, &chain, 0, NULL, NULL);
ATF_CHECK_EQ(result, ISC_R_SUCCESS);
- dns_fixedname_init(&found);
- foundname = dns_fixedname_name(&found);
+ foundname = dns_fixedname_initname(&found);
dns_test_namefromstring("a", &expect);
expected = dns_fixedname_name(&expect);
ret = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(ret, ISC_R_SUCCESS);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
isc_buffer_constinit(&buf, "rsa.", 4);
isc_buffer_add(&buf, 4);
ret = dns_name_fromtext(name, &buf, NULL, 0, NULL);
/* isc_log_setdebuglevel(lctx, 99); */
- dns_fixedname_init(&fkeyname);
- keyname = dns_fixedname_name(&fkeyname);
+ keyname = dns_fixedname_initname(&fkeyname);
result = dns_name_fromstring(keyname, "test", 0, NULL);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
if (result == ISC_R_SUCCESS)
gss_ctx = dst_key_getgssctx(tsigkey->key);
- dns_fixedname_init(&fixed);
- principal = dns_fixedname_name(&fixed);
+ principal = dns_fixedname_initname(&fixed);
/*
* Note that tctx->gsscred may be NULL if tctx->gssapi_keytab is set
goto failure;
}
- dns_fixedname_init(&fkeyname);
- keyname = dns_fixedname_name(&fkeyname);
+ keyname = dns_fixedname_initname(&fkeyname);
if (!dns_name_equal(qname, dns_rootname)) {
unsigned int n = dns_name_countlabels(qname);
*/
isc_stdtime_get(&now);
dns_name_init(&foundname, NULL);
- dns_fixedname_init(&fixedorigin);
- origin = dns_fixedname_name(&fixedorigin);
+ origin = dns_fixedname_initname(&fixedorigin);
again:
dns_rbtnodechain_init(&chain, ring->mctx);
if (isc_serial_lt(expire, now))
return (DNS_R_EXPIRED);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
isc_buffer_init(&b, namestr, strlen(namestr));
isc_buffer_add(&b, strlen(namestr));
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS)
return (result);
- dns_fixedname_init(&fcreator);
- creator = dns_fixedname_name(&fcreator);
+ creator = dns_fixedname_initname(&fcreator);
isc_buffer_init(&b, creatorstr, strlen(creatorstr));
isc_buffer_add(&b, strlen(creatorstr));
result = dns_name_fromtext(creator, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS)
return (result);
- dns_fixedname_init(&falgorithm);
- algorithm = dns_fixedname_name(&falgorithm);
+ algorithm = dns_fixedname_initname(&falgorithm);
isc_buffer_init(&b, algorithmstr, strlen(algorithmstr));
isc_buffer_add(&b, strlen(algorithmstr));
result = dns_name_fromtext(algorithm, &b, dns_rootname, 0, NULL);
isc_stdtime_get(&now);
dns_name_init(&foundname, NULL);
- dns_fixedname_init(&fixedorigin);
- origin = dns_fixedname_name(&fixedorigin);
+ origin = dns_fixedname_initname(&fixedorigin);
dns_rbtnodechain_init(&chain, ring->mctx);
result = dns_rbtnodechain_first(&chain, ring->keys, &foundname,
origin);
dns_name_t *child;
dns_dbiterator_t *dbit = NULL;
- dns_fixedname_init(&fixedname);
- child = dns_fixedname_name(&fixedname);
+ child = dns_fixedname_initname(&fixedname);
CHECK(dns_db_createiterator(db, DNS_DB_NONSEC3, &dbit));
} else {
dns_fixedname_t ffound;
dns_name_t *found;
- dns_fixedname_init(&ffound);
- found = dns_fixedname_name(&ffound);
+ found = dns_fixedname_initname(&ffound);
result = dns_db_find(db, newname, ver,
dns_rdatatype_soa,
DNS_DBFIND_NOWILD, 0, NULL, found,
dns_fixedname_t fixedname;
dns_name_t *target;
- dns_fixedname_init(&fixedname);
- target = dns_fixedname_name(&fixedname);
+ target = dns_fixedname_initname(&fixedname);
/*
* Find the successor name, aka NSEC target.
dns_fixedname_t fixedname;
dns_name_t *prevname;
- dns_fixedname_init(&fixedname);
- prevname = dns_fixedname_name(&fixedname);
+ prevname = dns_fixedname_initname(&fixedname);
if (oldver != NULL)
CHECK(name_exists(db, oldver, &t->name,
options = DNS_DBFIND_PENDINGOK;
if (type == dns_rdatatype_dlv)
options |= DNS_DBFIND_COVERINGNSEC;
- dns_fixedname_init(&fixedname);
- foundname = dns_fixedname_name(&fixedname);
+ foundname = dns_fixedname_initname(&fixedname);
result = dns_view_find(val->view, name, type, 0, options,
ISC_FALSE, ISC_FALSE, NULL, NULL, foundname,
&val->frdataset, &val->fsigrdataset);
dns_name_t *wild;
val->attributes |= VALATTR_TRIEDVERIFY;
- dns_fixedname_init(&fixed);
- wild = dns_fixedname_name(&fixed);
+ wild = dns_fixedname_initname(&fixed);
again:
result = dns_dnssec_verify(val->event->name, val->event->rdataset,
key, ignore, val->view->maxbits,
dns_fixedname_t fixed;
dns_name_t *found;
- dns_fixedname_init(&fixed);
- found = dns_fixedname_name(&fixed);
+ found = dns_fixedname_initname(&fixed);
dns_rdata_reset(&sigrdata);
dns_rdataset_current(val->event->sigrdataset,
&sigrdata);
dns_name_init(&tname, NULL);
dns_rdataset_init(&trdataset);
- dns_fixedname_init(&fclosest);
- dns_fixedname_init(&fnearest);
- dns_fixedname_init(&fzonename);
- closest = dns_fixedname_name(&fclosest);
- nearest = dns_fixedname_name(&fnearest);
- zonename = dns_fixedname_name(&fzonename);
+ closest = dns_fixedname_initname(&fclosest);
+ nearest = dns_fixedname_initname(&fnearest);
+ zonename = dns_fixedname_initname(&fzonename);
if (val->event->message == NULL) {
name = &tname;
if (dns_rdataset_isassociated(&val->fsigrdataset))
dns_rdataset_disassociate(&val->fsigrdataset);
- dns_fixedname_init(&val->fname);
- name = dns_fixedname_name(&val->fname);
+ name = dns_fixedname_initname(&val->fname);
rdataset = &val->frdataset;
dns_ncache_current(val->event->rdataset, name, rdataset);
return (DNS_R_MUSTBESECURE);
}
- dns_fixedname_init(&val->dlvsep);
- dlvsep = dns_fixedname_name(&val->dlvsep);
+ dlvsep = dns_fixedname_initname(&val->dlvsep);
dns_name_copy(val->event->name, dlvsep, NULL);
/*
* If this is a response to a DS query, we need to look in
dns_name_getlabelsequence(dlvsep, 1, labels - 1, dlvsep);
}
dns_name_init(&noroot, NULL);
- dns_fixedname_init(&dlvfixed);
- dlvname = dns_fixedname_name(&dlvfixed);
+ dlvname = dns_fixedname_initname(&dlvfixed);
labels = dns_name_countlabels(dlvsep);
if (labels == 0)
return (ISC_R_NOTFOUND);
dns_name_t *found;
dns_fixedname_t fixedfound;
- dns_fixedname_init(&fixedsecroot);
- secroot = dns_fixedname_name(&fixedsecroot);
- dns_fixedname_init(&fixedfound);
- found = dns_fixedname_name(&fixedfound);
+ secroot = dns_fixedname_initname(&fixedsecroot);
+ found = dns_fixedname_initname(&fixedfound);
if (val->havedlvsep)
dns_name_copy(dns_fixedname_name(&val->dlvsep), secroot, NULL);
else {
val->labels++)
{
- dns_fixedname_init(&val->fname);
- tname = dns_fixedname_name(&val->fname);
+ tname = dns_fixedname_initname(&val->fname);
if (val->labels == dns_name_countlabels(val->event->name))
dns_name_copy(val->event->name, tname, NULL);
else
if (view->secroots_priv == NULL)
return (ISC_R_NOTFOUND);
- dns_fixedname_init(&fn);
- anchor = dns_fixedname_name(&fn);
+ anchor = dns_fixedname_initname(&fn);
result = dns_keytable_issecuredomain(view->secroots_priv, name,
anchor, &secure);
REQUIRE(dbp != NULL && *dbp == NULL);
/* setup a "fixed" dns name */
- dns_fixedname_init(&fname);
- zonename = dns_fixedname_name(&fname);
+ zonename = dns_fixedname_initname(&fname);
/* count the number of labels in the name */
namelabels = dns_name_countlabels(name);
ntaname = dns_rootname;
else {
dns_name_t *fname;
- dns_fixedname_init(&fn);
- fname = dns_fixedname_name(&fn);
+ fname = dns_fixedname_initname(&fn);
isc_buffer_init(&b, name, (unsigned int)len);
isc_buffer_add(&b, (unsigned int)len);
else
level = ISC_LOG_WARNING;
- dns_fixedname_init(&fixed);
- foundname = dns_fixedname_name(&fixed);
+ foundname = dns_fixedname_initname(&fixed);
result = dns_db_find(db, name, NULL, dns_rdatatype_a,
0, 0, NULL, foundname, NULL, NULL);
else
level = ISC_LOG_WARNING;
- dns_fixedname_init(&fixed);
- foundname = dns_fixedname_name(&fixed);
+ foundname = dns_fixedname_initname(&fixed);
result = dns_db_find(db, name, NULL, dns_rdatatype_a,
0, 0, NULL, foundname, NULL, NULL);
else
level = ISC_LOG_WARNING;
- dns_fixedname_init(&fixed);
- foundname = dns_fixedname_name(&fixed);
+ foundname = dns_fixedname_initname(&fixed);
dns_rdataset_init(&a);
dns_rdataset_init(&aaaa);
isc_boolean_t ok = ISC_TRUE;
isc_result_t result;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
dns_rdataset_init(&rdataset);
result = dns_db_createiterator(db, 0, &dbiterator);
isc_result_t result;
isc_boolean_t ok = ISC_TRUE, have_spf, have_txt;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
- dns_fixedname_init(&fixedbottom);
- bottom = dns_fixedname_name(&fixedbottom);
+ name = dns_fixedname_initname(&fixed);
+ bottom = dns_fixedname_initname(&fixedbottom);
dns_rdataset_init(&rdataset);
dns_rdata_init(&rdata);
dns_rdataset_t next;
dns_rdataset_init(&next);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_db_getsigningtime(db, &next, name);
if (result == ISC_R_SUCCESS) {
else
level = ISC_LOG_WARNING;
- dns_fixedname_init(&fixed);
- foundname = dns_fixedname_name(&fixed);
+ foundname = dns_fixedname_initname(&fixed);
result = dns_db_find(db, name, version, dns_rdatatype_a,
0, 0, NULL, foundname, NULL, NULL);
ENTER;
dns_rdataset_init(&rdataset);
- dns_fixedname_init(&fixed);
dns_diff_init(zone->mctx, &_sig_diff);
zonediff_init(&zonediff, &_sig_diff);
check_ksk = DNS_ZONE_OPTION(zone, DNS_ZONEOPT_UPDATECHECKKSK);
keyset_kskonly = DNS_ZONE_OPTION(zone, DNS_ZONEOPT_DNSKEYKSKONLY);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_db_getsigningtime(db, &rdataset, name);
if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) {
dns_zone_log(zone, ISC_LOG_ERROR,
isc_result_t result;
unsigned char nsecbuffer[DNS_NSEC_BUFFERSIZE];
- dns_fixedname_init(&fixed);
- next = dns_fixedname_name(&fixed);
+ next = dns_fixedname_initname(&fixed);
CHECK(next_active(db, version, name, next, bottom));
CHECK(dns_nsec_buildrdata(db, version, node, next, nsecbuffer,
ENTER;
dns_rdataset_init(&rdataset);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
- dns_fixedname_init(&nextfixed);
- nextname = dns_fixedname_name(&nextfixed);
+ name = dns_fixedname_initname(&fixed);
+ nextname = dns_fixedname_initname(&nextfixed);
dns_diff_init(zone->mctx, ¶m_diff);
dns_diff_init(zone->mctx, &nsec3_diff);
dns_diff_init(zone->mctx, &nsec_diff);
if (first) {
dns_fixedname_t ffound;
dns_name_t *found;
- dns_fixedname_init(&ffound);
- found = dns_fixedname_name(&ffound);
+ found = dns_fixedname_initname(&ffound);
result = dns_db_find(db, name, version,
dns_rdatatype_soa,
DNS_DBFIND_NOWILD, 0, NULL, found,
if (first) {
dns_fixedname_t ffound;
dns_name_t *found;
- dns_fixedname_init(&ffound);
- found = dns_fixedname_name(&ffound);
+ found = dns_fixedname_initname(&ffound);
result = dns_db_find(db, name, version,
dns_rdatatype_soa,
DNS_DBFIND_NOWILD, 0, NULL, found,
ENTER;
dns_rdataset_init(&rdataset);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
- dns_fixedname_init(&nextfixed);
- nextname = dns_fixedname_name(&nextfixed);
+ name = dns_fixedname_initname(&fixed);
+ nextname = dns_fixedname_initname(&nextfixed);
dns_diff_init(zone->mctx, &_sig_diff);
dns_diff_init(zone->mctx, &post_diff);
zonediff_init(&zonediff, &_sig_diff);
if (first) {
dns_fixedname_t ffound;
dns_name_t *found;
- dns_fixedname_init(&ffound);
- found = dns_fixedname_name(&ffound);
+ found = dns_fixedname_initname(&ffound);
result = dns_db_find(db, name, version,
dns_rdatatype_soa,
DNS_DBFIND_NOWILD, 0, NULL, found,
kfetch->zone = zone;
zone->irefs++;
INSIST(zone->irefs != 0);
- dns_fixedname_init(&kfetch->name);
- kname = dns_fixedname_name(&kfetch->name);
+ kname = dns_fixedname_initname(&kfetch->name);
dns_name_dup(name, zone->mctx, kname);
dns_rdataset_init(&kfetch->dnskeyset);
dns_rdataset_init(&kfetch->dnskeysigset);
result = dns_rdatalist_tordataset(&temprdatalist, &temprdataset);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_db_nodefullname(db, node, name);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
dns_rdataset_getownercase(rdataset, name);
rawdb = ((struct secure_event *)event)->db;
isc_event_free(&event);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
dns_rdataset_init(&rdataset);
LOCK_ZONE(zone);
goto cleanup;
/* Configure key name */
- dns_fixedname_init(&fkeyname);
- keyname_base = dns_fixedname_name(&fkeyname);
+ keyname_base = dns_fixedname_initname(&fkeyname);
isc_buffer_constinit(&namebuf, keynamestr,
strlen(keynamestr));
isc_buffer_add(&namebuf, strlen(keynamestr));
namelen = strlen(domain);
isc_buffer_constinit(&b, domain, namelen);
isc_buffer_add(&b, namelen);
- dns_fixedname_init(&fixeddomain);
- qdomain = dns_fixedname_name(&fixeddomain);
+ qdomain = dns_fixedname_initname(&fixeddomain);
result = dns_name_fromtext(qdomain, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, state, sizeof(*state));
namelen = strlen(hostname);
isc_buffer_constinit(&b, hostname, namelen);
isc_buffer_add(&b, namelen);
- dns_fixedname_init(&state->fixedname);
- state->qname = dns_fixedname_name(&state->fixedname);
+ state->qname = dns_fixedname_initname(&state->fixedname);
result = dns_name_fromtext(state->qname, &b, qdomain, 0, NULL);
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, state, sizeof(*state));
/* Make query name */
isc_netaddr_fromsockaddr(&netaddr, (const isc_sockaddr_t *)sa);
- dns_fixedname_init(&ptrfname);
- ptrname = dns_fixedname_name(&ptrfname);
+ ptrname = dns_fixedname_initname(&ptrfname);
iresult = dns_byaddr_createptrname(&netaddr, 0, ptrname);
if (iresult != ISC_R_SUCCESS)
ERR(EAI_FAIL);
client->query.redirect.sigrdataset = NULL;
client->query.redirect.authoritative = ISC_FALSE;
client->query.redirect.is_zone = ISC_FALSE;
- dns_fixedname_init(&client->query.redirect.fixed);
client->query.redirect.fname =
- dns_fixedname_name(&client->query.redirect.fixed);
+ dns_fixedname_initname(&client->query.redirect.fixed);
query_reset(client, ISC_FALSE);
result = query_newdbversion(client, 3);
if (result != ISC_R_SUCCESS) {
}
node = NULL;
- dns_fixedname_init(&fixed);
- found = dns_fixedname_name(&fixed);
+ found = dns_fixedname_initname(&fixed);
dns_clientinfomethods_init(&cm, ns_client_sourceip);
dns_clientinfo_init(&ci, client, NULL);
result = dns_db_findext(*dbp, name, version, type, DNS_DBFIND_GLUEOK,
result = rpz_getdb(client, p_name, rpz_type, zonep, dbp, versionp);
if (result != ISC_R_SUCCESS)
return (DNS_R_NXDOMAIN);
- dns_fixedname_init(&foundf);
- found = dns_fixedname_name(&foundf);
+ found = dns_fixedname_initname(&foundf);
result = dns_db_findext(*dbp, p_name, *versionp, dns_rdatatype_any, 0,
client->now, nodep, found, &cm, &ci,
/*
* Get the DNSPRS imitation rdataset.
*/
- dns_fixedname_init(&foundf);
- found = dns_fixedname_name(&foundf);
+ found = dns_fixedname_initname(&foundf);
result = dns_db_find(p_db, st->p_name, NULL, searchtype,
0, 0, &p_node, found, *p_rdatasetp, NULL);
}
#endif
- dns_fixedname_init(&ip_namef);
- ip_name = dns_fixedname_name(&ip_namef);
+ ip_name = dns_fixedname_initname(&ip_namef);
p_zone = NULL;
p_db = NULL;
* Get the policy for a prefix at least as long
* as the prefix of the entry we had before.
*/
- dns_fixedname_init(&p_namef);
- p_name = dns_fixedname_name(&p_namef);
+ p_name = dns_fixedname_initname(&p_namef);
result = rpz_get_p_name(client, p_name, rpz, rpz_type, ip_name);
if (result != ISC_R_SUCCESS)
continue;
if (zbits == 0)
return (ISC_R_SUCCESS);
- dns_fixedname_init(&p_namef);
- p_name = dns_fixedname_name(&p_namef);
+ p_name = dns_fixedname_initname(&p_namef);
p_zone = NULL;
p_db = NULL;
st->m.ttl = ~0;
memset(&st->r, 0, sizeof(st->r));
memset(&st->q, 0, sizeof(st->q));
- dns_fixedname_init(&st->_p_namef);
- dns_fixedname_init(&st->_r_namef);
- dns_fixedname_init(&st->_fnamef);
- st->p_name = dns_fixedname_name(&st->_p_namef);
- st->r_name = dns_fixedname_name(&st->_r_namef);
- st->fname = dns_fixedname_name(&st->_fnamef);
+ st->p_name = dns_fixedname_initname(&st->_p_namef);
+ st->r_name = dns_fixedname_initname(&st->_r_namef);
+ st->fname = dns_fixedname_initname(&st->_fnamef);
st->have = have;
st->popt = popt;
st->rpz_ver = rpz_ver;
*/
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) == 0)
return (ISC_TRUE);
- dns_fixedname_init(&fixed);
- found = dns_fixedname_name(&fixed);
+ found = dns_fixedname_initname(&fixed);
dns_rdataset_init(&trdataset);
for (result = dns_rdataset_first(rdataset);
result == ISC_R_SUCCESS;
if (client->view->redirect == NULL)
return (ISC_R_NOTFOUND);
- dns_fixedname_init(&fixed);
- found = dns_fixedname_name(&fixed);
+ found = dns_fixedname_initname(&fixed);
dns_rdataset_init(&trdataset);
dns_clientinfomethods_init(&cm, ns_client_sourceip);
if (dns_name_issubdomain(name, client->view->redirectzone))
return (ISC_R_NOTFOUND);
- dns_fixedname_init(&fixed);
- found = dns_fixedname_name(&fixed);
+ found = dns_fixedname_initname(&fixed);
dns_rdataset_init(&trdataset);
dns_clientinfomethods_init(&cm, ns_client_sourceip);
}
}
- dns_fixedname_init(&fixedredirect);
- redirectname = dns_fixedname_name(&fixedredirect);
+ redirectname = dns_fixedname_initname(&fixedredirect);
if (dns_name_countlabels(name) > 1U) {
dns_name_t prefix;
unsigned int labels = dns_name_countlabels(name) - 1;
dns_fixedname_t fixed;
isc_buffer_t b;
- dns_fixedname_init(&fixed);
- found = dns_fixedname_name(&fixed);
+ found = dns_fixedname_initname(&fixed);
qname = qctx->client->query.qname;
query_findclosestnsec3(qname, qctx->db, qctx->version,
goto cleanup;
}
- dns_fixedname_init(&fwild);
- wild = dns_fixedname_name(&fwild);
- dns_fixedname_init(&fixed);
- fname = dns_fixedname_name(&fixed);
- dns_fixedname_init(&fsigner);
- signer = dns_fixedname_name(&fsigner);
- dns_fixedname_init(&fnowild);
- nowild = dns_fixedname_name(&fnowild);
+ wild = dns_fixedname_initname(&fwild);
+ fname = dns_fixedname_initname(&fixed);
+ signer = dns_fixedname_initname(&fsigner);
+ nowild = dns_fixedname_initname(&fnowild);
dns_clientinfomethods_init(&cm, ns_client_sourceip);
dns_clientinfo_init(&ci, qctx->client, NULL);
* Construct the new qname consisting of
* <found name prefix>.<dname target>
*/
- dns_fixedname_init(&fixed);
- prefix = dns_fixedname_name(&fixed);
+ prefix = dns_fixedname_initname(&fixed);
dns_name_split(qctx->client->query.qname, nlabels, prefix, NULL);
INSIST(qctx->fname == NULL);
qctx->dbuf = query_getnamebuf(qctx->client);
dns_fixedname_t foundname;
dns_name_t *fname;
- dns_fixedname_init(&foundname);
- fname = dns_fixedname_name(&foundname);
+ fname = dns_fixedname_initname(&foundname);
result = dns_db_findext(qctx->db, name, qctx->version,
dns_rdatatype_soa,
* Initialization.
*/
eresult = ISC_R_SUCCESS;
- dns_fixedname_init(&foundname);
- fname = dns_fixedname_name(&foundname);
+ fname = dns_fixedname_initname(&foundname);
dns_clientinfomethods_init(&cm, ns_client_sourceip);
dns_clientinfo_init(&ci, client, NULL);
* wild *.example
*/
options = client->query.dboptions | DNS_DBFIND_NOWILD;
- dns_fixedname_init(&wfixed);
- wname = dns_fixedname_name(&wfixed);
+ wname = dns_fixedname_initname(&wfixed);
again:
have_wname = ISC_FALSE;
/*
/*
* No NSEC proof available, return NSEC3 proofs instead.
*/
- dns_fixedname_init(&cfixed);
- cname = dns_fixedname_name(&cfixed);
+ cname = dns_fixedname_initname(&cfixed);
/*
* Find the closest encloser.
*/
isc_buffer_constinit(&buffer, name, strlen(name));
isc_buffer_add(&buffer, strlen(name));
- dns_fixedname_init(&fixorigin);
- origin = dns_fixedname_name(&fixorigin);
+ origin = dns_fixedname_initname(&fixorigin);
CHECK(dns_name_fromtext(origin, &buffer, dns_rootname, 0, NULL));
CHECK(dns_zone_setorigin(zone, origin));
dns_zone_setview(zone, view);
dns_fixedname_t fixed;
dns_name_t *name;
- dns_fixedname_init(&fixed);
- name = dns_fixedname_name(&fixed);
+ name = dns_fixedname_initname(&fixed);
result = dns_name_fromstring(name, origin, 0, NULL);
if (result != ISC_R_SUCCESS)
if (rr_action == add_rr_prepare_action) {
add_rr_prepare_ctx_t *ctx = rr_action_data;
- dns_fixedname_init(&fixed);
- ctx->oldname = dns_fixedname_name(&fixed);
+ ctx->oldname = dns_fixedname_initname(&fixed);
dns_name_copy(name, ctx->oldname, NULL);
dns_rdataset_getownercase(&rdataset, ctx->oldname);
}
struct in_addr addr;
dns_zoneopt_t options;
- dns_fixedname_init(&fixed);
- foundname = dns_fixedname_name(&fixed);
+ foundname = dns_fixedname_initname(&fixed);
dns_rdata_init(&rdata);
options = dns_zone_getoptions(zone);
FAILC(result, "'RRset exists (value dependent)' "
"prerequisite not satisfied");
- dns_fixedname_init(&tmpnamefixed);
- tmpname = dns_fixedname_name(&tmpnamefixed);
+ tmpname = dns_fixedname_initname(&tmpnamefixed);
result = temp_check(mctx, &temp, db, ver, tmpname, &type);
if (result != ISC_R_SUCCESS)
FAILNT(result, tmpname, type,
domainlen = strlen(buf);
isc_buffer_init(&b, buf, domainlen);
isc_buffer_add(&b, domainlen);
- dns_fixedname_init(&trans->fixedname);
- trans->qname = dns_fixedname_name(&trans->fixedname);
+ trans->qname = dns_fixedname_initname(&trans->fixedname);
result = dns_name_fromtext(trans->qname, &b, dns_rootname,
0, NULL);
goto cleanup;
}
- dns_fixedname_init(&pns->fixedname);
pns->name =
- dns_fixedname_name(&pns->fixedname);
+ dns_fixedname_initname(&pns->fixedname);
ISC_LINK_INIT(pns, link);
ISC_LIST_APPEND(trans->nslist, pns, link);
ISC_LIST_INIT(pns->servers);
domainlen = strlen(buf);
isc_buffer_init(&b, buf, domainlen);
isc_buffer_add(&b, domainlen);
- dns_fixedname_init(&trans->fixedname);
- trans->qname = dns_fixedname_name(&trans->fixedname);
+ trans->qname = dns_fixedname_initname(&trans->fixedname);
result = dns_name_fromtext(trans->qname, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS)
goto cleanup;
namelen = strlen(keynamestr);
isc_buffer_init(&b, keynamestr, namelen);
isc_buffer_add(&b, namelen);
- dns_fixedname_init(&fkeyname);
- keyname = dns_fixedname_name(&fkeyname);
+ keyname = dns_fixedname_initname(&fkeyname);
result = dns_name_fromtext(keyname, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "failed to construct key name\n");
namelen = strlen(name_space);
isc_buffer_constinit(&b, name_space, namelen);
isc_buffer_add(&b, namelen);
- dns_fixedname_init(&fname);
- name = dns_fixedname_name(&fname);
+ name = dns_fixedname_initname(&fname);
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "failed to convert qname: %u\n",
namelen = strlen(argv[0]);
isc_buffer_init(&b, argv[0], namelen);
isc_buffer_add(&b, namelen);
- dns_fixedname_init(&qname0);
- qname = dns_fixedname_name(&qname0);
+ qname = dns_fixedname_initname(&qname0);
result = dns_name_fromtext(qname, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS)
fprintf(stderr, "failed to convert qname: %u\n", result);
namelen = strlen(buf);
isc_buffer_init(&b, buf, namelen);
isc_buffer_add(&b, namelen);
- dns_fixedname_init(&trans->fixedname);
- trans->qname = dns_fixedname_name(&trans->fixedname);
+ trans->qname = dns_fixedname_initname(&trans->fixedname);
result = dns_name_fromtext(trans->qname, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS)
goto cleanup;
namelen = strlen(namestr);
isc_buffer_constinit(&b, namestr, namelen);
isc_buffer_add(&b, namelen);
- dns_fixedname_init(&fixedqname);
- qname0 = dns_fixedname_name(&fixedqname);
+ qname0 = dns_fixedname_initname(&fixedqname);
result = dns_name_fromtext(qname0, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "failed to convert qname: %u\n", result);
namelen = strlen(zonenamestr);
isc_buffer_init(&b, zonenamestr, namelen);
isc_buffer_add(&b, namelen);
- dns_fixedname_init(&zname0);
- zname = dns_fixedname_name(&zname0);
+ zname = dns_fixedname_initname(&zname0);
result = dns_name_fromtext(zname, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS)
fprintf(stderr, "failed to convert zone name: %u\n",
/* Construct prerequisite name (if given) */
if (prereqstr != NULL) {
- dns_fixedname_init(&pname0);
- pname = dns_fixedname_name(&pname0);
+ pname = dns_fixedname_initname(&pname0);
evaluate_prereq(umctx, prereqstr, pname);
ISC_LIST_APPEND(prereqlist, pname, link);
prereqlistp = &prereqlist;
/* Construct update name */
ISC_LIST_INIT(updatelist);
- dns_fixedname_init(&uname0);
- uname = dns_fixedname_name(&uname0);
+ uname = dns_fixedname_initname(&uname0);
update_addordelete(umctx, argv[1], isdelete, uname);
ISC_LIST_APPEND(updatelist, uname, link);
projects / thirdparty / bind9.git / commitdiff
