static dns_name_t *userzone = NULL;
static dns_name_t *zname = NULL;
static dns_name_t tmpzonename = DNS_NAME_INITEMPTY;
-static dns_name_t restart_master = DNS_NAME_INITEMPTY;
+static dns_name_t restart_primary = DNS_NAME_INITEMPTY;
static dns_tsig_keyring_t *gssring = NULL;
static dns_tsigkey_t *tsigkey = NULL;
static dst_key_t *sig0key = NULL;
static isc_sockaddr_t *servers = NULL;
-static isc_sockaddr_t *master_servers = NULL;
+static isc_sockaddr_t *primary_servers = NULL;
static bool default_servers = true;
static int ns_inuse = 0;
-static int master_inuse = 0;
+static int primary_inuse = 0;
static int ns_total = 0;
static int ns_alloc = 0;
-static int master_total = 0;
-static int master_alloc = 0;
+static int primary_total = 0;
+static int primary_alloc = 0;
static isc_sockaddr_t *localaddr4 = NULL;
static isc_sockaddr_t *localaddr6 = NULL;
static const char *keyfile = NULL;
sendrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
dns_request_t **request);
static void
-send_update(dns_name_t *zonename, isc_sockaddr_t *master);
+send_update(dns_name_t *zonename, isc_sockaddr_t *primary);
ISC_NORETURN static void
fatal(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
static void
failed_gssrequest(void);
static void
-start_gssrequest(dns_name_t *master);
+start_gssrequest(dns_name_t *primary);
static void
send_gssrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
dns_request_t **request, gss_ctx_id_t context);
#define STATUS_SYNTAX (uint16_t)3
static void
-master_from_servers(void) {
- if (master_servers != NULL && master_servers != servers) {
- isc_mem_put(gmctx, master_servers,
- master_alloc * sizeof(isc_sockaddr_t));
- }
- master_servers = servers;
- master_total = ns_total;
- master_alloc = ns_alloc;
- master_inuse = ns_inuse;
+primary_from_servers(void) {
+ if (primary_servers != NULL && primary_servers != servers) {
+ isc_mem_put(gmctx, primary_servers,
+ primary_alloc * sizeof(isc_sockaddr_t));
+ }
+ primary_servers = servers;
+ primary_total = ns_total;
+ primary_alloc = ns_alloc;
+ primary_inuse = ns_inuse;
}
static dns_rdataclass_t
* isc_mem_put of servers as it sets the servers pointer
* to NULL.
*/
- if (master_servers != NULL && master_servers != servers) {
- isc_mem_put(gmctx, master_servers,
- master_alloc * sizeof(isc_sockaddr_t));
+ if (primary_servers != NULL && primary_servers != servers) {
+ isc_mem_put(gmctx, primary_servers,
+ primary_alloc * sizeof(isc_sockaddr_t));
}
if (servers != NULL) {
nslist = irs_resconf_getnameservers(resconf);
if (servers != NULL) {
- if (master_servers == servers) {
- master_servers = NULL;
+ if (primary_servers == servers) {
+ primary_servers = NULL;
}
isc_mem_put(gmctx, servers, ns_alloc * sizeof(isc_sockaddr_t));
}
}
if (servers != NULL) {
- if (master_servers == servers) {
- master_servers = NULL;
+ if (primary_servers == servers) {
+ primary_servers = NULL;
}
isc_mem_put(gmctx, servers, ns_alloc * sizeof(isc_sockaddr_t));
}
fprintf(stdout, "nsupdate " PACKAGE_VERSION ":\n"
"local address [port] (set local "
"resolver)\n"
- "server address [port] (set master server "
+ "server address [port] (set primary server "
"for zone)\n"
"send (send the update "
"request)\n"
}
static bool
-next_master(const char *caller, isc_sockaddr_t *addr, isc_result_t eresult) {
+next_primary(const char *caller, isc_sockaddr_t *addr, isc_result_t eresult) {
char addrbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(addr, addrbuf, sizeof(addrbuf));
fprintf(stderr, "; Communication with %s failed: %s\n", addrbuf,
isc_result_totext(eresult));
- if (++master_inuse >= master_total) {
+ if (++primary_inuse >= primary_total) {
return (false);
}
ddebug("%s: trying next server", caller);
}
if (reqev->result != ISC_R_SUCCESS) {
- if (!next_master("update_completed",
- &master_servers[master_inuse], reqev->result))
+ if (!next_primary("update_completed",
+ &primary_servers[primary_inuse],
+ reqev->result))
{
seenerror = true;
goto done;
dns_request_destroy(&request);
dns_message_renderreset(updatemsg);
dns_message_settsigkey(updatemsg, NULL);
- send_update(zname, &master_servers[master_inuse]);
+ send_update(zname, &primary_servers[primary_inuse]);
isc_event_free(&event);
return;
}
dns_request_destroy(&request);
if (usegsstsig) {
dns_name_free(&tmpzonename, gmctx);
- dns_name_free(&restart_master, gmctx);
+ dns_name_free(&restart_primary, gmctx);
dns_name_init(&tmpzonename, 0);
- dns_name_init(&restart_master, 0);
+ dns_name_init(&restart_primary, 0);
}
isc_event_free(&event);
done_update();
}
static void
-send_update(dns_name_t *zone, isc_sockaddr_t *master) {
+send_update(dns_name_t *zone, isc_sockaddr_t *primary) {
isc_result_t result;
dns_request_t *request = NULL;
unsigned int options = DNS_REQUESTOPT_CASE;
if (debugging) {
char addrbuf[ISC_SOCKADDR_FORMATSIZE];
- isc_sockaddr_format(master, addrbuf, sizeof(addrbuf));
+ isc_sockaddr_format(primary, addrbuf, sizeof(addrbuf));
fprintf(stderr, "Sending update to %s\n", addrbuf);
}
- if (isc_sockaddr_pf(master) == AF_INET6) {
+ if (isc_sockaddr_pf(primary) == AF_INET6) {
srcaddr = localaddr6;
} else {
srcaddr = localaddr4;
updatemsg->tsigname->attributes |= DNS_NAMEATTR_NOCOMPRESS;
}
- result = dns_request_createvia(requestmgr, updatemsg, srcaddr, master,
+ result = dns_request_createvia(requestmgr, updatemsg, srcaddr, primary,
-1, options, tsigkey, timeout,
udp_timeout, udp_retries, global_task,
update_completed, NULL, &request);
dns_rdata_soa_t soa;
dns_rdata_t soarr = DNS_RDATA_INIT;
int pass = 0;
- dns_name_t master;
+ dns_name_t primary;
nsu_requestinfo_t *reqinfo;
dns_message_t *soaquery = NULL;
isc_sockaddr_t *addr;
result = dns_rdata_tostruct(&soarr, &soa, NULL);
check_result(result, "dns_rdata_tostruct");
- dns_name_init(&master, NULL);
- dns_name_clone(&soa.origin, &master);
+ dns_name_init(&primary, NULL);
+ dns_name_clone(&soa.origin, &primary);
if (userzone != NULL) {
zname = userzone;
if (debugging) {
char namestr[DNS_NAME_FORMATSIZE];
- dns_name_format(&master, namestr, sizeof(namestr));
- fprintf(stderr, "The master is: %s\n", namestr);
+ dns_name_format(&primary, namestr, sizeof(namestr));
+ fprintf(stderr, "The primary is: %s\n", namestr);
}
if (default_servers) {
size_t size;
isc_buffer_init(&buf, serverstr, sizeof(serverstr));
- result = dns_name_totext(&master, true, &buf);
+ result = dns_name_totext(&primary, true, &buf);
check_result(result, "dns_name_totext");
serverstr[isc_buffer_usedlength(&buf)] = 0;
- if (master_servers != NULL && master_servers != servers) {
- isc_mem_put(gmctx, master_servers,
- master_alloc * sizeof(isc_sockaddr_t));
+ if (primary_servers != NULL && primary_servers != servers) {
+ isc_mem_put(gmctx, primary_servers,
+ primary_alloc * sizeof(isc_sockaddr_t));
}
- master_alloc = MAX_SERVERADDRS;
- size = master_alloc * sizeof(isc_sockaddr_t);
- master_servers = isc_mem_get(gmctx, size);
+ primary_alloc = MAX_SERVERADDRS;
+ size = primary_alloc * sizeof(isc_sockaddr_t);
+ primary_servers = isc_mem_get(gmctx, size);
- memset(master_servers, 0, size);
- master_total = get_addresses(serverstr, dnsport, master_servers,
- master_alloc);
- if (master_total == 0) {
+ memset(primary_servers, 0, size);
+ primary_total = get_addresses(serverstr, dnsport,
+ primary_servers, primary_alloc);
+ if (primary_total == 0) {
exit(1);
}
- master_inuse = 0;
+ primary_inuse = 0;
} else {
- master_from_servers();
+ primary_from_servers();
}
dns_rdata_freestruct(&soa);
if (usegsstsig) {
dns_name_init(&tmpzonename, NULL);
dns_name_dup(zname, gmctx, &tmpzonename);
- dns_name_init(&restart_master, NULL);
- dns_name_dup(&master, gmctx, &restart_master);
- start_gssrequest(&master);
+ dns_name_init(&restart_primary, NULL);
+ dns_name_dup(&primary, gmctx, &restart_primary);
+ start_gssrequest(&primary);
} else {
- send_update(zname, &master_servers[master_inuse]);
+ send_update(zname, &primary_servers[primary_inuse]);
setzoneclass(dns_rdataclass_none);
}
#else /* HAVE_GSSAPI */
- send_update(zname, &master_servers[master_inuse]);
+ send_update(zname, &primary_servers[primary_inuse]);
setzoneclass(dns_rdataclass_none);
#endif /* HAVE_GSSAPI */
seenerror = true;
dns_name_free(&tmpzonename, gmctx);
- dns_name_free(&restart_master, gmctx);
+ dns_name_free(&restart_primary, gmctx);
dns_name_init(&tmpzonename, NULL);
- dns_name_init(&restart_master, NULL);
+ dns_name_init(&restart_primary, NULL);
done_update();
}
static void
-start_gssrequest(dns_name_t *master) {
+start_gssrequest(dns_name_t *primary) {
dns_gss_ctx_id_t context;
isc_buffer_t buf;
isc_result_t result;
isc_result_totext(result));
}
- dns_name_format(master, namestr, sizeof(namestr));
+ dns_name_format(primary, namestr, sizeof(namestr));
if (kserver == NULL) {
kserver = isc_mem_get(gmctx, sizeof(isc_sockaddr_t));
}
- memmove(kserver, &master_servers[master_inuse], sizeof(isc_sockaddr_t));
+ memmove(kserver, &primary_servers[primary_inuse],
+ sizeof(isc_sockaddr_t));
servname = dns_fixedname_initname(&fname);
if (eresult != ISC_R_SUCCESS) {
ddebug("Destroying request [%p]", request);
dns_request_destroy(&request);
- if (!next_master("recvgss", addr, eresult)) {
+ if (!next_primary("recvgss", addr, eresult)) {
dns_message_detach(&tsigquery);
failed_gssrequest();
} else {
dns_message_renderreset(tsigquery);
- memmove(kserver, &master_servers[master_inuse],
+ memmove(kserver, &primary_servers[primary_inuse],
sizeof(isc_sockaddr_t));
send_gssrequest(kserver, tsigquery, &request, context);
}
use_win2k_gsstsig = true;
}
tried_other_gsstsig = true;
- start_gssrequest(&restart_master);
+ start_gssrequest(&restart_primary);
goto done;
}
check_result(result, "dns_message_checksig");
#endif /* 0 */
- send_update(&tmpzonename, &master_servers[master_inuse]);
+ send_update(&tmpzonename, &primary_servers[primary_inuse]);
setzoneclass(dns_rdataclass_none);
break;
* the zone and / or the primary server.
*/
if (userzone != NULL && !default_servers && !usegsstsig) {
- master_from_servers();
- send_update(userzone, &master_servers[master_inuse]);
+ primary_from_servers();
+ send_update(userzone, &primary_servers[primary_inuse]);
setzoneclass(dns_rdataclass_none);
return;
}
if (dns_name_dynamic(&tmpzonename)) {
dns_name_free(&tmpzonename, gmctx);
}
- if (dns_name_dynamic(&restart_master)) {
- dns_name_free(&restart_master, gmctx);
+ if (dns_name_dynamic(&restart_primary)) {
+ dns_name_free(&restart_primary, gmctx);
}
#endif /* ifdef HAVE_GSSAPI */
uint32_t maxrecords;
- isc_sockaddr_t *masters;
- isc_dscp_t *masterdscps;
- dns_name_t **masterkeynames;
- dns_name_t **mastertlsnames;
- bool *mastersok;
- unsigned int masterscnt;
- unsigned int curmaster;
- isc_sockaddr_t masteraddr;
+ isc_sockaddr_t *primaries;
+ isc_dscp_t *primarydscps;
+ dns_name_t **primarykeynames;
+ dns_name_t **primarytlsnames;
+ bool *primariesok;
+ unsigned int primariescnt;
+ unsigned int curprimary;
+ isc_sockaddr_t primaryaddr;
isc_sockaddr_t *parentals;
isc_dscp_t *parentaldscps;
DNS_ZONEFLG_FIXJOURNAL = 0x00000800U, /*%< journal file had
* recoverable error,
* needs rewriting */
- DNS_ZONEFLG_NOMASTERS = 0x00001000U, /*%< an attempt to refresh a
+ DNS_ZONEFLG_NOPRIMARIES = 0x00001000U, /*%< an attempt to refresh a
* zone with no primaries
* occurred */
DNS_ZONEFLG_LOADING = 0x00002000U, /*%< load from disk in progress*/
if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror ||
zone->type == dns_zone_stub || zone->type == dns_zone_key ||
- (zone->type == dns_zone_redirect && zone->masters != NULL))
+ (zone->type == dns_zone_redirect && zone->primaries != NULL))
{
return (true);
}
if ((zone->type == dns_zone_secondary ||
zone->type == dns_zone_mirror || zone->type == dns_zone_stub ||
- (zone->type == dns_zone_redirect && zone->masters != NULL)) &&
+ (zone->type == dns_zone_redirect && zone->primaries != NULL)) &&
rbt)
{
if (zone->stream == NULL &&
result = DNS_R_NOMASTERFILE;
if (zone->type == dns_zone_primary ||
(zone->type == dns_zone_redirect &&
- zone->masters == NULL))
+ zone->primaries == NULL))
{
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD,
ISC_LOG_ERROR,
}
static unsigned int
-get_master_options(dns_zone_t *zone) {
+get_primary_options(dns_zone_t *zone) {
unsigned int options;
options = DNS_MASTER_ZONE | DNS_MASTER_RESIGN;
if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror ||
- (zone->type == dns_zone_redirect && zone->masters == NULL))
+ (zone->type == dns_zone_redirect && zone->primaries == NULL))
{
- options |= DNS_MASTER_SLAVE;
+ options |= DNS_MASTER_SECONDARY;
}
if (zone->type == dns_zone_key) {
options |= DNS_MASTER_KEY;
goto fail;
}
- options = get_master_options(load->zone);
+ options = get_primary_options(load->zone);
result = dns_master_loadfileinc(
load->zone->masterfile, dns_db_origin(load->db),
dns_zone_rpz_enable_db(zone, db);
dns_zone_catz_enable_db(zone, db);
- options = get_master_options(zone);
+ options = get_primary_options(zone);
if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_MANYERRORS)) {
options |= DNS_MASTER_MANYERRORS;
}
bool needdump = false;
bool fixjournal = false;
bool hasinclude = DNS_ZONE_FLAG(zone, DNS_ZONEFLG_HASINCLUDE);
- bool nomaster = false;
+ bool noprimary = false;
bool had_db = false;
dns_include_t *inc;
bool is_dynamic = false;
if (zone->type == dns_zone_secondary ||
zone->type == dns_zone_mirror ||
zone->type == dns_zone_stub ||
- (zone->type == dns_zone_redirect && zone->masters == NULL))
+ (zone->type == dns_zone_redirect &&
+ zone->primaries == NULL))
{
if (result == ISC_R_FILENOTFOUND) {
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD,
"loading from master file %s failed: %s",
zone->masterfile,
isc_result_totext(result));
- nomaster = true;
+ noprimary = true;
}
if (zone->type != dns_zone_key) {
* if there happens to be a journal file, we can roll forward from
* a sane starting point.)
*/
- if (nomaster && zone->type == dns_zone_key) {
+ if (noprimary && zone->type == dns_zone_key) {
result = add_soa(zone, db);
if (result != ISC_R_SUCCESS) {
goto cleanup;
ISC_LOG_ERROR,
"zone serial (%u) unchanged. "
"zone may fail to transfer "
- "to slaves.",
+ "to secondaries.",
serial);
}
}
if (zone->type == dns_zone_secondary ||
zone->type == dns_zone_mirror ||
zone->type == dns_zone_stub ||
- (zone->type == dns_zone_redirect && zone->masters != NULL))
+ (zone->type == dns_zone_redirect &&
+ zone->primaries != NULL))
{
isc_time_t t;
uint32_t delay;
}
if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror ||
zone->type == dns_zone_stub || zone->type == dns_zone_key ||
- (zone->type == dns_zone_redirect && zone->masters != NULL))
+ (zone->type == dns_zone_redirect && zone->primaries != NULL))
{
if (result != ISC_R_NOMEMORY) {
if (zone->journal != NULL) {
}
isc_result_t
-dns_zone_setprimaries(dns_zone_t *zone, const isc_sockaddr_t *masters,
+dns_zone_setprimaries(dns_zone_t *zone, const isc_sockaddr_t *primaries,
dns_name_t **keynames, dns_name_t **tlsnames,
uint32_t count) {
isc_result_t result = ISC_R_SUCCESS;
unsigned int i;
REQUIRE(DNS_ZONE_VALID(zone));
- REQUIRE(count == 0 || masters != NULL);
+ REQUIRE(count == 0 || primaries != NULL);
if (keynames != NULL || tlsnames != NULL) {
REQUIRE(count != 0);
}
* and update the primaries info. If it won't change then we can just
* unlock and exit.
*/
- if (count != zone->masterscnt ||
- !same_addrs(zone->masters, masters, count) ||
- !same_names(zone->masterkeynames, keynames, count) ||
- !same_names(zone->mastertlsnames, tlsnames, count))
+ if (count != zone->primariescnt ||
+ !same_addrs(zone->primaries, primaries, count) ||
+ !same_names(zone->primarykeynames, keynames, count) ||
+ !same_names(zone->primarytlsnames, tlsnames, count))
{
if (zone->request != NULL) {
dns_request_cancel(zone->request);
/*
* This needs to happen before clear_addresskeylist() sets
- * zone->masterscnt to 0:
+ * zone->primariescnt to 0:
*/
- if (zone->mastersok != NULL) {
- isc_mem_put(zone->mctx, zone->mastersok,
- zone->masterscnt * sizeof(bool));
- zone->mastersok = NULL;
+ if (zone->primariesok != NULL) {
+ isc_mem_put(zone->mctx, zone->primariesok,
+ zone->primariescnt * sizeof(bool));
+ zone->primariesok = NULL;
}
- clear_serverslist(&zone->masters, &zone->masterdscps,
- &zone->masterkeynames, &zone->mastertlsnames,
- &zone->masterscnt, zone->mctx);
+ clear_serverslist(&zone->primaries, &zone->primarydscps,
+ &zone->primarykeynames, &zone->primarytlsnames,
+ &zone->primariescnt, zone->mctx);
/*
- * If count == 0, don't allocate any space for masters, mastersok or
+ * If count == 0, don't allocate any space for primaries, primariesok or
* keynames so internally, those pointers are NULL if count == 0
*/
if (count == 0) {
}
/*
- * mastersok must contain count elements
+ * primariesok must contain count elements
*/
newok = isc_mem_get(zone->mctx, count * sizeof(*newok));
for (i = 0; i < count; i++) {
/*
* Now set up the primaries and primary key lists
*/
- result = set_serverslist(count, masters, &newaddrs, NULL, &newdscps,
+ result = set_serverslist(count, primaries, &newaddrs, NULL, &newdscps,
keynames, &newkeynames, tlsnames, &newtlsnames,
zone->mctx);
INSIST(newdscps == NULL);
/*
* Everything is ok so attach to the zone.
*/
- zone->curmaster = 0;
- zone->mastersok = newok;
- zone->masters = newaddrs;
- zone->masterdscps = newdscps;
- zone->masterkeynames = newkeynames;
- zone->mastertlsnames = newtlsnames;
- zone->masterscnt = count;
- DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NOMASTERS);
+ zone->curprimary = 0;
+ zone->primariesok = newok;
+ zone->primaries = newaddrs;
+ zone->primarydscps = newdscps;
+ zone->primarykeynames = newkeynames;
+ zone->primarytlsnames = newtlsnames;
+ zone->primariescnt = count;
+ DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NOPRIMARIES);
unlock:
UNLOCK_ZONE(zone);
*/
switch (zone->type) {
case dns_zone_redirect:
- if (zone->masters == NULL) {
+ if (zone->primaries == NULL) {
break;
}
/* FALLTHROUGH */
*/
switch (zone->type) {
case dns_zone_redirect:
- if (zone->masters == NULL) {
+ if (zone->primaries == NULL) {
break;
}
/* FALLTHROUGH */
*/
oldflags = atomic_load(&zone->flags);
- if (zone->masterscnt == 0) {
- DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOMASTERS);
- if ((oldflags & DNS_ZONEFLG_NOMASTERS) == 0) {
+ if (zone->primariescnt == 0) {
+ DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOPRIMARIES);
+ if ((oldflags & DNS_ZONEFLG_NOPRIMARIES) == 0) {
dns_zone_log(zone, ISC_LOG_ERROR,
"cannot refresh: no primaries");
}
zone->retry = ISC_MIN(zone->retry * 2, 6 * 3600);
}
- zone->curmaster = 0;
- for (j = 0; j < zone->masterscnt; j++) {
- zone->mastersok[j] = false;
+ zone->curprimary = 0;
+ for (j = 0; j < zone->primariescnt; j++) {
+ zone->primariesok[j] = false;
}
/* initiate soa query */
queue_soa_query(zone);
dns_db_t *zonedb = NULL;
dns_dbversion_t *version = NULL;
dns_name_t *origin = NULL;
- dns_name_t master;
+ dns_name_t primary;
dns_rdata_ns_t ns;
dns_rdata_soa_t soa;
uint32_t serial;
/*
* Find serial and primary server's name.
*/
- dns_name_init(&master, NULL);
+ dns_name_init(&primary, NULL);
result = dns_rdataset_first(&soardset);
if (result != ISC_R_SUCCESS) {
goto cleanup3;
result = dns_rdata_tostruct(&rdata, &soa, NULL);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
dns_rdata_reset(&rdata);
- dns_name_dup(&soa.origin, zone->mctx, &master);
+ dns_name_dup(&soa.origin, zone->mctx, &primary);
serial = soa.serial;
dns_rdataset_disassociate(&soardset);
* configured to do so.
*/
if (!DNS_ZONE_OPTION(zone, DNS_ZONEOPT_NOTIFYTOSOA) &&
- dns_name_compare(&master, &ns.name) == 0)
+ dns_name_compare(&primary, &ns.name) == 0)
{
result = dns_rdataset_next(&nsrdset);
continue;
dns_rdataset_disassociate(&nsrdset);
cleanup3:
- if (dns_name_dynamic(&master)) {
- dns_name_free(&master, zone->mctx);
+ if (dns_name_dynamic(&primary)) {
+ dns_name_free(&primary, zone->mctx);
}
cleanup2:
dns_db_detachnode(zonedb, &node);
dns_stub_t *stub = NULL;
dns_message_t *msg = NULL;
dns_zone_t *zone = NULL;
- char master[ISC_SOCKADDR_FORMATSIZE];
+ char primary[ISC_SOCKADDR_FORMATSIZE];
char source[ISC_SOCKADDR_FORMATSIZE];
uint32_t addr_count, cnamecnt;
isc_result_t result;
goto cleanup;
}
- isc_sockaddr_format(&zone->masteraddr, master, sizeof(master));
+ isc_sockaddr_format(&zone->primaryaddr, primary, sizeof(primary));
isc_sockaddr_format(&zone->sourceaddr, source, sizeof(source));
if (revent->result != ISC_R_SUCCESS) {
- dns_zonemgr_unreachableadd(zone->zmgr, &zone->masteraddr,
+ dns_zonemgr_unreachableadd(zone->zmgr, &zone->primaryaddr,
&zone->sourceaddr, &now);
dns_zone_log(zone, ISC_LOG_INFO,
- "could not refresh stub from master %s"
+ "could not refresh stub from primary %s"
" (source %s): %s",
- master, source, isc_result_totext(revent->result));
+ primary, source,
+ isc_result_totext(revent->result));
goto cleanup;
}
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
"unexpected opcode (%.*s) from %s (source %s)",
- (int)rb.used, opcode, master, source);
+ (int)rb.used, opcode, primary, source);
goto cleanup;
}
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
"unexpected rcode (%.*s) from %s (source %s)",
- (int)rb.used, rcode, master, source);
+ (int)rb.used, rcode, primary, source);
goto cleanup;
}
if (dns_request_usedtcp(revent->request)) {
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: truncated TCP "
- "response from master %s (source %s)",
- master, source);
+ "response from primary %s (source %s)",
+ primary, source);
}
goto cleanup;
}
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
"non-authoritative answer from "
- "master %s (source %s)",
- master, source);
+ "primary %s (source %s)",
+ primary, source);
goto cleanup;
}
if (cnamecnt != 0) {
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: unexpected CNAME response "
- "from master %s (source %s)",
- master, source);
+ "from primary %s (source %s)",
+ primary, source);
goto cleanup;
}
if (addr_count == 0) {
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: no %s records in response "
- "from master %s (source %s)",
- request->ipv4 ? "A" : "AAAA", master, source);
+ "from primary %s (source %s)",
+ request->ipv4 ? "A" : "AAAA", primary, source);
goto cleanup;
}
/*
result = dns_request_createvia(
zone->view->requestmgr, message, &zone->sourceaddr,
- &zone->masteraddr, args->dscp, DNS_REQUESTOPT_TCP,
+ &zone->primaryaddr, args->dscp, DNS_REQUESTOPT_TCP,
args->tsig_key, args->timeout * 3, args->timeout, 0, zone->task,
stub_glue_response_cb, request, &request->request);
dns_stub_t *stub = NULL;
dns_message_t *msg = NULL;
dns_zone_t *zone = NULL;
- char master[ISC_SOCKADDR_FORMATSIZE];
+ char primary[ISC_SOCKADDR_FORMATSIZE];
char source[ISC_SOCKADDR_FORMATSIZE];
uint32_t nscnt, cnamecnt;
isc_result_t result;
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING)) {
zone_debuglog(zone, me, 1, "exiting");
exiting = true;
- goto next_master;
+ goto next_primary;
}
- isc_sockaddr_format(&zone->masteraddr, master, sizeof(master));
+ isc_sockaddr_format(&zone->primaryaddr, primary, sizeof(primary));
isc_sockaddr_format(&zone->sourceaddr, source, sizeof(source));
if (revent->result != ISC_R_SUCCESS) {
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOEDNS);
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"refreshing stub: timeout retrying "
- " without EDNS master %s (source %s)",
- master, source);
- goto same_master;
+ "without EDNS primary %s (source %s)",
+ primary, source);
+ goto same_primary;
}
- dns_zonemgr_unreachableadd(zone->zmgr, &zone->masteraddr,
+ dns_zonemgr_unreachableadd(zone->zmgr, &zone->primaryaddr,
&zone->sourceaddr, &now);
dns_zone_log(zone, ISC_LOG_INFO,
- "could not refresh stub from master %s"
- " (source %s): %s",
- master, source, isc_result_totext(revent->result));
- goto next_master;
+ "could not refresh stub from primary "
+ "%s (source %s): %s",
+ primary, source,
+ isc_result_totext(revent->result));
+ goto next_primary;
}
dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg);
result = dns_request_getresponse(revent->request, msg, 0);
if (result != ISC_R_SUCCESS) {
- goto next_master;
+ goto next_primary;
}
/*
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
"unexpected opcode (%.*s) from %s (source %s)",
- (int)rb.used, opcode, master, source);
- goto next_master;
+ (int)rb.used, opcode, primary, source);
+ goto next_primary;
}
/*
{
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"refreshing stub: rcode (%.*s) retrying "
- "without EDNS master %s (source %s)",
- (int)rb.used, rcode, master, source);
+ "without EDNS primary %s (source %s)",
+ (int)rb.used, rcode, primary, source);
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOEDNS);
- goto same_master;
+ goto same_primary;
}
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
"unexpected rcode (%.*s) from %s (source %s)",
- (int)rb.used, rcode, master, source);
- goto next_master;
+ (int)rb.used, rcode, primary, source);
+ goto next_primary;
}
/*
if (dns_request_usedtcp(revent->request)) {
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: truncated TCP "
- "response from master %s (source %s)",
- master, source);
- goto next_master;
+ "response from primary %s (source %s)",
+ primary, source);
+ goto next_primary;
}
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_USEVC);
- goto same_master;
+ goto same_primary;
}
/*
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
"non-authoritative answer from "
- "master %s (source %s)",
- master, source);
- goto next_master;
+ "primary %s (source %s)",
+ primary, source);
+ goto next_primary;
}
/*
if (cnamecnt != 0) {
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: unexpected CNAME response "
- "from master %s (source %s)",
- master, source);
- goto next_master;
+ "from primary %s (source %s)",
+ primary, source);
+ goto next_primary;
}
if (nscnt == 0) {
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: no NS records in response "
- "from master %s (source %s)",
- master, source);
- goto next_master;
+ "from primary %s (source %s)",
+ primary, source);
+ goto next_primary;
}
atomic_fetch_add(&stub->pending_requests, 1);
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: unable to save NS records "
- "from master %s (source %s)",
- master, source);
- goto next_master;
+ "from primary %s (source %s)",
+ primary, source);
+ goto next_primary;
}
dns_message_detach(&msg);
UNLOCK_ZONE(zone);
return;
-next_master:
+next_primary:
isc_mem_put(zone->mctx, cb_args, sizeof(*cb_args));
if (stub->version != NULL) {
dns_db_closeversion(stub->db, &stub->version, false);
* Skip to next failed / untried primary.
*/
do {
- zone->curmaster++;
- } while (zone->curmaster < zone->masterscnt &&
- zone->mastersok[zone->curmaster]);
+ zone->curprimary++;
+ } while (zone->curprimary < zone->primariescnt &&
+ zone->primariesok[zone->curprimary]);
DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NOEDNS);
- if (exiting || zone->curmaster >= zone->masterscnt) {
+ if (exiting || zone->curprimary >= zone->primariescnt) {
bool done = true;
if (!exiting &&
DNS_ZONE_OPTION(zone, DNS_ZONEOPT_USEALTXFRSRC) &&
/*
* Did we get a good answer from all the primaries?
*/
- for (j = 0; j < zone->masterscnt; j++) {
- if (!zone->mastersok[j]) {
+ for (j = 0; j < zone->primariescnt; j++) {
+ if (!zone->primariesok[j]) {
{
done = false;
break;
done = true;
}
if (!done) {
- zone->curmaster = 0;
+ zone->curprimary = 0;
/*
- * Find the next failed master.
+ * Find the next failed primary.
*/
- while (zone->curmaster < zone->masterscnt &&
- zone->mastersok[zone->curmaster]) {
- zone->curmaster++;
+ while (zone->curprimary < zone->primariescnt &&
+ zone->primariesok[zone->curprimary])
+ {
+ zone->curprimary++;
}
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_USEALTXFRSRC);
} else {
queue_soa_query(zone);
goto free_stub;
-same_master:
+same_primary:
isc_mem_put(zone->mctx, cb_args, sizeof(*cb_args));
if (msg != NULL) {
dns_message_detach(&msg);
dns_message_t *msg = NULL;
uint32_t soacnt, cnamecnt, soacount, nscount;
isc_time_t now;
- char master[ISC_SOCKADDR_FORMATSIZE];
+ char primary[ISC_SOCKADDR_FORMATSIZE];
char source[ISC_SOCKADDR_FORMATSIZE];
dns_rdataset_t *rdataset = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
}
/*
- * if timeout log and next primary;
+ * If timeout, log and try the next primary
*/
-
- isc_sockaddr_format(&zone->masteraddr, master, sizeof(master));
+ isc_sockaddr_format(&zone->primaryaddr, primary, sizeof(primary));
isc_sockaddr_format(&zone->sourceaddr, source, sizeof(source));
if (revent->result != ISC_R_SUCCESS) {
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOEDNS);
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"refresh: timeout retrying without EDNS "
- "master %s (source %s)",
- master, source);
- goto same_master;
+ "primary %s (source %s)",
+ primary, source);
+ goto same_primary;
}
if (revent->result == ISC_R_TIMEDOUT &&
!dns_request_usedtcp(revent->request)) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: retry limit for "
- "master %s exceeded (source %s)",
- master, source);
- /* Try with slave with TCP. */
+ "primary %s exceeded (source %s)",
+ primary, source);
+ /* Try with secondary with TCP. */
if ((zone->type == dns_zone_secondary ||
zone->type == dns_zone_mirror ||
zone->type == dns_zone_redirect) &&
DNS_ZONE_OPTION(zone, DNS_ZONEOPT_TRYTCPREFRESH))
{
if (!dns_zonemgr_unreachable(
- zone->zmgr, &zone->masteraddr,
+ zone->zmgr, &zone->primaryaddr,
&zone->sourceaddr, &now))
{
DNS_ZONE_SETFLAG(
}
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"refresh: skipped tcp fallback "
- "as master %s (source %s) is "
+ "as primary %s (source %s) is "
"unreachable (cached)",
- master, source);
+ primary, source);
}
} else {
dns_zone_log(zone, ISC_LOG_INFO,
- "refresh: failure trying master "
+ "refresh: failure trying primary "
"%s (source %s): %s",
- master, source,
+ primary, source,
isc_result_totext(revent->result));
}
- goto next_master;
+ goto next_primary;
}
dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg);
result = dns_request_getresponse(revent->request, msg, 0);
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO,
- "refresh: unable to get response, master "
- "%s, source %s: %s",
- master, source, isc_result_totext(result));
- goto next_master;
+ "refresh: failure trying primary "
+ "%s (source %s): %s",
+ primary, source, isc_result_totext(result));
+ goto next_primary;
}
/*
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: "
"unexpected opcode (%.*s) from %s (source %s)",
- (int)rb.used, opcode, master, source);
- goto next_master;
+ (int)rb.used, opcode, primary, source);
+ goto next_primary;
}
/*
{
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"refresh: rcode (%.*s) retrying without "
- "EDNS master %s (source %s)",
- (int)rb.used, rcode, master, source);
+ "EDNS primary %s (source %s)",
+ (int)rb.used, rcode, primary, source);
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOEDNS);
- goto same_master;
+ goto same_primary;
}
if (!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NOEDNS) &&
msg->rcode == dns_rcode_badvers) {
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"refresh: rcode (%.*s) retrying without "
- "EDNS EXPIRE OPTION master %s (source %s)",
- (int)rb.used, rcode, master, source);
+ "EDNS EXPIRE OPTION primary %s "
+ "(source %s)",
+ (int)rb.used, rcode, primary, source);
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOEDNS);
- goto same_master;
+ goto same_primary;
}
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: unexpected rcode (%.*s) from "
- "master %s (source %s)",
- (int)rb.used, rcode, master, source);
+ "primary %s (source %s)",
+ (int)rb.used, rcode, primary, source);
/*
* Perhaps AXFR/IXFR is allowed even if SOA queries aren't.
*/
{
goto tcp_transfer;
}
- goto next_master;
+ goto next_primary;
}
/*
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: truncated UDP answer, "
"initiating TCP zone xfer "
- "for master %s (source %s)",
- master, source);
+ "for primary %s (source %s)",
+ primary, source);
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_SOABEFOREAXFR);
goto tcp_transfer;
} else {
if (dns_request_usedtcp(revent->request)) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: truncated TCP response "
- "from master %s (source %s)",
- master, source);
- goto next_master;
+ "from primary %s (source %s)",
+ primary, source);
+ goto next_primary;
}
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_USEVC);
- goto same_master;
+ goto same_primary;
}
}
/*
- * if non-auth log and next primary;
+ * If non-auth, log and try the next primary
*/
if ((msg->flags & DNS_MESSAGEFLAG_AA) == 0) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: non-authoritative answer from "
- "master %s (source %s)",
- master, source);
- goto next_master;
+ "primary %s (source %s)",
+ primary, source);
+ goto next_primary;
}
cnamecnt = message_count(msg, DNS_SECTION_ANSWER, dns_rdatatype_cname);
if (cnamecnt != 0) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: CNAME at top of zone "
- "in master %s (source %s)",
- master, source);
- goto next_master;
+ "in primary %s (source %s)",
+ primary, source);
+ goto next_primary;
}
/*
- * if referral log and next primary;
+ * If referral, log and try the next primary;
*/
if (soacnt == 0 && soacount == 0 && nscount != 0) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: referral response "
- "from master %s (source %s)",
- master, source);
- goto next_master;
+ "from primary %s (source %s)",
+ primary, source);
+ goto next_primary;
}
/*
- * if nodata log and next primary;
+ * If nodata, log and try the next primary;
*/
if (soacnt == 0 && (nscount == 0 || soacount != 0)) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: NODATA response "
- "from master %s (source %s)",
- master, source);
- goto next_master;
+ "from primary %s (source %s)",
+ primary, source);
+ goto next_primary;
}
/*
if (soacnt != 1) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: answer SOA count (%d) != 1 "
- "from master %s (source %s)",
- soacnt, master, source);
- goto next_master;
+ "from primary %s (source %s)",
+ soacnt, primary, source);
+ goto next_primary;
}
/*
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: unable to get SOA record "
- "from master %s (source %s)",
- master, source);
- goto next_master;
+ "from primary %s (source %s)",
+ primary, source);
+ goto next_primary;
}
result = dns_rdataset_first(rdataset);
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: dns_rdataset_first() failed");
- goto next_master;
+ goto next_primary;
}
dns_rdataset_current(rdataset, &rdata);
DNS_ZONE_FLAG(zone, DNS_ZONEFLG_FORCEXFER) ||
isc_serial_gt(serial, oldserial))
{
- if (dns_zonemgr_unreachable(zone->zmgr, &zone->masteraddr,
+ if (dns_zonemgr_unreachable(zone->zmgr, &zone->primaryaddr,
&zone->sourceaddr, &now))
{
dns_zone_log(zone, ISC_LOG_INFO,
- "refresh: skipping %s as master %s "
+ "refresh: skipping %s as primary %s "
"(source %s) is unreachable (cached)",
(zone->type == dns_zone_secondary ||
zone->type == dns_zone_mirror ||
zone->type == dns_zone_redirect)
? "zone transfer"
: "NS query",
- master, source);
- goto next_master;
+ primary, source);
+ goto next_primary;
}
tcp_transfer:
isc_event_free(&event);
}
DNS_ZONE_JITTER_ADD(&now, zone->refresh, &zone->refreshtime);
- zone->mastersok[zone->curmaster] = true;
- goto next_master;
+ zone->primariesok[zone->curprimary] = true;
+ goto next_primary;
} else {
if (!DNS_ZONE_OPTION(zone, DNS_ZONEOPT_MULTIMASTER)) {
dns_zone_log(zone, ISC_LOG_INFO,
"serial number (%u) "
- "received from master %s < ours (%u)",
- soa.serial, master, oldserial);
+ "received from primary %s < ours (%u)",
+ soa.serial, primary, oldserial);
} else {
zone_debuglog(zone, me, 1, "ahead");
}
- zone->mastersok[zone->curmaster] = true;
- goto next_master;
+ zone->primariesok[zone->curprimary] = true;
+ goto next_primary;
}
if (msg != NULL) {
dns_message_detach(&msg);
}
goto detach;
-next_master:
+next_primary:
if (msg != NULL) {
dns_message_detach(&msg);
}
* Skip to next failed / untried primary.
*/
do {
- zone->curmaster++;
- } while (zone->curmaster < zone->masterscnt &&
- zone->mastersok[zone->curmaster]);
+ zone->curprimary++;
+ } while (zone->curprimary < zone->primariescnt &&
+ zone->primariesok[zone->curprimary]);
DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NOEDNS);
- if (zone->curmaster >= zone->masterscnt) {
+ if (zone->curprimary >= zone->primariescnt) {
bool done = true;
if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_USEALTXFRSRC) &&
!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_USEALTXFRSRC))
/*
* Did we get a good answer from all the primaries?
*/
- for (j = 0; j < zone->masterscnt; j++) {
- if (!zone->mastersok[j]) {
+ for (j = 0; j < zone->primariescnt; j++) {
+ if (!zone->primariesok[j]) {
{
done = false;
break;
}
if (!done) {
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_USEALTXFRSRC);
- zone->curmaster = 0;
+ zone->curprimary = 0;
/*
* Find the next failed primary.
*/
- while (zone->curmaster < zone->masterscnt &&
- zone->mastersok[zone->curmaster]) {
- zone->curmaster++;
+ while (zone->curprimary < zone->primariescnt &&
+ zone->primariesok[zone->curprimary])
+ {
+ zone->curprimary++;
}
goto requeue;
}
queue_soa_query(zone);
goto detach;
-same_master:
+same_primary:
if (msg != NULL) {
dns_message_detach(&msg);
}
dns_message_t *message = NULL;
dns_zone_t *zone = event->ev_arg;
dns_zone_t *dummy = NULL;
- isc_netaddr_t masterip;
+ isc_netaddr_t primaryip;
dns_tsigkey_t *key = NULL;
dns_transport_t *transport = NULL;
uint32_t options;
}
again:
- INSIST(zone->masterscnt > 0);
- INSIST(zone->curmaster < zone->masterscnt);
+ INSIST(zone->primariescnt > 0);
+ INSIST(zone->curprimary < zone->primariescnt);
- zone->masteraddr = zone->masters[zone->curmaster];
+ zone->primaryaddr = zone->primaries[zone->curprimary];
- isc_netaddr_fromsockaddr(&masterip, &zone->masteraddr);
+ isc_netaddr_fromsockaddr(&primaryip, &zone->primaryaddr);
/*
* First, look for a tsig key in the primaries statement, then
* try for a server key.
*/
- if ((zone->masterkeynames != NULL) &&
- (zone->masterkeynames[zone->curmaster] != NULL))
+ if ((zone->primarykeynames != NULL) &&
+ (zone->primarykeynames[zone->curprimary] != NULL))
{
dns_view_t *view = dns_zone_getview(zone);
- dns_name_t *keyname = zone->masterkeynames[zone->curmaster];
+ dns_name_t *keyname = zone->primarykeynames[zone->curprimary];
result = dns_view_gettsig(view, keyname, &key);
if (result != ISC_R_SUCCESS) {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(keyname, namebuf, sizeof(namebuf));
dns_zone_log(zone, ISC_LOG_ERROR,
"unable to find key: %s", namebuf);
- goto skip_master;
+ goto skip_primary;
}
}
if (key == NULL) {
- result = dns_view_getpeertsig(zone->view, &masterip, &key);
+ result = dns_view_getpeertsig(zone->view, &primaryip, &key);
if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) {
char addrbuf[ISC_NETADDR_FORMATSIZE];
- isc_netaddr_format(&masterip, addrbuf, sizeof(addrbuf));
+ isc_netaddr_format(&primaryip, addrbuf,
+ sizeof(addrbuf));
dns_zone_log(zone, ISC_LOG_ERROR,
"unable to find TSIG key for %s", addrbuf);
- goto skip_master;
+ goto skip_primary;
}
}
- if ((zone->mastertlsnames != NULL) &&
- (zone->mastertlsnames[zone->curmaster] != NULL))
+ if ((zone->primarytlsnames != NULL) &&
+ (zone->primarytlsnames[zone->curprimary] != NULL))
{
dns_view_t *view = dns_zone_getview(zone);
- dns_name_t *tlsname = zone->mastertlsnames[zone->curmaster];
+ dns_name_t *tlsname = zone->primarytlsnames[zone->curprimary];
result = dns_view_gettransport(view, DNS_TRANSPORT_TLS, tlsname,
&transport);
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"unable to find TLS configuration: %s",
namebuf);
- goto skip_master;
+ goto skip_primary;
}
}
if (zone->view->peers != NULL) {
dns_peer_t *peer = NULL;
bool edns, usetcp;
- result = dns_peerlist_peerbyaddr(zone->view->peers, &masterip,
+ result = dns_peerlist_peerbyaddr(zone->view->peers, &primaryip,
&peer);
if (result == ISC_R_SUCCESS) {
result = dns_peer_getsupportedns(peer, &edns);
}
}
- switch (isc_sockaddr_pf(&zone->masteraddr)) {
+ switch (isc_sockaddr_pf(&zone->primaryaddr)) {
case PF_INET:
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_USEALTXFRSRC)) {
if (isc_sockaddr_equal(&zone->altxfrsource4,
&zone->xfrsource4)) {
- goto skip_master;
+ goto skip_primary;
}
zone->sourceaddr = zone->altxfrsource4;
if (!have_xfrdscp) {
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_USEALTXFRSRC)) {
if (isc_sockaddr_equal(&zone->altxfrsource6,
&zone->xfrsource6)) {
- goto skip_master;
+ goto skip_primary;
}
zone->sourceaddr = zone->altxfrsource6;
if (!have_xfrdscp) {
}
result = dns_request_createvia(
zone->view->requestmgr, message, &zone->sourceaddr,
- &zone->masteraddr, dscp, options, key, timeout * 3, timeout, 0,
+ &zone->primaryaddr, dscp, options, key, timeout * 3, timeout, 0,
zone->task, refresh_callback, zone, &zone->request);
if (result != ISC_R_SUCCESS) {
zone_idetach(&dummy);
zone_debuglog(zone, me, 1, "dns_request_createvia() failed: %s",
isc_result_totext(result));
- goto skip_master;
+ goto skip_primary;
} else {
- if (isc_sockaddr_pf(&zone->masteraddr) == PF_INET) {
+ if (isc_sockaddr_pf(&zone->primaryaddr) == PF_INET) {
inc_stats(zone, dns_zonestatscounter_soaoutv4);
} else {
inc_stats(zone, dns_zonestatscounter_soaoutv6);
dns_zone_idetach(&zone);
return;
-skip_master:
+skip_primary:
if (transport != NULL) {
dns_transport_detach(&transport);
}
* Skip to next failed / untried primary.
*/
do {
- zone->curmaster++;
- } while (zone->curmaster < zone->masterscnt &&
- zone->mastersok[zone->curmaster]);
- if (zone->curmaster < zone->masterscnt) {
+ zone->curprimary++;
+ } while (zone->curprimary < zone->primariescnt &&
+ zone->primariesok[zone->curprimary]);
+ if (zone->curprimary < zone->primariescnt) {
goto again;
}
- zone->curmaster = 0;
+ zone->curprimary = 0;
goto cleanup;
}
const char me[] = "ns_query";
isc_result_t result;
dns_message_t *message = NULL;
- isc_netaddr_t masterip;
+ isc_netaddr_t primaryip;
dns_tsigkey_t *key = NULL;
dns_dbnode_t *node = NULL;
int timeout;
result = create_query(zone, dns_rdatatype_ns, &zone->origin, &message);
INSIST(result == ISC_R_SUCCESS);
- INSIST(zone->masterscnt > 0);
- INSIST(zone->curmaster < zone->masterscnt);
- zone->masteraddr = zone->masters[zone->curmaster];
+ INSIST(zone->primariescnt > 0);
+ INSIST(zone->curprimary < zone->primariescnt);
+ zone->primaryaddr = zone->primaries[zone->curprimary];
- isc_netaddr_fromsockaddr(&masterip, &zone->masteraddr);
+ isc_netaddr_fromsockaddr(&primaryip, &zone->primaryaddr);
/*
* First, look for a tsig key in the primaries statement, then
* try for a server key.
*/
- if ((zone->masterkeynames != NULL) &&
- (zone->masterkeynames[zone->curmaster] != NULL))
+ if ((zone->primarykeynames != NULL) &&
+ (zone->primarykeynames[zone->curprimary] != NULL))
{
dns_view_t *view = dns_zone_getview(zone);
- dns_name_t *keyname = zone->masterkeynames[zone->curmaster];
+ dns_name_t *keyname = zone->primarykeynames[zone->curprimary];
result = dns_view_gettsig(view, keyname, &key);
if (result != ISC_R_SUCCESS) {
char namebuf[DNS_NAME_FORMATSIZE];
}
}
if (key == NULL) {
- (void)dns_view_getpeertsig(zone->view, &masterip, &key);
+ (void)dns_view_getpeertsig(zone->view, &primaryip, &key);
}
/* FIXME(OS): Do we need the transport here too? Most probably yes */
if (zone->view->peers != NULL) {
dns_peer_t *peer = NULL;
bool edns;
- result = dns_peerlist_peerbyaddr(zone->view->peers, &masterip,
+ result = dns_peerlist_peerbyaddr(zone->view->peers, &primaryip,
&peer);
if (result == ISC_R_SUCCESS) {
result = dns_peer_getsupportedns(peer, &edns);
/*
* Always use TCP so that we shouldn't truncate in additional section.
*/
- switch (isc_sockaddr_pf(&zone->masteraddr)) {
+ switch (isc_sockaddr_pf(&zone->primaryaddr)) {
case PF_INET:
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_USEALTXFRSRC)) {
zone->sourceaddr = zone->altxfrsource4;
result = dns_request_createvia(
zone->view->requestmgr, message, &zone->sourceaddr,
- &zone->masteraddr, dscp, DNS_REQUESTOPT_TCP, key, timeout * 3,
+ &zone->primaryaddr, dscp, DNS_REQUESTOPT_TCP, key, timeout * 3,
timeout, 0, zone->task, stub_callback, cb_args, &zone->request);
if (result != ISC_R_SUCCESS) {
zone_debuglog(zone, me, 1, "dns_request_createvia() failed: %s",
switch (zone->type) {
case dns_zone_redirect:
- if (zone->masters != NULL) {
- goto treat_as_slave;
+ if (zone->primaries != NULL) {
+ goto treat_as_secondary;
}
/* FALLTHROUGH */
case dns_zone_secondary:
case dns_zone_mirror:
- treat_as_slave:
+ treat_as_secondary:
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDNOTIFY) ||
DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDSTARTUPNOTIFY))
{
case dns_zone_stub:
if (!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_REFRESH) &&
- !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NOMASTERS) &&
+ !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NOPRIMARIES) &&
!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NOREFRESH) &&
!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADING) &&
!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADPENDING) &&
* ROLLOVER.
*
* SOA: RFC1996
- * Check that 'from' is a valid notify source, (zone->masters).
+ * Check that 'from' is a valid notify source, (zone->primaries).
* Return DNS_R_REFUSED if not.
*
* If the notify message contains a serial number check it
}
isc_netaddr_fromsockaddr(&netaddr, from);
- for (i = 0; i < zone->masterscnt; i++) {
- if (isc_sockaddr_eqaddr(from, &zone->masters[i])) {
+ for (i = 0; i < zone->primariescnt; i++) {
+ if (isc_sockaddr_eqaddr(from, &zone->primaries[i])) {
break;
}
if (zone->view->aclenv->match_mapped &&
IN6_IS_ADDR_V4MAPPED(&from->type.sin6.sin6_addr) &&
- isc_sockaddr_pf(&zone->masters[i]) == AF_INET)
+ isc_sockaddr_pf(&zone->primaries[i]) == AF_INET)
{
isc_netaddr_t na1, na2;
isc_netaddr_fromv4mapped(&na1, &netaddr);
- isc_netaddr_fromsockaddr(&na2, &zone->masters[i]);
+ isc_netaddr_fromsockaddr(&na2, &zone->primaries[i]);
if (isc_netaddr_equal(&na1, &na2)) {
break;
}
*/
tsigkey = dns_message_gettsigkey(msg);
tsig = dns_tsigkey_identity(tsigkey);
- if (i >= zone->masterscnt && zone->notify_acl != NULL &&
+ if (i >= zone->primariescnt && zone->notify_acl != NULL &&
(dns_acl_match(&netaddr, tsig, zone->notify_acl, zone->view->aclenv,
&match, NULL) == ISC_R_SUCCESS) &&
match > 0)
{
/* Accept notify. */
- } else if (i >= zone->masterscnt) {
+ } else if (i >= zone->primariescnt) {
UNLOCK_ZONE(zone);
dns_zone_log(zone, ISC_LOG_INFO,
- "refused notify from non-master: %s", fromtext);
+ "refused notify from non-primary: %s", fromtext);
inc_stats(zone, dns_zonestatscounter_notifyrej);
return (DNS_R_REFUSED);
}
REQUIRE(DNS_ZONE_VALID(zone));
REQUIRE(zone->type == dns_zone_redirect);
- return (zone->masters == NULL ? dns_zone_primary : dns_zone_secondary);
+ return (zone->primaries == NULL ? dns_zone_primary
+ : dns_zone_secondary);
}
dns_name_t *
RUNTIME_CHECK(soacount > 0U);
if ((zone->type == dns_zone_secondary ||
(zone->type == dns_zone_redirect &&
- zone->masters != NULL)) &&
+ zone->primaries != NULL)) &&
!isc_serial_gt(serial, oldserial))
{
uint32_t serialmin, serialmax;
ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
if (zone->db == NULL) {
ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
- goto same_master;
+ goto same_primary;
}
/*
}
DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_HAVETIMERS);
zone_unload(zone);
- goto next_master;
+ goto next_primary;
}
if (nscount == 0) {
dns_zone_log(zone, ISC_LOG_ERROR,
}
DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_HAVETIMERS);
zone_unload(zone);
- goto next_master;
+ goto next_primary;
}
zone->refresh = RANGE(refresh, zone->minrefresh,
zone->maxrefresh);
case DNS_R_BADIXFR:
/* Force retry with AXFR. */
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOIXFR);
- goto same_master;
+ goto same_primary;
case DNS_R_TOOMANYRECORDS:
case DNS_R_VERIFYFAILURE:
break;
default:
- next_master:
+ next_primary:
/*
* Skip to next failed / untried primary.
*/
do {
- zone->curmaster++;
- } while (zone->curmaster < zone->masterscnt &&
- zone->mastersok[zone->curmaster]);
+ zone->curprimary++;
+ } while (zone->curprimary < zone->primariescnt &&
+ zone->primariesok[zone->curprimary]);
/* FALLTHROUGH */
- same_master:
- if (zone->curmaster >= zone->masterscnt) {
- zone->curmaster = 0;
+ same_primary:
+ if (zone->curprimary >= zone->primariescnt) {
+ zone->curprimary = 0;
if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_USEALTXFRSRC) &&
!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_USEALTXFRSRC))
{
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_REFRESH);
DNS_ZONE_SETFLAG(zone,
DNS_ZONEFLG_USEALTXFRSRC);
- while (zone->curmaster < zone->masterscnt &&
- zone->mastersok[zone->curmaster]) {
- zone->curmaster++;
+ while (zone->curprimary < zone->primariescnt &&
+ zone->primariesok[zone->curprimary])
+ {
+ zone->curprimary++;
}
again = true;
} else {
got_transfer_quota(isc_task_t *task, isc_event_t *event) {
isc_result_t result = ISC_R_SUCCESS;
dns_peer_t *peer = NULL;
- char master[ISC_SOCKADDR_FORMATSIZE];
+ char primary[ISC_SOCKADDR_FORMATSIZE];
char source[ISC_SOCKADDR_FORMATSIZE];
dns_rdatatype_t xfrtype;
dns_zone_t *zone = event->ev_arg;
- isc_netaddr_t masterip;
+ isc_netaddr_t primaryip;
isc_sockaddr_t sourceaddr;
- isc_sockaddr_t masteraddr;
+ isc_sockaddr_t primaryaddr;
isc_time_t now;
const char *soa_before = "";
isc_dscp_t dscp = -1;
TIME_NOW(&now);
- isc_sockaddr_format(&zone->masteraddr, master, sizeof(master));
- if (dns_zonemgr_unreachable(zone->zmgr, &zone->masteraddr,
+ isc_sockaddr_format(&zone->primaryaddr, primary, sizeof(primary));
+ if (dns_zonemgr_unreachable(zone->zmgr, &zone->primaryaddr,
&zone->sourceaddr, &now))
{
isc_sockaddr_format(&zone->sourceaddr, source, sizeof(source));
dns_zone_logc(zone, DNS_LOGCATEGORY_XFER_IN, ISC_LOG_INFO,
"got_transfer_quota: skipping zone transfer as "
- "master %s (source %s) is unreachable (cached)",
- master, source);
+ "primary %s (source %s) is unreachable (cached)",
+ primary, source);
CHECK(ISC_R_CANCELED);
}
- isc_netaddr_fromsockaddr(&masterip, &zone->masteraddr);
- (void)dns_peerlist_peerbyaddr(zone->view->peers, &masterip, &peer);
+ isc_netaddr_fromsockaddr(&primaryip, &zone->primaryaddr);
+ (void)dns_peerlist_peerbyaddr(zone->view->peers, &primaryip, &peer);
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_SOABEFOREAXFR)) {
soa_before = "SOA before ";
dns_zone_logc(zone, DNS_LOGCATEGORY_XFER_IN, ISC_LOG_DEBUG(1),
"no database exists yet, requesting AXFR of "
"initial version from %s",
- master);
+ primary);
xfrtype = dns_rdatatype_axfr;
} else if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_FORCEXFER)) {
dns_zone_logc(zone, DNS_LOGCATEGORY_XFER_IN, ISC_LOG_DEBUG(1),
"forced reload, requesting AXFR of "
"initial version from %s",
- master);
+ primary);
xfrtype = dns_rdatatype_axfr;
} else if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NOIXFR)) {
dns_zone_logc(zone, DNS_LOGCATEGORY_XFER_IN, ISC_LOG_DEBUG(1),
"retrying with AXFR from %s due to "
"previous IXFR failure",
- master);
+ primary);
xfrtype = dns_rdatatype_axfr;
LOCK_ZONE(zone);
DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NOIXFR);
ISC_LOG_DEBUG(1),
"IXFR disabled, "
"requesting %sAXFR from %s",
- soa_before, master);
+ soa_before, primary);
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_SOABEFOREAXFR)) {
xfrtype = dns_rdatatype_soa;
} else {
} else {
dns_zone_logc(zone, DNS_LOGCATEGORY_XFER_IN,
ISC_LOG_DEBUG(1),
- "requesting IXFR from %s", master);
+ "requesting IXFR from %s", primary);
xfrtype = dns_rdatatype_ixfr;
}
}
* First, look for a tsig key in the primaries statement, then
* try for a server key.
*/
- if ((zone->masterkeynames != NULL) &&
- (zone->masterkeynames[zone->curmaster] != NULL))
+ if ((zone->primarykeynames != NULL) &&
+ (zone->primarykeynames[zone->curprimary] != NULL))
{
dns_view_t *view = dns_zone_getview(zone);
- dns_name_t *keyname = zone->masterkeynames[zone->curmaster];
+ dns_name_t *keyname = zone->primarykeynames[zone->curprimary];
result = dns_view_gettsig(view, keyname, &zone->tsigkey);
}
if (zone->tsigkey == NULL) {
- result = dns_view_getpeertsig(zone->view, &masterip,
+ result = dns_view_getpeertsig(zone->view, &primaryip,
&zone->tsigkey);
}
isc_result_totext(result));
}
- if ((zone->mastertlsnames != NULL) &&
- (zone->mastertlsnames[zone->curmaster] != NULL))
+ if ((zone->primarytlsnames != NULL) &&
+ (zone->primarytlsnames[zone->curprimary] != NULL))
{
dns_view_t *view = dns_zone_getview(zone);
- dns_name_t *tlsname = zone->mastertlsnames[zone->curmaster];
+ dns_name_t *tlsname = zone->primarytlsnames[zone->curprimary];
result = dns_view_gettransport(view, DNS_TRANSPORT_TLS, tlsname,
&zone->transport);
isc_result_totext(result));
}
- if (zone->masterdscps != NULL) {
- dscp = zone->masterdscps[zone->curmaster];
+ if (zone->primarydscps != NULL) {
+ dscp = zone->primarydscps[zone->curprimary];
}
LOCK_ZONE(zone);
- masteraddr = zone->masteraddr;
+ primaryaddr = zone->primaryaddr;
sourceaddr = zone->sourceaddr;
- switch (isc_sockaddr_pf(&masteraddr)) {
+ switch (isc_sockaddr_pf(&primaryaddr)) {
case PF_INET:
if (dscp == -1) {
dscp = zone->xfrsource4dscp;
ISC_UNREACHABLE();
}
UNLOCK_ZONE(zone);
- INSIST(isc_sockaddr_pf(&masteraddr) == isc_sockaddr_pf(&sourceaddr));
+ INSIST(isc_sockaddr_pf(&primaryaddr) == isc_sockaddr_pf(&sourceaddr));
if (zone->xfr != NULL) {
dns_xfrin_detach(&zone->xfr);
}
- CHECK(dns_xfrin_create(zone, xfrtype, &masteraddr, &sourceaddr, dscp,
+ CHECK(dns_xfrin_create(zone, xfrtype, &primaryaddr, &sourceaddr, dscp,
zone->tsigkey, zone->transport, zone->mctx,
zone->zmgr->netmgr, zone_xfrdone, &zone->xfr));
LOCK_ZONE(zone);
if (xfrtype == dns_rdatatype_axfr) {
- if (isc_sockaddr_pf(&masteraddr) == PF_INET) {
+ if (isc_sockaddr_pf(&primaryaddr) == PF_INET) {
inc_stats(zone, dns_zonestatscounter_axfrreqv4);
} else {
inc_stats(zone, dns_zonestatscounter_axfrreqv6);
}
} else if (xfrtype == dns_rdatatype_ixfr) {
- if (isc_sockaddr_pf(&masteraddr) == PF_INET) {
+ if (isc_sockaddr_pf(&primaryaddr) == PF_INET) {
inc_stats(zone, dns_zonestatscounter_ixfrreqv4);
} else {
inc_stats(zone, dns_zonestatscounter_ixfrreqv6);
}
static isc_result_t
-sendtomaster(dns_forward_t *forward) {
+sendtoprimary(dns_forward_t *forward) {
isc_result_t result;
isc_sockaddr_t src;
isc_dscp_t dscp = -1;
return (ISC_R_CANCELED);
}
- if (forward->which >= forward->zone->masterscnt) {
+ if (forward->which >= forward->zone->primariescnt) {
UNLOCK_ZONE(forward->zone);
return (ISC_R_NOMORE);
}
- forward->addr = forward->zone->masters[forward->which];
+ forward->addr = forward->zone->primaries[forward->which];
/*
* Always use TCP regardless of whether the original update
* used TCP.
const char me[] = "forward_callback";
dns_requestevent_t *revent = (dns_requestevent_t *)event;
dns_message_t *msg = NULL;
- char master[ISC_SOCKADDR_FORMATSIZE];
+ char primary[ISC_SOCKADDR_FORMATSIZE];
isc_result_t result;
dns_forward_t *forward;
dns_zone_t *zone;
ENTER;
- isc_sockaddr_format(&forward->addr, master, sizeof(master));
+ isc_sockaddr_format(&forward->addr, primary, sizeof(primary));
if (revent->result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO,
"could not forward dynamic update to %s: %s",
- master, isc_result_totext(revent->result));
- goto next_master;
+ primary, isc_result_totext(revent->result));
+ goto next_primary;
}
dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg);
DNS_MESSAGEPARSE_PRESERVEORDER |
DNS_MESSAGEPARSE_CLONEBUFFER);
if (result != ISC_R_SUCCESS) {
- goto next_master;
+ goto next_primary;
}
/*
dns_zone_log(zone, ISC_LOG_INFO,
"forwarding dynamic update: "
"unexpected opcode (%.*s) from %s",
- (int)rb.used, opcode, master);
- goto next_master;
+ (int)rb.used, opcode, primary);
+ goto next_primary;
}
switch (msg->rcode) {
(void)dns_rcode_totext(msg->rcode, &rb);
dns_zone_log(zone, ISC_LOG_INFO,
"forwarded dynamic update: "
- "master %s returned: %.*s",
- master, (int)rb.used, rcode);
+ "primary %s returned: %.*s",
+ primary, (int)rb.used, rcode);
break;
}
(void)dns_rcode_totext(msg->rcode, &rb);
dns_zone_log(zone, ISC_LOG_WARNING,
"forwarding dynamic update: "
- "unexpected response: master %s returned: %.*s",
- master, (int)rb.used, rcode);
- goto next_master;
+ "unexpected response: primary %s returned: %.*s",
+ primary, (int)rb.used, rcode);
+ goto next_primary;
}
/* Try another server for these rcodes. */
case dns_rcode_notimp:
case dns_rcode_badvers:
default:
- goto next_master;
+ goto next_primary;
}
/* call callback */
isc_event_free(&event);
return;
-next_master:
+next_primary:
if (msg != NULL) {
dns_message_detach(&msg);
}
isc_event_free(&event);
forward->which++;
dns_request_destroy(&forward->request);
- result = sendtomaster(forward);
+ result = sendtoprimary(forward);
if (result != ISC_R_SUCCESS) {
/* call callback */
dns_zone_log(zone, ISC_LOG_DEBUG(3),
isc_mem_attach(zone->mctx, &forward->mctx);
dns_zone_iattach(zone, &forward->zone);
- result = sendtomaster(forward);
+ result = sendtoprimary(forward);
cleanup:
if (result != ISC_R_SUCCESS) {
static isc_result_t
zmgr_start_xfrin_ifquota(dns_zonemgr_t *zmgr, dns_zone_t *zone) {
dns_peer_t *peer = NULL;
- isc_netaddr_t masterip;
+ isc_netaddr_t primaryip;
uint32_t nxfrsin, nxfrsperns;
dns_zone_t *x;
uint32_t maxtransfersin, maxtransfersperns;
* Find any configured information about the server we'd
* like to transfer this zone from.
*/
- isc_netaddr_fromsockaddr(&masterip, &zone->masteraddr);
- (void)dns_peerlist_peerbyaddr(zone->view->peers, &masterip, &peer);
+ isc_netaddr_fromsockaddr(&primaryip, &zone->primaryaddr);
+ (void)dns_peerlist_peerbyaddr(zone->view->peers, &primaryip, &peer);
UNLOCK_ZONE(zone);
/*
* Determine the total maximum number of simultaneous
* transfers allowed, and the maximum for this specific
- * master.
+ * primary.
*/
maxtransfersin = zmgr->transfersin;
maxtransfersperns = zmgr->transfersperns;
isc_netaddr_t xip;
LOCK_ZONE(x);
- isc_netaddr_fromsockaddr(&xip, &x->masteraddr);
+ isc_netaddr_fromsockaddr(&xip, &x->primaryaddr);
UNLOCK_ZONE(x);
nxfrsin++;
- if (isc_netaddr_equal(&xip, &masterip)) {
+ if (isc_netaddr_equal(&xip, &primaryip)) {
nxfrsperns++;
}
}
dns_zonemgr_unreachabledel(dns_zonemgr_t *zmgr, isc_sockaddr_t *remote,
isc_sockaddr_t *local) {
unsigned int i;
- char master[ISC_SOCKADDR_FORMATSIZE];
+ char primary[ISC_SOCKADDR_FORMATSIZE];
char source[ISC_SOCKADDR_FORMATSIZE];
- isc_sockaddr_format(remote, master, sizeof(master));
+ isc_sockaddr_format(remote, primary, sizeof(primary));
isc_sockaddr_format(local, source, sizeof(source));
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
REQUIRE(DNS_ZONE_VALID(zone));
if (zone->type == dns_zone_primary ||
- (zone->type == dns_zone_redirect && zone->masters == NULL))
+ (zone->type == dns_zone_redirect && zone->primaries == NULL))
{
return;
}
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DIALNOTIFY)) {
dns_zone_notify(zone);
}
- if (zone->type != dns_zone_primary && zone->masters != NULL &&
+ if (zone->type != dns_zone_primary && zone->primaries != NULL &&
DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DIALREFRESH))
{
dns_zone_refresh(zone);
projects / thirdparty / bind9.git / commitdiff
