}
isc_result_t
-setup_logging(isc_mem_t *mctx ISC_ATTR_UNUSED, FILE *errout, isc_log_t **logp) {
+setup_logging(FILE *errout) {
isc_logdestination_t destination;
isc_logconfig_t *logconfig = NULL;
- isc_log_t *log = NULL;
- isc_log_registercategories(log, categories);
- dns_log_init(log);
- cfg_log_init(log);
- ns_log_init(log);
+ isc_log_registercategories(categories);
+ dns_log_init();
+ cfg_log_init();
+ ns_log_init();
- logconfig = isc_logconfig_get(log);
+ logconfig = isc_logconfig_get();
destination.file.stream = errout;
destination.file.name = NULL;
destination.file.versions = ISC_LOG_ROLLNEVER;
RUNTIME_CHECK(isc_log_usechannel(logconfig, "stderr", NULL, NULL) ==
ISC_R_SUCCESS);
- *logp = log;
return (ISC_R_SUCCESS);
}
ISC_LANG_BEGINDECLS
isc_result_t
-setup_logging(isc_mem_t *mctx, FILE *errout, isc_log_t **logp);
+setup_logging(FILE *errout);
isc_result_t
load_zone(isc_mem_t *mctx, const char *zonename, const char *filename,
static const char *program = "named-checkconf";
-isc_log_t *logc = NULL;
-
#define CHECK(r) \
do { \
result = (r); \
directory = cfg_obj_asstring(obj);
result = isc_dir_chdir(directory);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logc, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"change directory to '%s' failed: %s\n", directory,
isc_result_totext(result));
return (result);
conffile = NAMED_CONFFILE;
}
- CHECK(setup_logging(mctx, stdout, &logc));
+ CHECK(setup_logging(stdout));
- CHECK(cfg_parser_create(mctx, logc, &parser));
+ CHECK(cfg_parser_create(mctx, &parser));
if (nodeprecate) {
cfg_parser_setflags(parser, CFG_PCTX_NODEPRECATED, true);
cfg_parser_setcallback(parser, directory_callback, NULL);
CHECK(cfg_parse_file(parser, conffile, &cfg_type_namedconf, &config));
- CHECK(isccfg_check_namedconf(config, checkflags, logc, mctx));
+ CHECK(isccfg_check_namedconf(config, checkflags, mctx));
if (load_zones || list_zones) {
CHECK(load_zones_fromconfig(config, mctx, list_zones));
}
int c;
char *origin = NULL;
const char *filename = NULL;
- isc_log_t *lctx = NULL;
isc_result_t result;
char classname_in[] = "IN";
char *classname = classname_in;
isc_mem_create(&mctx);
if (!quiet) {
- RUNTIME_CHECK(setup_logging(mctx, errout, &lctx) ==
- ISC_R_SUCCESS);
+ RUNTIME_CHECK(setup_logging(errout) == ISC_R_SUCCESS);
}
origin = argv[isc_commandline_index++];
/* Variables used internally by delv. */
char *progname = NULL;
static isc_mem_t *mctx = NULL;
-static isc_log_t *lctx = NULL;
static dns_view_t *view = NULL;
static ns_server_t *sctx = NULL;
static ns_interface_t *ifp = NULL;
va_list ap;
char msgbuf[2048];
- if (!isc_log_wouldlog(lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
va_start(ap, fmt);
vsnprintf(msgbuf, sizeof(msgbuf), fmt, ap);
- isc_log_write(lctx, LOGCATEGORY_DEFAULT, LOGMODULE_DEFAULT, level, "%s",
+ isc_log_write(LOGCATEGORY_DEFAULT, LOGMODULE_DEFAULT, level, "%s",
msgbuf);
va_end(ap);
}
isc_logconfig_t *logconfig = NULL;
int packetlevel = 10;
- isc_log_registercategories(lctx, categories);
- isc_log_registermodules(lctx, modules);
- dns_log_init(lctx);
- cfg_log_init(lctx);
+ isc_log_registercategories(categories);
+ isc_log_registermodules(modules);
+ dns_log_init();
+ cfg_log_init();
- logconfig = isc_logconfig_get(lctx);
+ logconfig = isc_logconfig_get();
destination.file.stream = errout;
destination.file.name = NULL;
destination.file.versions = ISC_LOG_ROLLNEVER;
ISC_LOG_DYNAMIC, &destination,
ISC_LOG_PRINTPREFIX);
- isc_log_setdebuglevel(lctx, loglevel);
+ isc_log_setdebuglevel(loglevel);
isc_log_settag(logconfig, ";; ");
result = isc_log_usechannel(logconfig, "stderr",
cleanup:
if (result == DST_R_NOCRYPTO) {
- cfg_obj_log(key, lctx, ISC_LOG_ERROR, "no crypto support");
+ cfg_obj_log(key, ISC_LOG_ERROR, "no crypto support");
} else if (result == DST_R_UNSUPPORTEDALG) {
- cfg_obj_log(key, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(key, ISC_LOG_WARNING,
"skipping trusted key '%s': %s", keynamestr,
isc_result_totext(result));
result = ISC_R_SUCCESS;
} else if (result != ISC_R_SUCCESS) {
- cfg_obj_log(key, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"failed to add trusted key '%s': %s", keynamestr,
isc_result_totext(result));
result = ISC_R_FAILURE;
CHECK(convert_name(&afn, &anchor_name, trust_anchor));
}
- CHECK(cfg_parser_create(mctx, dns_lctx, &parser));
+ CHECK(cfg_parser_create(mctx, &parser));
if (anchorfile != NULL) {
if (access(anchorfile, R_OK) != 0) {
unsigned int timeout = 0;
unsigned int extrabytes;
isc_mem_t *mctx = NULL;
-isc_log_t *lctx = NULL;
isc_nm_t *netmgr = NULL;
isc_loopmgr_t *loopmgr = NULL;
isc_loop_t *mainloop = NULL;
return (ISC_R_FILENOTFOUND);
}
- result = cfg_parser_create(mctx, NULL, &pctx);
+ result = cfg_parser_create(mctx, &pctx);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
isc_managers_create(&mctx, 1, &loopmgr, &netmgr);
- dns_log_init(lctx);
+ dns_log_init();
- logconfig = isc_logconfig_get(lctx);
+ logconfig = isc_logconfig_get();
result = isc_log_usechannel(logconfig, "default_debug", NULL, NULL);
check_result(result, "isc_log_usechannel");
- isc_log_setdebuglevel(lctx, 0);
+ isc_log_setdebuglevel(0);
isc_mem_setname(mctx, "dig");
mainloop = isc_loop_main(loopmgr);
/*
* Infrastructure
*/
-static isc_log_t *lctx = NULL;
static isc_mem_t *mctx = NULL;
/*
free_keytable(&new_key_tbl);
}
free_all_sets();
- if (lctx != NULL) {
- cleanup_logging(&lctx);
- }
if (mctx != NULL) {
if (print_mem_stats && verbose > 10) {
isc_mem_stats(mctx, stdout);
dtype[0] = DNS_DSDIGEST_SHA256;
}
- setup_logging(mctx, &lctx);
+ setup_logging();
if (ds_path == NULL) {
fatal("missing -d DS pathname");
bool usekeyset = false;
bool showall = false;
isc_result_t result;
- isc_log_t *log = NULL;
dns_rdataset_t rdataset;
dns_rdata_t rdata;
fatal("extraneous arguments");
}
- setup_logging(mctx, &log);
+ setup_logging();
dns_rdataset_init(&rdataset);
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
- cleanup_logging(&log);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}
char *endp;
int ch;
isc_result_t result;
- isc_log_t *log = NULL;
dns_rdataset_t rdataset;
dns_rdata_t rdata;
isc_stdtime_t now = isc_stdtime_now();
fatal("extraneous arguments");
}
- setup_logging(mctx, &log);
+ setup_logging();
dns_rdataset_init(&rdataset);
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
- cleanup_logging(&log);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}
isc_textregion_t r;
char filename[255];
isc_buffer_t buf;
- isc_log_t *log = NULL;
dns_rdataclass_t rdclass;
int options = DST_TYPE_PRIVATE | DST_TYPE_PUBLIC;
char *label = NULL;
}
}
- setup_logging(mctx, &log);
+ setup_logging();
if (predecessor == NULL) {
if (label == NULL) {
dst_key_free(&prevkey);
}
- cleanup_logging(&log);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}
static int min_rsa = 1024;
static int min_dh = 128;
-isc_log_t *lctx = NULL;
-
ISC_NORETURN static void
usage(void);
min_rsa = min_dh = 2048;
}
- setup_logging(mctx, &lctx);
+ setup_logging();
ctx.rdclass = strtoclass(classname);
dns_kasp_t *kasp = NULL;
dns_kasp_key_t *kaspkey = NULL;
- RUNTIME_CHECK(cfg_parser_create(mctx, lctx, &parser) ==
+ RUNTIME_CHECK(cfg_parser_create(mctx, &parser) ==
ISC_R_SUCCESS);
if (cfg_parse_file(parser, ctx.configfile,
&cfg_type_namedconf,
ctx.policy, ctx.configfile);
}
- kasp_from_conf(config, mctx, lctx, ctx.policy,
- ctx.directory, &kasp);
+ kasp_from_conf(config, mctx, ctx.policy, ctx.directory,
+ &kasp);
if (kasp == NULL) {
fatal("failed to load dnssec-policy '%s'",
ctx.policy);
keygen(&ctx, mctx, argc, argv);
}
- cleanup_logging(&lctx);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}
/*
* Infrastructure
*/
-static isc_log_t *lctx = NULL;
static isc_mem_t *mctx = NULL;
/*
* The domain we are working on
cfg_parser_t *parser = NULL;
cfg_obj_t *config = NULL;
- RUNTIME_CHECK(cfg_parser_create(mctx, lctx, &parser) == ISC_R_SUCCESS);
+ RUNTIME_CHECK(cfg_parser_create(mctx, &parser) == ISC_R_SUCCESS);
if (cfg_parse_file(parser, ksr->configfile, &cfg_type_namedconf,
&config) != ISC_R_SUCCESS)
{
fatal("unable to load dnssec-policy '%s' from '%s'",
ksr->policy, ksr->configfile);
}
- kasp_from_conf(config, mctx, lctx, ksr->policy, ksr->keydir, kasp);
+ kasp_from_conf(config, mctx, ksr->policy, ksr->keydir, kasp);
if (*kasp == NULL) {
fatal("failed to load dnssec-policy '%s'", ksr->policy);
}
min_rsa = min_dh = 2048;
}
- setup_logging(mctx, &lctx);
+ setup_logging();
if (set_fips_mode) {
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
bool epoch = false;
bool changed = false;
bool write_state = false;
- isc_log_t *log = NULL;
isc_stdtime_t syncadd = 0, syncdel = 0;
bool unsetsyncadd = false, setsyncadd = false;
bool unsetsyncdel = false, setsyncdel = false;
isc_mem_create(&mctx);
- setup_logging(mctx, &log);
+ setup_logging();
isc_commandline_errprint = false;
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}
- cleanup_logging(&log);
isc_mem_free(mctx, directory);
isc_mem_destroy(&mctx);
isc_time_t sign_start, sign_finish;
dns_dnsseckey_t *key;
isc_result_t result, vresult;
- isc_log_t *log = NULL;
bool free_output = false;
int tempfilelen = 0;
dns_rdataclass_t rdclass;
}
}
- setup_logging(mctx, &log);
+ setup_logging();
argc -= isc_commandline_index;
argv += isc_commandline_index;
dns_master_styledestroy(&dsstyle, mctx);
- cleanup_logging(&log);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}
char *origin = NULL, *file = NULL;
char *inputformatstr = NULL;
isc_result_t result;
- isc_log_t *log = NULL;
char *classname = NULL;
dns_rdataclass_t rdclass;
char *endp;
rdclass = strtoclass(classname);
- setup_logging(mctx, &log);
+ setup_logging();
argc -= isc_commandline_index;
argv += isc_commandline_index;
dns_db_closeversion(gdb, &gversion, false);
dns_db_detach(&gdb);
- cleanup_logging(&log);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}
}
void
-setup_logging(isc_mem_t *mctx ISC_ATTR_UNUSED, isc_log_t **logp) {
+setup_logging(void) {
isc_logdestination_t destination;
isc_logconfig_t *logconfig = NULL;
- isc_log_t *log = NULL;
int level;
if (verbose < 0) {
break;
}
- dns_log_init(log);
+ dns_log_init();
- logconfig = isc_logconfig_get(log);
+ logconfig = isc_logconfig_get();
isc_log_settag(logconfig, program);
RUNTIME_CHECK(isc_log_usechannel(logconfig, "stderr", NULL, NULL) ==
ISC_R_SUCCESS);
-
- *logp = log;
-}
-
-void
-cleanup_logging(isc_log_t **logp) {
- REQUIRE(logp != NULL);
-
- isc_log_t *log = *logp;
- *logp = NULL;
-
- if (log == NULL) {
- return;
- }
}
static isc_stdtime_t
}
void
-kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, isc_log_t *lctx,
- const char *name, const char *keydir, dns_kasp_t **kaspp) {
+kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, const char *name,
+ const char *keydir, dns_kasp_t **kaspp) {
isc_result_t result = ISC_R_NOTFOUND;
const cfg_listelt_t *element;
const cfg_obj_t *kasps = NULL;
{
cfg_obj_t *kconfig = cfg_listelt_value(element);
ks = NULL;
- result = cfg_keystore_fromconfig(kconfig, mctx, lctx, &kslist,
- NULL);
+ result = cfg_keystore_fromconfig(kconfig, mctx, &kslist, NULL);
if (result != ISC_R_SUCCESS) {
fatal("failed to configure key-store '%s': %s",
cfg_obj_asstring(cfg_tuple_get(kconfig, "name")),
}
/* Default key-directory key store. */
ks = NULL;
- (void)cfg_keystore_fromconfig(NULL, mctx, lctx, &kslist, &ks);
+ (void)cfg_keystore_fromconfig(NULL, mctx, &kslist, &ks);
INSIST(ks != NULL);
if (keydir != NULL) {
/* '-K keydir' takes priority */
continue;
}
- result = cfg_kasp_fromconfig(kconfig, NULL, true, mctx, lctx,
- &kslist, &kasplist, &kasp);
+ result = cfg_kasp_fromconfig(kconfig, NULL, true, mctx, &kslist,
+ &kasplist, &kasp);
if (result != ISC_R_SUCCESS) {
fatal("failed to configure dnssec-policy '%s': %s",
cfg_obj_asstring(cfg_tuple_get(kconfig, "name")),
(DNS_NAME_FORMATSIZE + DNS_SECALG_FORMATSIZE + sizeof("65535"))
void
-setup_logging(isc_mem_t *mctx, isc_log_t **logp);
-
-void
-cleanup_logging(isc_log_t **logp);
+setup_logging(void);
dns_ttl_t
strtottl(const char *str);
loadjournal(isc_mem_t *mctx, dns_db_t *db, const char *journal);
void
-kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, isc_log_t *lctx,
- const char *name, const char *keydir, dns_kasp_t **kaspp);
+kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, const char *name,
+ const char *keydir, dns_kasp_t **kaspp);
r.length = strlen(r.base);
result = dns_rdataclass_fromtext(classp, &r);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(classobj, named_g_lctx, ISC_LOG_ERROR,
- "unknown class '%s'", r.base);
+ cfg_obj_log(classobj, ISC_LOG_ERROR, "unknown class '%s'",
+ r.base);
}
return (result);
}
r.length = strlen(r.base);
result = dns_rdatatype_fromtext(typep, &r);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(typeobj, named_g_lctx, ISC_LOG_ERROR,
- "unknown type '%s'", r.base);
+ cfg_obj_log(typeobj, ISC_LOG_ERROR, "unknown type '%s'",
+ r.base);
}
return (result);
}
if (cfg_obj_isuint32(portobj)) {
uint32_t val = cfg_obj_asuint32(portobj);
if (val > UINT16_MAX) {
- cfg_obj_log(portobj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(portobj, ISC_LOG_ERROR,
"port '%u' out of range", val);
result = ISC_R_RANGE;
goto cleanup;
tresult = named_config_getremotesdef(config, listtype,
listname, &list);
if (tresult == ISC_R_NOTFOUND) {
- cfg_obj_log(addr, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(addr, ISC_LOG_ERROR,
"%s \"%s\" not found", listtype,
listname);
result = named_config_get(maps, type, &portobj);
INSIST(result == ISC_R_SUCCESS);
if (cfg_obj_asuint32(portobj) >= UINT16_MAX) {
- cfg_obj_log(portobj, named_g_lctx, ISC_LOG_ERROR,
- "port '%u' out of range",
+ cfg_obj_log(portobj, ISC_LOG_ERROR, "port '%u' out of range",
cfg_obj_asuint32(portobj));
return (ISC_R_RANGE);
}
!command_compare(command, NAMED_COMMAND_TESTGEN) &&
!command_compare(command, NAMED_COMMAND_ZONESTATUS))
{
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL, log_level,
"rejecting restricted control channel "
"command '%s'",
goto cleanup;
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_CONTROL, log_level,
- "received control channel command '%s'", cmdline);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_CONTROL,
+ log_level, "received control channel command '%s'",
+ cmdline);
/*
* After the lengthy "halt" and "stop", the commands are
{
result = named_server_changezone(named_g_server, cmdline, text);
} else if (command_compare(command, NAMED_COMMAND_CLOSELOGS)) {
- isc_log_closefilelogs(named_g_lctx);
+ isc_log_closefilelogs();
result = ISC_R_SUCCESS;
} else if (command_compare(command, NAMED_COMMAND_DELZONE)) {
result = named_server_delzone(named_g_server, lex, text);
result = named_server_notifycommand(named_g_server, lex, text);
} else if (command_compare(command, NAMED_COMMAND_NOTRACE)) {
named_g_debuglevel = 0;
- isc_log_setdebuglevel(named_g_lctx, named_g_debuglevel);
+ isc_log_setdebuglevel(named_g_debuglevel);
result = ISC_R_SUCCESS;
} else if (command_compare(command, NAMED_COMMAND_NTA)) {
result = named_server_nta(named_g_server, lex, readonly, text);
} else if (command_compare(command, NAMED_COMMAND_ZONESTATUS)) {
result = named_server_zonestatus(named_g_server, lex, text);
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL, ISC_LOG_WARNING,
"unknown control channel command '%s'", command);
result = DNS_R_UNKNOWNCOMMAND;
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&listener->address, socktext, sizeof(socktext));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_CONTROL, ISC_LOG_NOTICE,
- "stopping command channel on %s", socktext);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_CONTROL,
+ ISC_LOG_NOTICE, "stopping command channel on %s",
+ socktext);
isc_nm_stoplistening(listener->sock);
isc_nmsocket_close(&listener->sock);
isc_sockaddr_t peeraddr = isc_nmhandle_peeraddr(handle);
isc_sockaddr_format(&peeraddr, socktext, sizeof(socktext));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL, ISC_LOG_WARNING,
"error sending command response to %s: %s",
socktext, isc_result_totext(result));
isc_sockaddr_t peeraddr = isc_nmhandle_peeraddr(ccmsg->handle);
isc_sockaddr_format(&peeraddr, socktext, sizeof(socktext));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_CONTROL, ISC_LOG_ERROR,
- "invalid command from %s: %s", socktext,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_CONTROL,
+ ISC_LOG_ERROR, "invalid command from %s: %s", socktext,
isc_result_totext(result));
}
}
#endif /* ifdef ENABLE_AFL */
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_CONTROL, ISC_LOG_DEBUG(3),
- "freeing control connection");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_CONTROL,
+ ISC_LOG_DEBUG(3), "freeing control connection");
isc_mem_put(listener->mctx, conn, sizeof(*conn));
newconnection(controllistener_t *listener, isc_nmhandle_t *handle) {
/* Don't create new connection if we are shutting down */
if (listener->shuttingdown) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL, ISC_LOG_DEBUG(3),
"rejected new control connection: %s",
isc_result_totext(ISC_R_SHUTTINGDOWN));
}
controlconnection_t *conn = isc_mem_get(listener->mctx, sizeof(*conn));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_CONTROL, ISC_LOG_DEBUG(3),
- "allocate new control connection");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_CONTROL,
+ ISC_LOG_DEBUG(3), "allocate new control connection");
*conn = (controlconnection_t){
.alg = DST_ALG_UNKNOWN,
if (!address_ok(&peeraddr, listener)) {
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&peeraddr, socktext, sizeof(socktext));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL, ISC_LOG_WARNING,
"rejected command channel message from %s",
socktext);
result = cfgkeylist_find(keylist, keyid->keyname, &keydef);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(control, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(control, ISC_LOG_WARNING,
"couldn't find key '%s' for use with "
"command channel %s",
keyid->keyname, socktext);
result = named_config_getkeyalgorithm(algstr, &algtype,
NULL);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(control, named_g_lctx,
- ISC_LOG_WARNING,
+ cfg_obj_log(control, ISC_LOG_WARNING,
"unsupported algorithm '%s' in "
"key '%s' for use with command "
"channel %s",
result = isc_base64_decodestring(secretstr, &b);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(keydef, named_g_lctx,
- ISC_LOG_WARNING,
+ cfg_obj_log(keydef, ISC_LOG_WARNING,
"secret for key '%s' on "
"command channel %s: %s",
keyid->keyname, socktext,
unsigned int algtype;
isc_buffer_t b;
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_CONTROL, ISC_LOG_INFO,
- "configuring command channel from '%s'", named_g_keyfile);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_CONTROL,
+ ISC_LOG_INFO, "configuring command channel from '%s'",
+ named_g_keyfile);
if (!isc_file_exists(named_g_keyfile)) {
return (ISC_R_FILENOTFOUND);
}
- CHECK(cfg_parser_create(mctx, named_g_lctx, &pctx));
+ CHECK(cfg_parser_create(mctx, &pctx));
CHECK(cfg_parse_file(pctx, named_g_keyfile, &cfg_type_rndckey,
&config));
CHECK(cfg_map_get(config, "key", &key));
CHECK(ISC_R_NOMEMORY);
}
- CHECK(isccfg_check_key(key, named_g_lctx));
+ CHECK(isccfg_check_key(key));
(void)cfg_map_get(key, "algorithm", &algobj);
(void)cfg_map_get(key, "secret", &secretobj);
result = named_config_getkeyalgorithm(algstr, &algtype, NULL);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(key, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(key, ISC_LOG_WARNING,
"unsupported algorithm '%s' in "
"key '%s' for use with command "
"channel",
result = isc_base64_decodestring(secretstr, &b);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(key, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(key, ISC_LOG_WARNING,
"secret for key '%s' on command channel: %s",
keyid->keyname, isc_result_totext(result));
goto cleanup;
* sake of avoiding this message would be too much trouble.
*/
if (control != NULL) {
- cfg_obj_log(control, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(control, ISC_LOG_WARNING,
"couldn't install new keys for "
"command channel %s: %s",
socktext, isc_result_totext(result));
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL, ISC_LOG_WARNING,
"couldn't install new keys for "
"command channel %s: %s",
*/
if (control != NULL && type == isc_socktype_tcp) {
allow = cfg_tuple_get(control, "allow");
- result = cfg_acl_fromconfig(allow, config, named_g_lctx,
- aclconfctx, listener->mctx, 0,
- &new_acl);
+ result = cfg_acl_fromconfig(allow, config, aclconfctx,
+ listener->mctx, 0, &new_acl);
} else {
result = dns_acl_any(listener->mctx, &new_acl);
}
dns_acl_detach(&new_acl);
/* XXXDCL say the old acl is still used? */
} else if (control != NULL) {
- cfg_obj_log(control, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(control, ISC_LOG_WARNING,
"couldn't install new acl for "
"command channel %s: %s",
socktext, isc_result_totext(result));
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL, ISC_LOG_WARNING,
"couldn't install new acl for "
"command channel %s: %s",
const cfg_obj_t *readonly = NULL;
allow = cfg_tuple_get(control, "allow");
- CHECK(cfg_acl_fromconfig(allow, config, named_g_lctx,
- aclconfctx, mctx, 0, &new_acl));
+ CHECK(cfg_acl_fromconfig(allow, config, aclconfctx, mctx, 0,
+ &new_acl));
readonly = cfg_tuple_get(control, "read-only");
if (!cfg_obj_isvoid(readonly)) {
} else {
result = get_rndckey(mctx, &listener->keys);
if (result != ISC_R_SUCCESS && control != NULL) {
- cfg_obj_log(control, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(control, ISC_LOG_WARNING,
"couldn't install keys for "
"command channel %s: %s",
socktext, isc_result_totext(result));
&listener->address, control_newconn, listener, 5,
NULL, &listener->sock));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_CONTROL, ISC_LOG_NOTICE,
- "command channel listening on %s", socktext);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_CONTROL,
+ ISC_LOG_NOTICE, "command channel listening on %s",
+ socktext);
*listenerp = listener;
return;
shuttingdown:
if (control != NULL) {
- cfg_obj_log(control, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(control, ISC_LOG_WARNING,
"couldn't add command channel %s: %s", socktext,
isc_result_totext(result));
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL, ISC_LOG_NOTICE,
"couldn't add command channel %s: %s", socktext,
isc_result_totext(result));
(void)cfg_map_get(controls, "unix", &unixcontrols);
if (unixcontrols != NULL) {
- cfg_obj_log(controls, named_g_lctx,
- ISC_LOG_ERROR,
+ cfg_obj_log(controls, ISC_LOG_ERROR,
"UNIX domain sockets are not "
"supported");
return (ISC_R_FAILURE);
isc_sockaddr_format(&addr, socktext,
sizeof(socktext));
- isc_log_write(named_g_lctx,
- NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL,
ISC_LOG_DEBUG(9),
"processing control channel %s",
dlopen_log(int level, const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
- isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
+ isc_log_vwrite(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
ISC_LOG_DEBUG(level), fmt, ap);
va_end(ap);
}
n = snprintf(pathbuf, sizeof(pathbuf), "%s/%s", dir, dbfile);
if (n >= sizeof(pathbuf)) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"GeoIP2 database '%s/%s': path too long", dir,
dbfile);
return (NULL);
ret = MMDB_open(pathbuf, MMDB_MODE_MMAP, mmdb);
if (ret == MMDB_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "opened GeoIP2 database '%s'", pathbuf);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "opened GeoIP2 database '%s'",
+ pathbuf);
return (mmdb);
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_DEBUG(1),
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_DEBUG(1),
"unable to open GeoIP2 database '%s' (status %d)",
pathbuf, ret);
#if defined(HAVE_GEOIP2)
REQUIRE(dir != NULL);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "looking for GeoIP2 databases in '%s'", dir);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "looking for GeoIP2 databases in '%s'",
+ dir);
named_g_geoip->country = open_geoip2(dir, "GeoIP2-Country.mmdb",
&geoip_country);
/*
* Logging.
*/
-EXTERN isc_log_t *named_g_lctx INIT(NULL);
EXTERN isc_logcategory_t *named_g_categories INIT(NULL);
EXTERN isc_logmodule_t *named_g_modules INIT(NULL);
EXTERN unsigned int named_g_debuglevel INIT(0);
/*%
* Set up "category unmatched" to go to the right places.
*/
-
-void
-named_log_shutdown(void) __attribute__((__deprecated__));
named_g_categories = categories;
named_g_modules = modules;
- /*
- * Setup a logging context.
- */
-
/*
* named-checktool.c:setup_logging() needs to be kept in sync.
*/
- isc_log_registercategories(named_g_lctx, named_g_categories);
- isc_log_registermodules(named_g_lctx, named_g_modules);
- dns_log_init(named_g_lctx);
- cfg_log_init(named_g_lctx);
- ns_log_init(named_g_lctx);
+ isc_log_registercategories(named_g_categories);
+ isc_log_registermodules(named_g_modules);
+ dns_log_init();
+ cfg_log_init();
+ ns_log_init();
/*
* This is not technically needed, as we are calling named_log_init()
* hygiene.
*/
rcu_read_lock();
- lcfg = isc_logconfig_get(named_g_lctx);
+ lcfg = isc_logconfig_get();
if (safe) {
named_log_setsafechannels(lcfg);
} else {
/*
* Set the initial debug level.
*/
- isc_log_setdebuglevel(named_g_lctx, named_g_debuglevel);
+ isc_log_setdebuglevel(named_g_debuglevel);
}
void
* Setting the debug level to zero should get the output
* discarded a bit faster.
*/
- isc_log_setdebuglevel(named_g_lctx, 0);
+ isc_log_setdebuglevel(0);
} else {
- isc_log_setdebuglevel(named_g_lctx, named_g_debuglevel);
+ isc_log_setdebuglevel(named_g_debuglevel);
}
if (named_g_logfile != NULL) {
NULL);
return (result);
}
-
-void
-named_log_shutdown(void) {
- /* no-op */
-}
const cfg_listelt_t *element = NULL;
catname = cfg_obj_asstring(cfg_tuple_get(ccat, "name"));
- category = isc_log_categorybyname(named_g_lctx, catname);
+ category = isc_log_categorybyname(catname);
if (category == NULL) {
- cfg_obj_log(ccat, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(ccat, ISC_LOG_ERROR,
"unknown logging category '%s' ignored", catname);
/*
* Allow further processing by returning success.
result = isc_log_usechannel(logconfig, channelname, category,
module);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, CFG_LOGCATEGORY_CONFIG,
+ isc_log_write(CFG_LOGCATEGORY_CONFIG,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"logging channel '%s': %s", channelname,
isc_result_totext(result));
}
if (i != 1) {
- cfg_obj_log(channel, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(channel, ISC_LOG_ERROR,
"channel '%s': exactly one of file, syslog, "
"null, and stderr must be present",
channelname);
va_list args;
va_start(args, format);
- if (named_g_lctx != NULL) {
- isc_log_vwrite(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_WARNING, format,
- args);
+ if (named_g_categories != NULL) {
+ isc_log_vwrite(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_WARNING, format, args);
} else {
fprintf(stderr, "%s: ", program_name);
vfprintf(stderr, format, args);
va_list args;
va_start(args, format);
- if (named_g_lctx != NULL) {
- isc_log_vwrite(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_CRITICAL, format,
- args);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_CRITICAL,
+ if (named_g_categories != NULL) {
+ isc_log_vwrite(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_CRITICAL, format, args);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_CRITICAL,
"exiting (due to early fatal error)");
} else {
fprintf(stderr, "%s: ", program_name);
* Handle assertion failures.
*/
- if (named_g_lctx != NULL) {
+ if (named_g_categories != NULL) {
/*
* Reset the assertion callback in case it is the log
* routines causing the assertion.
*/
isc_assertion_setcallback(NULL);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_CRITICAL,
- "%s:%d: %s(%s) failed", file, line,
- isc_assertion_typetotext(type), cond);
- isc_backtrace_log(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_CRITICAL, "%s:%d: %s(%s) failed", file,
+ line, isc_assertion_typetotext(type), cond);
+ isc_backtrace_log(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_MAIN, ISC_LOG_CRITICAL);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_CRITICAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_CRITICAL,
"exiting (due to assertion failure)");
} else {
fprintf(stderr, "%s:%d: %s(%s) failed\n", file, line,
* Handle isc_error_fatal() calls from our libraries.
*/
- if (named_g_lctx != NULL) {
+ if (named_g_categories != NULL) {
/*
* Reset the error callback in case it is the log
* routines causing the assertion.
*/
isc_error_setfatal(NULL);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_CRITICAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_CRITICAL,
"%s:%d:%s(): fatal error: ", file, line, func);
- isc_log_vwrite(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_CRITICAL, format,
- args);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_CRITICAL,
+ isc_log_vwrite(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_CRITICAL, format, args);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_CRITICAL,
"exiting (due to fatal error in library)");
} else {
fprintf(stderr, "%s:%d:%s(): fatal error: ", file, line, func);
* Handle isc_error_unexpected() calls from our libraries.
*/
- if (named_g_lctx != NULL) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_ERROR,
+ if (named_g_categories != NULL) {
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_ERROR,
"%s:%d:%s(): unexpected error: ", file, line,
func);
- isc_log_vwrite(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_ERROR, format,
- args);
+ isc_log_vwrite(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_ERROR, format, args);
} else {
fprintf(stderr, "%s:%d:%s(): fatal error: ", file, line, func);
vfprintf(stderr, format, args);
static void
logit(isc_buffer_t *b) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE, "%.*s",
- (int)isc_buffer_usedlength(b),
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "%.*s", (int)isc_buffer_usedlength(b),
(char *)isc_buffer_base(b));
}
#define RTC(x) RUNTIME_CHECK((x) == ISC_R_SUCCESS)
isc_mem_t *mctx = NULL;
isc_mem_create(&mctx);
- RTC(cfg_parser_create(mctx, named_g_lctx, &parser));
+ RTC(cfg_parser_create(mctx, &parser));
RTC(named_config_parsedefaults(parser, &config));
RTC(cfg_map_get(config, "options", &defaults));
RTC(cfg_map_get(defaults, "geoip-directory", &obj));
named_g_cpus = named_g_cpus_detected;
}
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
- ISC_LOG_INFO, "found %u CPU%s, using %u worker thread%s",
- named_g_cpus_detected, named_g_cpus_detected == 1 ? "" : "s",
- named_g_cpus, named_g_cpus == 1 ? "" : "s");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "found %u CPU%s, using %u worker thread%s",
+ named_g_cpus_detected,
+ named_g_cpus_detected == 1 ? "" : "s", named_g_cpus,
+ named_g_cpus == 1 ? "" : "s");
isc_managers_create(&named_g_mctx, named_g_cpus, &named_g_loopmgr,
&named_g_netmgr);
named_os_daemonize();
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "starting %s%s <id:%s>", PACKAGE_STRING,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "starting %s%s <id:%s>", PACKAGE_STRING,
PACKAGE_DESCRIPTION, PACKAGE_SRCID);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE, "running on %s",
- named_os_uname());
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "running on %s", named_os_uname());
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE, "built with %s",
- PACKAGE_CONFIGARGS);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "built with %s", PACKAGE_CONFIGARGS);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "running as: %s%s%s", program_name, saved_command_line,
- ellipsis);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "running as: %s%s%s", program_name,
+ saved_command_line, ellipsis);
#ifdef __clang__
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled by CLANG %s", __VERSION__);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled by CLANG %s", __VERSION__);
#else /* ifdef __clang__ */
#if defined(__ICC) || defined(__INTEL_COMPILER)
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled by ICC %s", __VERSION__);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled by ICC %s", __VERSION__);
#else /* if defined(__ICC) || defined(__INTEL_COMPILER) */
#ifdef __GNUC__
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled by GCC %s", __VERSION__);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled by GCC %s", __VERSION__);
#endif /* ifdef __GNUC__ */
#endif /* if defined(__ICC) || defined(__INTEL_COMPILER) */
#endif /* ifdef __clang__ */
#ifdef __SUNPRO_C
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled by Solaris Studio %x", __SUNPRO_C);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled by Solaris Studio %x",
+ __SUNPRO_C);
#endif /* ifdef __SUNPRO_C */
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled with OpenSSL version: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled with OpenSSL version: %s",
OPENSSL_VERSION_TEXT);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "linked to OpenSSL version: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "linked to OpenSSL version: %s",
OpenSSL_version(OPENSSL_VERSION));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled with libuv version: %d.%d.%d", UV_VERSION_MAJOR,
- UV_VERSION_MINOR, UV_VERSION_PATCH);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "linked to libuv version: %s", uv_version_string());
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled with %s version: %s", RCU_FLAVOR, RCU_VERSION);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled with libuv version: %d.%d.%d",
+ UV_VERSION_MAJOR, UV_VERSION_MINOR, UV_VERSION_PATCH);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "linked to libuv version: %s",
+ uv_version_string());
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled with %s version: %s",
+ RCU_FLAVOR, RCU_VERSION);
#if defined(JEMALLOC_VERSION)
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE,
"compiled with jemalloc version: %u.%u.%u",
JEMALLOC_VERSION_MAJOR, JEMALLOC_VERSION_MINOR,
JEMALLOC_VERSION_BUGFIX);
#elif defined(M_VERSION)
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE,
"compiled with system jemalloc version: %u", M_VERSION);
#endif
#if HAVE_LIBNGHTTP2
nghttp2_info *nginfo = NULL;
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled with libnghttp2 version: %s", NGHTTP2_VERSION);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled with libnghttp2 version: %s",
+ NGHTTP2_VERSION);
nginfo = nghttp2_version(1);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "linked to libnghttp2 version: %s", nginfo->version_str);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "linked to libnghttp2 version: %s",
+ nginfo->version_str);
#endif
#ifdef HAVE_LIBXML2
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled with libxml2 version: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled with libxml2 version: %s",
LIBXML_DOTTED_VERSION);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "linked to libxml2 version: %s", xmlParserVersion);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "linked to libxml2 version: %s",
+ xmlParserVersion);
#endif /* ifdef HAVE_LIBXML2 */
#if defined(HAVE_JSON_C)
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled with json-c version: %s", JSON_C_VERSION);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "linked to json-c version: %s", json_c_version());
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled with json-c version: %s",
+ JSON_C_VERSION);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "linked to json-c version: %s",
+ json_c_version());
#endif /* if defined(HAVE_JSON_C) */
#if defined(HAVE_ZLIB) && defined(ZLIB_VERSION)
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled with zlib version: %s", ZLIB_VERSION);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "linked to zlib version: %s", zlibVersion());
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled with zlib version: %s",
+ ZLIB_VERSION);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "linked to zlib version: %s",
+ zlibVersion());
#endif /* if defined(HAVE_ZLIB) && defined(ZLIB_VERSION) */
#if defined(HAVE_GEOIP2)
/* Unfortunately, no version define on link time */
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "linked to maxminddb version: %s", MMDB_lib_version());
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "linked to maxminddb version: %s",
+ MMDB_lib_version());
#endif /* if defined(HAVE_GEOIP2) */
#if defined(HAVE_DNSTAP)
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "compiled with protobuf-c version: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "compiled with protobuf-c version: %s",
PROTOBUF_C_VERSION);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "linked to protobuf-c version: %s", protobuf_c_version());
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "linked to protobuf-c version: %s",
+ protobuf_c_version());
#endif /* if defined(HAVE_DNSTAP) */
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE,
"----------------------------------------------------");
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE,
"BIND 9 is maintained by Internet Systems Consortium,");
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE,
"Inc. (ISC), a non-profit 501(c)(3) public-benefit ");
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE,
"corporation. Support and training for BIND 9 are ");
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE,
"available at https://www.isc.org/support");
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE,
"----------------------------------------------------");
/*
*/
dlz_dlopen_clear();
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE, "exiting");
- named_log_shutdown();
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE, "exiting");
}
static char *memstats = NULL;
rlim_old = rl.rlim_cur;
if (rl.rlim_cur == rl.rlim_max) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE,
"the limit on open files is already at the "
"maximum allowed value: "
"%" PRIu64,
goto fail;
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_MAIN,
+ ISC_LOG_NOTICE,
"adjusted limit on open files from "
"%" PRIu64 " to "
"%" PRIu64,
} \
} while (0)
-#define CHECKM(op, msg) \
- do { \
- result = (op); \
- if (result != ISC_R_SUCCESS) { \
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL, \
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR, \
- "%s: %s", msg, \
- isc_result_totext(result)); \
- goto cleanup; \
- } \
+#define CHECKM(op, msg) \
+ do { \
+ result = (op); \
+ if (result != ISC_R_SUCCESS) { \
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, \
+ NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR, \
+ "%s: %s", msg, \
+ isc_result_totext(result)); \
+ goto cleanup; \
+ } \
} while (0)
-#define CHECKMF(op, msg, file) \
- do { \
- result = (op); \
- if (result != ISC_R_SUCCESS) { \
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL, \
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR, \
- "%s '%s': %s", msg, file, \
- isc_result_totext(result)); \
- goto cleanup; \
- } \
+#define CHECKMF(op, msg, file) \
+ do { \
+ result = (op); \
+ if (result != ISC_R_SUCCESS) { \
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, \
+ NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR, \
+ "%s '%s': %s", msg, file, \
+ isc_result_totext(result)); \
+ goto cleanup; \
+ } \
} while (0)
#define CHECKFATAL(op, msg) \
aclobj = cfg_tuple_get(aclobj, acltuplename);
}
- result = cfg_acl_fromconfig(aclobj, config, named_g_lctx, actx, mctx, 0,
- aclp);
+ result = cfg_acl_fromconfig(aclobj, config, actx, mctx, 0, aclp);
return (result);
}
* as lists of separate, nested ACLs, rather than merged together
* into IP tables as is usually done with ACLs.
*/
- result = cfg_acl_fromconfig(aclobj, config, named_g_lctx, actx, mctx, 3,
- aclp);
+ result = cfg_acl_fromconfig(aclobj, config, actx, mctx, 3, aclp);
return (result);
}
CHECK(dns_name_fromtext(name, &b, dns_rootname, 0, NULL));
result = dns_nametree_add(*ntp, name, true);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(nameobj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(nameobj, ISC_LOG_ERROR,
"failed to add %s for %s: %s", str,
confname, isc_result_totext(result));
goto cleanup;
} else if (strcasecmp(atstr, "initial-ds") == 0) {
anchortype = INIT_DS;
} else {
- cfg_obj_log(key, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"key '%s': "
"invalid initialization method '%s'",
namestr, atstr);
}
break;
default:
- cfg_obj_log(key, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"key '%s': "
"unknown ds digest type %u",
namestr, ds->digest_type);
* a fatal error - log a warning about this key being ignored,
* but do not prevent any further ones from being processed.
*/
- cfg_obj_log(key, named_g_lctx, ISC_LOG_WARNING,
- "ignoring %s for '%s': %s",
+ cfg_obj_log(key, ISC_LOG_WARNING, "ignoring %s for '%s': %s",
initializing ? "initial-key" : "static-key",
namestr, isc_result_totext(result));
return (ISC_R_SUCCESS);
/*
* Crypto support is not available.
*/
- cfg_obj_log(key, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"ignoring %s for '%s': no crypto support",
initializing ? "initial-key" : "static-key",
namestr);
* indicate an error so that the configuration loading process
* is interrupted.
*/
- cfg_obj_log(key, named_g_lctx, ISC_LOG_ERROR,
- "configuring %s for '%s': %s",
+ cfg_obj_log(key, ISC_LOG_ERROR, "configuring %s for '%s': %s",
initializing ? "initial-key" : "static-key",
namestr, isc_result_totext(result));
return (ISC_R_FAILURE);
if (!dns_resolver_algorithm_supported(view->resolver, keyname,
ds.algorithm))
{
- cfg_obj_log(key, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(key, ISC_LOG_WARNING,
"ignoring %s for '%s': algorithm is disabled",
initializing ? "initial-key" : "static-key",
namestr);
* the trust-anchors clause hard-coded in named_g_config.
*/
if (bindkeys != NULL) {
- isc_log_write(named_g_lctx, DNS_LOGCATEGORY_SECURITY,
+ isc_log_write(DNS_LOGCATEGORY_SECURITY,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"obtaining root key for view %s "
"from '%s'",
&builtin_keys);
if (builtin_keys == NULL) {
- isc_log_write(
- named_g_lctx, DNS_LOGCATEGORY_SECURITY,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "dnssec-validation auto: "
- "WARNING: root zone key "
- "not found");
+ isc_log_write(DNS_LOGCATEGORY_SECURITY,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
+ "dnssec-validation auto: "
+ "WARNING: root zone key "
+ "not found");
}
}
if (builtin_keys == NULL) {
- isc_log_write(named_g_lctx, DNS_LOGCATEGORY_SECURITY,
+ isc_log_write(DNS_LOGCATEGORY_SECURITY,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"using built-in root key for view %s",
view->name);
}
if (!keyloaded(view, dns_rootname)) {
- isc_log_write(named_g_lctx, DNS_LOGCATEGORY_SECURITY,
+ isc_log_write(DNS_LOGCATEGORY_SECURITY,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"root key not loaded");
result = ISC_R_FAILURE;
result = isc_file_isdirectory(directory);
}
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, DNS_LOGCATEGORY_SECURITY,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_SECURITY, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"invalid managed-keys-directory %s: %s",
directory, isc_result_totext(result));
goto cleanup;
} else if (directory != NULL) {
if (!isc_file_isdirwritable(directory)) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"managed-keys-directory '%s' "
"is not writable",
if (isc_sockaddr_getport(&sa) != 0) {
INSIST(obj != NULL);
if (is_firstview) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_INFO,
+ cfg_obj_log(obj, ISC_LOG_INFO,
"using specific query-source port "
"suppresses port randomization and can be "
"insecure.");
return (ISC_R_SUCCESS);
}
isc_sockaddr_format(&sa, buf, sizeof(buf));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"could not get query source dispatcher (%s): %s",
buf, isc_result_totext(result));
return (result);
if (obj != NULL) {
uint32_t padding = cfg_obj_asuint32(obj);
if (padding > 512U) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"server padding value cannot "
"exceed 512: lowering");
padding = 512U;
}
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"dynamic database '%s' configuration failed: %s",
name, isc_result_totext(result));
}
alg = ui;
}
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(cfg_listelt_value(element), named_g_lctx,
- ISC_LOG_ERROR, "invalid algorithm");
+ cfg_obj_log(cfg_listelt_value(element), ISC_LOG_ERROR,
+ "invalid algorithm");
CHECK(result);
}
CHECK(dns_resolver_disable_algorithm(resolver, name, alg));
/* disable_ds_digests handles numeric values. */
result = dns_dsdigest_fromtext(&digest, &r);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(cfg_listelt_value(element), named_g_lctx,
- ISC_LOG_ERROR, "invalid algorithm");
+ cfg_obj_log(cfg_listelt_value(element), ISC_LOG_ERROR,
+ "invalid algorithm");
CHECK(result);
}
CHECK(dns_resolver_disable_ds_digest(resolver, name, digest));
dns_zone_setoption(zone, DNS_ZONEOPT_NOCHECKNS, true);
setquerystats(zone, mctx, dns_zonestat_none);
CHECK(dns_view_addzone(view, zone));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "dns64 reverse zone%s%s: %s", sep, viewname, reverse);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "dns64 reverse zone%s%s: %s", sep, viewname,
+ reverse);
cleanup:
if (zone != NULL) {
return;
}
if (ctx == NULL) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"\"%s\" without \"dnsrps-enable yes\"", name);
return;
}
return;
}
if (ctx == NULL) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"\"%s\" without \"dnsrps-enable yes\"", name);
return;
}
result = dns_name_fromstring(name, str, dns_rootname, DNS_NAME_DOWNCASE,
view->mctx);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
- "invalid %s '%s'", msg, str);
+ cfg_obj_log(obj, DNS_RPZ_ERROR_LEVEL, "invalid %s '%s'", msg,
+ str);
}
return (result);
}
result = dns_name_fromstring(name, str, origin, DNS_NAME_DOWNCASE,
view->mctx);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
- "invalid zone '%s'", str);
+ cfg_obj_log(obj, DNS_RPZ_ERROR_LEVEL, "invalid zone '%s'", str);
}
return (result);
}
rpz_obj = cfg_listelt_value(element);
if (view->rpzs->p.num_zones >= DNS_RPZ_MAX_ZONES) {
- cfg_obj_log(rpz_obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
+ cfg_obj_log(rpz_obj, DNS_RPZ_ERROR_LEVEL,
"limit of %d response policy zones exceeded",
DNS_RPZ_MAX_ZONES);
return (ISC_R_FAILURE);
result = dns_rpz_new_zone(view->rpzs, &zone);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(rpz_obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
+ cfg_obj_log(rpz_obj, DNS_RPZ_ERROR_LEVEL,
"Error creating new RPZ zone : %s",
isc_result_totext(result));
return (result);
return (result);
}
if (dns_name_equal(&zone->origin, dns_rootname)) {
- cfg_obj_log(rpz_obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
+ cfg_obj_log(rpz_obj, DNS_RPZ_ERROR_LEVEL,
"invalid zone name '%s'", str);
return (DNS_R_EMPTYLABEL);
}
if (dns_name_equal(&view->rpzs->zones[rpz_num]->origin,
&zone->origin))
{
- cfg_obj_log(rpz_obj, named_g_lctx,
- DNS_RPZ_ERROR_LEVEL,
+ cfg_obj_log(rpz_obj, DNS_RPZ_ERROR_LEVEL,
"duplicate '%s'", str);
result = DNS_R_DUPLICATE;
return (result);
}
#ifndef USE_DNSRPS
if (dnsrps_enabled) {
- cfg_obj_log(rpz_obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
+ cfg_obj_log(rpz_obj, DNS_RPZ_ERROR_LEVEL,
"\"dnsrps-enable yes\" but"
" without `./configure --enable-dnsrps`");
return (ISC_R_FAILURE);
#else /* ifndef USE_DNSRPS */
if (dnsrps_enabled) {
if (librpz == NULL) {
- cfg_obj_log(rpz_obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
+ cfg_obj_log(rpz_obj, DNS_RPZ_ERROR_LEVEL,
"\"dnsrps-enable yes\" but %s",
librpz_lib_open_emsg.c);
return (ISC_R_FAILURE);
} else if (old != NULL && pview != NULL) {
++pview->rpzs->rpz_ver;
view->rpzs->rpz_ver = pview->rpzs->rpz_ver;
- cfg_obj_log(rpz_obj, named_g_lctx, DNS_RPZ_DEBUG_LEVEL1,
+ cfg_obj_log(rpz_obj, DNS_RPZ_DEBUG_LEVEL1,
"updated RPZ policy: version %d",
view->rpzs->rpz_ver);
}
cfg = (ns_cfgctx_t *)cz->view->new_zone_config;
if (cfg == NULL) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"catz: allow-new-zones statement missing from "
"config; cannot add zone from the catalog");
goto cleanup;
if (result == ISC_R_SUCCESS &&
dnsforwarders->fwdpolicy == dns_fwdpolicy_only)
{
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
"catz: catz_addmodzone_cb: "
"zone '%s' will not be processed because of the "
"explicitly configured forwarding for that zone",
dns_catz_zone_t *parentcatz;
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"catz: error \"%s\" while trying to "
"modify zone '%s'",
}
if (!dns_zone_getadded(zone)) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"catz: catz_addmodzone_cb: "
"zone '%s' is not a dynamically "
parentcatz = dns_zone_get_parentcatz(zone);
if (parentcatz == NULL) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"catz: catz_addmodzone_cb: "
"zone '%s' exists and is not added by "
goto cleanup;
}
if (parentcatz != cz->origin) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"catz: catz_addmodzone_cb: "
"zone '%s' exists in multiple "
/* Zone shouldn't already exist when adding */
if (result == ISC_R_SUCCESS) {
if (dns_zone_get_parentcatz(zone) == NULL) {
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "catz: "
- "catz_addmodzone_cb: "
- "zone '%s' will not be added "
- "because it is an explicitly "
- "configured zone",
- nameb);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
+ "catz: "
+ "catz_addmodzone_cb: "
+ "zone '%s' will not be added "
+ "because it is an explicitly "
+ "configured zone",
+ nameb);
} else {
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "catz: "
- "catz_addmodzone_cb: "
- "zone '%s' will not be added "
- "because another catalog zone "
- "already contains an entry with "
- "that zone",
- nameb);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
+ "catz: "
+ "catz_addmodzone_cb: "
+ "zone '%s' will not be added "
+ "because another catalog zone "
+ "already contains an entry with "
+ "that zone",
+ nameb);
}
goto cleanup;
} else {
* failed.
*/
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"catz: error \"%s\" while trying to generate "
"config for zone '%s'",
isc_result_totext(result), nameb);
isc_loopmgr_resume(named_g_loopmgr);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
"catz: failed to configure zone '%s' - %d", nameb,
result);
goto cleanup;
result = dns_zone_load(zone, true);
if (result != ISC_R_SUCCESS) {
dns_db_t *dbp = NULL;
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"catz: dns_zone_load() failed "
"with %s; reverting.",
isc_result_totext(result));
result = dns_view_findzone(cz->view, dns_catz_entry_getname(cz->entry),
DNS_ZTFIND_EXACT, &zone);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
"catz: catz_delzone_cb: "
"zone '%s' not found",
cname);
}
if (!dns_zone_getadded(zone)) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
"catz: catz_delzone_cb: "
"zone '%s' is not a dynamically added zone",
cname);
}
if (dns_zone_get_parentcatz(zone) != cz->origin) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
"catz: catz_delzone_cb: zone "
"'%s' exists in multiple catalog zones",
cname);
}
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
"catz: catz_delzone_cb: "
"zone '%s' deleted",
cname);
}
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(catz_obj, named_g_lctx, DNS_CATZ_ERROR_LEVEL,
+ cfg_obj_log(catz_obj, DNS_CATZ_ERROR_LEVEL,
"catz: invalid zone name '%s'", str);
goto cleanup;
}
opts->zonedir = isc_mem_strdup(view->mctx,
cfg_obj_asstring(obj));
if (isc_file_isdirectory(opts->zonedir) != ISC_R_SUCCESS) {
- cfg_obj_log(obj, named_g_lctx, DNS_CATZ_ERROR_LEVEL,
+ cfg_obj_log(obj, DNS_CATZ_ERROR_LEVEL,
"catz: zone-directory '%s' "
"not found; zone files will not be "
"saved",
return (result);
}
-#define CHECK_RRL(cond, pat, val1, val2) \
- do { \
- if (!(cond)) { \
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR, pat, \
- val1, val2); \
- result = ISC_R_RANGE; \
- goto cleanup; \
- } \
+#define CHECK_RRL(cond, pat, val1, val2) \
+ do { \
+ if (!(cond)) { \
+ cfg_obj_log(obj, ISC_LOG_ERROR, pat, val1, val2); \
+ result = ISC_R_RANGE; \
+ goto cleanup; \
+ } \
} while (0)
#define CHECK_RRL_RATE(rate, def, max_rate, name) \
obj = NULL;
result = cfg_map_get(map, "exempt-clients", &obj);
if (result == ISC_R_SUCCESS) {
- result = cfg_acl_fromconfig(obj, config, named_g_lctx,
- named_g_aclconfctx, named_g_mctx, 0,
- &rrl->exempt);
+ result = cfg_acl_fromconfig(obj, config, named_g_aclconfctx,
+ named_g_mctx, 0, &rrl->exempt);
CHECK_RRL(result == ISC_R_SUCCESS, "invalid %s%s",
"address match list", "");
}
viewname = "";
}
dns_name_format(name, namebuf, sizeof(namebuf));
- isc_log_write(named_g_lctx, DNS_LOGCATEGORY_ZONELOAD,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "automatic empty zone%s%s: %s", sep, viewname, namebuf);
+ isc_log_write(DNS_LOGCATEGORY_ZONELOAD, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "automatic empty zone%s%s: %s", sep,
+ viewname, namebuf);
cleanup:
if (zone != NULL) {
CHECK(dns_view_addzone(view, zone));
dns_name_format(name, namebuf, sizeof(namebuf));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "automatic ipv4only zone%s%s: %s", sep, viewname,
- namebuf);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "automatic ipv4only zone%s%s: %s", sep,
+ viewname, namebuf);
cleanup:
if (zone != NULL) {
if (obj2 != NULL && cfg_obj_isuint64(obj2)) {
max_size = cfg_obj_asuint64(obj2);
if (max_size > SIZE_MAX) {
- cfg_obj_log(obj2, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj2, ISC_LOG_WARNING,
"'dnstap-output size "
"%" PRIu64 "' "
"is too large for this "
result = ns_plugin_expandpath(plugin_path, full_path,
sizeof(full_path));
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"%s: plugin configuration failed: "
"unable to get full plugin path: %s",
plugin_path, isc_result_totext(result));
result = ns_plugin_register(full_path, parameters, config,
cfg_obj_file(obj), cfg_obj_line(obj),
- named_g_mctx, named_g_lctx,
- named_g_aclconfctx, view);
+ named_g_mctx, named_g_aclconfctx, view);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"%s: plugin configuration failed: %s", full_path,
isc_result_totext(result));
}
if (view->rdclass != dns_rdataclass_in && need_hints &&
named_config_get(maps, "catalog-zones", &obj) == ISC_R_SUCCESS)
{
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"'catalog-zones' option is only supported "
"for views with class IN");
}
dns_name_format(&view->rpzs->zones[n]->origin,
namebuf, sizeof(namebuf));
- isc_log_write(named_g_lctx,
- NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER,
DNS_RPZ_ERROR_LEVEL,
"rpz '%s' is not a primary or a "
} else {
uint64_t value = cfg_obj_asuint64(obj);
if (value > SIZE_MAX) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"'max-cache-size "
"%" PRIu64 "' "
"is too large for this "
max_cache_size =
(size_t)(totalphys * max_cache_size_percent / 100);
if (totalphys == 0) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"Unable to determine amount of physical "
"memory, setting 'max-cache-size' to "
"unlimited");
} else {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_INFO,
+ cfg_obj_log(obj, ISC_LOG_INFO,
"'max-cache-size %d%%' "
"- setting to %" PRIu64 "MB "
"(out of %" PRIu64 "MB)",
obj = NULL;
(void)cfg_map_get(map, "clients", &obj);
if (obj != NULL) {
- result = cfg_acl_fromconfig(obj, config,
- named_g_lctx, actx,
+ result = cfg_acl_fromconfig(obj, config, actx,
mctx, 0, &clients);
if (result != ISC_R_SUCCESS) {
goto cleanup;
obj = NULL;
(void)cfg_map_get(map, "mapped", &obj);
if (obj != NULL) {
- result = cfg_acl_fromconfig(obj, config,
- named_g_lctx, actx,
+ result = cfg_acl_fromconfig(obj, config, actx,
mctx, 0, &mapped);
if (result != ISC_R_SUCCESS) {
goto cleanup;
obj = NULL;
(void)cfg_map_get(map, "exclude", &obj);
if (obj != NULL) {
- result = cfg_acl_fromconfig(obj, config,
- named_g_lctx, actx,
+ result = cfg_acl_fromconfig(obj, config, actx,
mctx, 0, &excluded);
if (result != ISC_R_SUCCESS) {
goto cleanup;
if (view->staleanswerclienttimeout != 0) {
view->staleanswerclienttimeout = 0;
isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"BIND 9 no longer supports non-zero values of "
"stale-answer-client-timeout, adjusted to 0");
max_cache_size, max_stale_ttl,
stale_refresh_time))
{
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"views %s and %s can't share the cache "
"due to configuration parameter mismatch",
if (!cache_reusable(pview, view,
zero_no_soattl))
{
- isc_log_write(named_g_lctx,
- NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER,
ISC_LOG_DEBUG(1),
"cache cannot be reused "
view->name);
} else {
INSIST(pview->cache != NULL);
- isc_log_write(named_g_lctx,
- NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER,
ISC_LOG_DEBUG(3),
"reusing existing cache");
INSIST(result == ISC_R_SUCCESS);
lame_ttl = cfg_obj_asduration(obj);
if (lame_ttl > 0) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"disabling lame cache despite lame-ttl > 0 as it "
"may cause performance issues");
lame_ttl = 0;
need_hints = false;
}
if (need_hints) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"no root hints for view '%s'",
view->name);
uint32_t padding = cfg_obj_asuint32(padobj);
if (padding > 512U) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"response-padding block-size cannot "
"exceed 512: lowering");
padding = 512U;
}
view->padding = (uint16_t)padding;
- CHECK(cfg_acl_fromconfig(aclobj, config, named_g_lctx, actx,
- named_g_mctx, 0, &view->pad_acl));
+ CHECK(cfg_acl_fromconfig(aclobj, config, actx, named_g_mctx, 0,
+ &view->pad_acl));
}
obj = NULL;
if (dctx == NULL) {
const void *hashinit = isc_hash_get_initializer();
- CHECK(dns_dyndb_createctx(mctx, hashinit, named_g_lctx,
- view, named_g_server->zonemgr,
+ CHECK(dns_dyndb_createctx(mctx, hashinit, view,
+ named_g_server->zonemgr,
named_g_loopmgr, &dctx));
}
ns_plugins_create(view->mctx, (ns_plugins_t **)&view->plugins);
view->plugins_free = ns_plugins_free;
- CHECK(cfg_pluginlist_foreach(config, plugin_list, named_g_lctx,
+ CHECK(cfg_pluginlist_foreach(config, plugin_list,
register_one_plugin, view));
}
result2 = configure_rpz(pview, view, maps, obj,
&old_rpz_ok);
if (result2 != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx,
- NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER,
ISC_LOG_ERROR,
"rpz configuration "
result2 = configure_catz(pview, view, config,
obj);
if (result2 != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx,
- NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER,
ISC_LOG_ERROR,
"catz configuration "
if (cfg_obj_isuint32(portobj)) {
uint32_t val = cfg_obj_asuint32(portobj);
if (val > UINT16_MAX) {
- cfg_obj_log(portobj, named_g_lctx,
- ISC_LOG_ERROR,
+ cfg_obj_log(portobj, ISC_LOG_ERROR,
"port '%u' out of range", val);
return (ISC_R_RANGE);
}
if (cfg_obj_isuint32(portobj)) {
uint32_t val = cfg_obj_asuint32(portobj);
if (val > UINT16_MAX) {
- cfg_obj_log(portobj, named_g_lctx,
- ISC_LOG_ERROR,
+ cfg_obj_log(portobj, ISC_LOG_ERROR,
"port '%u' out of range",
val);
return (ISC_R_RANGE);
static isc_result_t
validate_tls(const cfg_obj_t *config, dns_view_t *view, const cfg_obj_t *obj,
- isc_log_t *logctx, const char *str, dns_name_t **name) {
+ const char *str, dns_name_t **name) {
dns_fixedname_t fname;
dns_name_t *nm = dns_fixedname_initname(&fname);
isc_result_t result = dns_name_fromstring(nm, str, dns_rootname, 0,
NULL);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
- "'%s' is not a valid name", str);
+ cfg_obj_log(obj, ISC_LOG_ERROR, "'%s' is not a valid name",
+ str);
return (result);
}
const cfg_obj_t *tlsmap = find_maplist(config, "tls", str);
if (tlsmap == NULL) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"tls '%s' is not defined", str);
return (ISC_R_FAILURE);
}
if (cfg_obj_isuint32(portobj)) {
uint32_t val = cfg_obj_asuint32(portobj);
if (val > UINT16_MAX) {
- cfg_obj_log(portobj, named_g_lctx,
- ISC_LOG_ERROR,
+ cfg_obj_log(portobj, ISC_LOG_ERROR,
"port '%u' out of range", val);
return (ISC_R_RANGE);
}
tls = cfg_obj_asstring(tlspobj);
if (tls != NULL) {
result = validate_tls(config, view, tlspobj,
- named_g_lctx, tls, NULL);
+ tls, NULL);
if (result != ISC_R_SUCCESS) {
return (result);
}
cur_tls = tls;
}
if (cur_tls != NULL) {
- result = validate_tls(config, view, faddresses,
- named_g_lctx, cur_tls,
+ result = validate_tls(config, view, faddresses, cur_tls,
&fwd->tlsname);
if (result != ISC_R_SUCCESS) {
isc_mem_put(view->mctx, fwd,
if (ISC_LIST_EMPTY(fwdlist)) {
if (forwardtype != NULL) {
- cfg_obj_log(forwardtype, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(forwardtype, ISC_LOG_WARNING,
"no forwarders seen; disabling "
"forwarding");
}
if (result != ISC_R_SUCCESS) {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(origin, namebuf, sizeof(namebuf));
- cfg_obj_log(forwarders, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(forwarders, ISC_LOG_WARNING,
"could not set up forwarding for domain '%s': %s",
namebuf, isc_result_totext(result));
goto cleanup;
CHECK(named_config_getclass(classobj, dns_rdataclass_in,
&viewclass));
if (dns_rdataclass_ismeta(viewclass)) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"view '%s': class must not be meta",
viewname);
vname = "<default view>";
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"zone '%s': wrong class for view '%s'", zname,
vname);
result = ISC_R_FAILURE;
dns_view_t *otherview = NULL;
if (viewlist == NULL) {
- cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"'in-view' option is not permitted in "
"dynamically added zones");
result = ISC_R_FAILURE;
result = dns_viewlist_find(viewlist, inview, view->rdclass,
&otherview);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"view '%s' is not yet defined.", inview);
result = ISC_R_FAILURE;
goto cleanup;
&zone);
dns_view_detach(&otherview);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"zone '%s' not defined in view '%s'", zname,
inview);
result = ISC_R_FAILURE;
(void)cfg_map_get(zoptions, "type", &typeobj);
if (typeobj == NULL) {
- cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"zone '%s' 'type' not specified", zname);
result = ISC_R_FAILURE;
goto cleanup;
if (strcasecmp(ztypestr, "hint") == 0) {
const cfg_obj_t *fileobj = NULL;
if (cfg_map_get(zoptions, "file", &fileobj) != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"zone '%s': 'file' not specified", zname);
result = ISC_R_FAILURE;
CHECK(configure_hints(view, hintsfile));
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"ignoring non-root hint zone '%s'",
zname);
*/
if (strcasecmp(ztypestr, "redirect") == 0) {
if (view->redirect != NULL) {
- cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"redirect zone already exists");
result = ISC_R_EXISTS;
goto cleanup;
/*
* We already have this zone!
*/
- cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"zone '%s' already exists", zname);
dns_zone_detach(&dupzone);
result = ISC_R_EXISTS;
if (rpz_num != DNS_RPZ_INVALID_NUM) {
result = dns_zone_rpz_enable(zone, view->rpzs, rpz_num);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"zone '%s': incompatible"
" masterfile-format or database"
if (cfg_map_get(zoptions, "ixfr-from-differences",
&ixfrfromdiffs) == ISC_R_SUCCESS)
{
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"zone '%s': 'ixfr-from-differences' is "
"ignored for inline-signed zones",
}
dns_zone_attach(zone, &view->managed_keys);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO,
"set up managed keys zone for view %s, file '%s'",
view->name, filename);
directory = cfg_obj_asstring(obj);
if (!isc_file_ischdiridempotent(directory)) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"option 'directory' contains relative path '%s'",
directory);
}
if (!isc_file_isdirwritable(directory)) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "directory '%s' is not writable", directory);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "directory '%s' is not writable",
+ directory);
return (ISC_R_NOPERM);
}
result = isc_dir_chdir(directory);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"change directory to '%s' failed: %s", directory,
isc_result_totext(result));
return (result);
tatname = dns_fixedname_name(&tat->tatname);
dns_name_format(tatname, namebuf, sizeof(namebuf));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO,
"%s: sending trust-anchor-telemetry query '%s/NULL'",
tat->view->name, namebuf);
isc_region_t key_rawregion;
FILE *fp = NULL;
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "generating session key for dynamic DNS");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "generating session key for dynamic DNS");
/* generate key */
result = dst_key_generate(keyname, alg, bits, 1, 0, DNS_KEYPROTO_ANY,
/* Dump the key to the key file. */
fp = named_os_openfile(filename, S_IRUSR | S_IWUSR, first_time);
if (fp == NULL) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "could not create %s", filename);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "could not create %s", filename);
result = ISC_R_NOPERM;
goto cleanup;
}
return (ISC_R_SUCCESS);
cleanup:
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"failed to generate session key "
"for dynamic DNS: %s",
isc_result_totext(result));
if (result != ISC_R_SUCCESS) {
const char *s = " (keeping current key)";
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"session-keyalg: "
"unsupported or unknown algorithm '%s'%s",
algstr, server->session_keyfile != NULL ? s : "");
dir = cfg_obj_asstring(nzdir);
result = isc_file_isdirectory(dir);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, DNS_LOGCATEGORY_SECURITY,
+ isc_log_write(DNS_LOGCATEGORY_SECURITY,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"invalid new-zones-directory %s: %s", dir,
isc_result_totext(result));
return (result);
}
if (!isc_file_isdirwritable(dir)) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"new-zones-directory '%s' "
"is not writable",
if (result == ISC_R_SUCCESS && obj != NULL) {
mapsize = cfg_obj_asuint64(obj);
if (mapsize < (1ULL << 20)) { /* 1 megabyte */
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'lmdb-mapsize "
"%" PRId64 "' "
"is too small",
mapsize);
return (ISC_R_FAILURE);
} else if (mapsize > (1ULL << 40)) { /* 1 terabyte */
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'lmdb-mapsize "
"%" PRId64 "' "
"is too large",
return (ISC_R_SUCCESS);
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "loading additional zones for view '%s'", view->name);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "loading additional zones for view '%s'",
+ view->name);
zonelist = NULL;
cfg_map_get(nzctx->nzf_config, "zone", &zonelist);
result = cfg_parse_buffer(named_g_addparser, *text, bufname, 0,
&cfg_type_addzoneconf, 0, &zoneconf);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"parsing config for zone '%.*s' in "
"NZD database '%s' failed",
(int)zone_name_len, zone_name, view->new_zone_db);
return (ISC_R_SUCCESS);
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO,
"loading NZD configs from '%s' "
"for view '%s'",
view->new_zone_db, view->name);
CHECK(nzd_open(view, MDB_RDONLY, &txn, &dbi));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO,
"loading NZD config from '%s' "
"for zone '%s'",
view->new_zone_db, zonename);
* Parse the configuration file using the new config code.
*/
config = NULL;
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "loading configuration from '%s'", filename);
- result = cfg_parser_create(named_g_mctx, named_g_lctx, &conf_parser);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "loading configuration from '%s'",
+ filename);
+ result = cfg_parser_create(named_g_mctx, &conf_parser);
if (result != ISC_R_SUCCESS) {
goto cleanup_exclusive;
}
* registered.)
*/
result = isccfg_check_namedconf(config, BIND_CHECK_ALGORITHMS,
- named_g_lctx, named_g_mctx);
+ named_g_mctx);
if (result != ISC_R_SUCCESS) {
goto cleanup_config;
}
setstring(server, &server->bindkeysfile, cfg_obj_asstring(obj));
INSIST(server->bindkeysfile != NULL);
if (access(server->bindkeysfile, R_OK) != 0) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"unable to open '%s'; using built-in "
"keys instead",
server->bindkeysfile);
} else {
- result = cfg_parser_create(named_g_mctx, named_g_lctx,
+ result = cfg_parser_create(named_g_mctx,
&bindkeys_parser);
if (result != ISC_R_SUCCESS) {
goto cleanup_config;
server->bindkeysfile,
&cfg_type_bindkeys, &bindkeys);
if (result != ISC_R_SUCCESS) {
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "unable to parse '%s' "
- "error '%s'; using "
- "built-in keys instead",
- server->bindkeysfile,
- isc_result_totext(result));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO,
+ "unable to parse '%s' "
+ "error '%s'; using "
+ "built-in keys instead",
+ server->bindkeysfile,
+ isc_result_totext(result));
}
}
} else {
if (max > 1000) {
unsigned int margin = ISC_MAX(100, named_g_cpus + 1);
if (margin + 100 > max) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"'recursive-clients %d' too low when "
"running with %d worker threads",
result = named_config_get(maps, "sig0checks-quota-exempt", &obj);
if (result == ISC_R_SUCCESS) {
result = cfg_acl_fromconfig(
- obj, config, named_g_lctx, named_g_aclconfctx,
- named_g_mctx, 0, &server->sctx->sig0checksquota_exempt);
+ obj, config, named_g_aclconfctx, named_g_mctx, 0,
+ &server->sctx->sig0checksquota_exempt);
INSIST(result == ISC_R_SUCCESS);
}
INSIST(result == ISC_R_SUCCESS);
initial = cfg_obj_asuint32(obj) * 100;
if (initial > MAX_INITIAL_TIMEOUT) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"tcp-initial-timeout value is out of range: "
"lowering to %" PRIu32,
MAX_INITIAL_TIMEOUT / 100);
initial = MAX_INITIAL_TIMEOUT;
} else if (initial < MIN_INITIAL_TIMEOUT) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"tcp-initial-timeout value is out of range: "
"raising to %" PRIu32,
MIN_INITIAL_TIMEOUT / 100);
INSIST(result == ISC_R_SUCCESS);
idle = cfg_obj_asuint32(obj) * 100;
if (idle > MAX_IDLE_TIMEOUT) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"tcp-idle-timeout value is out of range: "
"lowering to %" PRIu32,
MAX_IDLE_TIMEOUT / 100);
idle = MAX_IDLE_TIMEOUT;
} else if (idle < MIN_IDLE_TIMEOUT) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"tcp-idle-timeout value is out of range: "
"raising to %" PRIu32,
MIN_IDLE_TIMEOUT / 100);
INSIST(result == ISC_R_SUCCESS);
keepalive = cfg_obj_asuint32(obj) * 100;
if (keepalive > MAX_KEEPALIVE_TIMEOUT) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"tcp-keepalive-timeout value is out of range: "
"lowering to %" PRIu32,
MAX_KEEPALIVE_TIMEOUT / 100);
keepalive = MAX_KEEPALIVE_TIMEOUT;
} else if (keepalive < MIN_KEEPALIVE_TIMEOUT) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"tcp-keepalive-timeout value is out of range: "
"raising to %" PRIu32,
MIN_KEEPALIVE_TIMEOUT / 100);
INSIST(result == ISC_R_SUCCESS);
advertised = cfg_obj_asuint32(obj) * 100;
if (advertised > MAX_ADVERTISED_TIMEOUT) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"tcp-advertized-timeout value is out of range: "
"lowering to %" PRIu32,
MAX_ADVERTISED_TIMEOUT / 100);
*/
result = isc_portset_create(named_g_mctx, &v4portset);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "creating UDP/IPv4 port set: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "creating UDP/IPv4 port set: %s",
isc_result_totext(result));
goto cleanup_bindkeys_parser;
}
result = isc_portset_create(named_g_mctx, &v6portset);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "creating UDP/IPv6 port set: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "creating UDP/IPv6 port set: %s",
isc_result_totext(result));
goto cleanup_v4portset;
}
result = isc_net_getudpportrange(AF_INET, &udpport_low,
&udpport_high);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"get the default UDP/IPv4 port range: %s",
isc_result_totext(result));
udpport_high);
}
if (!ns_server_getoption(server->sctx, NS_SERVER_DISABLE4)) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"using default UDP/IPv4 port range: "
"[%d, %d]",
result = isc_net_getudpportrange(AF_INET6, &udpport_low,
&udpport_high);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"get the default UDP/IPv6 port range: %s",
isc_result_totext(result));
udpport_high);
}
if (!ns_server_getoption(server->sctx, NS_SERVER_DISABLE6)) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"using default UDP/IPv6 port range: "
"[%d, %d]",
} else if (loadbalancesockets !=
isc_nm_getloadbalancesockets(named_g_netmgr))
{
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"changing reuseport value requires server restart");
}
#else
if (loadbalancesockets) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"reuseport has no effect on this system");
}
#endif
* and we should fail.
*/
if (result == ISC_R_ADDRINUSE) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"unable to listen on any configured "
"interfaces");
* that from the configuration options.
*/
isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"Disabling periodic interface re-scans timer");
server->interface_interval = 0;
/*
* Create the built-in key store ("key-directory").
*/
- result = cfg_keystore_fromconfig(NULL, named_g_mctx, named_g_lctx,
- &keystorelist, NULL);
+ result = cfg_keystore_fromconfig(NULL, named_g_mctx, &keystorelist,
+ NULL);
if (result != ISC_R_SUCCESS) {
goto cleanup_keystorelist;
}
cfg_obj_t *kconfig = cfg_listelt_value(element);
keystore = NULL;
result = cfg_keystore_fromconfig(kconfig, named_g_mctx,
- named_g_lctx, &keystorelist,
- NULL);
+ &keystorelist, NULL);
if (result != ISC_R_SUCCESS) {
goto cleanup_keystorelist;
}
kasp = NULL;
result = cfg_kasp_fromconfig(kconfig, default_kasp, true,
- named_g_mctx, named_g_lctx,
- &keystorelist, &kasplist, &kasp);
+ named_g_mctx, &keystorelist,
+ &kasplist, &kasp);
if (result != ISC_R_SUCCESS) {
goto cleanup_kasplist;
}
cfg_obj_t *kconfig = cfg_listelt_value(element);
kasp = NULL;
result = cfg_kasp_fromconfig(kconfig, default_kasp, true,
- named_g_mctx, named_g_lctx,
- &keystorelist, &kasplist, &kasp);
+ named_g_mctx, &keystorelist,
+ &kasplist, &kasp);
if (result != ISC_R_SUCCESS) {
goto cleanup_kasplist;
}
}
setstring(server, &server->dnsrpslib, cfg_obj_asstring(obj));
result = dns_dnsrps_server_create(server->dnsrpslib);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_DEBUG(1),
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_DEBUG(1),
"initializing DNSRPS RPZ provider '%s': %s",
server->dnsrpslib, isc_result_totext(result));
/*
result = named_tkeyctx_fromconfig(options, named_g_mctx,
&tkeyctx);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"configuring TKEY: %s",
isc_result_totext(result));
* Check that the working directory is writable.
*/
if (!isc_file_isdirwritable(".")) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"the working directory is not writable");
result = ISC_R_NOPERM;
goto cleanup_cachelist;
if (named_g_logstderr) {
const cfg_obj_t *logobj = NULL;
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO,
"not using config file logging "
"statement for logging due to "
"-g option");
if (logobj != NULL) {
result = named_logconfig(NULL, logobj);
if (result != ISC_R_SUCCESS) {
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "checking logging configuration "
- "failed: %s",
- isc_result_totext(result));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
+ "checking logging configuration "
+ "failed: %s",
+ isc_result_totext(result));
goto cleanup_cachelist;
}
}
} else {
const cfg_obj_t *logobj = NULL;
- isc_logconfig_create(named_g_lctx, &logc);
+ isc_logconfig_create(&logc);
logobj = NULL;
(void)cfg_map_get(config, "logging", &logobj);
if (logobj != NULL) {
result = named_logconfig(logc, logobj);
if (result != ISC_R_SUCCESS) {
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "configuring logging: %s",
- isc_result_totext(result));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
+ "configuring logging: %s",
+ isc_result_totext(result));
goto cleanup_logc;
}
} else {
named_log_setdefaultsslkeylogfile(logc);
result = named_log_setunmatchedcategory(logc);
if (result != ISC_R_SUCCESS) {
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "setting up default 'category "
- "unmatched': %s",
- isc_result_totext(result));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
+ "setting up default 'category "
+ "unmatched': %s",
+ isc_result_totext(result));
goto cleanup_logc;
}
result = named_log_setdefaultcategory(logc);
if (result != ISC_R_SUCCESS) {
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "setting up default 'category "
- "default': %s",
- isc_result_totext(result));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
+ "setting up default 'category "
+ "default': %s",
+ isc_result_totext(result));
goto cleanup_logc;
}
}
- isc_logconfig_set(named_g_lctx, logc);
+ isc_logconfig_set(logc);
logc = NULL;
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_DEBUG(1),
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_DEBUG(1),
"now using logging configuration from "
"config file");
}
if (usedlength != expectedlength) {
result = ISC_R_RANGE;
isc_log_write(
- named_g_lctx,
NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER,
ISC_LOG_ERROR,
result = named_statschannels_configure(named_g_server, config,
named_g_aclconfctx);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"configuring statistics server(s): %s",
isc_result_totext(result));
goto cleanup_altsecrets;
result = named_controls_configure(named_g_server->controls, config,
named_g_aclconfctx);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "binding control channel(s): %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "binding control channel(s): %s",
isc_result_totext(result));
goto cleanup_altsecrets;
}
isc_loopmgr_resume(named_g_loopmgr);
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_DEBUG(1),
- "load_configuration: %s", isc_result_totext(result));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_DEBUG(1), "load_configuration: %s",
+ isc_result_totext(result));
return (result);
}
* as it is
*/
if (reconfig) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"any newly configured zones are now "
"loaded");
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_NOTICE,
"all zones loaded");
}
view->managed_keys);
if (result != ISC_R_SUCCESS) {
isc_log_write(
- named_g_lctx,
DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC,
ISC_LOG_ERROR,
named_os_started();
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_NOTICE,
- "FIPS mode is %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_NOTICE, "FIPS mode is %s",
isc_fips_mode() ? "enabled" : "disabled");
#if HAVE_LIBSYSTEMD
atomic_store(&server->reload_status, NAMED_RELOAD_DONE);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_NOTICE,
- "running");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_NOTICE, "running");
}
return (ISC_R_SUCCESS);
isc_timer_create(named_g_mainloop, pps_timer_tick, server,
&server->pps_timer);
- CHECKFATAL(
- cfg_parser_create(named_g_mctx, named_g_lctx, &named_g_parser),
- "creating default configuration parser");
+ CHECKFATAL(cfg_parser_create(named_g_mctx, &named_g_parser),
+ "creating default configuration parser");
- CHECKFATAL(cfg_parser_create(named_g_mctx, named_g_lctx,
- &named_g_addparser),
+ CHECKFATAL(cfg_parser_create(named_g_mctx, &named_g_addparser),
"creating additional configuration parser");
CHECKFATAL(load_configuration(named_g_conffile, server, true),
isc_loopmgr_pause(named_g_loopmgr);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO, "shutting down%s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "shutting down%s",
flush ? ": flushing changes" : "");
cleanup_session_key(server, server->mctx);
if (named_g_loopmgr_running) {
isc_loopmgr_pause(named_g_loopmgr);
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_CRITICAL, "%s: %s", msg,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_CRITICAL, "%s: %s", msg,
isc_result_totext(result));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_CRITICAL,
- "exiting (due to fatal error)");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_CRITICAL, "exiting (due to fatal error)");
named_os_shutdown();
_exit(EXIT_FAILURE);
}
isc_result_t result;
result = load_configuration(named_g_conffile, server, false);
if (result == ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO,
"reloading configuration succeeded");
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"reloading configuration failed: %s",
isc_result_totext(result));
atomic_store(&server->reload_status, NAMED_RELOAD_FAILED);
result = load_zones(server, false);
if (result == ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "reloading zones succeeded");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "reloading zones succeeded");
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "reloading zones failed: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "reloading zones failed: %s",
isc_result_totext(result));
atomic_store(&server->reload_status, NAMED_RELOAD_FAILED);
}
named_server_reload(void *arg) {
named_server_t *server = (named_server_t *)arg;
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "received SIGHUP signal to reload zones");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "received SIGHUP signal to reload zones");
(void)reload(server);
}
named_server_closelogs(void *arg) {
UNUSED(arg);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO,
"received SIGUSR1 signal to close log files");
- isc_log_closefilelogs(named_g_lctx);
+ isc_log_closefilelogs();
}
static void
void
named_server_scan_interfaces(named_server_t *server) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_DEBUG(1),
- "automatic interface rescan");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_DEBUG(1), "automatic interface rescan");
ns_interfacemgr_scan(server->interfacemgr, true, false);
}
result = load_zones(server, true);
if (result == ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "scheduled loading new zones");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "scheduled loading new zones");
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "loading new zones failed: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "loading new zones failed: %s",
isc_result_totext(result));
atomic_store(&server->reload_status, NAMED_RELOAD_FAILED);
}
ns_server_setoption(server->sctx, NS_SERVER_LOGQUERIES, value);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "query logging is now %s", value ? "on" : "off");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "query logging is now %s",
+ value ? "on" : "off");
return (ISC_R_SUCCESS);
}
tlsmap = find_maplist(config, "tls", tlsname);
if (tlsmap == NULL) {
- cfg_obj_log(tlsobj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(tlsobj, ISC_LOG_ERROR,
"tls '%s' is not defined",
cfg_obj_asstring(tlsobj));
return (ISC_R_FAILURE);
http_server = find_maplist(config, "http", httpname);
if (http_server == NULL && strcasecmp(httpname, "default") != 0)
{
- cfg_obj_log(httpobj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(httpobj, ISC_LOG_ERROR,
"http '%s' is not defined",
cfg_obj_asstring(httpobj));
return (ISC_R_FAILURE);
}
result = cfg_acl_fromconfig(cfg_tuple_get(listener, "acl"), config,
- named_g_lctx, actx, mctx, family,
- &delt->acl);
+ actx, mctx, family, &delt->acl);
if (result != ISC_R_SUCCESS) {
ns_listenelt_destroy(delt);
return (result);
(void)isc_stdio_close(fp);
}
if (result == ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "dumpstats complete");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "dumpstats complete");
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "dumpstats failed: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "dumpstats failed: %s",
isc_result_totext(result));
}
return (result);
fprintf(dctx->fp, "; Dump complete\n");
result = isc_stdio_flush(dctx->fp);
if (result == ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "dumpdb complete");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "dumpdb complete");
}
cleanup:
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "dumpdb failed: %s", isc_result_totext(result));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "dumpdb failed: %s",
+ isc_result_totext(result));
}
dumpcontext_destroy(dctx);
}
ptr = next_token(lex, NULL);
sep = (ptr == NULL) ? "" : ": ";
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "dumpdb started%s%s", sep, (ptr != NULL) ? ptr : "");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "dumpdb started%s%s", sep,
+ (ptr != NULL) ? ptr : "");
if (ptr != NULL && strcmp(ptr, "-all") == 0) {
/* also dump zones */
}
if (result == ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "dumpsecroots complete");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "dumpsecroots complete");
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "dumpsecroots failed: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "dumpsecroots failed: %s",
isc_result_totext(result));
}
return (result);
result = isc_stdio_close(fp);
}
if (result == ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "dumprecursing complete");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "dumprecursing complete");
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "dumprecursing failed: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "dumprecursing failed: %s",
isc_result_totext(result));
}
return (result);
}
named_g_debuglevel = (unsigned int)newlevel;
}
- isc_log_setdebuglevel(named_g_lctx, named_g_debuglevel);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "debug level is now %u", named_g_debuglevel);
+ isc_log_setdebuglevel(named_g_debuglevel);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "debug level is now %u",
+ named_g_debuglevel);
return (ISC_R_SUCCESS);
}
result = dns_view_flushcache(nsc->primaryview, false);
if (result != ISC_R_SUCCESS) {
flushed = false;
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"flushing cache in view '%s' failed: %s",
nsc->primaryview->name,
if (result != ISC_R_SUCCESS) {
flushed = false;
isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"fixing cache in view '%s' "
"failed: %s",
if (flushed && found) {
if (ptr != NULL) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"flushing cache in view '%s' succeeded",
ptr);
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"flushing caches in all views succeeded");
}
result = ISC_R_SUCCESS;
} else {
if (!found) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"flushing cache in view '%s' failed: "
"view not found",
result = dns_view_flushnode(view, name, tree);
if (result != ISC_R_SUCCESS) {
flushed = false;
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"flushing %s '%s' in cache view '%s' "
"failed: %s",
}
if (flushed && found) {
if (viewname != NULL) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"flushing %s '%s' in cache view '%s' "
"succeeded",
tree ? "tree" : "name", target, viewname);
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"flushing %s '%s' in all cache views "
"succeeded",
result = ISC_R_SUCCESS;
} else {
if (!found) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"flushing %s '%s' in cache view '%s' "
"failed: view not found",
}
}
isc_loopmgr_resume(named_g_loopmgr);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "dumping all zones%s: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "dumping all zones%s: %s",
cleanup ? ", removing journal files" : "",
isc_result_totext(result));
return (tresult);
dns_rdataclass_format(dns_zone_getclass(zone), classstr,
sizeof(classstr));
dns_name_format(dns_zone_getorigin(zone), zonename, sizeof(zonename));
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
- ISC_LOG_INFO, "sync: dumping zone '%s/%s'%s%s%s: %s", zonename,
- classstr, sep, vname, cleanup ? ", removing journal file" : "",
- isc_result_totext(result));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "sync: dumping zone '%s/%s'%s%s%s: %s",
+ zonename, classstr, sep, vname,
+ cleanup ? ", removing journal file" : "",
+ isc_result_totext(result));
dns_zone_detach(&zone);
return (result);
}
}
}
isc_loopmgr_resume(named_g_loopmgr);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "%s all zones: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "%s all zones: %s",
freeze ? "freezing" : "thawing",
isc_result_totext(tresult));
return (tresult);
sizeof(classstr));
dns_name_format(dns_zone_getorigin(mayberaw), zonename,
sizeof(zonename));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "%s zone '%s/%s'%s%s: %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "%s zone '%s/%s'%s%s: %s",
freeze ? "freezing" : "thawing", zonename, classstr, sep,
vname, isc_result_totext(result));
dns_zone_detach(&mayberaw);
result2 = isc_file_truncate(view->new_zone_file,
offset);
if (result2 != ISC_R_SUCCESS) {
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "Error truncating NZF file '%s' "
- "during rollback from append: "
- "%s",
- view->new_zone_file,
- isc_result_totext(result2));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
+ "Error truncating NZF file '%s' "
+ "during rollback from append: "
+ "%s",
+ view->new_zone_file,
+ isc_result_totext(result2));
}
}
}
result = cfg_parse_file(named_g_addparser, view->new_zone_file,
&cfg_type_addzoneconf, &nzcfg->nzf_config);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "Error parsing NZF file '%s': %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "Error parsing NZF file '%s': %s",
view->new_zone_file, isc_result_totext(result));
}
/* We're deleting the zone from the database */
status = mdb_del(*txnp, dbi, &key, NULL);
if (status != MDB_SUCCESS && status != MDB_NOTFOUND) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"Error deleting zone %s "
"from NZD database: %s",
zoptions = cfg_tuple_get(zconfig, "options");
if (zoptions == NULL) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"Unable to get options from config in "
"nzd_save()");
dzarg.result = ISC_R_SUCCESS;
cfg_printx(zoptions, CFG_PRINTER_ONELINE, dumpzone, &dzarg);
if (dzarg.result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"Error writing zone config to "
"buffer in nzd_save(): %s",
status = mdb_put(*txnp, dbi, &key, &data, 0);
if (status != MDB_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"Error inserting zone in "
"NZD database: %s",
} else {
status = mdb_txn_commit(*txnp);
if (status != MDB_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"Error committing "
"NZD database: %s",
status = mdb_txn_begin((MDB_env *)view->new_zone_dbenv, 0, 0, &txn);
if (status != MDB_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "mdb_txn_begin: %s", mdb_strerror(status));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING, "mdb_txn_begin: %s",
+ mdb_strerror(status));
return (ISC_R_FAILURE);
}
status = mdb_dbi_open(txn, NULL, 0, &dbi);
if (status != MDB_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "mdb_dbi_open: %s", mdb_strerror(status));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING, "mdb_dbi_open: %s",
+ mdb_strerror(status));
result = ISC_R_FAILURE;
}
status = mdb_txn_begin((MDB_env *)view->new_zone_dbenv, 0, flags, &txn);
if (status != MDB_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "mdb_txn_begin: %s", mdb_strerror(status));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING, "mdb_txn_begin: %s",
+ mdb_strerror(status));
goto cleanup;
}
status = mdb_dbi_open(txn, NULL, 0, dbi);
if (status != MDB_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "mdb_dbi_open: %s", mdb_strerror(status));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING, "mdb_dbi_open: %s",
+ mdb_strerror(status));
goto cleanup;
}
status = mdb_env_create(&env);
if (status != MDB_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- ISC_LOGMODULE_OTHER, ISC_LOG_ERROR,
- "mdb_env_create failed: %s",
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, ISC_LOGMODULE_OTHER,
+ ISC_LOG_ERROR, "mdb_env_create failed: %s",
mdb_strerror(status));
CHECK(ISC_R_FAILURE);
}
if (view->new_zone_mapsize != 0ULL) {
status = mdb_env_set_mapsize(env, view->new_zone_mapsize);
if (status != MDB_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
ISC_LOGMODULE_OTHER, ISC_LOG_ERROR,
"mdb_env_set_mapsize failed: %s",
mdb_strerror(status));
status = mdb_env_open(env, view->new_zone_db, DNS_LMDB_FLAGS, 0600);
if (status != MDB_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- ISC_LOGMODULE_OTHER, ISC_LOG_ERROR,
- "mdb_env_open of '%s' failed: %s",
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, ISC_LOGMODULE_OTHER,
+ ISC_LOG_ERROR, "mdb_env_open of '%s' failed: %s",
view->new_zone_db, mdb_strerror(status));
CHECK(ISC_R_FAILURE);
}
goto cleanup;
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO,
"Migrating zones from NZF file '%s' to "
"NZD database '%s'",
view->new_zone_file, view->new_zone_db);
result = cfg_parse_file(named_g_addparser, view->new_zone_file,
&cfg_type_addzoneconf, &nzf_config);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "Error parsing NZF file '%s': %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "Error parsing NZF file '%s': %s",
view->new_zone_file, isc_result_totext(result));
goto cleanup;
}
dzarg.result = ISC_R_SUCCESS;
cfg_printx(zoptions, CFG_PRINTER_ONELINE, dumpzone, &dzarg);
if (dzarg.result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"Error writing zone config to "
"buffer in load_nzf(): %s",
status = mdb_put(txn, dbi, &key, &data, MDB_NOOVERWRITE);
if (status != MDB_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"Error inserting zone in "
"NZD database: %s",
} else {
result = dns_view_findzone(view, name, DNS_ZTFIND_EXACT, &zone);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"added new zone was not found: %s",
isc_result_totext(result));
TCHECK(putstr(text, "dns_zone_loadnew failed: "));
TCHECK(putstr(text, isc_result_totext(result)));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "addzone failed; reverting.");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "addzone failed; reverting.");
/* If the zone loaded partially, unload it */
if (dns_zone_getdb(zone, &dbp) == ISC_R_SUCCESS) {
TCHECK(putstr(text, "Use 'rndc addzone' to correct\n"));
TCHECK(putstr(text, "the problem and restore service."));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "modzone failed; removing zone.");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "modzone failed; removing zone.");
/* If the zone loaded partially, unload it */
if (dns_zone_getdb(zone, &dbp) == ISC_R_SUCCESS) {
redirect, text));
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "%s zone %s in view %s via %s",
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "%s zone %s in view %s via %s",
addzone ? "added" : "updated", zonename, view->name,
addzone ? NAMED_COMMAND_ADDZONE : NAMED_COMMAND_MODZONE);
cfg = (ns_cfgctx_t *)view->new_zone_config;
dns_name_format(dns_zone_getorigin(zone), zonename, sizeof(zonename));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "deleting zone %s in view %s via delzone", zonename,
- view->name);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "deleting zone %s in view %s via delzone",
+ zonename, view->name);
/*
* Remove the zone from configuration (and NZF file if applicable)
LOCK(&view->new_zone_lock);
result = nzd_open(view, 0, &txn, &dbi);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"unable to open NZD database for '%s'",
view->new_zone_db);
}
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"unable to delete zone configuration: %s",
isc_result_totext(result));
dns_zone_getorigin(zone),
nzf_writeconf);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"unable to delete zone configuration: %s",
isc_result_totext(result));
dns_zone_getorigin(zone), NULL);
}
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"unable to delete zone configuration: %s",
isc_result_totext(result));
file = dns_zone_getfile(mayberaw);
result = isc_file_remove(file);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"file %s not removed: %s", file,
isc_result_totext(result));
file = dns_zone_getjournal(mayberaw);
result = isc_file_remove(file);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"file %s not removed: %s", file,
isc_result_totext(result));
file = dns_zone_getfile(zone);
result = isc_file_remove(file);
if (result != ISC_R_SUCCESS) {
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "file %s not removed: %s", file,
- isc_result_totext(result));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
+ "file %s not removed: %s", file,
+ isc_result_totext(result));
}
file = dns_zone_getjournal(zone);
result = isc_file_remove(file);
if (result != ISC_R_SUCCESS) {
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "file %s not removed: %s", file,
- isc_result_totext(result));
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
+ "file %s not removed: %s", file,
+ isc_result_totext(result));
}
}
}
}
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "zone %s scheduled for removal via delzone", zonename);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO, "zone %s scheduled for removal via delzone",
+ zonename);
/* Removing a zone counts as reconfiguration */
named_g_configtime = isc_time_now();
}
if (readonly) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_CONTROL, ISC_LOG_INFO,
"rejecting restricted control channel "
"NTA command");
}
result = dns_view_flushnode(view, ntaname, true);
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO,
"flush tree '%s' in cache view '%s': %s", namebuf,
view->name, isc_result_totext(result));
CHECK(putstr(text, ", expires "));
CHECK(putstr(text, tbuf));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"added NTA '%s' (%d sec) in view '%s'",
namebuf, ntattl, view->name);
CHECK(putstr(text, view->name));
if (wasremoved) {
- isc_log_write(
- named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
- "removed NTA '%s' in view %s", namebuf,
- view->name);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
+ NAMED_LOGMODULE_SERVER,
+ ISC_LOG_INFO,
+ "removed NTA '%s' in view %s",
+ namebuf, view->name);
}
}
result = dns_view_saventa(view);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"error writing NTA file "
"for view '%s': %s",
isc_result_t result = dns_view_saventa(view);
if (result != ISC_R_SUCCESS) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"error writing NTA file "
"for view '%s': %s",
(result != ISC_R_FILENOTFOUND) &&
(result != ISC_R_NOTFOUND))
{
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"error loading NTA file "
"for view '%s': %s",
if (result == ISC_R_SUCCESS) {
removed_a_file = true;
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "file %s not removed: %s", file,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING, "file %s not removed: %s", file,
isc_result_totext(result));
}
if (result == ISC_R_SUCCESS) {
removed_a_file = true;
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "file %s not removed: %s", file,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING, "file %s not removed: %s", file,
isc_result_totext(result));
}
return (ISC_R_SUCCESS);
#ifdef HAVE_LIBXML2
cleanup:
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "failed at dump_counters()");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "failed at dump_counters()");
return (ISC_R_FAILURE);
#endif /* ifdef HAVE_LIBXML2 */
}
return;
#ifdef HAVE_LIBXML2
cleanup:
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "failed at rdtypestat_dump()");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "failed at rdtypestat_dump()");
dumparg->result = ISC_R_FAILURE;
return;
#endif /* ifdef HAVE_LIBXML2 */
return;
#ifdef HAVE_LIBXML2
cleanup:
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "failed at rdatasetstats_dump()");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "failed at rdatasetstats_dump()");
dumparg->result = ISC_R_FAILURE;
#endif /* ifdef HAVE_LIBXML2 */
}
#ifdef HAVE_LIBXML2
cleanup:
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "failed at opcodestat_dump()");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "failed at opcodestat_dump()");
dumparg->result = ISC_R_FAILURE;
return;
#endif /* ifdef HAVE_LIBXML2 */
#ifdef HAVE_LIBXML2
cleanup:
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "failed at rcodestat_dump()");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "failed at rcodestat_dump()");
dumparg->result = ISC_R_FAILURE;
return;
#endif /* ifdef HAVE_LIBXML2 */
return;
#ifdef HAVE_LIBXML2
cleanup:
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "failed at dnssecsignstat_dump()");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "failed at dnssecsignstat_dump()");
dumparg->result = ISC_R_FAILURE;
return;
#endif /* ifdef HAVE_LIBXML2 */
return (ISC_R_SUCCESS);
cleanup:
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "Failed at zone_xmlrender()");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "Failed at zone_xmlrender()");
return (ISC_R_FAILURE);
}
dns_xfrin_detach(&xfr);
}
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "Failed at xfrin_xmlrender()");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "Failed at xfrin_xmlrender()");
return (ISC_R_FAILURE);
}
return (ISC_R_SUCCESS);
cleanup:
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "failed generating XML response");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "failed generating XML response");
if (writer != NULL) {
xmlFreeTextWriter(writer);
}
*freecb = wrap_xmlfree;
*freecb_args = NULL;
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "failed at rendering XML()");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "failed at rendering XML()");
}
return (result);
*freecb = wrap_jsonfree;
*freecb_args = bindstats;
} else {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "failed at rendering JSON()");
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "failed at rendering JSON()");
}
return (result);
shutdown_listener(named_statschannel_t *listener) {
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&listener->address, socktext, sizeof(socktext));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_NOTICE,
- "stopping statistics channel on %s", socktext);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_NOTICE, "stopping statistics channel on %s",
+ socktext);
isc_httpdmgr_shutdown(&listener->httpdmgr);
}
UNLOCK(&listener->lock);
isc_sockaddr_format(fromaddr, socktext, sizeof(socktext));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
- "rejected statistics connection from %s", socktext);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING, "rejected statistics connection from %s",
+ socktext);
return (false);
}
allow = cfg_tuple_get(listen_params, "allow");
if (allow != NULL && cfg_obj_islist(allow)) {
- result = cfg_acl_fromconfig(allow, config, named_g_lctx,
- aclconfctx, listener->mctx, 0,
- &new_acl);
+ result = cfg_acl_fromconfig(allow, config, aclconfctx,
+ listener->mctx, 0, &new_acl);
} else {
result = dns_acl_any(listener->mctx, &new_acl);
}
server);
*listenerp = listener;
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_NOTICE,
- "statistics channel listening on %s", socktext);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_NOTICE, "statistics channel listening on %s",
+ socktext);
return (ISC_R_SUCCESS);
*/
allow = cfg_tuple_get(listen_params, "allow");
if (allow != NULL && cfg_obj_islist(allow)) {
- result = cfg_acl_fromconfig(allow, config, named_g_lctx,
- aclconfctx, listener->mctx, 0,
- &new_acl);
+ result = cfg_acl_fromconfig(allow, config, aclconfctx,
+ listener->mctx, 0, &new_acl);
} else {
result = dns_acl_any(listener->mctx, &new_acl);
}
UNLOCK(&listener->lock);
} else {
- cfg_obj_log(listen_params, named_g_lctx, ISC_LOG_WARNING,
+ cfg_obj_log(listen_params, ISC_LOG_WARNING,
"couldn't install new acl for "
"statistics channel %s: %s",
socktext, isc_result_totext(result));
*/
if (statschannellist != NULL) {
#ifndef EXTENDED_STATS
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
"statistics-channels specified but not effective "
"due to missing XML and/or JSON library");
#else /* EXTENDED_STATS */
#ifndef HAVE_LIBXML2
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
"statistics-channels: XML library missing, "
"only JSON stats will be available");
#endif /* !HAVE_LIBXML2 */
#ifndef HAVE_JSON_C
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_WARNING,
"statistics-channels: JSON library missing, "
"only XML stats will be available");
#endif /* !HAVE_JSON_C */
isc_sockaddr_format(&addr, socktext,
sizeof(socktext));
- isc_log_write(named_g_lctx,
- NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER,
ISC_LOG_DEBUG(9),
"processing statistics "
if (r != ISC_R_SUCCESS) {
cfg_obj_log(
listen_params,
- named_g_lctx,
ISC_LOG_WARNING,
"couldn't allocate "
"statistics channel"
} while (0)
#include <named/log.h>
-#define LOG(msg) \
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL, \
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR, "%s", msg)
+#define LOG(msg) \
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER, \
+ ISC_LOG_ERROR, "%s", msg)
isc_result_t
named_tkeyctx_fromconfig(const cfg_obj_t *options, isc_mem_t *mctx,
return (ISC_R_SUCCESS);
failure:
- cfg_obj_log(doh, named_g_lctx, ISC_LOG_ERROR,
- "configuring DoH '%s': %s", dohid,
+ cfg_obj_log(doh, ISC_LOG_ERROR, "configuring DoH '%s': %s", dohid,
isc_result_totext(result));
return (result);
return (ISC_R_SUCCESS);
failure:
- cfg_obj_log(tls, named_g_lctx, ISC_LOG_ERROR,
- "configuring tls '%s': %s", tlsid,
+ cfg_obj_log(tls, ISC_LOG_ERROR, "configuring tls '%s': %s", tlsid,
isc_result_totext(result));
return (result);
if (named_config_getkeyalgorithm(algstr, &alg, &bits) !=
ISC_R_SUCCESS)
{
- cfg_obj_log(algobj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(algobj, ISC_LOG_ERROR,
"key '%s': has a "
"unsupported algorithm '%s'",
keyid, algstr);
if (secret != NULL) {
isc_mem_put(mctx, secret, secretalloc);
}
- cfg_obj_log(key, named_g_lctx, ISC_LOG_ERROR,
- "configuring key '%s': %s", keyid, isc_result_totext(ret));
+ cfg_obj_log(key, ISC_LOG_ERROR, "configuring key '%s': %s", keyid,
+ isc_result_totext(ret));
return (ret);
}
}
parse_acl:
- result = cfg_acl_fromconfig(aclobj, config, named_g_lctx, actx,
- named_g_mctx, 0, &acl);
+ result = cfg_acl_fromconfig(aclobj, config, actx, named_g_mctx, 0,
+ &acl);
if (result != ISC_R_SUCCESS) {
return (result);
}
result = dns_name_fromtext(dns_fixedname_name(&fident), &b,
dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(identity, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(identity, ISC_LOG_ERROR,
"'%s' is not a valid name", str);
goto cleanup;
}
result = dns_name_fromtext(dns_fixedname_name(&fname),
&b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(identity, named_g_lctx,
- ISC_LOG_ERROR,
+ cfg_obj_log(identity, ISC_LOG_ERROR,
"'%s' is not a valid name", str);
goto cleanup;
}
if (max > 0xffff || end[0] != /*(*/ ')' ||
end[1] != 0)
{
- cfg_obj_log(identity, named_g_lctx,
- ISC_LOG_ERROR,
+ cfg_obj_log(identity, ISC_LOG_ERROR,
"'%s' is not a valid count",
bracket);
isc_mem_cput(mctx, types, n,
result = dns_rdatatype_fromtext(&types[i++].type, &r);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(identity, named_g_lctx,
- ISC_LOG_ERROR,
+ cfg_obj_log(identity, ISC_LOG_ERROR,
"'%.*s' is not a valid type",
(int)r.length, str);
isc_mem_cput(mctx, types, n, sizeof(*types));
dns_ssuruletype_t any = { dns_rdatatype_any, 0 };
if (named_g_server->session_keyname == NULL) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"failed to enable auto DDNS policy "
"for zone %s: session key not found",
sa = cfg_obj_assockaddr(address);
if (isc_sockaddr_getport(sa) != 0) {
- cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"port is not configurable for "
"static stub server-addresses");
return (ISC_R_FAILURE);
}
isc_netaddr_fromsockaddr(&na, sa);
if (isc_netaddr_getzone(&na) != 0) {
- cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"scoped address is not allowed "
"for static stub "
"server-addresses");
isc_buffer_add(&b, strlen(str));
result = dns_name_fromtext(nsname, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"server-name '%s' is not a valid "
"name",
str);
return (result);
}
if (dns_name_issubdomain(nsname, dns_zone_getorigin(zone))) {
- cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"server-name '%s' must not be a "
"subdomain of zone name '%s'",
str, zname);
* to trigger delegation.
*/
if (ISC_LIST_EMPTY(rdatalist_ns.rdata)) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR,
"No NS record is configured for a "
"static-stub zone '%s'",
zname);
* hierarchy supplied in 'maps'.
*/
if (named_config_get(maps, "notify", &obj) == ISC_R_SUCCESS) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_INFO,
+ cfg_obj_log(obj, ISC_LOG_INFO,
"'notify explicit;' will be used for mirror zone "
"'%s'",
zname);
size_t len;
if (cpval != default_dbtype) {
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"zone '%s': both 'database' and 'dlz' "
"specified",
if (ztype == dns_zone_primary && cpval == default_dbtype &&
filename == NULL)
{
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "zone '%s': 'file' not specified", zname);
+ isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
+ ISC_LOG_ERROR, "zone '%s': 'file' not specified",
+ zname);
CHECK(ISC_R_FAILURE);
}
const char *masterstylestr = cfg_obj_asstring(obj);
if (masterformat != dns_masterformat_text) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"zone '%s': 'masterfile-style' "
"can only be used with "
"'masterfile-format text'",
&kasp);
if (result != ISC_R_SUCCESS) {
cfg_obj_log(
- obj, named_g_lctx,
- ISC_LOG_ERROR,
+ obj, ISC_LOG_ERROR,
"dnssec-policy '%s' not found ",
kaspname);
CHECK(result);
} else {
uint64_t value = cfg_obj_asuint64(obj);
if (value > DNS_JOURNAL_SIZE_MAX) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'max-journal-size "
"%" PRId64 "' "
"is too large",
} else {
uint64_t value = cfg_obj_asuint64(obj);
if (value > DNS_JOURNAL_SIZE_MAX) {
- cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'max-journal-size "
"%" PRId64 "' "
"is too large",
updateacl = dns_zone_getupdateacl(mayberaw);
if (updateacl != NULL && dns_acl_isinsecure(updateacl)) {
- isc_log_write(named_g_lctx, DNS_LOGCATEGORY_SECURITY,
+ isc_log_write(DNS_LOGCATEGORY_SECURITY,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"zone '%s' allows unsigned updates "
"from remote hosts, which is insecure",
static bool local_only = false;
static isc_nm_t *netmgr = NULL;
static isc_loopmgr_t *loopmgr = NULL;
-static isc_log_t *glctx = NULL;
static isc_mem_t *gmctx = NULL;
static dns_dispatchmgr_t *dispatchmgr = NULL;
static dns_requestmgr_t *requestmgr = NULL;
* Get a key from a named.conf format keyfile
*/
static isc_result_t
-read_sessionkey(isc_mem_t *mctx, isc_log_t *lctx) {
+read_sessionkey(isc_mem_t *mctx) {
cfg_parser_t *pctx = NULL;
cfg_obj_t *sessionkey = NULL;
const cfg_obj_t *key = NULL;
return (ISC_R_FILENOTFOUND);
}
- result = cfg_parser_create(mctx, lctx, &pctx);
+ result = cfg_parser_create(mctx, &pctx);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
}
static void
-setup_keyfile(isc_mem_t *mctx, isc_log_t *lctx) {
+setup_keyfile(isc_mem_t *mctx) {
dst_key_t *dstkey = NULL;
isc_result_t result;
dst_algorithm_t hmac_alg = DST_ALG_UNKNOWN;
/* If that didn't work, try reading it as a session.key keyfile */
if (result != ISC_R_SUCCESS) {
- result = read_sessionkey(mctx, lctx);
+ result = read_sessionkey(mctx);
if (result == ISC_R_SUCCESS) {
return;
}
ddebug("setup_system()");
- dns_log_init(glctx);
+ dns_log_init();
- logconfig = isc_logconfig_get(glctx);
+ logconfig = isc_logconfig_get();
result = isc_log_usechannel(logconfig, "default_debug", NULL, NULL);
check_result(result, "isc_log_usechannel");
- isc_log_setdebuglevel(glctx, logdebuglevel);
+ isc_log_setdebuglevel(logdebuglevel);
result = irs_resconf_load(gmctx, resolvconf, &resconf);
if (result != ISC_R_SUCCESS && result != ISC_R_FILENOTFOUND) {
if (keystr != NULL) {
setup_keystr();
} else if (local_only) {
- result = read_sessionkey(gmctx, glctx);
+ result = read_sessionkey(gmctx);
if (result != ISC_R_SUCCESS) {
fatal("can't read key from %s: %s\n", keyfile,
isc_result_totext(result));
}
} else if (keyfile != NULL) {
- setup_keyfile(gmctx, glctx);
+ setup_keyfile(gmctx);
}
isc_mutex_init(&answer_lock);
}
static isc_result_t
-check_syntax(cfg_obj_t *fmap, const void *cfg, isc_mem_t *mctx, isc_log_t *lctx,
- void *actx) {
+check_syntax(cfg_obj_t *fmap, const void *cfg, isc_mem_t *mctx, void *actx) {
isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *aclobj = NULL;
dns_acl_t *acl = NULL;
return (result);
}
- CHECK(cfg_acl_fromconfig(aclobj, (const cfg_obj_t *)cfg, lctx,
+ CHECK(cfg_acl_fromconfig(aclobj, (const cfg_obj_t *)cfg,
(cfg_aclconfctx_t *)actx, mctx, 0, &acl));
CHECK(parse_filter_a_on(fmap, "filter-a-on-v6", &f6));
CHECK(parse_filter_a_on(fmap, "filter-a-on-v4", &f4));
if ((f4 != NONE || f6 != NONE) && dns_acl_isnone(acl)) {
- cfg_obj_log(aclobj, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(aclobj, ISC_LOG_WARNING,
"\"filter-a\" is 'none;' but "
"either filter-a-on-v6 or filter-a-on-v4 "
"is enabled");
result = ISC_R_FAILURE;
} else if (f4 == NONE && f6 == NONE && !dns_acl_isnone(acl)) {
- cfg_obj_log(aclobj, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(aclobj, ISC_LOG_WARNING,
"\"filter-a\" is set but "
"neither filter-a-on-v6 or filter-a-on-v4 "
"is enabled");
static isc_result_t
parse_parameters(filter_instance_t *inst, const char *parameters,
const void *cfg, const char *cfg_file, unsigned long cfg_line,
- isc_mem_t *mctx, isc_log_t *lctx, void *actx) {
+ isc_mem_t *mctx, void *actx) {
isc_result_t result = ISC_R_SUCCESS;
cfg_parser_t *parser = NULL;
cfg_obj_t *param_obj = NULL;
const cfg_obj_t *obj = NULL;
isc_buffer_t b;
- CHECK(cfg_parser_create(mctx, lctx, &parser));
+ CHECK(cfg_parser_create(mctx, &parser));
isc_buffer_constinit(&b, parameters, strlen(parameters));
isc_buffer_add(&b, strlen(parameters));
CHECK(cfg_parse_buffer(parser, &b, cfg_file, cfg_line,
&cfg_type_parameters, 0, ¶m_obj));
- CHECK(check_syntax(param_obj, cfg, mctx, lctx, actx));
+ CHECK(check_syntax(param_obj, cfg, mctx, actx));
CHECK(parse_filter_a_on(param_obj, "filter-a-on-v6", &inst->v6_a));
CHECK(parse_filter_a_on(param_obj, "filter-a-on-v4", &inst->v4_a));
result = cfg_map_get(param_obj, "filter-a", &obj);
if (result == ISC_R_SUCCESS) {
- CHECK(cfg_acl_fromconfig(obj, (const cfg_obj_t *)cfg, lctx,
+ CHECK(cfg_acl_fromconfig(obj, (const cfg_obj_t *)cfg,
(cfg_aclconfctx_t *)actx, mctx, 0,
&inst->a_acl));
} else {
*/
isc_result_t
plugin_register(const char *parameters, const void *cfg, const char *cfg_file,
- unsigned long cfg_line, isc_mem_t *mctx, isc_log_t *lctx,
- void *actx, ns_hooktable_t *hooktable, void **instp) {
+ unsigned long cfg_line, isc_mem_t *mctx, void *actx,
+ ns_hooktable_t *hooktable, void **instp) {
filter_instance_t *inst = NULL;
isc_result_t result = ISC_R_SUCCESS;
- isc_log_write(lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
- ISC_LOG_INFO,
+ isc_log_write(NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS, ISC_LOG_INFO,
"registering 'filter-a' "
"module from %s:%lu, %s parameters",
cfg_file, cfg_line, parameters != NULL ? "with" : "no");
if (parameters != NULL) {
CHECK(parse_parameters(inst, parameters, cfg, cfg_file,
- cfg_line, mctx, lctx, actx));
+ cfg_line, mctx, actx));
}
isc_ht_init(&inst->ht, mctx, 1, ISC_HT_CASE_SENSITIVE);
isc_result_t
plugin_check(const char *parameters, const void *cfg, const char *cfg_file,
- unsigned long cfg_line, isc_mem_t *mctx, isc_log_t *lctx,
- void *actx) {
+ unsigned long cfg_line, isc_mem_t *mctx, void *actx) {
isc_result_t result = ISC_R_SUCCESS;
cfg_parser_t *parser = NULL;
cfg_obj_t *param_obj = NULL;
isc_buffer_t b;
- CHECK(cfg_parser_create(mctx, lctx, &parser));
+ CHECK(cfg_parser_create(mctx, &parser));
isc_buffer_constinit(&b, parameters, strlen(parameters));
isc_buffer_add(&b, strlen(parameters));
CHECK(cfg_parse_buffer(parser, &b, cfg_file, cfg_line,
&cfg_type_parameters, 0, ¶m_obj));
- CHECK(check_syntax(param_obj, cfg, mctx, lctx, actx));
+ CHECK(check_syntax(param_obj, cfg, mctx, actx));
cleanup:
if (param_obj != NULL) {
}
static isc_result_t
-check_syntax(cfg_obj_t *fmap, const void *cfg, isc_mem_t *mctx, isc_log_t *lctx,
- void *actx) {
+check_syntax(cfg_obj_t *fmap, const void *cfg, isc_mem_t *mctx, void *actx) {
isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *aclobj = NULL;
dns_acl_t *acl = NULL;
return (result);
}
- CHECK(cfg_acl_fromconfig(aclobj, (const cfg_obj_t *)cfg, lctx,
+ CHECK(cfg_acl_fromconfig(aclobj, (const cfg_obj_t *)cfg,
(cfg_aclconfctx_t *)actx, mctx, 0, &acl));
CHECK(parse_filter_aaaa_on(fmap, "filter-aaaa-on-v4", &f4));
CHECK(parse_filter_aaaa_on(fmap, "filter-aaaa-on-v6", &f6));
if ((f4 != NONE || f6 != NONE) && dns_acl_isnone(acl)) {
- cfg_obj_log(aclobj, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(aclobj, ISC_LOG_WARNING,
"\"filter-aaaa\" is 'none;' but "
"either filter-aaaa-on-v4 or filter-aaaa-on-v6 "
"is enabled");
result = ISC_R_FAILURE;
} else if (f4 == NONE && f6 == NONE && !dns_acl_isnone(acl)) {
- cfg_obj_log(aclobj, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(aclobj, ISC_LOG_WARNING,
"\"filter-aaaa\" is set but "
"neither filter-aaaa-on-v4 or filter-aaaa-on-v6 "
"is enabled");
static isc_result_t
parse_parameters(filter_instance_t *inst, const char *parameters,
const void *cfg, const char *cfg_file, unsigned long cfg_line,
- isc_mem_t *mctx, isc_log_t *lctx, void *actx) {
+ isc_mem_t *mctx, void *actx) {
isc_result_t result = ISC_R_SUCCESS;
cfg_parser_t *parser = NULL;
cfg_obj_t *param_obj = NULL;
const cfg_obj_t *obj = NULL;
isc_buffer_t b;
- CHECK(cfg_parser_create(mctx, lctx, &parser));
+ CHECK(cfg_parser_create(mctx, &parser));
isc_buffer_constinit(&b, parameters, strlen(parameters));
isc_buffer_add(&b, strlen(parameters));
CHECK(cfg_parse_buffer(parser, &b, cfg_file, cfg_line,
&cfg_type_parameters, 0, ¶m_obj));
- CHECK(check_syntax(param_obj, cfg, mctx, lctx, actx));
+ CHECK(check_syntax(param_obj, cfg, mctx, actx));
CHECK(parse_filter_aaaa_on(param_obj, "filter-aaaa-on-v4",
&inst->v4_aaaa));
result = cfg_map_get(param_obj, "filter-aaaa", &obj);
if (result == ISC_R_SUCCESS) {
- CHECK(cfg_acl_fromconfig(obj, (const cfg_obj_t *)cfg, lctx,
+ CHECK(cfg_acl_fromconfig(obj, (const cfg_obj_t *)cfg,
(cfg_aclconfctx_t *)actx, mctx, 0,
&inst->aaaa_acl));
} else {
*/
isc_result_t
plugin_register(const char *parameters, const void *cfg, const char *cfg_file,
- unsigned long cfg_line, isc_mem_t *mctx, isc_log_t *lctx,
- void *actx, ns_hooktable_t *hooktable, void **instp) {
+ unsigned long cfg_line, isc_mem_t *mctx, void *actx,
+ ns_hooktable_t *hooktable, void **instp) {
filter_instance_t *inst = NULL;
isc_result_t result = ISC_R_SUCCESS;
- isc_log_write(lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
- ISC_LOG_INFO,
+ isc_log_write(NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS, ISC_LOG_INFO,
"registering 'filter-aaaa' "
"module from %s:%lu, %s parameters",
cfg_file, cfg_line, parameters != NULL ? "with" : "no");
if (parameters != NULL) {
CHECK(parse_parameters(inst, parameters, cfg, cfg_file,
- cfg_line, mctx, lctx, actx));
+ cfg_line, mctx, actx));
}
isc_ht_init(&inst->ht, mctx, 1, ISC_HT_CASE_SENSITIVE);
isc_result_t
plugin_check(const char *parameters, const void *cfg, const char *cfg_file,
- unsigned long cfg_line, isc_mem_t *mctx, isc_log_t *lctx,
- void *actx) {
+ unsigned long cfg_line, isc_mem_t *mctx, void *actx) {
isc_result_t result = ISC_R_SUCCESS;
cfg_parser_t *parser = NULL;
cfg_obj_t *param_obj = NULL;
isc_buffer_t b;
- CHECK(cfg_parser_create(mctx, lctx, &parser));
+ CHECK(cfg_parser_create(mctx, &parser));
isc_buffer_constinit(&b, parameters, strlen(parameters));
isc_buffer_add(&b, strlen(parameters));
CHECK(cfg_parse_buffer(parser, &b, cfg_file, cfg_line,
&cfg_type_parameters, 0, ¶m_obj));
- CHECK(check_syntax(param_obj, cfg, mctx, lctx, actx));
+ CHECK(check_syntax(param_obj, cfg, mctx, actx));
cleanup:
if (param_obj != NULL) {
}
static void
-parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
- cfg_parser_t **pctxp, cfg_obj_t **configp) {
+parse_config(isc_mem_t *mctx, const char *keyname, cfg_parser_t **pctxp,
+ cfg_obj_t **configp) {
isc_result_t result;
const char *conffile = admin_conffile;
const cfg_obj_t *addresses = NULL;
admin_keyfile, admin_conffile);
}
- DO("create parser", cfg_parser_create(mctx, log, pctxp));
+ DO("create parser", cfg_parser_create(mctx, pctxp));
/*
* The parser will output its own errors, so DO() is not used.
main(int argc, char **argv) {
isc_result_t result = ISC_R_SUCCESS;
bool show_final_mem = false;
- isc_log_t *log = NULL;
isc_logconfig_t *logconfig = NULL;
isc_logdestination_t logdest;
cfg_parser_t *pctx = NULL;
isc_nm_settimeouts(netmgr, timeout, timeout, timeout, 0);
- logconfig = isc_logconfig_get(log);
+ logconfig = isc_logconfig_get();
isc_log_settag(logconfig, progname);
logdest.file.stream = stderr;
logdest.file.name = NULL;
DO("enabling log channel",
isc_log_usechannel(logconfig, "stderr", NULL, NULL));
- parse_config(rndc_mctx, log, keyname, &pctx, &config);
+ parse_config(rndc_mctx, keyname, &pctx, &config);
isc_buffer_allocate(rndc_mctx, &databuf, 2048);
va_list args;
va_start(args, format);
- isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
- level, format, args);
+ isc_log_vwrite(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB, level,
+ format, args);
va_end(args);
}
isc_mem_t *mctx;
isc_ht_t *ht;
isc_mutex_t hlock;
- isc_log_t *lctx;
} async_instance_t;
typedef struct state {
va_list ap;
va_start(ap, fmt);
- isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
- ISC_LOG_INFO, fmt, ap);
+ isc_log_write(NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS, ISC_LOG_INFO,
+ fmt, ap);
va_end(ap);
}
*/
isc_result_t
plugin_register(const char *parameters, const void *cfg, const char *cfg_file,
- unsigned long cfg_line, isc_mem_t *mctx, isc_log_t *lctx,
- void *actx, ns_hooktable_t *hooktable, void **instp) {
+ unsigned long cfg_line, isc_mem_t *mctx, void *actx,
+ ns_hooktable_t *hooktable, void **instp) {
async_instance_t *inst = NULL;
UNUSED(parameters);
UNUSED(cfg);
UNUSED(actx);
- isc_log_write(lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
- ISC_LOG_INFO,
+ isc_log_write(NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS, ISC_LOG_INFO,
"registering 'test-async' module from %s:%lu", cfg_file,
cfg_line);
isc_result_t
plugin_check(const char *parameters, const void *cfg, const char *cfg_file,
- unsigned long cfg_line, isc_mem_t *mctx, isc_log_t *lctx,
- void *actx) {
+ unsigned long cfg_line, isc_mem_t *mctx, void *actx) {
UNUSED(parameters);
UNUSED(cfg);
UNUSED(cfg_file);
UNUSED(cfg_line);
UNUSED(mctx);
- UNUSED(lctx);
UNUSED(actx);
return (ISC_R_SUCCESS);
#include <dns/types.h>
isc_mem_t *mctx = NULL;
-isc_log_t *lctx = NULL;
/*
* Logging categories: this needs to match the list in bin/named/log.c.
isc_mem_debugging |= ISC_MEM_DEBUGRECORD;
isc_mem_create(&mctx);
- isc_log_registercategories(lctx, categories);
- dns_log_init(lctx);
+ isc_log_registercategories(categories);
+ dns_log_init();
- logconfig = isc_logconfig_get(lctx);
+ logconfig = isc_logconfig_get();
destination.file.stream = stderr;
destination.file.name = NULL;
destination.file.versions = ISC_LOG_ROLLNEVER;
dns_name_t *name;
unsigned int bits = 2048U;
isc_mem_t *mctx;
-isc_log_t *log_;
isc_logconfig_t *logconfig;
int level = ISC_LOG_WARNING;
isc_logdestination_t destination;
isc_mem_create(&mctx);
- dns_log_init(log_);
+ dns_log_init();
- logconfig = isc_logconfig_get(log_);
+ logconfig = isc_logconfig_get();
isc_log_settag(logconfig, "bigkey");
destination.file.stream = stderr;
/*
* Setup logging to use stderr.
*/
-static isc_result_t
-setup_logging(isc_mem_t *mctx ISC_ATTR_UNUSED, FILE *errout, isc_log_t **logp) {
+static void
+setup_logging(FILE *errout) {
isc_logdestination_t destination;
isc_logconfig_t *logconfig = NULL;
- isc_log_t *log = NULL;
- dns_log_init(log);
+ dns_log_init();
- logconfig = isc_logconfig_get(log);
+ logconfig = isc_logconfig_get();
destination.file.stream = errout;
destination.file.name = NULL;
destination.file.versions = ISC_LOG_ROLLNEVER;
RUNTIME_CHECK(isc_log_usechannel(logconfig, "stderr", NULL, NULL) ==
ISC_R_SUCCESS);
-
- *logp = log;
- return (ISC_R_SUCCESS);
}
int
char *file;
isc_mem_t *mctx = NULL;
isc_result_t result;
- isc_log_t *lctx = NULL;
uint32_t flags = 0U;
int ch;
bool compact = false;
file = argv[0];
isc_mem_create(&mctx);
- RUNTIME_CHECK(setup_logging(mctx, stderr, &lctx) == ISC_R_SUCCESS);
+ setup_logging(stderr);
if (upgrade) {
flags = DNS_JOURNAL_COMPACTALL;
##### Externally visible structure
-The types used by programs for configuring log message destinations are
-`isc_log_t` and `isc_logconfig_t`. The `isc_log_t` type is normally
-created only once by a program, to hold static information about what
-categories and modules exist in the program and some other housekeeping
-information. `isc_logconfig_t` is used to store the configurable
-specification of message destinations, which can be changed during the
-course of the program.
-
-A starting configuration (`isc_logconfig_t`) is created implicitly when
-the context (`isc_log_t`) is created. The pointer to this configuration
-is returned via a parameter to `isc_log_create()` so that it can then be
-configured. A new log configuration can be established by creating
-it with `isc_logconfig_create()`, configuring it, then installing it as
-the active configuration with `isc_logconfig_set()`.
+The type used by programs for configuring log message destinations is
+`isc_logconfig_t`. It is used to store the configurable specification of
+message destinations, which can be changed during the course of the program.
+
+A starting configuration (`isc_logconfig_t`) is created implicitly. The pointer
+to this configuration is returned via `isc_logconfig_get()` so that it can then
+be configured. A new log configuration can be established by creating it with
+`isc_logconfig_create()`, configuring it, then installing it as the active
+configuration with `isc_logconfig_set()`.
##### Logging in multithreaded programs
rudimentary initialization of both.
isc_mem_t *mctx;
- isc_log_t *lctx;
isc_logconfig_t *lcfg;
- isc_mem_create(&mctx);
- isc_log_create(mctx, &lctx, &lcfg) != ISC_R_SUCCESS);
+ lcfg = isc_logconfig_get();
1. Initialize any additional libraries. The convention for the name of
the initialization function is `{library}_log_init()`, with a pointer to
the logging context as an argument. The function can only be called
once in a program or it will generate an assertion.
- `dns_log_init(lctx);`
+ `dns_log_init();`
If you do not want a library to write any log messages, simply do not
call its the initialization function.
to control logging behavior, two to work with the debugging level and one
to control the closing of log files.
- void isc_log_setdebuglevel(isc_log_t *lctx, unsigned int level);
- unsigned int isc_log_getdebuglevel(isc_log_t *lctx);
+ void isc_log_setdebuglevel(unsigned int level);
+ unsigned int isc_log_getdebuglevel();
These set and retrieve the current debugging level of the program.
`isc_log_getdebuglevel()` can be used so that you need not keep track of
the level yourself in another variable.
- void isc_log_closefilelogs(isc_log_t *lcxt);
+ void isc_log_closefilelogs();
This function closes any open log files. This is useful for programs that
do not want to do file rotation as with the internal rolling mechanism.
main(int argc, char **argv) {
isc_result_t result;
isc_mem_t *mctx = NULL;
- isc_log_t *lctx = NULL;
isc_logconfig_t *lcfg = NULL;
isc_logdestination_t destination;
cfg_parser_t *pctx = NULL;
/*
* Create and install the default channel.
*/
- lcfg = isc_logconfig_get(lctx);
+ lcfg = isc_logconfig_get();
destination.file.stream = stderr;
destination.file.name = NULL;
destination.file.versions = ISC_LOG_ROLLNEVER;
/*
* Set the initial debug level.
*/
- isc_log_setdebuglevel(lctx, 2);
+ isc_log_setdebuglevel(2);
if (argc < 3) {
usage();
if (type == NULL || filename == NULL) {
usage();
}
- RUNTIME_CHECK(cfg_parser_create(mctx, lctx, &pctx) ==
- ISC_R_SUCCESS);
+ RUNTIME_CHECK(cfg_parser_create(mctx, &pctx) == ISC_R_SUCCESS);
result = cfg_parse_file(pctx, filename, type, &cfg);
va_list args;
va_start(args, format);
- isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_ADB,
- level, format, args);
+ isc_log_vwrite(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_ADB, level,
+ format, args);
va_end(args);
}
isc_netaddr_fromsockaddr(&netaddr, &entry->sockaddr);
isc_netaddr_format(&netaddr, addrbuf, sizeof(addrbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_ADB,
- ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_ADB, ISC_LOG_INFO,
"adb: quota %s (%" PRIuFAST32 "/%" PRIuFAST32 "): %s",
addrbuf, atomic_load_relaxed(&entry->active),
atomic_load_relaxed(&entry->quota), msgbuf);
REQUIRE(loop != NULL);
}
- if (isc_log_wouldlog(dns_lctx, DEF_LEVEL)) {
+ if (isc_log_wouldlog(DEF_LEVEL)) {
dns_name_format(name, namebuf, sizeof(namebuf));
}
UNUSED(callbacks);
va_start(ap, fmt);
- isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, /* XXX */
+ isc_log_vwrite(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, /* XXX */
ISC_LOG_ERROR, fmt, ap);
va_end(ap);
}
va_start(ap, fmt);
- isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, /* XXX */
+ isc_log_vwrite(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, /* XXX */
ISC_LOG_WARNING, fmt, ap);
va_end(ap);
}
dns_name_format(&nentry->name, zname, DNS_NAME_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_DEBUG(3),
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_DEBUG(3),
"catz: iterating over '%s' from catalog '%s'",
zname, czname);
dns_catz_options_setdefault(catz->catzs->mctx,
{
dns_name_format(&parentcatz->name, pczname,
DNS_NAME_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER,
ISC_LOG_DEBUG(3),
"catz: zone '%s' "
result = delzone(nentry, parentcatz,
parentcatz->catzs->view,
parentcatz->catzs->zmm->udata);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER,
ISC_LOG_INFO,
"catz: deleting zone '%s' "
* perform deletions earlier than additions and
* modifications.
*/
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER,
ISC_LOG_INFO,
"catz: zone '%s' unique label "
}
if (find_result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_DEBUG(3),
"catz: zone '%s' was expected to exist "
"but can not be found, will be restored",
dns_name_format(&entry->name, zname, DNS_NAME_FORMATSIZE);
result = delzone(entry, catz, catz->catzs->view,
catz->catzs->zmm->udata);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_INFO,
"catz: deleting zone '%s' from catalog '%s' - %s",
zname, czname, isc_result_totext(result));
dns_catz_entry_detach(catz, &entry);
dns_name_format(&entry->name, zname, DNS_NAME_FORMATSIZE);
result = addzone(entry, catz, catz->catzs->view,
catz->catzs->zmm->udata);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_INFO,
"catz: adding zone '%s' from catalog "
"'%s' - %s",
zname, czname, isc_result_totext(result));
dns_name_format(&entry->name, zname, DNS_NAME_FORMATSIZE);
result = modzone(entry, catz, catz->catzs->view,
catz->catzs->zmm->udata);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_INFO,
"catz: modifying zone '%s' from catalog "
"'%s' - %s",
zname, czname, isc_result_totext(result));
char dname[DNS_NAME_FORMATSIZE];
dns_name_format(&catz->name, dname, DNS_NAME_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_INFO,
"catz: %s: new zone version came "
"too soon, deferring update for "
"%" PRIu64 " seconds",
char zname[DNS_NAME_FORMATSIZE];
dns_name_format(name, zname, DNS_NAME_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
ISC_LOG_DEBUG(3), "catz: dns_catz_zone_add %s", zname);
LOCK(&catzs->lock);
}
if (dns_rdataset_count(value) != 1) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_WARNING,
"catz: 'coo' property PTR RRset contains "
"more than one record, which is invalid");
catz->broken = true;
}
if (dns_rdataset_count(value) != 1) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_WARNING,
"catz: member zone PTR RRset contains "
"more than one record, which is invalid");
catz->broken = true;
}
if (dns_rdataset_count(value) != 1) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_WARNING,
"catz: 'version' property TXT RRset contains "
"more than one record, which is invalid");
catz->broken = true;
cleanup:
dns_rdata_freestruct(&rdatatxt);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_WARNING,
"catz: invalid record for the catalog "
"zone version property");
catz->broken = true;
}
if (dns_rdataset_count(value) > 1) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_WARNING,
"catz: more than one APL entry for member zone, "
"result is undefined");
}
isc_result_t result = isc_ht_add(ht, key, (uint32_t)keysize, nentry);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_ERROR,
"catz: error %s zone '%s' from catalog '%s' - %s",
msg, zname, czname, isc_result_totext(result));
}
REQUIRE(ISC_MAGIC_VALID(src_name, DNS_NAME_MAGIC));
if (rdataset->rdclass != dns_rdataclass_in) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_ERROR,
"catz: RR found which has a non-IN class");
catz->broken = true;
return (ISC_R_FAILURE);
default:
dns_name_format(&entry->name, zname,
DNS_NAME_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"catz: zone '%s' uses an invalid primary "
"(no IP address assigned)",
dns_name_format(&catz->name, domain, DNS_NAME_FORMATSIZE);
if (!catz->active) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_INFO,
"catz: %s: no longer active, reload is canceled",
domain);
catz->updaterunning = false;
catz->updbversion = catz->dbversion;
catz->dbversion = NULL;
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
ISC_LOG_INFO, "catz: %s: reload start", domain);
dns_catz_zone_ref(catz);
catz->updatepending = true;
dns_name_format(&catz->name, dname, DNS_NAME_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_DEBUG(3),
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_DEBUG(3),
"catz: %s: update already queued or running",
dname);
if (catz->dbversion != NULL) {
UNLOCK(&catzs->lock);
if (result != ISC_R_SUCCESS) {
/* This can happen if we remove the zone in the meantime. */
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
- "catz: zone '%s' not in config", bname);
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_ERROR, "catz: zone '%s' not in config",
+ bname);
goto exit;
}
if (!is_active) {
/* This can happen during a reconfiguration. */
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_INFO,
"catz: zone '%s' is no longer active", bname);
result = ISC_R_CANCELED;
goto exit;
result = dns_db_getsoaserial(updb, oldcatz->updbversion, &vers);
if (result != ISC_R_SUCCESS) {
/* A zone without SOA record?!? */
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_ERROR,
"catz: zone '%s' has no SOA record (%s)", bname,
isc_result_totext(result));
goto exit;
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
ISC_LOG_INFO,
"catz: updating catalog zone '%s' with serial %" PRIu32,
bname, vers);
result = dns_db_createiterator(updb, DNS_DB_NONSEC3, &updbit);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_ERROR,
"catz: failed to create DB iterator - %s",
isc_result_totext(result));
goto exit;
result = dns_name_fromstring(name, "version", &updb->origin, 0, NULL);
if (result != ISC_R_SUCCESS) {
dns_dbiterator_destroy(&updbit);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_ERROR,
"catz: failed to create name from string - %s",
isc_result_totext(result));
goto exit;
result = dns_dbiterator_seek(updbit, name);
if (result != ISC_R_SUCCESS) {
dns_dbiterator_destroy(&updbit);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_ERROR,
"catz: zone '%s' has no 'version' record (%s) "
"and will not be processed",
bname, isc_result_totext(result));
result = dns_dbiterator_current(updbit, &node, name);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"catz: failed to get db iterator - %s",
isc_result_totext(result));
result = dns_db_allrdatasets(updb, node, oldcatz->updbversion,
0, 0, &rdsiter);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"catz: failed to fetch rrdatasets - %s",
isc_result_totext(result));
sizeof(classbuf));
dns_rdatatype_format(rdataset.type, typebuf,
sizeof(typebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER,
ISC_LOG_WARNING,
"catz: invalid record in catalog "
}
dns_dbiterator_destroy(&updbit);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
ISC_LOG_DEBUG(3),
"catz: update_from_db: iteration finished: %s",
isc_result_totext(result));
? oldcatz->version
: newcatz->version;
if (catz_vers == DNS_CATZ_VERSION_UNDEFINED) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_WARNING,
"catz: zone '%s' version is not set", bname);
newcatz->broken = true;
} else if (catz_vers != 1 && catz_vers != 2) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_WARNING,
"catz: zone '%s' unsupported version "
"'%" PRIu32 "'",
bname, catz_vers);
if (newcatz->broken) {
dns_name_format(name, cname, DNS_NAME_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_ERROR,
"catz: new catalog zone '%s' is broken and "
"will not be processed",
bname);
result = dns__catz_zones_merge(oldcatz, newcatz);
dns_catz_zone_detach(&newcatz);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
- "catz: failed merging zones: %s",
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_ERROR, "catz: failed merging zones: %s",
isc_result_totext(result));
goto exit;
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
ISC_LOG_DEBUG(3),
"catz: update_from_db: new zone merged");
UNLOCK(&catz->catzs->lock);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
ISC_LOG_INFO, "catz: %s: reload done: %s", dname,
isc_result_totext(catz->updateresult));
char cname[DNS_NAME_FORMATSIZE];
dns_name_format(&catz->name, cname,
DNS_NAME_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_WARNING,
"catz: removing catalog zone %s", cname);
RWUNLOCK(&implock, isc_rwlocktype_read);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DB,
- ISC_LOG_ERROR, "unsupported database type '%s'", db_type);
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DB, ISC_LOG_ERROR,
+ "unsupported database type '%s'", db_type);
return (ISC_R_NOTFOUND);
}
goto failure; \
} while (0)
-#define DIFF_COMMON_LOGARGS \
- dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_DIFF
-
static dns_rdatatype_t
rdata_covers(dns_rdata_t *rdata) {
return (rdata->type == dns_rdatatype_rrsig ? dns_rdata_covers(rdata)
dns_rdataclass_format(t->rdata.rdclass,
classbuf,
sizeof(classbuf));
- isc_log_write(DIFF_COMMON_LOGARGS,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_DIFF,
ISC_LOG_WARNING,
"'%s/%s/%s': TTL differs "
"in "
dns_rdataclass_format(dns_db_class(db),
classbuf,
sizeof(classbuf));
- isc_log_write(DIFF_COMMON_LOGARGS,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_DIFF,
ISC_LOG_WARNING,
"%s/%s: dns_diff_apply: "
"update with no effect",
dns_rdataclass_format(rdclass, classbuf,
sizeof(classbuf));
isc_log_write(
- DIFF_COMMON_LOGARGS,
+ DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_DIFF,
ISC_LOG_ERROR,
"dns_diff_apply: %s/%s/%s: %s "
"%s",
result = callbacks->add(callbacks->add_private, name,
&rds DNS__DB_FILELINE);
if (result == DNS_R_UNCHANGED) {
- isc_log_write(DIFF_COMMON_LOGARGS,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_DIFF,
ISC_LOG_WARNING,
"dns_diff_load: "
"update with no effect");
fprintf(file, "%s %.*s\n", op, (int)r.length,
(char *)r.base);
} else {
- isc_log_write(DIFF_COMMON_LOGARGS, ISC_LOG_DEBUG(7),
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_DIFF, ISC_LOG_DEBUG(7),
"%s %.*s", op, (int)r.length,
(char *)r.base);
}
char msgbuf[2048];
va_list ap;
- if (!isc_log_wouldlog(dns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
vsnprintf(msgbuf, sizeof(msgbuf), fmt, ap);
va_end(ap);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DISPATCH,
- DNS_LOGMODULE_DISPATCH, level, "dispatchmgr %p: %s", mgr,
- msgbuf);
+ isc_log_write(DNS_LOGCATEGORY_DISPATCH, DNS_LOGMODULE_DISPATCH, level,
+ "dispatchmgr %p: %s", mgr, msgbuf);
}
static void
va_list ap;
int r;
- if (!isc_log_wouldlog(dns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
}
va_end(ap);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DISPATCH,
- DNS_LOGMODULE_DISPATCH, level, "dispatch %p: %s", disp,
- msgbuf);
+ isc_log_write(DNS_LOGCATEGORY_DISPATCH, DNS_LOGMODULE_DISPATCH, level,
+ "dispatch %p: %s", disp, msgbuf);
}
static void
va_list ap;
int r;
- if (!isc_log_wouldlog(dns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
NULL) == ISC_R_SUCCESS &&
match > 0)
{
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(10))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(10))) {
char netaddrstr[ISC_NETADDR_FORMATSIZE];
isc_netaddr_format(&netaddr, netaddrstr,
sizeof(netaddrstr));
rcu_read_unlock();
}
- if (isc_log_wouldlog(dns_lctx, 90)) {
+ if (isc_log_wouldlog(90)) {
char addrbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&disp->local, addrbuf,
dispatch_allocate(mgr, isc_socktype_udp, tid, &disp);
- if (isc_log_wouldlog(dns_lctx, 90)) {
+ if (isc_log_wouldlog(90)) {
char addrbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(localaddr, addrbuf,
dns_dispentry_t *next = NULL;
dns_displist_t resps = ISC_LIST_INITIALIZER;
- if (isc_log_wouldlog(dns_lctx, 90)) {
+ if (isc_log_wouldlog(90)) {
char localbuf[ISC_SOCKADDR_FORMATSIZE];
char peerbuf[ISC_SOCKADDR_FORMATSIZE];
if (handle != NULL) {
REQUIRE(mctx != NULL);
/* write log message */
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
- ISC_LOG_INFO, "Loading '%s' using driver %s", dlzname,
- drivername);
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_INFO,
+ "Loading '%s' using driver %s", dlzname, drivername);
/* lock the dlz_implementations list so we can search it. */
RWLOCK(&dlz_implock, isc_rwlocktype_read);
if (impinfo == NULL) {
RWUNLOCK(&dlz_implock, isc_rwlocktype_read);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DLZ, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
+ ISC_LOG_ERROR,
"unsupported DLZ database driver '%s'."
" %s not loaded.",
drivername, dlzname);
db->magic = DNS_DLZ_MAGIC;
isc_mem_attach(mctx, &db->mctx);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
ISC_LOG_DEBUG(2), "DLZ driver loaded successfully.");
*dbp = db;
return (ISC_R_SUCCESS);
failure:
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
ISC_LOG_ERROR, "DLZ driver failed to load.");
/* impinfo->methods->create failed. */
dns_dlzdb_t *db;
/* Write debugging message to log */
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
ISC_LOG_DEBUG(2), "Unloading DLZ driver.");
/*
dns_dlzimplementation_t *dlz_imp;
/* Write debugging message to log */
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
ISC_LOG_DEBUG(2), "Registering DLZ driver '%s'",
drivername);
*/
dlz_imp = dlz_impfind(drivername);
if (dlz_imp != NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DLZ, ISC_LOG_DEBUG(2),
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
+ ISC_LOG_DEBUG(2),
"DLZ Driver '%s' already registered", drivername);
RWUNLOCK(&dlz_implock, isc_rwlocktype_write);
return (ISC_R_EXISTS);
dns_dlzimplementation_t *dlz_imp;
/* Write debugging message to log */
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
ISC_LOG_DEBUG(2), "Unregistering DLZ driver.");
/*
origin = dns_fixedname_name(&fixorigin);
if (!dlzdb->search) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DLZ, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
+ ISC_LOG_WARNING,
"DLZ %s has 'search no;', but attempted to "
"register writeable zone %s.",
dlzdb->dlzname, zone_name);
impl = dlzdatabase->implementation;
if (impl->methods->ssumatch == NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DLZ, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
+ ISC_LOG_INFO,
"No ssumatch method for DLZ database");
return (false);
}
isc_level = DNS_RPZ_ERROR_LEVEL;
break;
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
- isc_level, "dnsrps: %s", buf);
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB, isc_level,
+ "dnsrps: %s", buf);
}
/*
librpz->set_log(dnsrps_log_fnc, NULL);
clist = librpz->clist_create(&emsg, dnsrps_lock, dnsrps_unlock,
- dnsrps_mutex_destroy, &dnsrps_mutex,
- dns_lctx);
+ dnsrps_mutex_destroy, &dnsrps_mutex, NULL);
if (clist == NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
- DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
- "dnsrps: %s", emsg.c);
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ DNS_RPZ_ERROR_LEVEL, "dnsrps: %s", emsg.c);
return (ISC_R_NOMEMORY);
}
return (ISC_R_SUCCESS);
if (librpz != NULL) {
INSIST(librpz_handle != NULL);
if (dlclose(librpz_handle) != 0) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
- DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ DNS_RPZ_ERROR_LEVEL,
"dnsrps: dlclose(): %s", dlerror());
}
librpz_handle = NULL;
dns_dnsrps_view_init(dns_rpz_zones_t *new, char *rps_cstr) {
librpz_emsg_t emsg;
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
DNS_RPZ_DEBUG_LEVEL3, "dnsrps configuration \"%s\"",
rps_cstr);
new->rps_client = librpz->client_create(&emsg, clist, rps_cstr, false);
if (new->rps_client == NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
- DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ DNS_RPZ_ERROR_LEVEL,
"librpz->client_create(): %s", emsg.c);
new->p.dnsrps_enabled = false;
return (ISC_R_FAILURE);
* Fail only if we failed to link to librpz.
*/
if (librpz == NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
- DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
- "librpz->connect(): %s", librpz_lib_open_emsg.c);
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ DNS_RPZ_ERROR_LEVEL, "librpz->connect(): %s",
+ librpz_lib_open_emsg.c);
return (ISC_R_FAILURE);
}
if (!librpz->connect(&emsg, rpzs->rps_client, true)) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
- DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
- "librpz->connect(): %s", emsg.c);
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ DNS_RPZ_ERROR_LEVEL, "librpz->connect(): %s",
+ emsg.c);
return (ISC_R_SUCCESS);
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
DNS_RPZ_INFO_LEVEL, "dnsrps: librpz version %s",
librpz->version);
if (ret == ISC_R_SUCCESS && downcase) {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(&sig.signer, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_DEBUG(1),
"successfully validated after lower casing "
"signer '%s'",
namebuf);
}
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_WARNING,
"dns_dnssec_findmatchingkeys: "
"error reading key file %s: %s",
algbuf, dst_key_id(dnskey));
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_WARNING,
"dns_dnssec_keylistfromrdataset: error "
"reading %s: %s",
char algbuf[DNS_DSDIGEST_FORMATSIZE];
dns_dsdigest_format(digesttype, algbuf,
DNS_DSDIGEST_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_ERROR,
"build rdata CDS (%s) for key %s failed", algbuf,
keystr);
return (r);
char algbuf[DNS_DSDIGEST_FORMATSIZE];
dns_dsdigest_format(digesttype, algbuf,
DNS_DSDIGEST_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_INFO,
"CDS (%s) for key %s is now published", algbuf,
keystr);
addrdata(&cdsrdata, diff, origin, ttl, mctx);
char algbuf[DNS_DSDIGEST_FORMATSIZE];
dns_dsdigest_format(digesttype, algbuf,
DNS_DSDIGEST_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_INFO,
"CDS (%s) for key %s is now deleted", algbuf,
keystr);
delrdata(&cdsrdata, diff, origin, cds->ttl, mctx);
!exists(cdnskey, &cdnskeyrdata)))
{
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"CDNSKEY for key %s is now published",
keystr);
if (dns_rdataset_isassociated(cdnskey)) {
if (exists(cdnskey, &cdnskeyrdata)) {
- isc_log_write(dns_lctx,
- DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC,
ISC_LOG_INFO,
"CDNSKEY for key %s is "
if (dns_rdataset_isassociated(cdnskey)) {
if (exists(cdnskey, &cdnskeyrdata)) {
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"CDNSKEY for key %s is now deleted",
keystr);
if (!dns_rdataset_isassociated(cds) ||
!exists(cds, &cds_delete))
{
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"CDS (DELETE) for zone %s is now "
"published",
} else {
if (dns_rdataset_isassociated(cds) && exists(cds, &cds_delete))
{
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"CDS (DELETE) for zone %s is now "
"deleted",
if (!dns_rdataset_isassociated(cdnskey) ||
!exists(cdnskey, &cdnskey_delete))
{
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"CDNSKEY (DELETE) for zone %s is now "
"published",
if (dns_rdataset_isassociated(cdnskey) &&
exists(cdnskey, &cdnskey_delete))
{
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"CDNSKEY (DELETE) for zone %s is now "
"deleted",
RETERR(publish_key(diff, key1, origin, ttl,
mctx, report));
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"DNSKEY %s (%s) is now published",
keystr1,
if (key1->hint_sign || key1->force_sign) {
key1->first_sign = true;
isc_log_write(
- dns_lctx,
DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC,
ISC_LOG_INFO,
if (removed != NULL) {
ISC_LIST_APPEND(*removed, key2, link);
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"DNSKEY %s (%s) is now deleted",
keystr2,
if (removed != NULL) {
ISC_LIST_APPEND(*removed, key2, link);
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"DNSKEY %s (%s) is now revoked; "
"new ID is %05d",
{
key2->first_sign = true;
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"DNSKEY %s (%s) is now active", keystr1,
key1->ksk ? (key1->zsk ? "CSK" : "KSK")
!key1->force_sign)
{
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"DNSKEY %s (%s) is now inactive",
keystr1,
REQUIRE(envp != NULL && *envp == NULL);
REQUIRE(foptp != NULL && *foptp != NULL);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSTAP, DNS_LOGMODULE_DNSTAP,
+ isc_log_write(DNS_LOGCATEGORY_DNSTAP, DNS_LOGMODULE_DNSTAP,
ISC_LOG_INFO, "opening dnstap destination '%s'", path);
atomic_fetch_add_release(&global_generation, 1);
env->iothr = fstrm_iothr_init(*foptp, &fw);
if (env->iothr == NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSTAP,
- DNS_LOGMODULE_DNSTAP, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_DNSTAP, DNS_LOGMODULE_DNSTAP,
+ ISC_LOG_WARNING,
"unable to initialize dnstap I/O thread");
fstrm_writer_destroy(&fw);
CHECK(ISC_R_FAILURE);
/*
* We are committed here.
*/
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSTAP, DNS_LOGMODULE_DNSTAP,
+ isc_log_write(DNS_LOGCATEGORY_DNSTAP, DNS_LOGMODULE_DNSTAP,
ISC_LOG_INFO, "%s dnstap destination '%s'",
(roll < 0) ? "reopening" : "rolling", env->path);
env->iothr = fstrm_iothr_init(env->fopt, &fw);
if (env->iothr == NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSTAP,
- DNS_LOGMODULE_DNSTAP, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_DNSTAP, DNS_LOGMODULE_DNSTAP,
+ ISC_LOG_WARNING,
"unable to initialize dnstap I/O thread");
CHECK(ISC_R_FAILURE);
}
static void
destroy(dns_dtenv_t *env) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSTAP, DNS_LOGMODULE_DNSTAP,
+ isc_log_write(DNS_LOGCATEGORY_DNSTAP, DNS_LOGMODULE_DNSTAP,
ISC_LOG_INFO, "closing dnstap");
env->magic = 0;
dm.m.has_query_time_nsec = 1;
break;
default:
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSTAP,
- DNS_LOGMODULE_DNSTAP, ISC_LOG_ERROR,
- "invalid dnstap message type %d", msgtype);
+ isc_log_write(DNS_LOGCATEGORY_DNSTAP, DNS_LOGMODULE_DNSTAP,
+ ISC_LOG_ERROR, "invalid dnstap message type %d",
+ msgtype);
return;
}
int level;
level = ISC_LOG_WARNING;
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_DNSSEC, level,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_DNSSEC,
+ level,
"Permissions on the file %s "
"have changed from 0%o to 0600 as "
"a result of this operation.",
if (errmsg == NULL) {
errmsg = "returned function pointer is NULL";
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DYNDB, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
+ ISC_LOG_ERROR,
"failed to lookup symbol %s in "
"DynDB module '%s': %s",
symbol_name, filename, errmsg);
REQUIRE(impp != NULL && *impp == NULL);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
ISC_LOG_INFO, "loading DynDB instance '%s' driver '%s'",
instname, filename);
if (errmsg == NULL) {
errmsg = "unknown error";
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DYNDB, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
+ ISC_LOG_ERROR,
"failed to dlopen() DynDB instance '%s' driver "
"'%s': %s",
instname, filename, errmsg);
if (version < (DNS_DYNDB_VERSION - DNS_DYNDB_AGE) ||
version > DNS_DYNDB_VERSION)
{
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DYNDB, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
+ ISC_LOG_ERROR,
"driver API version mismatch: %d/%d", version,
DNS_DYNDB_VERSION);
CHECK(ISC_R_FAILURE);
return (ISC_R_SUCCESS);
cleanup:
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
ISC_LOG_ERROR,
"failed to dynamically load DynDB instance '%s' driver "
"'%s': %s",
while (elem != NULL) {
prev = PREV(elem, link);
UNLINK(dyndb_implementations, elem, link);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DYNDB, ISC_LOG_INFO,
- "unloading DynDB instance '%s'", elem->name);
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
+ ISC_LOG_INFO, "unloading DynDB instance '%s'",
+ elem->name);
elem->destroy_func(&elem->inst);
ENSURE(elem->inst == NULL);
unload_library(&elem);
}
isc_result_t
-dns_dyndb_createctx(isc_mem_t *mctx, const void *hashinit, isc_log_t *lctx,
- dns_view_t *view, dns_zonemgr_t *zmgr,
- isc_loopmgr_t *loopmgr, dns_dyndbctx_t **dctxp) {
+dns_dyndb_createctx(isc_mem_t *mctx, const void *hashinit, dns_view_t *view,
+ dns_zonemgr_t *zmgr, isc_loopmgr_t *loopmgr,
+ dns_dyndbctx_t **dctxp) {
dns_dyndbctx_t *dctx;
REQUIRE(dctxp != NULL && *dctxp == NULL);
*dctx = (dns_dyndbctx_t){
.loopmgr = loopmgr,
.hashinit = hashinit,
- .lctx = lctx,
};
if (view != NULL) {
dns_zonemgr_detach(&dctx->zmgr);
}
dctx->loopmgr = NULL;
- dctx->lctx = NULL;
isc_mem_putanddetach(&dctx->mctx, dctx, sizeof(*dctx));
}
va_list ap;
va_start(ap, fmt);
- isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_TKEY,
+ isc_log_vwrite(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_TKEY,
ISC_LOG_DEBUG(level), fmt, ap);
va_end(ap);
}
isc_result_t result; \
result = hmac_parse(ISC_MD_##alg, key, lexer, pub); \
if (result == ISC_R_SUCCESS && file != NULL) { \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, \
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, \
DNS_LOGMODULE_CRYPTO, ISC_LOG_WARNING, \
"%s: Use of K* file pairs for HMAC is " \
"deprecated\n", \
unsigned int magic;
const void *hashinit;
isc_mem_t *mctx;
- isc_log_t *lctx;
dns_view_t *view;
dns_zonemgr_t *zmgr;
isc_loopmgr_t *loopmgr;
*/
isc_result_t
-dns_dyndb_createctx(isc_mem_t *mctx, const void *hashinit, isc_log_t *lctx,
- dns_view_t *view, dns_zonemgr_t *zmgr,
- isc_loopmgr_t *loopmgr, dns_dyndbctx_t **dctxp);
+dns_dyndb_createctx(isc_mem_t *mctx, const void *hashinit, dns_view_t *view,
+ dns_zonemgr_t *zmgr, isc_loopmgr_t *loopmgr,
+ dns_dyndbctx_t **dctxp);
/*%
* Create a dyndb initialization context structure, with
* pointers to structures in the server that the dyndb module will
#include <isc/lang.h>
#include <isc/log.h>
-extern isc_log_t *dns_lctx;
extern isc_logcategory_t dns_categories[];
extern isc_logmodule_t dns_modules[];
ISC_LANG_BEGINDECLS
void
-dns_log_init(isc_log_t *lctx);
+dns_log_init(void);
/*%
* Make the libdns categories and modules available for use with the
* ISC logging library.
*/
void
-dns_resolver_logfetch(dns_fetch_t *fetch, isc_log_t *lctx,
- isc_logcategory_t *category, isc_logmodule_t *module,
- int level, bool duplicateok);
+dns_resolver_logfetch(dns_fetch_t *fetch, isc_logcategory_t *category,
+ isc_logmodule_t *module, int level, bool duplicateok);
/*%<
* Dump a log message on internal state at the completion of given 'fetch'.
* 'lctx', 'category', 'module', and 'level' are used to write the log message.
* Miscellaneous utilities.
*/
-#define JOURNAL_COMMON_LOGARGS \
- dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL
-
-#define JOURNAL_DEBUG_LOGARGS(n) JOURNAL_COMMON_LOGARGS, ISC_LOG_DEBUG(n)
-
/*%
* It would be non-sensical (or at least obtuse) to use FAIL() with an
* ISC_R_SUCCESS code, but the test is there to keep the Solaris compiler
result = isc_stdio_seek(j->fp, (off_t)offset, SEEK_SET);
if (result != ISC_R_SUCCESS) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "%s: seek: %s", j->filename,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "%s: seek: %s", j->filename,
isc_result_totext(result));
return (ISC_R_UNEXPECTED);
}
if (result == ISC_R_EOF) {
return (ISC_R_NOMORE);
}
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "%s: read: %s", j->filename,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "%s: read: %s", j->filename,
isc_result_totext(result));
return (ISC_R_UNEXPECTED);
}
result = isc_stdio_write(mem, 1, nbytes, j->fp, NULL);
if (result != ISC_R_SUCCESS) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "%s: write: %s", j->filename,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "%s: write: %s", j->filename,
isc_result_totext(result));
return (ISC_R_UNEXPECTED);
}
result = isc_stdio_flush(j->fp);
if (result != ISC_R_SUCCESS) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "%s: flush: %s", j->filename,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "%s: flush: %s", j->filename,
isc_result_totext(result));
return (ISC_R_UNEXPECTED);
}
result = isc_stdio_sync(j->fp);
if (result != ISC_R_SUCCESS) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "%s: fsync: %s", j->filename,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "%s: fsync: %s", j->filename,
isc_result_totext(result));
return (ISC_R_UNEXPECTED);
}
result = isc_stdio_open(filename, "wb", &fp);
if (result != ISC_R_SUCCESS) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "%s: create: %s", filename,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "%s: create: %s", filename,
isc_result_totext(result));
return (ISC_R_UNEXPECTED);
}
result = isc_stdio_write(mem, 1, (size_t)size, fp, NULL);
if (result != ISC_R_SUCCESS) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "%s: write: %s", filename,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "%s: write: %s", filename,
isc_result_totext(result));
(void)isc_stdio_close(fp);
(void)isc_file_remove(filename);
result = isc_stdio_close(fp);
if (result != ISC_R_SUCCESS) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "%s: close: %s", filename,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "%s: close: %s", filename,
isc_result_totext(result));
(void)isc_file_remove(filename);
return (ISC_R_UNEXPECTED);
result = isc_stdio_open(j->filename, writable ? "rb+" : "rb", &fp);
if (result == ISC_R_FILENOTFOUND) {
if (create) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_DEBUG(1),
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_JOURNAL, ISC_LOG_DEBUG(1),
"journal file %s does not exist, "
"creating it",
j->filename);
}
}
if (result != ISC_R_SUCCESS) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "%s: open: %s", j->filename,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "%s: open: %s", j->filename,
isc_result_totext(result));
FAIL(ISC_R_UNEXPECTED);
}
*/
j->header_ver1 = false;
} else {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR,
"%s: journal format not recognized", j->filename);
FAIL(ISC_R_UNEXPECTED);
}
if (j->xhdr_version == XHDR_VERSION1 && xhdr->serial1 == serial)
{
isc_log_write(
- JOURNAL_COMMON_LOGARGS, ISC_LOG_DEBUG(3),
+ DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_DEBUG(3),
"%s: XHDR_VERSION1 -> XHDR_VERSION2 at %u",
j->filename, serial);
j->xhdr_version = XHDR_VERSION2;
xhdr->count == serial)
{
isc_log_write(
- JOURNAL_COMMON_LOGARGS, ISC_LOG_DEBUG(3),
+ DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_DEBUG(3),
"%s: XHDR_VERSION2 -> XHDR_VERSION1 at %u",
j->filename, serial);
j->xhdr_version = XHDR_VERSION1;
if (value != 0L) {
CHECK(journal_seek(j, offset + 12));
} else {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_DEBUG(3),
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_JOURNAL, ISC_LOG_DEBUG(3),
"%s: XHDR_VERSION1 count zero at %u",
j->filename, serial);
j->xhdr_version = XHDR_VERSION2;
xhdr->serial1 == 0U &&
isc_serial_gt(xhdr->serial0, xhdr->count))
{
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_DEBUG(3),
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_DEBUG(3),
"%s: XHDR_VERSION2 count zero at %u", j->filename,
serial);
xhdr->serial1 = xhdr->serial0;
if (xhdr.serial0 != pos->serial ||
isc_serial_le(xhdr.serial1, xhdr.serial0))
{
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR,
"%s: journal file corrupt: "
"expected serial %u, got %u",
j->filename, pos->serial, xhdr.serial0);
: sizeof(journal_rawxhdr_ver1_t);
if ((off_t)(pos->offset + hdrsize + xhdr.size) < pos->offset) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "%s: offset too large", j->filename);
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "%s: offset too large",
+ j->filename);
return (ISC_R_UNEXPECTED);
}
REQUIRE(DNS_DIFF_VALID(diff));
REQUIRE(j->state == JOURNAL_STATE_TRANSACTION);
- isc_log_write(JOURNAL_DEBUG_LOGARGS(3), "writing to journal");
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_DEBUG(3), "writing to journal");
(void)dns_diff_print(diff, NULL);
/*
}
if (size >= DNS_JOURNAL_SIZE_MAX) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR,
"dns_journal_writediff: %s: journal entry "
"too big to be stored: %" PRIu64 " bytes",
j->filename, size);
* Perform some basic consistency checks.
*/
if (j->x.n_soa != 2) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR,
"%s: malformed transaction: %d SOAs", j->filename,
j->x.n_soa);
return (ISC_R_UNEXPECTED);
}
if (!DNS_SERIAL_GT(j->x.pos[1].serial, j->x.pos[0].serial)) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR,
"%s: malformed transaction: serial number "
"did not increase",
j->filename);
}
if (!JOURNAL_EMPTY(&j->header)) {
if (j->x.pos[0].serial != j->header.end.serial) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_JOURNAL, ISC_LOG_ERROR,
"malformed transaction: "
"%s last serial %u != "
"transaction first serial %u",
*/
total = j->x.pos[1].offset - j->x.pos[0].offset;
if (total >= DNS_JOURNAL_SIZE_MAX) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR,
"transaction too big to be stored in journal: "
"%" PRIu64 "b (max is %" PRIu64 "b)",
total, (uint64_t)DNS_JOURNAL_SIZE_MAX);
n_soa = 1;
}
if (n_soa == 0) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_JOURNAL, ISC_LOG_ERROR,
"%s: journal file corrupt: missing "
"initial SOA",
j->filename);
dns_diff_append(&diff, &tuple);
if (++n_put > 100) {
- isc_log_write(JOURNAL_DEBUG_LOGARGS(3),
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_JOURNAL, ISC_LOG_DEBUG(3),
"%s: applying diff to database (%u)",
j->filename, db_serial);
(void)dns_diff_print(&diff, NULL);
CHECK(result);
if (n_put != 0) {
- isc_log_write(JOURNAL_DEBUG_LOGARGS(3),
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_DEBUG(3),
"%s: applying final diff to database (%u)",
j->filename, db_serial);
(void)dns_diff_print(&diff, NULL);
result = dns_journal_open(mctx, filename, DNS_JOURNAL_READ, &j);
if (result == ISC_R_NOTFOUND) {
- isc_log_write(JOURNAL_DEBUG_LOGARGS(3), "no journal file");
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_DEBUG(3), "no journal file");
return (DNS_R_NOJOURNAL);
} else if (result != ISC_R_SUCCESS) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "journal open failure: %s: %s",
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "journal open failure: %s: %s",
isc_result_totext(result), filename);
return (result);
}
}
}
if (n_soa == 0) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_JOURNAL, ISC_LOG_ERROR,
"%s: journal file corrupt: missing "
"initial SOA",
j->filename);
goto cleanup;
failure:
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
- "%s: cannot print: journal file corrupt", j->filename);
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR, "%s: cannot print: journal file corrupt",
+ j->filename);
cleanup:
if (source.base != NULL) {
dns_journal_t save = *j;
if (j->offset > j->it.epos.offset) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR,
"%s: journal corrupt: possible integer overflow",
j->filename);
return (ISC_R_UNEXPECTED);
*/
CHECK(journal_read_xhdr(j, &xhdr));
if (xhdr.size == 0) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_JOURNAL, ISC_LOG_ERROR,
"%s: journal corrupt: empty transaction",
j->filename);
FAIL(ISC_R_UNEXPECTED);
if (xhdr.serial0 != j->it.current_serial ||
isc_serial_le(xhdr.serial1, xhdr.serial0))
{
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_JOURNAL, ISC_LOG_ERROR,
"%s: journal file corrupt: "
"expected serial %u, got %u",
j->filename, j->it.current_serial,
* size owner name, well below 70 k total.
*/
if (rrhdr.size < 1 + 10 || rrhdr.size > 70000) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR,
"%s: journal corrupt: impossible RR size "
"(%d bytes)",
j->filename, rrhdr.size);
rdlen = isc_buffer_getuint16(&j->it.source);
if (rdlen > DNS_RDATA_MAXLENGTH) {
- isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
+ ISC_LOG_ERROR,
"%s: journal corrupt: impossible rdlen "
"(%u bytes)",
j->filename, rdlen);
if (journal != NULL) {
if (ISC_LIST_EMPTY(diff->tuples)) {
- isc_log_write(JOURNAL_DEBUG_LOGARGS(3), "no changes");
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_JOURNAL, ISC_LOG_DEBUG(3),
+ "no changes");
} else {
CHECK(dns_journal_write_transaction(journal, diff));
}
size = xhdr.size;
if (size > len) {
- isc_log_write(JOURNAL_COMMON_LOGARGS,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_JOURNAL,
ISC_LOG_ERROR,
"%s: journal file corrupt, "
"transaction too large",
size = xhdr.size;
if (size > len) {
isc_log_write(
- JOURNAL_COMMON_LOGARGS,
+ DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGMODULE_JOURNAL,
ISC_LOG_ERROR,
"%s: journal file corrupt, "
"transaction too large",
dst_key_setstate((key), (state), (target)); \
dst_key_settime((key), (timing), time); \
\
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) { \
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) { \
dst_key_format((key), keystr, sizeof(keystr)); \
isc_log_write( \
- dns_lctx, DNS_LOGCATEGORY_DNSSEC, \
+ DNS_LOGCATEGORY_DNSSEC, \
DNS_LOGMODULE_DNSSEC, \
ISC_LOG_DEBUG(3), \
"keymgr: DNSKEY %s (%s) initialize " \
log_key_overflow(dst_key_t *key, const char *what) {
char keystr[DST_KEY_FORMATSIZE];
dst_key_format(key, keystr, sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
- ISC_LOG_WARNING,
- "keymgr: DNSKEY %s (%s) calculation overflowed", keystr,
- what);
+ isc_log_write(
+ DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC, ISC_LOG_WARNING,
+ "keymgr: DNSKEY %s (%s) calculation overflowed", keystr, what);
}
/*
}
dst_key_format(key->key, keystr, sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
ISC_LOG_INFO, "keymgr: retire DNSKEY %s (%s)", keystr,
keymgr_keyrole(key->key));
}
}
if (conflict) {
/* Try again. */
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_WARNING,
"keymgr: key collision id %d",
dst_key_id(newkey));
int type, dst_key_state_t next_state,
bool secure_to_insecure) {
/* Debug logging. */
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
bool rule1a, rule1b, rule2a, rule2b, rule3a, rule3b;
char keystr[DST_KEY_FORMATSIZE];
dst_key_format(key->key, keystr, sizeof(keystr));
rule3a = keymgr_have_rrsig(keyring, key, type, NA);
rule3b = keymgr_have_rrsig(keyring, key, type, next_state);
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
ISC_LOG_DEBUG(1),
"keymgr: dnssec evaluation of %s %s record %s: "
"rule1=(~%s or %s) rule2=(~%s or %s) "
continue;
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: examine %s %s type %s "
"in state %s",
* No change needed, continue with the next
* record type.
*/
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC,
ISC_LOG_DEBUG(1),
"keymgr: %s %s type %s in "
continue;
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: can we transition %s %s type %s "
"state %s to state %s?",
{
/* No, please respect rollover methods. */
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: policy says no to %s %s type "
"%s "
{
/* No, this would make the zone bogus. */
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: dnssec says no to %s %s type "
"%s "
if (when > now) {
/* Not yet. */
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: time says no to %s %s type %s "
"state %s to state %s (wait %u "
continue;
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: transition %s %s type %s "
"state %s to state %s!",
/* Do we need to create a successor for the active key? */
if (active_key != NULL) {
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
dst_key_format(active_key->key, keystr, sizeof(keystr));
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
+ DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_DEBUG(1),
"keymgr: DNSKEY %s (%s) is active in policy %s",
keystr, keymgr_keyrole(active_key->key),
dns_kasp_getname(kasp));
prepub = keymgr_prepublication_time(active_key, kasp, lifetime,
now);
if (prepub > now) {
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
dst_key_format(active_key->key, keystr,
sizeof(keystr));
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: new successor needed for "
"DNSKEY %s (%s) (policy %s) in %u "
if (keymgr_key_has_successor(active_key, keyring)) {
/* Key already has successor. */
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
dst_key_format(active_key->key, keystr,
sizeof(keystr));
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: key DNSKEY %s (%s) (policy "
"%s) already has successor",
return (ISC_R_SUCCESS);
}
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
dst_key_format(active_key->key, keystr, sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: need successor for DNSKEY %s "
"(%s) (policy %s)",
*/
if (!rollover) {
dst_key_format(active_key->key, keystr, sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_WARNING,
"keymgr: DNSKEY %s (%s) is offline in "
"policy %s, cannot start rollover",
dns_kasp_getname(kasp));
return (ISC_R_SUCCESS);
}
- } else if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
+ } else if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
char namestr[DNS_NAME_FORMATSIZE];
dns_name_format(origin, namestr, sizeof(namestr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_DEBUG(1),
"keymgr: no active key found for %s (policy %s)",
namestr, dns_kasp_getname(kasp));
}
/* Logging. */
dst_key_format(new_key->key, keystr, sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
ISC_LOG_INFO, "keymgr: DNSKEY %s (%s) %s for policy %s",
keystr, keymgr_keyrole(new_key->key),
(candidate != NULL) ? "selected" : "created",
if (ret != ISC_R_SUCCESS) {
char keystr[DST_KEY_FORMATSIZE];
dst_key_format(key, keystr, sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_WARNING,
"keymgr: failed to purge DNSKEY %s (%s): cannot "
"build filename (%s)",
keystr, keymgr_keyrole(key),
if (unlink(filename) < 0) {
char keystr[DST_KEY_FORMATSIZE];
dst_key_format(key, keystr, sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_WARNING,
"keymgr: failed to purge DNSKEY %s (%s): unlink "
"'%s' failed",
keystr, keymgr_keyrole(key), filename);
*nexttime = 0;
/* Debug logging: what keys are available in the keyring? */
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
if (ISC_LIST_EMPTY(*keyring)) {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(origin, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: keyring empty (zone %s policy "
"%s)",
dkey != NULL; dkey = ISC_LIST_NEXT(dkey, link))
{
dst_key_format(dkey->key, keystr, sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: keyring: %s (policy %s)", keystr,
dns_kasp_getname(kasp));
dkey != NULL; dkey = ISC_LIST_NEXT(dkey, link))
{
dst_key_format(dkey->key, keystr, sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: dnskeys: %s (policy %s)", keystr,
dns_kasp_getname(kasp));
dns_kasp_purgekeys(kasp), now))
{
dst_key_format(dkey->key, keystr, sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"keymgr: purge DNSKEY %s (%s) according "
"to policy %s",
/* Found a match. */
dst_key_format(dkey->key, keystr,
sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC,
ISC_LOG_DEBUG(1),
"keymgr: DNSKEY %s (%s) matches "
dst_key_format(dnskey->key, keystr,
sizeof(keystr));
isc_log_write(
- dns_lctx,
DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC,
ISC_LOG_DEBUG(1),
RETERR(dst_key_tofile(dkey->key, options, directory));
dst_key_setmodified(dkey->key, false);
- if (!isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ if (!isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
continue;
}
dst_key_format(dkey->key, keystr, sizeof(keystr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(3),
"keymgr: DNSKEY %s (%s) "
"saved to directory %s, policy %s",
}
}
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(origin, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(3),
- "keymgr: %s done", namebuf);
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_DEBUG(3), "keymgr: %s done", namebuf);
}
return (result);
}
}
}
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_NOTICE)) {
+ if (isc_log_wouldlog(ISC_LOG_NOTICE)) {
char keystr[DST_KEY_FORMATSIZE];
char timestr[26]; /* Minimal buf as per ctime_r() spec. */
dst_key_format(ksk_key->key, keystr, sizeof(keystr));
isc_stdtime_tostring(when, timestr, sizeof(timestr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_NOTICE,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_NOTICE,
"keymgr: checkds DS for key %s seen %s at %s",
keystr, dspublish ? "published" : "withdrawn",
timestr);
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(origin, namebuf, sizeof(namebuf));
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_ERROR,
+ DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_ERROR,
"keystore: failed to create PKCS#11 object "
"for zone %s, policy %s: %s",
namebuf, policy, isc_result_totext(result));
if (result != ISC_R_SUCCESS) {
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_ERROR,
+ DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_ERROR,
"keystore: failed to generate PKCS#11 object "
"%s: %s",
label, isc_result_totext(result));
return (result);
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_DNSSEC, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
+ ISC_LOG_ERROR,
"keystore: generated PKCS#11 object %s", label);
} else {
result = dst_key_generate(origin, alg, size, 0, flags,
{ "dns/qp", 0 }, { NULL, 0 },
};
-isc_log_t *dns_lctx = NULL;
-
void
-dns_log_init(isc_log_t *lctx) {
- isc_log_registercategories(lctx, dns_categories);
- isc_log_registermodules(lctx, dns_modules);
+dns_log_init(void) {
+ isc_log_registercategories(dns_categories);
+ isc_log_registermodules(dns_modules);
}
}
if (result != ISC_R_SUCCESS && logit) {
if (temp != NULL) {
- isc_log_write(dns_lctx, ISC_LOGCATEGORY_GENERAL,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTERDUMP, ISC_LOG_ERROR,
"dumping to master file: %s: flush: %s",
temp, isc_result_totext(result));
} else {
- isc_log_write(dns_lctx, ISC_LOGCATEGORY_GENERAL,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTERDUMP, ISC_LOG_ERROR,
"dumping to stream: flush: %s",
isc_result_totext(result));
}
if (result != ISC_R_SUCCESS && logit) {
if (temp != NULL) {
- isc_log_write(dns_lctx, ISC_LOGCATEGORY_GENERAL,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTERDUMP, ISC_LOG_ERROR,
"dumping to master file: %s: fsync: %s",
temp, isc_result_totext(result));
} else {
- isc_log_write(dns_lctx, ISC_LOGCATEGORY_GENERAL,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTERDUMP, ISC_LOG_ERROR,
"dumping to stream: fsync: %s",
isc_result_totext(result));
result = tresult;
}
if (result != ISC_R_SUCCESS && logit) {
- isc_log_write(dns_lctx, ISC_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTERDUMP, ISC_LOG_ERROR,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTERDUMP,
+ ISC_LOG_ERROR,
"dumping master file: %s: fclose: %s", temp,
isc_result_totext(result));
logit = false;
(void)isc_file_remove(temp);
}
if (result != ISC_R_SUCCESS && logit) {
- isc_log_write(dns_lctx, ISC_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTERDUMP, ISC_LOG_ERROR,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTERDUMP,
+ ISC_LOG_ERROR,
"dumping master file: rename: %s: %s", file,
isc_result_totext(result));
}
result = isc_file_openunique(tempname, &f);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, ISC_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTERDUMP, ISC_LOG_ERROR,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTERDUMP,
+ ISC_LOG_ERROR,
"dumping master file: %s: open: %s", tempname,
isc_result_totext(result));
goto cleanup;
isc_buffer_remainingregion(source, &r);
if (r.length != 0) {
- isc_log_write(dns_lctx, ISC_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MESSAGE, ISC_LOG_DEBUG(3),
+ isc_log_write(ISC_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MESSAGE,
+ ISC_LOG_DEBUG(3),
"message has %u byte(s) of trailing garbage",
r.length);
}
int len = 1024;
isc_result_t result;
- if (!isc_log_wouldlog(dns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
isc_mem_put(mctx, buf, len);
len += 1024;
} else if (result == ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, category, module, level,
- "%s%s%s%s%.*s", description, space,
- addrbuf, newline,
+ isc_log_write(category, module, level, "%s%s%s%s%.*s",
+ description, space, addrbuf, newline,
(int)isc_buffer_usedlength(&buffer), buf);
}
} while (result == ISC_R_NOSPACE);
{
char nb[DNS_NAME_FORMATSIZE];
dns_name_format(&nta->name, nb, sizeof(nb));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_NTA, ISC_LOG_INFO,
- "deleting expired NTA at %s", nb);
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_NTA,
+ ISC_LOG_INFO, "deleting expired NTA at %s", nb);
dns_qp_deletename(qp, &nta->name, NULL, NULL);
dns__nta_shutdown(nta);
dns__nta_unref(nta);
REQUIRE(VALID_NTA(nta));
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
char nb[DNS_NAME_FORMATSIZE];
dns_name_format(&nta->name, nb, sizeof(nb));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_NTA, ISC_LOG_DEBUG(3),
- "shutting down NTA %p at %s", nta, nb);
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_NTA,
+ ISC_LOG_DEBUG(3), "shutting down NTA %p at %s",
+ nta, nb);
}
if (nta->timer) {
isc_timer_stop(nta->timer);
#define PRItime " %" PRIu64 " ns "
#if DNS_QP_LOG_STATS
-#define LOG_STATS(...) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_QP, \
+#define LOG_STATS(...) \
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_QP, \
ISC_LOG_DEBUG(1), __VA_ARGS__)
#else
#define LOG_STATS(...)
*/
#define TRACE(fmt, ...) \
do { \
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(7))) { \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, \
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(7))) { \
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, \
DNS_LOGMODULE_QP, ISC_LOG_DEBUG(7), \
"%s:%d:%s(qp %p uctx \"%s\"):t%u: " fmt, \
__FILE__, __LINE__, __func__, qp, \
* letting compact+recycle fail repeatedly.
*/
if (QP_AUTOGC(qp)) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_QP, ISC_LOG_NOTICE,
"qp %p uctx \"%s\" compact/recycle "
"failed to recover any space, "
delete_node(qpcache_t *qpdb, qpcnode_t *node) {
isc_result_t result = ISC_R_UNEXPECTED;
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
char printname[DNS_NAME_FORMATSIZE];
dns_name_format(&node->name, printname, sizeof(printname));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
+ ISC_LOG_DEBUG(1),
"delete_node(): %p %s (bucket %d)", node,
printname, node->locknum);
}
*/
result = dns_qp_deletename(qpdb->nsec, &node->name, NULL, NULL);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
"delete_node(): "
"dns_qp_deletename: %s",
break;
}
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
+ ISC_LOG_WARNING,
"delete_node(): "
"dns_qp_deletename: %s",
isc_result_totext(result));
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
- "done free_qpdb(%s)", buf);
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
+ ISC_LOG_DEBUG(1), "done free_qpdb(%s)", buf);
}
if (dns_name_dynamic(&qpdb->common.origin)) {
dns_name_free(&qpdb->common.origin, qpdb->common.mctx);
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
"calling free_qpdb(%s)", buf);
free_qpdb(qpdb, true);
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
"calling free_qpdb(%s)", buf);
free_qpdb(qpdb, true);
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DB, ISC_LOG_DEBUG(1),
- "called free_qpdb(%s)", buf);
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DB,
+ ISC_LOG_DEBUG(1), "called free_qpdb(%s)", buf);
}
call_rcu(&qpdb->rcu_head, free_db_rcu);
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_DB, ISC_LOG_DEBUG(1),
"calling free_qpdb(%s)", buf);
free_qpdb(qpdb, true);
* nodes in the auxiliary tree that are awaiting deletion.
*/
if (result != DNS_R_PARTIALMATCH && result != ISC_R_NOTFOUND) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_DB, ISC_LOG_ERROR,
"previous_closest_nsec(): %s",
isc_result_totext(result));
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_DB, ISC_LOG_DEBUG(1),
"calling free_qpdb(%s)", buf);
free_qpdb(qpdb, true);
* nodes in the auxiliary tree that are awaiting deletion.
*/
if (result != DNS_R_PARTIALMATCH && result != ISC_R_NOTFOUND) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_ERROR,
"previous_closest_nsec(): %s",
isc_result_totext(result));
if (nsecresult == ISC_R_EXISTS) {
#if 1 /* 0 */
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
+ ISC_LOG_WARNING,
"addnode: NSEC node already exists");
#endif /* if 1 */
node->nsec = DNS_DB_NSEC_HAS_NSEC;
*/
tmpresult = dns_rbt_deletenode(rbtdb->tree, node, false);
if (tmpresult != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
"loading_addrdataset: "
"dns_rbt_deletenode: %s after "
nodes = (nodes + old * 3) / 4;
if (nodes != old) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
+ ISC_LOG_DEBUG(1),
"adjust_quantum: old=%d, new=%d", old, nodes);
}
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
- "done free_rbtdb(%s)", buf);
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
+ ISC_LOG_DEBUG(1), "done free_rbtdb(%s)", buf);
}
if (dns_name_dynamic(&rbtdb->common.origin)) {
dns_name_free(&rbtdb->common.origin, rbtdb->common.mctx);
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
"calling free_rbtdb(%s)", buf);
free_rbtdb(rbtdb, true);
INSIST(!ISC_LINK_LINKED(node, deadlink));
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
char printname[DNS_NAME_FORMATSIZE];
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
+ ISC_LOG_DEBUG(1),
"delete_node(): %p %s (bucket %d)", node,
dns_rbt_formatnodename(node, printname,
sizeof(printname)),
NULL, DNS_RBTFIND_EMPTYDATA, NULL,
NULL);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
"delete_node: "
"dns_rbt_findnode(nsec): %s",
false);
if (result != ISC_R_SUCCESS) {
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
"delete_node(): "
"dns_rbt_deletenode(nsecnode): %s",
break;
}
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
+ ISC_LOG_WARNING,
"delete_node(): "
"dns_rbt_deletenode: %s",
isc_result_totext(result));
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
+ isc_log_write(DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
"calling free_rbtdb(%s)", buf);
free_rbtdb(rbtdb, true);
va_list ap;
va_start(ap, fmt);
- isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_REQUEST,
- level, fmt, ap);
+ isc_log_vwrite(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_REQUEST, level,
+ fmt, ap);
va_end(ap);
}
#include <dns/zone.h>
#ifdef WANT_QUERYTRACE
-#define RTRACE(m) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER, \
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3), "res %p: %s", \
- res, (m))
-#define RRTRACE(r, m) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER, \
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3), "res %p: %s", \
- (r), (m))
-#define FCTXTRACE(m) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER, \
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3), \
- "fctx %p(%s): %s", fctx, fctx->info, (m))
-#define FCTXTRACE2(m1, m2) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER, \
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3), \
- "fctx %p(%s): %s %s", fctx, fctx->info, (m1), (m2))
-#define FCTXTRACE3(m, res) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER, \
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3), \
- "fctx %p(%s): [result: %s] %s", fctx, fctx->info, \
- isc_result_totext(res), (m))
+#define RTRACE(m) \
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, \
+ ISC_LOG_DEBUG(3), "res %p: %s", res, (m))
+#define RRTRACE(r, m) \
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, \
+ ISC_LOG_DEBUG(3), "res %p: %s", (r), (m))
+#define FCTXTRACE(m) \
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, \
+ ISC_LOG_DEBUG(3), "fctx %p(%s): %s", fctx, fctx->info, \
+ (m))
+#define FCTXTRACE2(m1, m2) \
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, \
+ ISC_LOG_DEBUG(3), "fctx %p(%s): %s %s", fctx, \
+ fctx->info, (m1), (m2))
+#define FCTXTRACE3(m, res) \
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, \
+ ISC_LOG_DEBUG(3), "fctx %p(%s): [result: %s] %s", fctx, \
+ fctx->info, isc_result_totext(res), (m))
#define FCTXTRACE4(m1, m2, res) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER, \
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3), \
- "fctx %p(%s): [result: %s] %s %s", fctx, fctx->info, \
- isc_result_totext(res), (m1), (m2))
-#define FCTXTRACE5(m1, m2, v) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER, \
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3), \
- "fctx %p(%s): %s %s%u", fctx, fctx->info, (m1), (m2), \
- (v))
-#define FTRACE(m) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER, \
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3), \
- "fetch %p (fctx %p(%s)): %s", fetch, fetch->private, \
- fetch->private->info, (m))
-#define QTRACE(m) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER, \
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3), \
- "resquery %p (fctx %p(%s)): %s", query, query->fctx, \
- query->fctx->info, (m))
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, \
+ ISC_LOG_DEBUG(3), "fctx %p(%s): [result: %s] %s %s", \
+ fctx, fctx->info, isc_result_totext(res), (m1), (m2))
+#define FCTXTRACE5(m1, m2, v) \
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, \
+ ISC_LOG_DEBUG(3), "fctx %p(%s): %s %s%u", fctx, \
+ fctx->info, (m1), (m2), (v))
+#define FTRACE(m) \
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, \
+ ISC_LOG_DEBUG(3), "fetch %p (fctx %p(%s)): %s", fetch, \
+ fetch->private, fetch->private->info, (m))
+#define QTRACE(m) \
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, \
+ ISC_LOG_DEBUG(3), "resquery %p (fctx %p(%s)): %s", \
+ query, query->fctx, query->fctx->info, (m))
#else /* ifdef WANT_QUERYTRACE */
#define RTRACE(m) \
do { \
char dbuf[DNS_NAME_FORMATSIZE];
isc_stdtime_t now;
- if (!isc_log_wouldlog(dns_lctx, ISC_LOG_INFO)) {
+ if (!isc_log_wouldlog(ISC_LOG_INFO)) {
return;
}
dns_name_format(fctx->domain, dbuf, sizeof(dbuf));
if (!final) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_SPILL,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_SPILL, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_INFO,
"too many simultaneous fetches for %s "
"(allowed %" PRIuFAST32 " spilled %" PRIuFAST32
"; %s)",
: "cumulative since "
"initial trigger event");
} else {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_SPILL,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_SPILL, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_INFO,
"fetch counters for %s now being discarded "
"(allowed %" PRIuFAST32 " spilled %" PRIuFAST32
"; cumulative since initial trigger event)",
}
UNLOCK(&fctx->res->lock);
if (logit) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER,
DNS_LOGMODULE_RESOLVER, ISC_LOG_NOTICE,
"clients-per-query increased to %u",
new_spillat);
if (result == ISC_R_SUCCESS) {
if (fctx->qmin_warning != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_LAME_SERVERS,
+ isc_log_write(DNS_LOGCATEGORY_LAME_SERVERS,
DNS_LOGMODULE_RESOLVER, ISC_LOG_INFO,
"success resolving '%s' after disabling "
"qname minimization due to '%s'",
/* format new address */
isc_sockaddr_format(&sockaddr, sockaddrbuf2,
sizeof(sockaddrbuf2));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER,
DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3),
"Using DNS64 address %s to talk to %s\n",
sockaddrbuf2, sockaddrbuf1);
if (result != ISC_R_SUCCESS && (query->options & DNS_FETCHOPT_TCP) != 0)
{
int log_level = ISC_LOG_NOTICE;
- if (isc_log_wouldlog(dns_lctx, log_level)) {
+ if (isc_log_wouldlog(log_level)) {
char peerbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&sockaddr, peerbuf,
ISC_SOCKADDR_FORMATSIZE);
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_RESOLVER,
+ DNS_LOGCATEGORY_RESOLVER,
DNS_LOGMODULE_RESOLVER, log_level,
"Unable to establish a connection to %s: %s\n",
peerbuf, isc_result_totext(result));
dns_rdatatype_format(fctx->type, typebuf, sizeof(typebuf));
dns_rdataclass_format(fctx->res->rdclass, classbuf, sizeof(classbuf));
isc_sockaddr_format(address, addrbuf, sizeof(addrbuf));
- isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_LAME_SERVERS, DNS_LOGMODULE_RESOLVER,
- ISC_LOG_INFO, "%s%s%s resolving '%s/%s/%s': %s", code, spc,
- isc_result_totext(reason), namebuf, typebuf, classbuf, addrbuf);
+ isc_log_write(DNS_LOGCATEGORY_LAME_SERVERS, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_INFO, "%s%s%s resolving '%s/%s/%s': %s", code,
+ spc, isc_result_totext(reason), namebuf, typebuf,
+ classbuf, addrbuf);
}
/*
NULL, res->view->dstport, fctx->depth + 1,
fctx->qc, &find);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3),
- "fctx %p(%s): createfind for %s - %s", fctx, fctx->info,
- fctx->clientstr, isc_result_totext(result));
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_DEBUG(3), "fctx %p(%s): createfind for %s - %s",
+ fctx, fctx->info, fctx->clientstr,
+ isc_result_totext(result));
if (result != ISC_R_SUCCESS) {
if (result == DNS_R_ALIAS) {
dns_adb_destroyfind(&find);
fctx->adberr++;
dns_name_format(name, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_CNAME,
+ isc_log_write(DNS_LOGCATEGORY_CNAME,
DNS_LOGMODULE_RESOLVER, ISC_LOG_INFO,
"skipping nameserver '%s' because it "
"is a CNAME, while resolving '%s'",
*/
if (waiting_for(find, fctx->type) && dns_name_equal(name, fctx->name)) {
fctx->adberr++;
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_INFO,
- "loop detected resolving '%s'", fctx->info);
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_INFO, "loop detected resolving '%s'",
+ fctx->info);
if ((find->options & DNS_ADBFIND_WANTEVENT) != 0) {
atomic_fetch_add_relaxed(&fctx->pending, 1);
res = fctx->res;
if (fctx->depth > res->maxdepth) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3),
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_DEBUG(3),
"too much NS indirection resolving '%s' "
"(depth=%u, maxdepth=%u)",
fctx->info, fctx->depth, res->maxdepth);
return;
}
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
char buf[ISC_NETADDR_FORMATSIZE];
isc_netaddr_fromsockaddr(&na, sa);
isc_netaddr_format(&na, buf, sizeof(buf));
/* We've already exceeded maximum query count */
if (isc_counter_used(fctx->qc) > res->maxqueries) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3),
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_DEBUG(3),
"exceeded max queries resolving '%s' "
"(querycount=%u, maxqueries=%u)",
fctx->info, isc_counter_used(fctx->qc),
dns_rdatatype_format(fctx->qmintype, typebuf,
sizeof(typebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER,
DNS_LOGMODULE_RESOLVER, ISC_LOG_ERROR,
"fctx %p(%s): attempting QNAME "
"minimization fetch for %s/%s but "
result = isc_counter_increment(fctx->qc);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3),
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_DEBUG(3),
"exceeded max queries resolving '%s'",
fctx->info);
goto done;
break;
default:
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(5),
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_DEBUG(5),
"QNAME minimization: unexpected result %s",
isc_result_totext(result));
break;
REQUIRE(VALID_FCTX(fctx));
REQUIRE(fctx->tid == isc_tid());
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_INFO,
"shut down hung fetch while resolving %p(%s)", fctx,
fctx->info);
fctx_done_detach(&fctx, DNS_R_SERVFAIL);
dns_name_format(fctx->name, namebuf, sizeof(namebuf));
dns_name_format(fctx->domain, domainbuf, sizeof(domainbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(10),
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_DEBUG(10),
"log_ns_ttl: fctx %p: %s: %s (in '%s'?): %u %u", fctx,
where, namebuf, domainbuf, fctx->ns_ttl_ok, fctx->ns_ttl);
}
if (qc != NULL) {
isc_counter_attach(qc, &fctx->qc);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(9),
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_DEBUG(9),
"fctx %p(%s): attached to counter %p (%d)", fctx,
fctx->info, fctx->qc, isc_counter_used(fctx->qc));
} else {
if (result != ISC_R_SUCCESS) {
goto cleanup_fetch;
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(9),
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_DEBUG(9),
"fctx %p(%s): created counter %p", fctx,
fctx->info, fctx->qc);
}
dns_name_format(fctx->name, namebuf, sizeof(namebuf));
dns_name_format(fctx->domain, domainbuf, sizeof(domainbuf));
isc_sockaddr_format(&addrinfo->sockaddr, addrbuf, sizeof(addrbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_LAME_SERVERS,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_INFO,
- "lame server resolving '%s' (in '%s'?): %s", namebuf,
- domainbuf, addrbuf);
+ isc_log_write(DNS_LOGCATEGORY_LAME_SERVERS, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_INFO, "lame server resolving '%s' (in '%s'?): %s",
+ namebuf, domainbuf, addrbuf);
}
static void
isc_sockaddr_format(&fctx->addrinfo->sockaddr, nsbuf, sizeof(nsbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_NOTICE,
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_NOTICE,
"DNS format error from %s resolving %s for %s: %s", nsbuf,
fctx->info, fctx->clientstr, msgbuf);
}
vsnprintf(msgbuf, sizeof(msgbuf), fmt, args);
va_end(args);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, level, "fctx %p(%s): %s", fctx,
- fctx->info, msgbuf);
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, level,
+ "fctx %p(%s): %s", fctx, fctx->info, msgbuf);
}
static isc_result_t
sizeof(typebuf));
dns_rdataclass_format(rdataset->rdclass, classbuf,
sizeof(classbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER,
DNS_LOGMODULE_RESOLVER, ISC_LOG_NOTICE,
"check-names %s %s/%s/%s",
fail ? "failure" : "warning", namebuf,
sizeof(typebuf));
dns_rdataclass_format(rdataset->rdclass, classbuf,
sizeof(classbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER,
DNS_LOGMODULE_RESOLVER, ISC_LOG_NOTICE,
"answer address %s denied for %s/%s/%s",
addrbuf, namebuf, typebuf, classbuf);
dns_rdatatype_format(rdataset->type, typebuf, sizeof(typebuf));
dns_rdataclass_format(view->rdclass, classbuf,
sizeof(classbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_NOTICE,
- "%s target %s denied for %s/%s", typebuf,
- tnamebuf, qnamebuf, classbuf);
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_NOTICE, "%s target %s denied for %s/%s",
+ typebuf, tnamebuf, qnamebuf, classbuf);
return (false);
}
dns_name_format(fctx->name, namebuf, sizeof(namebuf));
dns_rdatatype_format(fctx->type, tbuf, sizeof(tbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(10),
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_DEBUG(10),
"fctx %p: trimming ttl of %s/NS for %s/%s: "
"%u -> %u",
fctx, ns_namebuf, namebuf, tbuf, rdataset->ttl,
isc_sockaddr_format(&query->addrinfo->sockaddr, addrbuf,
sizeof(addrbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_NSID, DNS_LOGMODULE_RESOLVER,
- level, "received NSID %s (\"%s\") from %s", buf, pbuf,
- addrbuf);
+ isc_log_write(DNS_LOGCATEGORY_NSID, DNS_LOGMODULE_RESOLVER, level,
+ "received NSID %s (\"%s\") from %s", buf, pbuf, addrbuf);
isc_mem_put(mctx, pbuf, nsid_len + 1);
isc_mem_put(mctx, buf, buflen);
* keep listening for a good answer.
*/
rctx->nextitem = true;
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_INFO)) {
+ if (isc_log_wouldlog(ISC_LOG_INFO)) {
char addrbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&query->addrinfo->sockaddr, addrbuf,
sizeof(addrbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER,
DNS_LOGMODULE_RESOLVER, ISC_LOG_INFO,
"bad cookie from %s", addrbuf);
}
if (dns_adb_getcookie(query->addrinfo, NULL, 0) >
CLIENT_COOKIE_SIZE)
{
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_INFO)) {
+ if (isc_log_wouldlog(ISC_LOG_INFO)) {
char addrbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&query->addrinfo->sockaddr,
addrbuf, sizeof(addrbuf));
- isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_INFO,
- "missing expected cookie "
- "from %s",
- addrbuf);
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER,
+ DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_INFO,
+ "missing expected cookie "
+ "from %s",
+ addrbuf);
}
rctx->retryopts |= DNS_FETCHOPT_TCP;
rctx->resend = true;
result = dns_peer_getrequirecookie(peer,
&required);
if (result == ISC_R_SUCCESS && required) {
- if (isc_log_wouldlog(dns_lctx,
- ISC_LOG_INFO))
- {
+ if (isc_log_wouldlog(ISC_LOG_INFO)) {
char addrbuf
[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(
addrbuf,
sizeof(addrbuf));
isc_log_write(
- dns_lctx,
DNS_LOGCATEGORY_RESOLVER,
DNS_LOGMODULE_RESOLVER,
ISC_LOG_INFO,
}
UNLOCK(&res->lock);
if (spillat > 0) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_NOTICE,
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_NOTICE,
"clients-per-query decreased to %u", spillat);
}
}
int level = (resp->result == ISC_R_SUCCESS) ? ISC_LOG_DEBUG(1)
: ISC_LOG_NOTICE;
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, level,
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, level,
"resolver priming query complete: %s",
isc_result_totext(resp->result));
* If there's no chance of logging it, don't render (format) the
* name and RDATA type (further below), and return early.
*/
- if (!isc_log_wouldlog(dns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
dns_name_format(name, namebuf, sizeof(namebuf));
dns_rdatatype_format(type, typebuf, sizeof(typebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, level, "fetch: %s/%s", namebuf,
- typebuf);
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, level,
+ "fetch: %s/%s", namebuf, typebuf);
}
static void
char domainbuf[DNS_NAME_FORMATSIZE];
dns_name_format(fctx->qminname, domainbuf, sizeof(domainbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
- DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(5),
+ isc_log_write(DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER,
+ ISC_LOG_DEBUG(5),
"QNAME minimization - %s minimized, qmintype %d "
"qminname %s",
fctx->minimized ? "" : "not", fctx->qmintype, domainbuf);
}
void
-dns_resolver_logfetch(dns_fetch_t *fetch, isc_log_t *lctx,
- isc_logcategory_t *category, isc_logmodule_t *module,
- int level, bool duplicateok) {
+dns_resolver_logfetch(dns_fetch_t *fetch, isc_logcategory_t *category,
+ isc_logmodule_t *module, int level, bool duplicateok) {
fetchctx_t *fctx = NULL;
REQUIRE(DNS_FETCH_VALID(fetch));
if (!fctx->logged || duplicateok) {
char domainbuf[DNS_NAME_FORMATSIZE];
dns_name_format(fctx->domain, domainbuf, sizeof(domainbuf));
- isc_log_write(lctx, category, module, level,
+ isc_log_write(category, module, level,
"fetch completed for %s in "
"%" PRIu64 "."
"%06" PRIu64 ": %s/%s "
goto failure;
}
if (check_hints(db) != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_HINTS, ISC_LOG_WARNING,
- "extra data in root hints '%s'",
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_HINTS,
+ ISC_LOG_WARNING, "extra data in root hints '%s'",
(filename != NULL) ? filename : "<BUILT-IN>");
}
*target = db;
return (ISC_R_SUCCESS);
failure:
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_HINTS,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_HINTS,
ISC_LOG_ERROR,
"could not configure root hints from "
"'%s': %s",
databuf[isc_buffer_usedlength(&buffer)] = '\0';
if (missing) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_HINTS, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_HINTS,
+ ISC_LOG_WARNING,
"checkhints%s%s: %s/%s (%s) missing from hints",
sep, viewname, namebuf, typebuf, databuf);
} else {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_HINTS, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_HINTS,
+ ISC_LOG_WARNING,
"checkhints%s%s: %s/%s (%s) extra record "
"in hints",
sep, viewname, namebuf, typebuf, databuf);
result = dns_db_find(hints, dns_rootname, NULL, dns_rdatatype_ns, 0,
now, NULL, name, &hintns, NULL);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_HINTS, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_HINTS,
+ ISC_LOG_WARNING,
"checkhints%s%s: unable to get root NS rrset "
"from hints: %s",
sep, viewname, isc_result_totext(result));
result = dns_db_find(db, dns_rootname, NULL, dns_rdatatype_ns, 0, now,
NULL, name, &rootns, NULL);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_HINTS, ISC_LOG_WARNING,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_HINTS,
+ ISC_LOG_WARNING,
"checkhints%s%s: unable to get root NS rrset "
"from cache: %s",
sep, viewname, isc_result_totext(result));
char namebuf[DNS_NAME_FORMATSIZE];
/* missing from hints */
dns_name_format(&ns.name, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_HINTS, ISC_LOG_WARNING,
"checkhints%s%s: unable to find root "
"NS '%s' in hints",
char namebuf[DNS_NAME_FORMATSIZE];
/* extra entry in hints */
dns_name_format(&ns.name, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_HINTS, ISC_LOG_WARNING,
"checkhints%s%s: extra NS '%s' in hints",
sep, viewname, namebuf);
}
set:
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
DNS_RPZ_DEBUG_QUIET,
"computed RPZ qname_skip_recurse mask=0x%" PRIx64,
(uint64_t)mask);
/*
* bin/tests/system/rpz/tests.sh looks for "invalid rpz".
*/
- if (level < DNS_RPZ_DEBUG_QUIET && isc_log_wouldlog(dns_lctx, level)) {
+ if (level < DNS_RPZ_DEBUG_QUIET && isc_log_wouldlog(level)) {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(name, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
- DNS_LOGMODULE_RBTDB, level,
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB, level,
"invalid rpz IP address \"%s\"%s%s", namebuf,
str1, str2);
}
/*
* Complain about bad names but be generous and accept them.
*/
- if (log_level < DNS_RPZ_DEBUG_QUIET &&
- isc_log_wouldlog(dns_lctx, log_level))
- {
+ if (log_level < DNS_RPZ_DEBUG_QUIET && isc_log_wouldlog(log_level)) {
/*
* Convert the address back to a canonical domain name
* to ensure that the original name is in canonical form.
{
char ip2_str[DNS_NAME_FORMATSIZE];
dns_name_format(ip_name2, ip2_str, sizeof(ip2_str));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
- DNS_LOGMODULE_RBTDB, log_level,
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ log_level,
"rpz IP address \"%s\""
" is not the canonical \"%s\"",
ip_str, ip2_str);
* bin/tests/system/rpz/tests.sh looks for "rpz.*failed".
*/
dns_name_format(src_name, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
- DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ DNS_RPZ_ERROR_LEVEL,
"rpz add_cidr(%s) failed: %s", namebuf,
isc_result_totext(result));
goto done;
rpz->updatepending = true;
dns_name_format(&rpz->origin, dname, DNS_NAME_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_DEBUG(3),
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_DEBUG(3),
"rpz: %s: update already queued or running",
dname);
if (rpz->dbversion != NULL) {
char dname[DNS_NAME_FORMATSIZE];
dns_name_format(&rpz->origin, dname, DNS_NAME_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_INFO,
"rpz: %s: new zone version came "
"too soon, deferring update for "
"%" PRIu64 " seconds",
UNLOCK(&rpz->rpzs->maint_lock);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
ISC_LOG_INFO, "rpz: %s: reload done: %s", dname,
isc_result_totext(rpz->updateresult));
result = dns_db_createiterator(rpz->updb, DNS_DB_NONSEC3, &updbit);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_ERROR,
"rpz: %s: failed to create DB iterator - %s",
domain, isc_result_totext(result));
return (result);
result = dns_dbiterator_first(updbit);
if (result != ISC_R_SUCCESS && result != ISC_R_NOMORE) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ ISC_LOG_ERROR,
"rpz: %s: failed to get db iterator - %s", domain,
isc_result_totext(result));
goto cleanup;
result = dns_dbiterator_current(updbit, &node, name);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"rpz: %s: failed to get dbiterator - %s",
domain, isc_result_totext(result));
result = dns_db_allrdatasets(rpz->updb, node, rpz->updbversion,
0, 0, &rdsiter);
if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"rpz: %s: failed to fetch "
"rrdatasets - %s",
if (result != ISC_R_SUCCESS) { /* skip empty non-terminal */
if (result != ISC_R_NOMORE) {
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"rpz: %s: error %s while creating "
"rdatasetiter",
result = isc_ht_add(newnodes, name->ndata, name->length, rpz);
if (result != ISC_R_SUCCESS) {
dns_name_format(name, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"rpz: %s, adding node %s to HT error %s",
domain, namebuf,
if (result != ISC_R_SUCCESS) {
dns_name_format(name, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"rpz: %s: adding node %s "
"to RPZ error %s",
domain, namebuf,
isc_result_totext(result));
- } else if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ } else if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
dns_name_format(name, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_DEBUG(3),
"rpz: %s: adding node %s", domain,
namebuf);
rpz->dbversion = NULL;
dns_name_format(&rpz->origin, domain, DNS_NAME_FORMATSIZE);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
ISC_LOG_INFO, "rpz: %s: reload start", domain);
dns_rpz_zones_ref(rpz->rpzs);
* "rpz.*failed".
*/
dns_name_format(src_name, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
- DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ DNS_RPZ_ERROR_LEVEL,
"rpz del_name(%s) node delete "
"failed: %s",
namebuf, isc_result_totext(result));
/*
* bin/tests/system/rpz/tests.sh looks for "rpz.*failed".
*/
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
- DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
- "rpz ip2name() failed: %s",
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ DNS_RPZ_ERROR_LEVEL, "rpz ip2name() failed: %s",
isc_result_totext(result));
return (DNS_RPZ_INVALID_NUM);
}
* bin/tests/system/rpz/tests.sh looks for "rpz.*failed".
*/
dns_name_format(trig_name, namebuf, sizeof(namebuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
- DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
+ isc_log_write(DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
+ DNS_RPZ_ERROR_LEVEL,
"dns_rpz_find_name(%s) failed: %s", namebuf,
isc_result_totext(result));
break;
}
} while (pp < &primes[sizeof(primes) / sizeof(primes[0])]);
- if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DEBUG3)) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL,
- DNS_LOGMODULE_REQUEST, DNS_RRL_LOG_DEBUG3,
+ if (isc_log_wouldlog(DNS_RRL_LOG_DEBUG3)) {
+ isc_log_write(DNS_LOGCATEGORY_RRL, DNS_LOGMODULE_REQUEST,
+ DNS_RRL_LOG_DEBUG3,
"%d hash_divisor() divisions in %d tries"
" to get %d from %d",
divisions, tries, result, initial);
}
if (i != 0) {
isc_log_write(
- dns_lctx, DNS_LOGCATEGORY_RRL,
- DNS_LOGMODULE_REQUEST, DNS_RRL_LOG_DEBUG1,
+ DNS_LOGCATEGORY_RRL, DNS_LOGMODULE_REQUEST,
+ DNS_RRL_LOG_DEBUG1,
"rrl new time base scanned %d entries"
" at %d for %d %d %d %d",
i, now, rrl->ts_bases[ts_gen],
* Log expansions so that the user can tune max-table-size
* and min-table-size.
*/
- if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DROP) && rrl->hash != NULL) {
+ if (isc_log_wouldlog(DNS_RRL_LOG_DROP) && rrl->hash != NULL) {
rate = rrl->probes;
if (rrl->searches != 0) {
rate /= rrl->searches;
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL,
- DNS_LOGMODULE_REQUEST, DNS_RRL_LOG_DROP,
+ isc_log_write(DNS_LOGCATEGORY_RRL, DNS_LOGMODULE_REQUEST,
+ DNS_RRL_LOG_DROP,
"increase from %d to %d RRL entries with"
" %d bins; average search length %.1f",
rrl->num_entries, rrl->num_entries + newsize,
rrl->hash_gen ^= 1;
hash->gen = rrl->hash_gen;
- if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DROP) && old_bins != 0) {
+ if (isc_log_wouldlog(DNS_RRL_LOG_DROP) && old_bins != 0) {
rate = rrl->probes;
if (rrl->searches != 0) {
rate /= rrl->searches;
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL,
- DNS_LOGMODULE_REQUEST, DNS_RRL_LOG_DROP,
+ isc_log_write(DNS_LOGCATEGORY_RRL, DNS_LOGMODULE_REQUEST,
+ DNS_RRL_LOG_DROP,
"increase from %d to %d RRL bins for"
" %d entries; average search length %.1f",
old_bins, new_bins, rrl->num_entries, rate);
snprintf(buf, sizeof(buf), "age=%d", age);
age_str = buf;
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL, DNS_LOGMODULE_REQUEST,
+ isc_log_write(DNS_LOGCATEGORY_RRL, DNS_LOGMODULE_REQUEST,
DNS_RRL_LOG_DEBUG3, "rrl %08x %6s responses=%-3d %s",
hash_key(&e->key), age_str, e->responses, action);
}
new_rate = 1;
}
if (ratep->scaled != new_rate) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL,
+ isc_log_write(DNS_LOGCATEGORY_RRL,
DNS_LOGMODULE_REQUEST, DNS_RRL_LOG_DEBUG1,
"%d qps scaled %s by %.2f"
" from %d to %d",
* Debit the entry for this response.
*/
if (--e->responses >= 0) {
- if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DEBUG3)) {
+ if (isc_log_wouldlog(DNS_RRL_LOG_DEBUG3)) {
debit_log(e, age, "");
}
return (DNS_RRL_RESULT_OK);
new_slip = 2;
}
if (rrl->slip.scaled != new_slip) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL,
+ isc_log_write(DNS_LOGCATEGORY_RRL,
DNS_LOGMODULE_REQUEST, DNS_RRL_LOG_DEBUG1,
"%d qps scaled slip"
" by %.2f from %d to %d",
if ((int)e->slip_cnt >= slip) {
e->slip_cnt = 0;
}
- if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DEBUG3)) {
+ if (isc_log_wouldlog(DNS_RRL_LOG_DEBUG3)) {
debit_log(e, age, "slip");
}
return (DNS_RRL_RESULT_SLIP);
}
}
- if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DEBUG3)) {
+ if (isc_log_wouldlog(DNS_RRL_LOG_DEBUG3)) {
debit_log(e, age, "drop");
}
return (DNS_RRL_RESULT_DROP);
: "stop limiting ",
true, NULL, false, DNS_RRL_RESULT_OK,
ISC_R_SUCCESS, log_buf, log_buf_len);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL,
- DNS_LOGMODULE_REQUEST, DNS_RRL_LOG_DROP, "%s",
- log_buf);
+ isc_log_write(DNS_LOGCATEGORY_RRL, DNS_LOGMODULE_REQUEST,
+ DNS_RRL_LOG_DROP, "%s", log_buf);
free_qname(rrl, e);
e->logged = false;
--rrl->num_logged;
} else {
qps = (1.0 * rrl->qps_responses) / secs;
if (secs >= rrl->window) {
- if (isc_log_wouldlog(dns_lctx,
- DNS_RRL_LOG_DEBUG3))
- {
- isc_log_write(dns_lctx,
- DNS_LOGCATEGORY_RRL,
+ if (isc_log_wouldlog(DNS_RRL_LOG_DEBUG3)) {
+ isc_log_write(DNS_LOGCATEGORY_RRL,
DNS_LOGMODULE_REQUEST,
DNS_RRL_LOG_DEBUG3,
"%d responses/%d seconds"
return (DNS_RRL_RESULT_OK);
}
- if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DEBUG1)) {
+ if (isc_log_wouldlog(DNS_RRL_LOG_DEBUG1)) {
/*
* Do not worry about speed or releasing the lock.
* This message appears before messages from debit_rrl_entry().
make_log_buf(rrl, e, "consider limiting ", NULL, false, qname,
false, DNS_RRL_RESULT_OK, resp_result, log_buf,
log_buf_len);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL,
- DNS_LOGMODULE_REQUEST, DNS_RRL_LOG_DEBUG1, "%s",
- log_buf);
+ isc_log_write(DNS_LOGCATEGORY_RRL, DNS_LOGMODULE_REQUEST,
+ DNS_RRL_LOG_DEBUG1, "%s", log_buf);
}
rrl_result = debit_rrl_entry(rrl, e, qps, scale, client_addr, now,
if (rrl_all_result != DNS_RRL_RESULT_OK) {
e = e_all;
rrl_result = rrl_all_result;
- if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DEBUG1)) {
+ if (isc_log_wouldlog(DNS_RRL_LOG_DEBUG1)) {
make_log_buf(rrl, e,
"prefer all-per-second limiting ",
NULL, true, qname, false,
DNS_RRL_RESULT_OK, resp_result,
log_buf, log_buf_len);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL,
+ isc_log_write(DNS_LOGCATEGORY_RRL,
DNS_LOGMODULE_REQUEST,
DNS_RRL_LOG_DEBUG1, "%s",
log_buf);
* Log occasionally in the rate-limit category.
*/
if ((!e->logged || e->log_secs >= DNS_RRL_MAX_LOG_SECS) &&
- isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DROP))
+ isc_log_wouldlog(DNS_RRL_LOG_DROP))
{
make_log_buf(rrl, e, rrl->log_only ? "would " : NULL,
e->logged ? "continue limiting " : "limit ", true,
UNLOCK(&rrl->lock);
e = NULL;
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL,
- DNS_LOGMODULE_REQUEST, DNS_RRL_LOG_DROP, "%s",
- log_buf);
+ isc_log_write(DNS_LOGCATEGORY_RRL, DNS_LOGMODULE_REQUEST,
+ DNS_RRL_LOG_DROP, "%s", log_buf);
}
/*
sdlz_log(int level, const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
- isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
+ isc_log_vwrite(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
ISC_LOG_DEBUG(level), fmt, ap);
va_end(ap);
}
rcu_read_unlock();
if (match == 0) {
if (signer != NULL) {
- isc_log_write(dns_lctx,
- DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_SSU,
ISC_LOG_WARNING,
"update-policy local: "
va_list ap;
va_start(ap, fmt);
- isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_SECURITY, DNS_LOGMODULE_ZONE,
+ isc_log_vwrite(DNS_LOGCATEGORY_SECURITY, DNS_LOGMODULE_ZONE,
ISC_LOG_DEBUG(level), fmt, ap);
va_end(ap);
}
va_list ap;
va_start(ap, fmt);
- isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_REQUEST,
+ isc_log_vwrite(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_REQUEST,
ISC_LOG_DEBUG(4), fmt, ap);
va_end(ap);
}
char namestr[DNS_NAME_FORMATSIZE];
char creatorstr[DNS_NAME_FORMATSIZE];
- if (!isc_log_wouldlog(dns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
if (key != NULL) {
vsnprintf(message, sizeof(message), fmt, ap);
va_end(ap);
if (key != NULL && key->generated) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_TSIG, level,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_TSIG, level,
"tsig key '%s' (%s): %s", namestr, creatorstr,
message);
} else {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_TSIG, level, "tsig key '%s': %s",
- namestr, message);
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_TSIG, level,
+ "tsig key '%s': %s", namestr, message);
}
}
{
char namestr[DNS_NAME_FORMATSIZE];
dns_name_format(name, namestr, sizeof(namestr));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_TSIG, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_TSIG,
+ ISC_LOG_INFO,
"the key '%s' is too short to be secure",
namestr);
}
case DNS_R_NXRRSET: \
_what = "unsuccessful"; \
} \
- if (isc_log_wouldlog(dns_lctx, LOGLEVEL_PROTOCOL)) { \
+ if (isc_log_wouldlog(LOGLEVEL_PROTOCOL)) { \
char _nbuf[DNS_NAME_FORMATSIZE]; \
dns_name_format(name, _nbuf, sizeof(_nbuf)); \
update_log(log, zone, LOGLEVEL_PROTOCOL, \
case DNS_R_NXRRSET: \
_what = "unsuccessful"; \
} \
- if (isc_log_wouldlog(dns_lctx, LOGLEVEL_PROTOCOL)) { \
+ if (isc_log_wouldlog(LOGLEVEL_PROTOCOL)) { \
char _nbuf[DNS_NAME_FORMATSIZE]; \
char _tbuf[DNS_RDATATYPE_FORMATSIZE]; \
dns_name_format(name, _nbuf, sizeof(_nbuf)); \
return;
}
- if (!isc_log_wouldlog(dns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
dns_name_format(val->name, namebuf, sizeof(namebuf));
dns_rdatatype_format(val->type, typebuf, sizeof(typebuf));
- isc_log_write(dns_lctx, category, module, level,
+ isc_log_write(category, module, level,
"%s%s%s%.*svalidating %s/%s: %s", sep1, viewname,
sep2, depth, spaces, namebuf, typebuf, msgbuf);
} else {
- isc_log_write(dns_lctx, category, module, level,
+ isc_log_write(category, module, level,
"%s%s%s%.*svalidator @%p: %s", sep1, viewname,
sep2, depth, spaces, val, msgbuf);
}
validator_log(void *val, int level, const char *fmt, ...) {
va_list ap;
- if (!isc_log_wouldlog(dns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
status = mdb_env_create(&env);
if (status != MDB_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- ISC_LOGMODULE_OTHER, ISC_LOG_ERROR,
- "mdb_env_create failed: %s",
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, ISC_LOGMODULE_OTHER,
+ ISC_LOG_ERROR, "mdb_env_create failed: %s",
mdb_strerror(status));
CHECK(ISC_R_FAILURE);
}
if (mapsize != 0ULL) {
status = mdb_env_set_mapsize(env, mapsize);
if (status != MDB_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
ISC_LOGMODULE_OTHER, ISC_LOG_ERROR,
"mdb_env_set_mapsize failed: %s",
mdb_strerror(status));
status = mdb_env_open(env, view->new_zone_db, DNS_LMDB_FLAGS, 0600);
if (status != MDB_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- ISC_LOGMODULE_OTHER, ISC_LOG_ERROR,
- "mdb_env_open of '%s' failed: %s",
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, ISC_LOGMODULE_OTHER,
+ ISC_LOG_ERROR, "mdb_env_open of '%s' failed: %s",
view->new_zone_db, mdb_strerror(status));
CHECK(ISC_R_FAILURE);
}
} else {
char nb[DNS_NAME_FORMATSIZE];
dns_name_format(ntaname, nb, sizeof(nb));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
- DNS_LOGMODULE_NTA, ISC_LOG_INFO,
+ isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_NTA,
+ ISC_LOG_INFO,
"ignoring expired NTA at %s", nb);
}
}
char primarytext[ISC_SOCKADDR_FORMATSIZE];
char msgtext[2048];
- if (!isc_log_wouldlog(dns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
vsnprintf(msgtext, sizeof(msgtext), fmt, ap);
va_end(ap);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_XFER_IN, DNS_LOGMODULE_XFER_IN,
- level, "%p: transfer of '%s' from %s: %s", xfr, xfr->info,
+ isc_log_write(DNS_LOGCATEGORY_XFER_IN, DNS_LOGMODULE_XFER_IN, level,
+ "%p: transfer of '%s' from %s: %s", xfr, xfr->info,
primarytext, msgtext);
}
if (remove(zone->journal) < 0 && errno != ENOENT) {
char strbuf[ISC_STRERRORSIZE];
strerror_r(errno, strbuf, sizeof(strbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_ZONE,
ISC_LOG_WARNING,
"unable to remove journal "
algbuf, dst_key_id(pubkey));
}
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_WARNING,
"dns_zone_findkeys: error reading %s: %s",
filename, isc_result_totext(result));
dns_rdataset_clone(kdset, &kfetch->keydataset);
dns_db_attach(db, &kfetch->db);
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(kname, namebuf,
sizeof(namebuf));
REQUIRE(DNS_ZONE_VALID(zone));
- if (!isc_log_wouldlog(dns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
zstr = "zone ";
}
- isc_log_write(dns_lctx, category, DNS_LOGMODULE_ZONE, level,
- "%s%s%s%s: %s", (prefix != NULL ? prefix : ""),
+ isc_log_write(category, DNS_LOGMODULE_ZONE, level, "%s%s%s%s: %s",
+ (prefix != NULL ? prefix : ""),
(prefix != NULL ? ": " : ""), zstr, zone->strnamerd,
message);
}
dns_rdata_t private = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_ZONE, ISC_LOG_DEBUG(3),
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_ZONE,
+ ISC_LOG_DEBUG(3),
"looping through nsec3param data");
nsec3param = isc_mem_get(zone->mctx, sizeof(nsec3param_t));
ISC_LINK_INIT(nsec3param, link);
dns_rdata_t private = DNS_RDATA_INIT;
dns_rdataset_current(&prdataset, &private);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_ZONE, ISC_LOG_DEBUG(3),
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_ZONE,
+ ISC_LOG_DEBUG(3),
"looping through nsec3param private data");
/*
{
char strbuf[ISC_STRERRORSIZE];
strerror_r(errno, strbuf, sizeof(strbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_ZONE,
ISC_LOG_WARNING,
"unable to remove masterfile "
* up-to-date, it is useless and should be
* removed.
*/
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_ZONE, ISC_LOG_DEBUG(3),
"removing journal file");
if (remove(zone->journal) < 0 && errno != ENOENT) {
char strbuf[ISC_STRERRORSIZE];
strerror_r(errno, strbuf, sizeof(strbuf));
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
+ isc_log_write(DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_ZONE,
ISC_LOG_WARNING,
"unable to remove journal "
dnssec_report(const char *format, ...) {
va_list args;
va_start(args, format);
- isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_ZONE,
- ISC_LOG_INFO, format, args);
+ isc_log_vwrite(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_ZONE, ISC_LOG_INFO,
+ format, args);
va_end(args);
}
break;
}
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
char nsnamebuf[DNS_NAME_FORMATSIZE];
dns_name_format(&ns.name, nsnamebuf, sizeof(nsnamebuf));
dns_zone_log(zone, ISC_LOG_DEBUG(3),
goto cleanup;
}
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(&nsfetch->pname, namebuf, sizeof(namebuf));
dnssec_log(zone, ISC_LOG_WARNING,
dns_rdataset_init(&nsfetch->nsrrset);
dns_rdataset_init(&nsfetch->nssigset);
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
dnssec_log(zone, ISC_LOG_DEBUG(3),
"Creating parent NS fetch in "
"nsfetch_levelup()");
dns_name_dup(&zone->origin, zone->mctx, name);
dns_rdataset_init(&nsfetch->nsrrset);
dns_rdataset_init(&nsfetch->nssigset);
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
dnssec_log(
zone, ISC_LOG_DEBUG(3),
"Creating parent NS fetch in zone_checkds()");
}
UNLOCK_ZONE(zone);
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
np->rdata = param;
- if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
unsigned char salttext[255 * 2 + 1];
if (param.salt != NULL) {
salt2text(param.salt, param.salt_length,
sizeof(classstr));
dns_name_format(dns_zone_getorigin(zone), zonename, sizeof(zonename));
level = (result != ISC_R_SUCCESS) ? ISC_LOG_ERROR : ISC_LOG_DEBUG(1);
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_ZONE,
- level, "%s zone '%s/%s'%s%s: %s",
+ isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_ZONE, level,
+ "%s zone '%s/%s'%s%s: %s",
params->freeze ? "freezing" : "thawing", zonename,
classstr, sep, vname, isc_result_totext(result));
if (raw != NULL) {
}
void
-isc_backtrace_log(isc_log_t *lctx, isc_logcategory_t *category,
- isc_logmodule_t *module, int level) {
+isc_backtrace_log(isc_logcategory_t *category, isc_logmodule_t *module,
+ int level) {
void *tracebuf[ISC_BACKTRACE_MAXFRAME];
int nframes;
char **strs;
return;
}
for (int i = 0; i < nframes; i++) {
- isc_log_write(lctx, category, module, level, "%s", strs[i]);
+ isc_log_write(category, module, level, "%s", strs[i]);
}
}
}
void
-isc_backtrace_log(isc_log_t *lctx, isc_logcategory_t *category,
- isc_logmodule_t *module, int level) {
- UNUSED(lctx);
+isc_backtrace_log(isc_logcategory_t *category, isc_logmodule_t *module,
+ int level) {
UNUSED(category);
UNUSED(module);
UNUSED(level);
if (f == NULL) {
result = isc__errno2result(errno);
if (remove(templet) < 0) {
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL,
ISC_LOGMODULE_FILE, ISC_LOG_ERROR,
"remove '%s': failed", templet);
}
*/
void
-isc_backtrace_log(isc_log_t *lctx, isc_logcategory_t *category,
- isc_logmodule_t *module, int level);
+isc_backtrace_log(isc_logcategory_t *category, isc_logmodule_t *module,
+ int level);
/*
* Write a backtrace to the log.
*/
* the order of the names.
*/
extern isc_logcategory_t isc_categories[];
-extern isc_log_t *isc_lctx __attribute__((__deprecated__));
extern isc_logmodule_t isc_modules[];
/*@}*/
ISC_LANG_BEGINDECLS
void
-isc_logconfig_create(isc_log_t *lctx, isc_logconfig_t **lcfgp);
+isc_logconfig_create(isc_logconfig_t **lcfgp);
/*%<
* Create the data structure that holds all of the configurable information
* about where messages are actually supposed to be sent -- the information
*/
isc_logconfig_t *
-isc_logconfig_get(isc_log_t *lctx);
+isc_logconfig_get(void);
void
-isc_logconfig_set(isc_log_t *lctx, isc_logconfig_t *lcfg);
+isc_logconfig_set(isc_logconfig_t *lcfg);
/*%<
* Getter/setter for a configuration with a logging context.
*
*/
void
-isc_log_registercategories(isc_log_t *lctx, isc_logcategory_t categories[]);
+isc_log_registercategories(isc_logcategory_t categories[]);
/*%<
* Identify logging categories a library will use.
*
*/
void
-isc_log_registermodules(isc_log_t *lctx, isc_logmodule_t modules[]);
+isc_log_registermodules(isc_logmodule_t modules[]);
/*%<
* Identify logging categories a library will use.
*
* meaningful error.
*/
void
-isc_log_write(isc_log_t *lctx, isc_logcategory_t *category,
- isc_logmodule_t *module, int level, const char *format, ...)
+isc_log_write(isc_logcategory_t *category, isc_logmodule_t *module, int level,
+ const char *format, ...)
- ISC_FORMAT_PRINTF(5, 6);
+ ISC_FORMAT_PRINTF(4, 5);
/*%
* Write a message to the log channels.
* meaningful error.
*/
void
-isc_log_vwrite(isc_log_t *lctx, isc_logcategory_t *category,
- isc_logmodule_t *module, int level, const char *format,
- va_list args)
+isc_log_vwrite(isc_logcategory_t *category, isc_logmodule_t *module, int level,
+ const char *format, va_list args)
- ISC_FORMAT_PRINTF(5, 0);
+ ISC_FORMAT_PRINTF(4, 0);
void
-isc_log_setdebuglevel(isc_log_t *lctx, unsigned int level);
+isc_log_setdebuglevel(unsigned int level);
/*%<
* Set the debugging level used for logging.
*
*/
unsigned int
-isc_log_getdebuglevel(isc_log_t *lctx);
+isc_log_getdebuglevel(void);
/*%<
* Get the current debugging level.
*
*/
bool
-isc_log_wouldlog(isc_log_t *lctx, int level);
+isc_log_wouldlog(int level);
/*%<
* Determine whether logging something to 'lctx' at 'level' would
* actually cause something to be logged somewhere.
*/
void
-isc_log_closefilelogs(isc_log_t *lctx);
+isc_log_closefilelogs(void);
/*%<
* Close all open files used by #ISC_LOG_TOFILE channels.
*
*/
isc_logcategory_t *
-isc_log_categorybyname(isc_log_t *lctx, const char *name);
+isc_log_categorybyname(const char *name);
/*%<
* Find a category by its name.
*
*/
isc_logmodule_t *
-isc_log_modulebyname(isc_log_t *lctx, const char *name);
+isc_log_modulebyname(const char *name);
/*%<
* Find a module by its name.
*
typedef struct isc_interface isc_interface_t; /*%< Interface */
typedef struct isc_interfaceiter isc_interfaceiter_t; /*%< Interface Iterator */
typedef struct isc_lex isc_lex_t; /*%< Lex */
-typedef struct isc_log isc_log_t; /*%< Log */
typedef struct isc_logcategory isc_logcategory_t; /*%< Log Category */
typedef struct isc_logconfig isc_logconfig_t; /*%< Log Configuration */
typedef struct isc_logmodule isc_logmodule_t; /*%< Log Module */
*/
#define LOG_BUFFER_SIZE (8 * 1024)
+/*
+ * Private isc_log_t data type.
+ */
+typedef struct isc_log isc_log_t;
+
/*!
* This is the structure that holds each named channel. A simple linked
* list chains all of the channels together, so an individual channel is
/*!
* libisc logs to this context.
*/
-isc_log_t *isc_lctx __attribute__((__deprecated__)) = NULL;
static isc_log_t *isc__lctx = NULL;
/*!
sync_channellist(isc_logconfig_t *lcfg);
static void
-sync_highest_level(isc_log_t *__lctx ISC_ATTR_UNUSED, isc_logconfig_t *lcfg);
+sync_highest_level(isc_logconfig_t *lcfg);
static isc_result_t
greatest_version(isc_logfile_t *file, int versions, int *greatest);
static void
-isc_log_doit(isc_log_t *__lctx ISC_ATTR_UNUSED, isc_logcategory_t *category,
- isc_logmodule_t *module, int level, const char *format,
- va_list args) ISC_FORMAT_PRINTF(5, 0);
+isc_log_doit(isc_logcategory_t *category, isc_logmodule_t *module, int level,
+ const char *format, va_list args) ISC_FORMAT_PRINTF(4, 0);
/*@{*/
/*!
****/
void
-isc_logconfig_create(isc_log_t *__lctx ISC_ATTR_UNUSED,
- isc_logconfig_t **lcfgp) {
+isc_logconfig_create(isc_logconfig_t **lcfgp) {
REQUIRE(lcfgp != NULL && *lcfgp == NULL);
REQUIRE(VALID_CONTEXT(isc__lctx));
}
isc_logconfig_t *
-isc_logconfig_get(isc_log_t *__lctx ISC_ATTR_UNUSED) {
+isc_logconfig_get(void) {
REQUIRE(VALID_CONTEXT(isc__lctx));
return (rcu_dereference(isc__lctx->logconfig));
}
void
-isc_logconfig_set(isc_log_t *__lctx ISC_ATTR_UNUSED, isc_logconfig_t *lcfg) {
+isc_logconfig_set(isc_logconfig_t *lcfg) {
REQUIRE(VALID_CONTEXT(isc__lctx));
REQUIRE(VALID_CONFIG(lcfg));
REQUIRE(lcfg->lctx == isc__lctx);
isc_logconfig_t *old_cfg = rcu_xchg_pointer(&isc__lctx->logconfig,
lcfg);
- sync_highest_level(isc__lctx, lcfg);
+ sync_highest_level(lcfg);
synchronize_rcu();
if (old_cfg != NULL) {
}
void
-isc_log_registercategories(isc_log_t *__lctx ISC_ATTR_UNUSED,
- isc_logcategory_t categories[]) {
+isc_log_registercategories(isc_logcategory_t categories[]) {
REQUIRE(VALID_CONTEXT(isc__lctx));
REQUIRE(categories != NULL && categories[0].name != NULL);
}
isc_logcategory_t *
-isc_log_categorybyname(isc_log_t *__lctx ISC_ATTR_UNUSED, const char *name) {
+isc_log_categorybyname(const char *name) {
isc_logcategory_t *catp;
REQUIRE(VALID_CONTEXT(isc__lctx));
}
void
-isc_log_registermodules(isc_log_t *__lctx ISC_ATTR_UNUSED,
- isc_logmodule_t modules[]) {
+isc_log_registermodules(isc_logmodule_t modules[]) {
REQUIRE(VALID_CONTEXT(isc__lctx));
REQUIRE(modules != NULL && modules[0].name != NULL);
}
isc_logmodule_t *
-isc_log_modulebyname(isc_log_t *__lctx ISC_ATTR_UNUSED, const char *name) {
+isc_log_modulebyname(const char *name) {
isc_logmodule_t *modp;
REQUIRE(VALID_CONTEXT(isc__lctx));
*/
rcu_read_lock();
if (rcu_dereference(lcfg->lctx->logconfig) == lcfg) {
- sync_highest_level(lctx, lcfg);
+ sync_highest_level(lcfg);
}
rcu_read_unlock();
}
void
-isc_log_write(isc_log_t *__lctx ISC_ATTR_UNUSED, isc_logcategory_t *category,
- isc_logmodule_t *module, int level, const char *format, ...) {
+isc_log_write(isc_logcategory_t *category, isc_logmodule_t *module, int level,
+ const char *format, ...) {
va_list args;
/*
*/
va_start(args, format);
- isc_log_doit(NULL, category, module, level, format, args);
+ isc_log_doit(category, module, level, format, args);
va_end(args);
}
void
-isc_log_vwrite(isc_log_t *__lctx ISC_ATTR_UNUSED, isc_logcategory_t *category,
- isc_logmodule_t *module, int level, const char *format,
- va_list args) {
+isc_log_vwrite(isc_logcategory_t *category, isc_logmodule_t *module, int level,
+ const char *format, va_list args) {
/*
* Contract checking is done in isc_log_doit().
*/
- isc_log_doit(NULL, category, module, level, format, args);
+ isc_log_doit(category, module, level, format, args);
}
void
-isc_log_setdebuglevel(isc_log_t *__lctx ISC_ATTR_UNUSED, unsigned int level) {
+isc_log_setdebuglevel(unsigned int level) {
REQUIRE(VALID_CONTEXT(isc__lctx));
atomic_store_release(&isc__lctx->debug_level, level);
}
unsigned int
-isc_log_getdebuglevel(isc_log_t *__lctx ISC_ATTR_UNUSED) {
+isc_log_getdebuglevel(void) {
REQUIRE(VALID_CONTEXT(isc__lctx));
return (atomic_load_acquire(&isc__lctx->debug_level));
}
void
-isc_log_closefilelogs(isc_log_t *__lctx ISC_ATTR_UNUSED) {
+isc_log_closefilelogs(void) {
REQUIRE(VALID_CONTEXT(isc__lctx));
rcu_read_lock();
}
static void
-sync_highest_level(isc_log_t *__lctx ISC_ATTR_UNUSED, isc_logconfig_t *lcfg) {
+sync_highest_level(isc_logconfig_t *lcfg) {
atomic_store(&isc__lctx->highest_level, lcfg->highest_level);
atomic_store(&isc__lctx->dynamic, lcfg->dynamic);
}
}
ISC_NO_SANITIZE_THREAD bool
-isc_log_wouldlog(isc_log_t *__lctx ISC_ATTR_UNUSED, int level) {
+isc_log_wouldlog(int level) {
/*
* Try to avoid locking the mutex for messages which can't
* possibly be logged to any channels -- primarily debugging
}
static void
-isc_log_doit(isc_log_t *__lctx ISC_ATTR_UNUSED, isc_logcategory_t *category,
- isc_logmodule_t *module, int level, const char *format,
- va_list args) {
+isc_log_doit(isc_logcategory_t *category, isc_logmodule_t *module, int level,
+ const char *format, va_list args) {
int syslog_level;
const char *time_string;
char local_time[64];
REQUIRE(category->id < isc__lctx->category_count);
REQUIRE(module->id < isc__lctx->module_count);
- if (!isc_log_wouldlog(isc__lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
isc_mutex_init(&isc__lctx->lock);
- isc_log_registercategories(isc__lctx, isc_categories);
- isc_log_registermodules(isc__lctx, isc_modules);
+ isc_log_registercategories(isc_categories);
+ isc_log_registermodules(isc_modules);
/* Create default logging configuration */
isc_logconfig_t *lcfg = NULL;
- isc_logconfig_create(isc__lctx, &lcfg);
+ isc_logconfig_create(&lcfg);
sync_channellist(lcfg);
atomic_init(&isc__lctx->highest_level, lcfg->highest_level);
isc_loopmgr_pause(isc_loopmgr_t *loopmgr) {
REQUIRE(VALID_LOOPMGR(loopmgr));
- if (isc_log_wouldlog(isc_lctx, ISC_LOG_DEBUG(1))) {
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
- ISC_LOGMODULE_OTHER, ISC_LOG_DEBUG(1),
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
+ isc_log_write(ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_OTHER,
+ ISC_LOG_DEBUG(1),
"loop exclusive mode: starting");
}
&(bool){ false }, true));
pause_loop(CURRENT_LOOP(loopmgr));
- if (isc_log_wouldlog(isc_lctx, ISC_LOG_DEBUG(1))) {
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
- ISC_LOGMODULE_OTHER, ISC_LOG_DEBUG(1),
- "loop exclusive mode: started");
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
+ isc_log_write(ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_OTHER,
+ ISC_LOG_DEBUG(1), "loop exclusive mode: started");
}
}
isc_loopmgr_resume(isc_loopmgr_t *loopmgr) {
REQUIRE(VALID_LOOPMGR(loopmgr));
- if (isc_log_wouldlog(isc_lctx, ISC_LOG_DEBUG(1))) {
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
- ISC_LOGMODULE_OTHER, ISC_LOG_DEBUG(1),
- "loop exclusive mode: ending");
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
+ isc_log_write(ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_OTHER,
+ ISC_LOG_DEBUG(1), "loop exclusive mode: ending");
}
RUNTIME_CHECK(atomic_compare_exchange_strong(&loopmgr->paused,
&(bool){ true }, false));
resume_loop(CURRENT_LOOP(loopmgr));
- if (isc_log_wouldlog(isc_lctx, ISC_LOG_DEBUG(1))) {
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
- ISC_LOGMODULE_OTHER, ISC_LOG_DEBUG(1),
- "loop exclusive mode: ended");
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
+ isc_log_write(ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_OTHER,
+ ISC_LOG_DEBUG(1), "loop exclusive mode: ended");
}
}
len = sizeof(sin6);
if (getsockname(s, (struct sockaddr *)&sin6, (void *)&len) < 0)
{
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL,
ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
"retrieving the address of an IPv6 "
"socket from the kernel failed.");
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL,
ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
"IPv6 is not supported.");
result = ISC_R_NOTFOUND;
if (len == sizeof(struct sockaddr_in6)) {
result = ISC_R_SUCCESS;
} else {
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL,
ISC_LOGMODULE_SOCKET,
ISC_LOG_ERROR,
"IPv6 structures in kernel and "
"user space do not match.");
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL,
ISC_LOGMODULE_SOCKET,
ISC_LOG_ERROR,
"IPv6 is not supported.");
char client_sabuf[ISC_SOCKADDR_FORMATSIZE];
char local_sabuf[ISC_SOCKADDR_FORMATSIZE];
- if (!isc_log_wouldlog(isc_lctx, log_level)) {
+ if (!isc_log_wouldlog(log_level)) {
return;
}
int r = uv_tcp_close_reset(&sock->uv_handle.tcp,
reset_shutdown);
if (r != 0) {
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL,
ISC_LOGMODULE_NETMGR, ISC_LOG_DEBUG(1),
"TCP Reset (RST) failed: %s",
uv_strerror(r));
REQUIRE(tls != NULL);
- if (!isc_log_wouldlog(isc_lctx, log_level)) {
+ if (!isc_log_wouldlog(log_level)) {
return;
};
char msgbuf[2048];
va_list ap;
- if (!isc_log_wouldlog(isc_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
vsnprintf(msgbuf, sizeof(msgbuf), fmt, ap);
va_end(ap);
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_DEFAULT, ISC_LOGMODULE_NETMGR,
- level, "netmgr %p: %s", netmgr, msgbuf);
+ isc_log_write(ISC_LOGCATEGORY_DEFAULT, ISC_LOGMODULE_NETMGR, level,
+ "netmgr %p: %s", netmgr, msgbuf);
}
void
char msgbuf[2048];
va_list ap;
- if (!isc_log_wouldlog(isc_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
vsnprintf(msgbuf, sizeof(msgbuf), fmt, ap);
va_end(ap);
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_DEFAULT, ISC_LOGMODULE_NETMGR,
- level, "socket %p: %s", sock, msgbuf);
+ isc_log_write(ISC_LOGCATEGORY_DEFAULT, ISC_LOGMODULE_NETMGR, level,
+ "socket %p: %s", sock, msgbuf);
}
void
char msgbuf[2048];
va_list ap;
- if (!isc_log_wouldlog(isc_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
const char *real_addresses_msg =
"real source and destination addresses are used";
- if (!isc_log_wouldlog(isc_lctx, log_level)) {
+ if (!isc_log_wouldlog(log_level)) {
return;
}
real_peer_fmt, real_local_fmt, proto);
if (cmd == ISC_PROXY2_CMD_LOCAL) {
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_DEFAULT,
- ISC_LOGMODULE_NETMGR, log_level,
- "%s: command: LOCAL (%s)", common_msg,
+ isc_log_write(ISC_LOGCATEGORY_DEFAULT, ISC_LOGMODULE_NETMGR,
+ log_level, "%s: command: LOCAL (%s)", common_msg,
real_addresses_msg);
return;
} else if (cmd == ISC_PROXY2_CMD_PROXY) {
switch (socktype) {
case 0:
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_DEFAULT,
+ isc_log_write(ISC_LOGCATEGORY_DEFAULT,
ISC_LOGMODULE_NETMGR, log_level,
"%s: command: PROXY (unspecified address "
"and socket type, %s)",
dst_addr_msg = dst_addr_fmt;
}
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_DEFAULT,
- ISC_LOGMODULE_NETMGR, log_level,
+ isc_log_write(ISC_LOGCATEGORY_DEFAULT, ISC_LOGMODULE_NETMGR,
+ log_level,
"%s: command: PROXY, socket type: %s, source: "
"%s, destination: %s, TLVs: %s",
common_msg, socktype_name, src_addr_msg,
}
}
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_NETMGR,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_NETMGR,
ISC_LOG_DEBUG(3),
"throttling TCP connection, the other side is not "
"reading the data, switching to uv_write()");
*/
static void
sslkeylogfile_append(const SSL *ssl ISC_ATTR_UNUSED, const char *line) {
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_SSLKEYLOG, ISC_LOGMODULE_NETMGR,
+ isc_log_write(ISC_LOGCATEGORY_SSLKEYLOG, ISC_LOGMODULE_NETMGR,
ISC_LOG_INFO, "%s", line);
}
ssl_error:
err = ERR_get_error();
ERR_error_string_n(err, errbuf, sizeof(errbuf));
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_NETMGR,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_NETMGR,
ISC_LOG_ERROR, "Error initializing TLS context: %s",
errbuf);
ssl_error:
err = ERR_get_error();
ERR_error_string_n(err, errbuf, sizeof(errbuf));
- isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_NETMGR,
+ isc_log_write(ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_NETMGR,
ISC_LOG_ERROR, "Error initializing TLS context: %s",
errbuf);
goto done;
}
- isc_log_write(isc_lctx, category, module, ISC_LOG_WARNING,
+ isc_log_write(category, module, ISC_LOG_WARNING,
"%s (%s:%d) failed (%s)", funcname, file, line,
isc_result_totext(result));
char buf[256];
ERR_error_string_n(err, buf, sizeof(buf));
- isc_log_write(isc_lctx, category, module, ISC_LOG_INFO,
- "%s:%s:%d:%s", buf, file, line,
+ isc_log_write(category, module, ISC_LOG_INFO, "%s:%s:%d:%s",
+ buf, file, line,
((flags & ERR_TXT_STRING) != 0) ? data : "");
}
static isc_result_t
convert_named_acl(const cfg_obj_t *nameobj, const cfg_obj_t *cctx,
- isc_log_t *lctx, cfg_aclconfctx_t *ctx, isc_mem_t *mctx,
+ cfg_aclconfctx_t *ctx, isc_mem_t *mctx,
unsigned int nest_level, dns_acl_t **target) {
isc_result_t result;
const cfg_obj_t *cacl = NULL;
{
if (strcasecmp(aclname, dacl->name) == 0) {
if (ISC_MAGIC_VALID(dacl, LOOP_MAGIC)) {
- cfg_obj_log(nameobj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(nameobj, ISC_LOG_ERROR,
"acl loop detected: %s", aclname);
return (ISC_R_FAILURE);
}
/* Not yet converted. Convert now. */
result = get_acl_def(cctx, aclname, &cacl);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(nameobj, lctx, ISC_LOG_WARNING,
- "undefined ACL '%s'", aclname);
+ cfg_obj_log(nameobj, ISC_LOG_WARNING, "undefined ACL '%s'",
+ aclname);
return (result);
}
/*
loop.name = UNCONST(aclname);
loop.magic = LOOP_MAGIC;
ISC_LIST_APPEND(ctx->named_acl_cache, &loop, nextincache);
- result = cfg_acl_fromconfig(cacl, cctx, lctx, ctx, mctx, nest_level,
- &dacl);
+ result = cfg_acl_fromconfig(cacl, cctx, ctx, mctx, nest_level, &dacl);
ISC_LIST_UNLINK(ctx->named_acl_cache, &loop, nextincache);
loop.magic = 0;
loop.name = NULL;
}
static isc_result_t
-convert_keyname(const cfg_obj_t *keyobj, isc_log_t *lctx, isc_mem_t *mctx,
- dns_name_t *dnsname) {
+convert_keyname(const cfg_obj_t *keyobj, isc_mem_t *mctx, dns_name_t *dnsname) {
isc_result_t result;
isc_buffer_t buf;
dns_fixedname_t fixname;
result = dns_name_fromtext(dns_fixedname_name(&fixname), &buf,
dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(keyobj, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(keyobj, ISC_LOG_WARNING,
"key name '%s' is not a valid domain name",
txtname);
return (result);
*/
static isc_result_t
count_acl_elements(const cfg_obj_t *caml, const cfg_obj_t *cctx,
- isc_log_t *lctx, cfg_aclconfctx_t *ctx, isc_mem_t *mctx,
- uint32_t *count, bool *has_negative) {
+ cfg_aclconfctx_t *ctx, isc_mem_t *mctx, uint32_t *count,
+ bool *has_negative) {
const cfg_listelt_t *elt;
isc_result_t result;
uint32_t n = 0;
} else if (cfg_obj_islist(ce)) {
bool negative;
uint32_t sub;
- result = count_acl_elements(ce, cctx, lctx, ctx, mctx,
- &sub, &negative);
+ result = count_acl_elements(ce, cctx, ctx, mctx, &sub,
+ &negative);
if (result != ISC_R_SUCCESS) {
return (result);
}
* Convert any named acls we reference now if
* they have not already been converted.
*/
- result = convert_named_acl(ce, cctx, lctx, ctx,
- mctx, 0, &inneracl);
+ result = convert_named_acl(ce, cctx, ctx, mctx,
+ 0, &inneracl);
if (result == ISC_R_SUCCESS) {
if (inneracl->has_negatives) {
n++;
#if defined(HAVE_GEOIP2)
static dns_geoip_subtype_t
-get_subtype(const cfg_obj_t *obj, isc_log_t *lctx, dns_geoip_subtype_t subtype,
+get_subtype(const cfg_obj_t *obj, dns_geoip_subtype_t subtype,
const char *dbname) {
if (dbname == NULL) {
return (subtype);
} else if (strcasecmp(dbname, "country") == 0) {
return (dns_geoip_country_code);
}
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"invalid database specified for "
"country search: ignored");
return (subtype);
} else if (strcasecmp(dbname, "country") == 0) {
return (dns_geoip_country_name);
}
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"invalid database specified for "
"country search: ignored");
return (subtype);
} else if (strcasecmp(dbname, "country") == 0) {
return (dns_geoip_country_continentcode);
}
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"invalid database specified for "
"continent search: ignored");
return (subtype);
} else if (strcasecmp(dbname, "country") == 0) {
return (dns_geoip_country_continent);
}
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"invalid database specified for "
"continent search: ignored");
return (subtype);
if (strcasecmp(dbname, "city") == 0) {
return (dns_geoip_city_region);
}
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"invalid database specified for "
"region/subdivision search: ignored");
return (subtype);
if (strcasecmp(dbname, "city") == 0) {
return (dns_geoip_city_regionname);
}
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"invalid database specified for "
"region/subdivision search: ignored");
return (subtype);
case dns_geoip_city_areacode:
case dns_geoip_city_timezonecode:
if (strcasecmp(dbname, "city") != 0) {
- cfg_obj_log(obj, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"invalid database specified for "
"a 'city'-only search type: ignoring");
}
return (subtype);
case dns_geoip_isp_name:
if (strcasecmp(dbname, "isp") != 0) {
- cfg_obj_log(obj, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"invalid database specified for "
"an 'isp' search: ignoring");
}
return (subtype);
case dns_geoip_org_name:
if (strcasecmp(dbname, "org") != 0) {
- cfg_obj_log(obj, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"invalid database specified for "
"an 'org' search: ignoring");
}
return (subtype);
case dns_geoip_as_asnum:
if (strcasecmp(dbname, "asnum") != 0) {
- cfg_obj_log(obj, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"invalid database specified for "
"an 'asnum' search: ignoring");
}
return (subtype);
case dns_geoip_domain_name:
if (strcasecmp(dbname, "domain") != 0) {
- cfg_obj_log(obj, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"invalid database specified for "
"a 'domain' search: ignoring");
}
return (subtype);
case dns_geoip_netspeed_id:
if (strcasecmp(dbname, "netspeed") != 0) {
- cfg_obj_log(obj, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"invalid database specified for "
"a 'netspeed' search: ignoring");
}
}
static isc_result_t
-parse_geoip_element(const cfg_obj_t *obj, isc_log_t *lctx,
- cfg_aclconfctx_t *ctx, dns_aclelement_t *dep) {
+parse_geoip_element(const cfg_obj_t *obj, cfg_aclconfctx_t *ctx,
+ dns_aclelement_t *dep) {
const cfg_obj_t *ge;
const char *dbname = NULL;
const char *stype = NULL, *search = NULL;
}
}
if (geoip_dbnames[i] == NULL) {
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"database '%s' is not defined for GeoIP2",
dbname);
return (ISC_R_UNEXPECTED);
len = strlen(search);
if (len == 0) {
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"zero-length geoip search field");
return (ISC_R_FAILURE);
}
sizeof(de.geoip_elem.as_string));
} else if (strcasecmp(stype, "country") == 0 && len == 3) {
/* Three-letter country code */
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"three-letter country codes are unavailable "
"in GeoIP2 databases");
return (ISC_R_FAILURE);
strlcpy(de.geoip_elem.as_string, search,
sizeof(de.geoip_elem.as_string));
} else {
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"geoiop postal code (%s) too long", search);
return (ISC_R_FAILURE);
}
strlcpy(de.geoip_elem.as_string, search,
sizeof(de.geoip_elem.as_string));
} else {
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"type '%s' is unavailable "
"in GeoIP2 databases",
stype);
return (ISC_R_FAILURE);
}
- de.geoip_elem.subtype = get_subtype(obj, lctx, subtype, dbname);
+ de.geoip_elem.subtype = get_subtype(obj, subtype, dbname);
if (!geoip_can_answer(&de, ctx)) {
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"no GeoIP2 database installed which can answer "
"queries of type '%s'",
stype);
isc_result_t
cfg_acl_fromconfig(const cfg_obj_t *acl_data, const cfg_obj_t *cctx,
- isc_log_t *lctx, cfg_aclconfctx_t *ctx, isc_mem_t *mctx,
+ cfg_aclconfctx_t *ctx, isc_mem_t *mctx,
unsigned int nest_level, dns_acl_t **target) {
isc_result_t result;
dns_acl_t *dacl = NULL, *inneracl = NULL;
uint32_t nelem;
if (nest_level == 0) {
- result = count_acl_elements(caml, cctx, lctx, ctx, mctx,
+ result = count_acl_elements(caml, cctx, ctx, mctx,
&nelem, NULL);
if (result != ISC_R_SUCCESS) {
return (result);
if (result != ISC_R_SUCCESS) {
char buf[ISC_NETADDR_FORMATSIZE + 1];
isc_netaddr_format(&addr, buf, sizeof(buf));
- cfg_obj_log(ce, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(ce, ISC_LOG_ERROR,
"'%s/%u': address/prefix length "
"mismatch",
buf, bitlen);
if (inneracl != NULL) {
dns_acl_detach(&inneracl);
}
- result = cfg_acl_fromconfig(ce, cctx, lctx, ctx, mctx,
+ result = cfg_acl_fromconfig(ce, cctx, ctx, mctx,
new_nest_level, &inneracl);
if (result != ISC_R_SUCCESS) {
goto cleanup;
de->type = dns_aclelementtype_keyname;
de->negative = neg;
dns_name_init(&de->keyname, NULL);
- result = convert_keyname(ce, lctx, mctx, &de->keyname);
+ result = convert_keyname(ce, mctx, &de->keyname);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
cfg_obj_isvoid(cfg_tuple_get(ce, "negated")))
{
INSIST(dacl->length < dacl->alloc);
- result = parse_geoip_element(ce, lctx, ctx, de);
+ result = parse_geoip_element(ce, ctx, de);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
* This call should just find the cached
* of the named acl.
*/
- result = convert_named_acl(ce, cctx, lctx, ctx,
- mctx, new_nest_level,
+ result = convert_named_acl(ce, cctx, ctx, mctx,
+ new_nest_level,
&inneracl);
if (result != ISC_R_SUCCESS) {
goto cleanup;
goto nested_acl;
}
} else {
- cfg_obj_log(ce, lctx, ISC_LOG_WARNING,
+ cfg_obj_log(ce, ISC_LOG_WARNING,
"address match list contains "
"unsupported element type");
result = ISC_R_FAILURE;
static in_port_t dnsport = 53;
static isc_result_t
-fileexist(const cfg_obj_t *obj, isc_symtab_t *symtab, bool writeable,
- isc_log_t *logctxlogc);
+fileexist(const cfg_obj_t *obj, isc_symtab_t *symtab, bool writeable);
static isc_result_t
keydirexist(const cfg_obj_t *zcgf, const char *optname, dns_name_t *zname,
const char *dirname, const char *kaspnamestr, isc_symtab_t *symtab,
- isc_log_t *logctx, isc_mem_t *mctx);
+ isc_mem_t *mctx);
static const cfg_obj_t *
find_maplist(const cfg_obj_t *config, const char *listname, const char *name);
}
static isc_result_t
-check_orderent(const cfg_obj_t *ent, isc_log_t *logctx) {
+check_orderent(const cfg_obj_t *ent) {
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
isc_textregion_t r;
r.length = strlen(r.base);
tresult = dns_rdataclass_fromtext(&rdclass, &r);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"rrset-order: invalid class '%s'", r.base);
if (result == ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
r.length = strlen(r.base);
tresult = dns_rdatatype_fromtext(&rdtype, &r);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"rrset-order: invalid type '%s'", r.base);
if (result == ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
tresult = dns_name_fromtext(dns_fixedname_name(&fixed), &b,
dns_rootname, 0, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"rrset-order: invalid name '%s'", str);
if (result == ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
if (!cfg_obj_isstring(obj) ||
strcasecmp("order", cfg_obj_asstring(obj)) != 0)
{
- cfg_obj_log(ent, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(ent, ISC_LOG_ERROR,
"rrset-order: keyword 'order' missing");
if (result == ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
obj = cfg_tuple_get(ent, "ordering");
if (!cfg_obj_isstring(obj)) {
- cfg_obj_log(ent, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(ent, ISC_LOG_ERROR,
"rrset-order: missing ordering");
if (result == ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
} else if (strcasecmp(cfg_obj_asstring(obj), "fixed") == 0) {
#if DNS_RDATASET_FIXED
if ((ent->pctx->flags & CFG_PCTX_NODEPRECATED) == 0) {
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"rrset-order: order 'fixed' is deprecated");
}
#else
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"rrset-order: order 'fixed' was disabled at "
"compilation time");
#endif /* if !DNS_RDATASET_FIXED */
strcasecmp(cfg_obj_asstring(obj), "cyclic") != 0 &&
strcasecmp(cfg_obj_asstring(obj), "none") != 0)
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"rrset-order: invalid order '%s'",
cfg_obj_asstring(obj));
if (result == ISC_R_SUCCESS) {
}
static isc_result_t
-check_order(const cfg_obj_t *options, isc_log_t *logctx) {
+check_order(const cfg_obj_t *options) {
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
const cfg_listelt_t *element;
for (element = cfg_list_first(obj); element != NULL;
element = cfg_list_next(element))
{
- tresult = check_orderent(cfg_listelt_value(element), logctx);
+ tresult = check_orderent(cfg_listelt_value(element));
if (result == ISC_R_SUCCESS && tresult != ISC_R_SUCCESS) {
result = tresult;
}
}
static isc_result_t
-check_dual_stack(const cfg_obj_t *options, isc_log_t *logctx) {
+check_dual_stack(const cfg_obj_t *options) {
const cfg_listelt_t *element;
const cfg_obj_t *alternates = NULL;
const cfg_obj_t *value;
if (cfg_obj_isuint32(obj)) {
uint32_t val = cfg_obj_asuint32(obj);
if (val > UINT16_MAX) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"port '%u' out of range", val);
if (result == ISC_R_SUCCESS) {
result = ISC_R_RANGE;
tresult = dns_name_fromtext(name, &buffer, dns_rootname, 0,
NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR, "bad name '%s'",
- str);
+ cfg_obj_log(obj, ISC_LOG_ERROR, "bad name '%s'", str);
if (result == ISC_R_SUCCESS) {
result = tresult;
}
if (cfg_obj_isuint32(obj)) {
uint32_t val = cfg_obj_asuint32(obj);
if (val > UINT16_MAX) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"port '%u' out of range", val);
if (result == ISC_R_SUCCESS) {
result = ISC_R_RANGE;
}
static isc_result_t
-validate_tls(const cfg_obj_t *config, const cfg_obj_t *obj, isc_log_t *logctx,
- const char *str) {
+validate_tls(const cfg_obj_t *config, const cfg_obj_t *obj, const char *str) {
dns_fixedname_t fname;
dns_name_t *nm = dns_fixedname_initname(&fname);
isc_result_t result = dns_name_fromstring(nm, str, dns_rootname, 0,
NULL);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
- "'%s' is not a valid name", str);
+ cfg_obj_log(obj, ISC_LOG_ERROR, "'%s' is not a valid name",
+ str);
return (result);
}
const cfg_obj_t *tlsmap = find_maplist(config, "tls", str);
if (tlsmap == NULL) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"tls '%s' is not defined", str);
return (ISC_R_FAILURE);
}
static isc_result_t
check_forward(const cfg_obj_t *config, const cfg_obj_t *options,
- const cfg_obj_t *global, isc_log_t *logctx) {
+ const cfg_obj_t *global) {
const cfg_obj_t *forward = NULL;
const cfg_obj_t *forwarders = NULL;
const cfg_obj_t *faddresses = NULL;
if (forwarders != NULL && global != NULL) {
const char *file = cfg_obj_file(global);
unsigned int line = cfg_obj_line(global);
- cfg_obj_log(forwarders, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(forwarders, ISC_LOG_ERROR,
"forwarders declared in root zone and "
"in general configuration: %s:%u",
file, line);
return (ISC_R_FAILURE);
}
if (forward != NULL && forwarders == NULL) {
- cfg_obj_log(forward, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(forward, ISC_LOG_ERROR,
"no matching 'forwarders' statement");
return (ISC_R_FAILURE);
}
if (tlspobj != NULL && cfg_obj_isstring(tlspobj)) {
const char *tls = cfg_obj_asstring(tlspobj);
if (tls != NULL) {
- result = validate_tls(config, tlspobj, logctx,
- tls);
+ result = validate_tls(config, tlspobj, tls);
if (result != ISC_R_SUCCESS) {
return (result);
}
const cfg_obj_t *forwarder = cfg_listelt_value(element);
const char *tls = cfg_obj_getsockaddrtls(forwarder);
if (tls != NULL) {
- result = validate_tls(config, faddresses,
- logctx, tls);
+ result = validate_tls(config, faddresses, tls);
if (result != ISC_R_SUCCESS) {
return (result);
}
}
static isc_result_t
-disabled_algorithms(const cfg_obj_t *disabled, isc_log_t *logctx) {
+disabled_algorithms(const cfg_obj_t *disabled) {
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
const cfg_listelt_t *element;
isc_buffer_add(&b, strlen(str));
tresult = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR, "bad domain name '%s'",
- str);
+ cfg_obj_log(obj, ISC_LOG_ERROR, "bad domain name '%s'", str);
result = tresult;
}
tresult = dns_secalg_fromtext(&alg, &r);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(cfg_listelt_value(element), logctx,
- ISC_LOG_ERROR, "invalid algorithm '%s'",
- r.base);
+ cfg_obj_log(cfg_listelt_value(element), ISC_LOG_ERROR,
+ "invalid algorithm '%s'", r.base);
result = tresult;
}
}
}
static isc_result_t
-disabled_ds_digests(const cfg_obj_t *disabled, isc_log_t *logctx) {
+disabled_ds_digests(const cfg_obj_t *disabled) {
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
const cfg_listelt_t *element;
isc_buffer_add(&b, strlen(str));
tresult = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR, "bad domain name '%s'",
- str);
+ cfg_obj_log(obj, ISC_LOG_ERROR, "bad domain name '%s'", str);
result = tresult;
}
/* works with a numeric argument too */
tresult = dns_dsdigest_fromtext(&digest, &r);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(cfg_listelt_value(element), logctx,
- ISC_LOG_ERROR, "invalid digest type '%s'",
- r.base);
+ cfg_obj_log(cfg_listelt_value(element), ISC_LOG_ERROR,
+ "invalid digest type '%s'", r.base);
result = tresult;
}
}
static isc_result_t
exists(const cfg_obj_t *obj, const char *name, int value, isc_symtab_t *symtab,
- const char *fmt, isc_log_t *logctx, isc_mem_t *mctx) {
+ const char *fmt, isc_mem_t *mctx) {
char *key;
const char *file;
unsigned int line;
if (file == NULL) {
file = "<unknown file>";
}
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR, fmt, key, file, line);
+ cfg_obj_log(obj, ISC_LOG_ERROR, fmt, key, file, line);
isc_mem_free(mctx, key);
result = ISC_R_EXISTS;
}
}
static isc_result_t
-mustbesecure(const cfg_obj_t *secure, isc_symtab_t *symtab, isc_log_t *logctx,
- isc_mem_t *mctx) {
+mustbesecure(const cfg_obj_t *secure, isc_symtab_t *symtab, isc_mem_t *mctx) {
const cfg_obj_t *obj;
char namebuf[DNS_NAME_FORMATSIZE];
const char *str;
isc_buffer_add(&b, strlen(str));
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR, "bad domain name '%s'",
- str);
+ cfg_obj_log(obj, ISC_LOG_ERROR, "bad domain name '%s'", str);
} else {
dns_name_format(name, namebuf, sizeof(namebuf));
result = exists(secure, namebuf, 1, symtab,
"dnssec-must-be-secure '%s': already exists "
"previous definition: %s:%u",
- logctx, mctx);
+ mctx);
}
return (result);
}
static isc_result_t
checkacl(const char *aclname, cfg_aclconfctx_t *actx, const cfg_obj_t *zconfig,
- const cfg_obj_t *voptions, const cfg_obj_t *config, isc_log_t *logctx,
- isc_mem_t *mctx) {
+ const cfg_obj_t *voptions, const cfg_obj_t *config, isc_mem_t *mctx) {
isc_result_t result;
const cfg_obj_t *aclobj = NULL;
const cfg_obj_t *options;
if (aclobj == NULL) {
return (ISC_R_SUCCESS);
}
- result = cfg_acl_fromconfig(aclobj, config, logctx, actx, mctx, 0,
- &acl);
+ result = cfg_acl_fromconfig(aclobj, config, actx, mctx, 0, &acl);
if (acl != NULL) {
dns_acl_detach(&acl);
}
if (cfg_obj_isuint32(obj_port) &&
cfg_obj_asuint32(obj_port) >= UINT16_MAX)
{
- cfg_obj_log(obj_port, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj_port, ISC_LOG_ERROR,
"port value '%u' is out of range",
cfg_obj_asuint32(obj_port));
}
if (!found) {
- cfg_obj_log(obj_proto, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj_proto, ISC_LOG_ERROR,
"'%s' is not a valid transport "
"protocol for "
"zone "
static isc_result_t
check_viewacls(cfg_aclconfctx_t *actx, const cfg_obj_t *voptions,
- const cfg_obj_t *config, isc_log_t *logctx, isc_mem_t *mctx) {
+ const cfg_obj_t *config, isc_mem_t *mctx) {
isc_result_t result = ISC_R_SUCCESS, tresult;
int i = 0;
while (acls[i] != NULL) {
tresult = checkacl(acls[i++], actx, NULL, voptions, config,
- logctx, mctx);
+ mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
}
static void
-dns64_error(const cfg_obj_t *obj, isc_log_t *logctx, isc_netaddr_t *netaddr,
+dns64_error(const cfg_obj_t *obj, isc_netaddr_t *netaddr,
unsigned int prefixlen, const char *message) {
char buf[ISC_NETADDR_FORMATSIZE + 1];
isc_netaddr_format(netaddr, buf, sizeof(buf));
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR, "dns64 prefix %s/%u %s", buf,
- prefixlen, message);
+ cfg_obj_log(obj, ISC_LOG_ERROR, "dns64 prefix %s/%u %s", buf, prefixlen,
+ message);
}
static isc_result_t
check_dns64(cfg_aclconfctx_t *actx, const cfg_obj_t *voptions,
- const cfg_obj_t *config, isc_log_t *logctx, isc_mem_t *mctx) {
+ const cfg_obj_t *config, isc_mem_t *mctx) {
isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *dns64 = NULL;
const cfg_obj_t *options;
cfg_obj_asnetprefix(obj, &na, &prefixlen);
if (na.family != AF_INET6) {
- dns64_error(map, logctx, &na, prefixlen,
- "must be IPv6");
+ dns64_error(map, &na, prefixlen, "must be IPv6");
result = ISC_R_FAILURE;
continue;
}
if (na.type.in6.s6_addr[8] != 0) {
- dns64_error(map, logctx, &na, prefixlen,
+ dns64_error(map, &na, prefixlen,
"bits [64..71] must be zero");
result = ISC_R_FAILURE;
continue;
if (prefixlen != 32 && prefixlen != 40 && prefixlen != 48 &&
prefixlen != 56 && prefixlen != 64 && prefixlen != 96)
{
- dns64_error(map, logctx, &na, prefixlen,
+ dns64_error(map, &na, prefixlen,
"length is not 32/40/48/56/64/96");
result = ISC_R_FAILURE;
continue;
dns_acl_t *acl = NULL;
isc_result_t tresult;
- tresult = cfg_acl_fromconfig(obj, config,
- logctx, actx, mctx,
- 0, &acl);
+ tresult = cfg_acl_fromconfig(obj, config, actx,
+ mctx, 0, &acl);
if (acl != NULL) {
dns_acl_detach(&acl);
}
static const unsigned char zeros[16];
isc_netaddr_fromsockaddr(&sa, cfg_obj_assockaddr(obj));
if (sa.family != AF_INET6) {
- cfg_obj_log(map, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(map, ISC_LOG_ERROR,
"dns64 requires a IPv6 suffix");
result = ISC_R_FAILURE;
continue;
char netaddrbuf[ISC_NETADDR_FORMATSIZE];
isc_netaddr_format(&sa, netaddrbuf,
sizeof(netaddrbuf));
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"bad suffix '%s' leading "
"%u octets not zeros",
netaddrbuf, nbytes);
return (result);
}
-#define CHECK_RRL(cond, pat, val1, val2) \
- do { \
- if (!(cond)) { \
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR, pat, val1, \
- val2); \
- if (result == ISC_R_SUCCESS) \
- result = ISC_R_RANGE; \
- } \
+#define CHECK_RRL(cond, pat, val1, val2) \
+ do { \
+ if (!(cond)) { \
+ cfg_obj_log(obj, ISC_LOG_ERROR, pat, val1, val2); \
+ if (result == ISC_R_SUCCESS) \
+ result = ISC_R_RANGE; \
+ } \
} while (0)
#define CHECK_RRL_RATE(rate, def, max_rate, name) \
static isc_result_t
check_ratelimit(cfg_aclconfctx_t *actx, const cfg_obj_t *voptions,
- const cfg_obj_t *config, isc_log_t *logctx, isc_mem_t *mctx) {
+ const cfg_obj_t *config, isc_mem_t *mctx) {
isc_result_t result = ISC_R_SUCCESS;
isc_result_t mresult;
const cfg_obj_t *map = NULL;
dns_acl_t *acl = NULL;
isc_result_t tresult;
- tresult = cfg_acl_fromconfig(obj, config, logctx, actx, mctx, 0,
- &acl);
+ tresult = cfg_acl_fromconfig(obj, config, actx, mctx, 0, &acl);
if (acl != NULL) {
dns_acl_detach(&acl);
}
}
static isc_result_t
-check_fetchlimit(const cfg_obj_t *voptions, const cfg_obj_t *config,
- isc_log_t *logctx) {
+check_fetchlimit(const cfg_obj_t *voptions, const cfg_obj_t *config) {
const cfg_obj_t *map = NULL;
const cfg_obj_t *options = NULL;
const cfg_obj_t *obj = NULL;
obj = cfg_tuple_get(map, "low");
low = (double)cfg_obj_asfixedpoint(obj) / 100.0;
if (low < 0.0 || low > 1.0) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"fetch-quota-param low value (%0.1f) "
"out of range",
low);
obj = cfg_tuple_get(map, "high");
high = (double)cfg_obj_asfixedpoint(obj) / 100.0;
if (high < 0.0 || high > 1.0) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"fetch-quota-param high value (%0.1f) "
"out of range",
high);
obj = cfg_tuple_get(map, "discount");
discount = (double)cfg_obj_asfixedpoint(obj) / 100.0;
if (discount < 0.0 || discount > 1.0) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"fetch-quota-param discount value (%0.1f) "
"out of range",
discount);
static isc_result_t
check_recursionacls(cfg_aclconfctx_t *actx, const cfg_obj_t *voptions,
const char *viewname, const cfg_obj_t *config,
- isc_log_t *logctx, isc_mem_t *mctx) {
+ isc_mem_t *mctx) {
const cfg_obj_t *options, *aclobj, *obj = NULL;
dns_acl_t *acl = NULL;
isc_result_t result = ISC_R_SUCCESS, tresult;
continue;
}
- tresult = cfg_acl_fromconfig(aclobj, config, logctx, actx, mctx,
- 0, &acl);
+ tresult = cfg_acl_fromconfig(aclobj, config, actx, mctx, 0,
+ &acl);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
if (!recursion && !dns_acl_isnone(acl)) {
- cfg_obj_log(aclobj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(aclobj, ISC_LOG_WARNING,
"both \"recursion no;\" and "
"\"%s\" active%s%s",
acls[i], forview, viewname);
static isc_result_t
check_listener(const cfg_obj_t *listener, const cfg_obj_t *config,
- cfg_aclconfctx_t *actx, isc_log_t *logctx, isc_mem_t *mctx) {
+ cfg_aclconfctx_t *actx, isc_mem_t *mctx) {
isc_result_t tresult, result = ISC_R_SUCCESS;
const cfg_obj_t *ltup = NULL;
const cfg_obj_t *tlsobj = NULL, *httpobj = NULL;
tlsmap = find_maplist(config, "tls", tlsname);
if (tlsmap == NULL) {
- cfg_obj_log(tlsobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(tlsobj, ISC_LOG_ERROR,
"tls '%s' is not defined",
cfg_obj_asstring(tlsobj));
result = ISC_R_FAILURE;
const char *httpname = cfg_obj_asstring(httpobj);
if (!do_tls && !no_tls) {
- cfg_obj_log(httpobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(httpobj, ISC_LOG_ERROR,
"http must specify a 'tls' "
"statement, 'tls ephemeral', or "
"'tls none'");
http_server = find_maplist(config, "http", httpname);
if (http_server == NULL && strcasecmp(httpname, "default") != 0)
{
- cfg_obj_log(httpobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(httpobj, ISC_LOG_ERROR,
"http '%s' is not defined",
cfg_obj_asstring(httpobj));
result = ISC_R_FAILURE;
if (cfg_obj_isuint32(portobj) &&
cfg_obj_asuint32(portobj) >= UINT16_MAX)
{
- cfg_obj_log(portobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(portobj, ISC_LOG_ERROR,
"port value '%u' is out of range",
cfg_obj_asuint32(portobj));
(strcasecmp(proxyval, "encrypted") != 0 &&
strcasecmp(proxyval, "plain") != 0))
{
- cfg_obj_log(proxyobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(proxyobj, ISC_LOG_ERROR,
"'proxy' must have one of the following "
"values: 'plain', 'encrypted'");
if (proxyval != NULL &&
strcasecmp(proxyval, "encrypted") == 0 && !do_tls)
{
- cfg_obj_log(proxyobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(proxyobj, ISC_LOG_ERROR,
"'proxy encrypted' can be used only when "
"encryption is enabled by setting 'tls' to "
"a defined value or to 'ephemeral'");
}
tresult = cfg_acl_fromconfig(cfg_tuple_get(listener, "acl"), config,
- logctx, actx, mctx, 0, &acl);
+ actx, mctx, 0, &acl);
if (result == ISC_R_SUCCESS) {
result = tresult;
}
static isc_result_t
check_listeners(const cfg_obj_t *list, const cfg_obj_t *config,
- cfg_aclconfctx_t *actx, isc_log_t *logctx, isc_mem_t *mctx) {
+ cfg_aclconfctx_t *actx, isc_mem_t *mctx) {
isc_result_t tresult, result = ISC_R_SUCCESS;
const cfg_listelt_t *elt = NULL;
for (elt = cfg_list_first(list); elt != NULL; elt = cfg_list_next(elt))
{
const cfg_obj_t *obj = cfg_listelt_value(elt);
- tresult = check_listener(obj, config, actx, logctx, mctx);
+ tresult = check_listener(obj, config, actx, mctx);
if (result == ISC_R_SUCCESS) {
result = tresult;
}
}
static isc_result_t
-check_port(const cfg_obj_t *options, isc_log_t *logctx, const char *type,
- in_port_t *portp) {
+check_port(const cfg_obj_t *options, const char *type, in_port_t *portp) {
const cfg_obj_t *portobj = NULL;
isc_result_t result;
}
if (cfg_obj_asuint32(portobj) >= UINT16_MAX) {
- cfg_obj_log(portobj, logctx, ISC_LOG_ERROR,
- "port '%u' out of range",
+ cfg_obj_log(portobj, ISC_LOG_ERROR, "port '%u' out of range",
cfg_obj_asuint32(portobj));
return (ISC_R_RANGE);
}
static isc_result_t
check_options(const cfg_obj_t *options, const cfg_obj_t *config,
- bool check_algorithms, isc_log_t *logctx, isc_mem_t *mctx,
- optlevel_t optlevel) {
+ bool check_algorithms, isc_mem_t *mctx, optlevel_t optlevel) {
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
unsigned int i;
/*
* Check port values, and record "port" for later use.
*/
- tresult = check_port(options, logctx, "port", &dnsport);
+ tresult = check_port(options, "port", &dnsport);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
- tresult = check_port(options, logctx, "tls-port", NULL);
+ tresult = check_port(options, "tls-port", NULL);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
- tresult = check_port(options, logctx, "http-port", NULL);
+ tresult = check_port(options, "http-port", NULL);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
- tresult = check_port(options, logctx, "https-port", NULL);
+ tresult = check_port(options, "https-port", NULL);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
cfg_obj_assockaddr(obj);
in_port_t port = isc_sockaddr_getport(sa);
if (port == dnsport) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'%s' cannot specify the "
"DNS listener port (%d)",
sources[i], port);
result = ISC_R_FAILURE;
} else if (port != 0) {
- cfg_obj_log(obj, logctx,
- ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"'%s': specifying a port "
"is not recommended",
sources[i]);
val = cfg_obj_asuint32(obj);
}
if (val > intervals[i].max) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"%s '%u' is out of range (0..%u)",
intervals[i].name, val, intervals[i].max);
result = ISC_R_RANGE;
} else if (val > (UINT32_MAX / intervals[i].scale)) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"%s '%d' is out of range",
intervals[i].name, val);
result = ISC_R_RANGE;
(void)cfg_map_get(options, "key-store", &obj);
if (obj != NULL) {
if (optlevel != optlevel_config) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"may only be configured at the top level");
if (result == ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
cfg_tuple_get(kconfig, "name"));
if (strcmp(DNS_KEYSTORE_KEYDIRECTORY, val) == 0)
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"name '%s' not allowed",
DNS_KEYSTORE_KEYDIRECTORY);
if (result == ISC_R_SUCCESS) {
break;
case ISC_R_FILENOTFOUND:
cfg_obj_log(
- obj, logctx,
- ISC_LOG_WARNING,
+ obj, ISC_LOG_WARNING,
"key-store directory: "
"'%s' does not exist",
val);
break;
case ISC_R_INVALIDFILE:
cfg_obj_log(
- obj, logctx,
- ISC_LOG_WARNING,
+ obj, ISC_LOG_WARNING,
"key-store directory: "
"'%s' is not a "
"directory",
break;
default:
cfg_obj_log(
- obj, logctx,
- ISC_LOG_WARNING,
+ obj, ISC_LOG_WARNING,
"key-store directory: "
"'%s' %s",
val,
}
}
- ret = cfg_keystore_fromconfig(
- kconfig, mctx, logctx, &kslist, NULL);
+ ret = cfg_keystore_fromconfig(kconfig, mctx,
+ &kslist, NULL);
if (ret != ISC_R_SUCCESS) {
if (result == ISC_R_SUCCESS) {
result = ret;
/*
* Add default key-store "key-directory".
*/
- tresult = cfg_keystore_fromconfig(NULL, mctx, logctx, &kslist, NULL);
+ tresult = cfg_keystore_fromconfig(NULL, mctx, &kslist, NULL);
if (tresult != ISC_R_SUCCESS) {
if (result == ISC_R_SUCCESS) {
result = tresult;
ret = cfg_kasp_fromconfig(
kconfig, NULL, check_algorithms,
- mctx, logctx, &kslist, &list,
- &kasp);
+ mctx, &kslist, &list, &kasp);
if (ret != ISC_R_SUCCESS) {
if (result == ISC_R_SUCCESS) {
result = ret;
}
if (bad_kasp) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-policy may only be configured at "
"the top level, please use name reference "
"at the zone level");
result = ISC_R_FAILURE;
}
} else if (bad_name) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-policy name may not be 'insecure', "
"'none', or 'default' (which are built-in "
"policies)");
val = cfg_obj_asuint32(obj);
if (val != 0 && (val < 35 || val > 4096)) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"max-rsa-exponent-size '%u' is out of "
"range (35..4096)",
val);
if (strcasecmp(str, "a") != 0 && strcasecmp(str, "aaaa") != 0 &&
strcasecmp(str, "none") != 0)
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"preferred-glue unexpected value '%s'",
str);
}
element = cfg_list_next(element))
{
obj = cfg_listelt_value(element);
- tresult = disabled_algorithms(obj, logctx);
+ tresult = disabled_algorithms(obj);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
element = cfg_list_next(element))
{
obj = cfg_listelt_value(element);
- tresult = disabled_ds_digests(obj, logctx);
+ tresult = disabled_ds_digests(obj);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
element = cfg_list_next(element))
{
obj = cfg_listelt_value(element);
- tresult = mustbesecure(obj, symtab, logctx,
- mctx);
+ tresult = mustbesecure(obj, symtab, mctx);
if (result == ISC_R_SUCCESS &&
tresult != ISC_R_SUCCESS)
{
if (obj != NULL) {
str = cfg_obj_asstring(obj);
if (check_name(str) != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"%s: invalid name '%s'",
server_contact[i], str);
if (result == ISC_R_SUCCESS) {
obj = cfg_listelt_value(element);
str = cfg_obj_asstring(obj);
if (check_name(str) != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"disable-empty-zone: invalid name '%s'",
str);
if (result == ISC_R_SUCCESS) {
if (obj != NULL && cfg_obj_isstring(obj) &&
strlen(cfg_obj_asstring(obj)) > 1024U)
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'server-id' too big (>1024 bytes)");
if (result == ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
if (obj != NULL) {
lifetime = cfg_obj_asduration(obj);
if (lifetime > 604800) { /* 7 days */
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'nta-lifetime' cannot exceed one week");
if (result == ISC_R_SUCCESS) {
result = ISC_R_RANGE;
}
} else if (lifetime == 0) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'nta-lifetime' may not be zero");
if (result == ISC_R_SUCCESS) {
result = ISC_R_RANGE;
if (obj != NULL) {
uint32_t recheck = cfg_obj_asduration(obj);
if (recheck > 604800) { /* 7 days */
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'nta-recheck' cannot exceed one week");
if (result == ISC_R_SUCCESS) {
result = ISC_R_RANGE;
}
if (recheck > lifetime) {
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"'nta-recheck' (%d seconds) is "
"greater than 'nta-lifetime' "
"(%d seconds)",
if (obj != NULL) {
ccalg = cfg_obj_asstring(obj);
if (strcasecmp(ccalg, "aes") == 0) {
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"cookie-algorithm 'aes' is obsolete and "
"should be removed");
if (result == ISC_R_SUCCESS) {
isc_buffer_init(&b, secret, sizeof(secret));
tresult = isc_hex_decodestring(str, &b);
if (tresult == ISC_R_NOSPACE) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"cookie-secret: too long");
} else if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"cookie-secret: invalid hex "
"string");
}
if (strcasecmp(ccalg, "siphash24") == 0 &&
usedlength != ISC_SIPHASH24_KEY_LENGTH)
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"SipHash-2-4 cookie-secret must be "
"128 bits");
if (result == ISC_R_SUCCESS) {
(fstrm[i].max != 0U && value > fstrm[i].max))
{
if (fstrm[i].max != 0U) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"%s '%u' out of range (%u..%u)",
fstrm[i].name, value, fstrm[i].min,
fstrm[i].max);
} else {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"%s out of range (%u < %u)",
fstrm[i].name, value, fstrm[i].min);
}
value >>= 1;
} while (value != 0U);
if (bits != 1) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"%s '%u' not a power-of-2",
fstrm[i].name,
cfg_obj_asuint32(obj));
obj2 = cfg_tuple_get(obj, "mode");
if (obj2 == NULL) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnstap-output mode not found");
if (result == ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
if (obj2 != NULL && !cfg_obj_isvoid(obj2) &&
dmode == dns_dtmode_unix)
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnstap-output size "
"cannot be set with mode unix");
if (result == ISC_R_SUCCESS) {
if (obj2 != NULL && !cfg_obj_isvoid(obj2) &&
dmode == dns_dtmode_unix)
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnstap-output versions "
"cannot be set with mode unix");
if (result == ISC_R_SUCCESS) {
if (obj2 != NULL && !cfg_obj_isvoid(obj2) &&
dmode == dns_dtmode_unix)
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnstap-output suffix "
"cannot be set with mode unix");
if (result == ISC_R_SUCCESS) {
uint64_t mapsize = cfg_obj_asuint64(obj);
if (mapsize < (1ULL << 20)) { /* 1 megabyte */
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'lmdb-mapsize "
"%" PRId64 "' "
"is too small",
result = ISC_R_RANGE;
}
} else if (mapsize > (1ULL << 40)) { /* 1 terabyte */
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'lmdb-mapsize "
"%" PRId64 "' "
"is too large",
if (obj != NULL && cfg_obj_ispercentage(obj)) {
uint32_t percent = cfg_obj_aspercentage(obj);
if (percent == 0) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'ixfr-max-ratio' must be a nonzero "
"percentage or 'unlimited')");
if (result == ISC_R_SUCCESS) {
result = ISC_R_RANGE;
}
} else if (percent > 100) {
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"'ixfr-max-ratio %d%%' exceeds 100%%",
percent);
}
const char *keyword = cfg_obj_asstring(type);
if (strcasecmp(keyword, "primary") == 0) {
if ((values & PRI) == PRI) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'check-names primary' "
"duplicated");
if (result == ISC_R_SUCCESS) {
values |= PRI;
} else if (strcasecmp(keyword, "master") == 0) {
if ((values & MAS) == MAS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'check-names master' "
"duplicated");
if (result == ISC_R_SUCCESS) {
values |= MAS;
} else if (strcasecmp(keyword, "secondary") == 0) {
if ((values & SCN) == SCN) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'check-names secondary' "
"duplicated");
if (result == ISC_R_SUCCESS) {
values |= SCN;
} else if (strcasecmp(keyword, "slave") == 0) {
if ((values & SLA) == SLA) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'check-names slave' "
"duplicated");
if (result == ISC_R_SUCCESS) {
}
if ((values & (PRI | MAS)) == (PRI | MAS)) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'check-names' cannot take both "
"'primary' and 'master'");
if (result == ISC_R_SUCCESS) {
}
if ((values & (SCN | SLA)) == (SCN | SLA)) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'check-names' cannot take both "
"'secondary' and 'slave'");
if (result == ISC_R_SUCCESS) {
if (obj != NULL) {
uint32_t refresh_time = cfg_obj_asduration(obj);
if (refresh_time > 0 && refresh_time < 30) {
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"'stale-refresh-time' should either be 0 "
"or otherwise 30 seconds or higher");
}
if (obj != NULL) {
dns_acl_t *acl = NULL;
- tresult = cfg_acl_fromconfig(obj, config, logctx, actx, mctx, 0,
- &acl);
+ tresult = cfg_acl_fromconfig(obj, config, actx, mctx, 0, &acl);
if (acl != NULL) {
dns_acl_detach(&acl);
}
(void)cfg_map_get(options, "listen-on", &obj);
if (obj != NULL) {
INSIST(config != NULL);
- tresult = check_listeners(obj, config, actx, logctx, mctx);
+ tresult = check_listeners(obj, config, actx, mctx);
if (result == ISC_R_SUCCESS) {
result = tresult;
}
(void)cfg_map_get(options, "listen-on-v6", &obj);
if (obj != NULL) {
INSIST(config != NULL);
- tresult = check_listeners(obj, config, actx, logctx, mctx);
+ tresult = check_listeners(obj, config, actx, mctx);
if (result == ISC_R_SUCCESS) {
result = tresult;
}
if (obj != NULL) {
uint32_t restarts = cfg_obj_asuint32(obj);
if (restarts == 0 || restarts > 255) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'max-query-restarts' is out of "
"range 1..255)");
if (result == ISC_R_SUCCESS) {
*/
static isc_result_t
check_remoteserverlist(const cfg_obj_t *cctx, const char *list,
- isc_log_t *logctx, isc_symtab_t *symtab,
- isc_mem_t *mctx) {
+ isc_symtab_t *symtab, isc_mem_t *mctx) {
isc_symvalue_t symvalue;
isc_result_t result, tresult;
const cfg_obj_t *obj = NULL;
if (file == NULL) {
file = "<unknown file>";
}
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"%s list '%s' is duplicated: "
"also defined at %s:%u",
list, name, file, line);
* Check primaries lists for duplicates.
*/
static isc_result_t
-check_primarylists(const cfg_obj_t *cctx, isc_log_t *logctx, isc_mem_t *mctx) {
+check_primarylists(const cfg_obj_t *cctx, isc_mem_t *mctx) {
isc_result_t result, tresult;
isc_symtab_t *symtab = NULL;
if (result != ISC_R_SUCCESS) {
return (result);
}
- tresult = check_remoteserverlist(cctx, "primaries", logctx, symtab,
- mctx);
+ tresult = check_remoteserverlist(cctx, "primaries", symtab, mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
- tresult = check_remoteserverlist(cctx, "masters", logctx, symtab, mctx);
+ tresult = check_remoteserverlist(cctx, "masters", symtab, mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
* Check parental-agents lists for duplicates.
*/
static isc_result_t
-check_parentalagentlists(const cfg_obj_t *cctx, isc_log_t *logctx,
- isc_mem_t *mctx) {
+check_parentalagentlists(const cfg_obj_t *cctx, isc_mem_t *mctx) {
isc_result_t result, tresult;
isc_symtab_t *symtab = NULL;
if (result != ISC_R_SUCCESS) {
return (result);
}
- tresult = check_remoteserverlist(cctx, "parental-agents", logctx,
- symtab, mctx);
+ tresult = check_remoteserverlist(cctx, "parental-agents", symtab, mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
#if HAVE_LIBNGHTTP2
static isc_result_t
-check_httpserver(const cfg_obj_t *http, isc_log_t *logctx,
- isc_symtab_t *symtab) {
+check_httpserver(const cfg_obj_t *http, isc_symtab_t *symtab) {
isc_result_t result, tresult;
const char *name = cfg_obj_asstring(cfg_map_getname(http));
const cfg_obj_t *eps = NULL;
isc_symvalue_t symvalue;
if (strcasecmp(name, "default") == 0) {
- cfg_obj_log(http, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(http, ISC_LOG_ERROR,
"'http' name cannot be '%s' (which is a "
"built-in configuration)",
name);
file = "<unknown file>";
}
- cfg_obj_log(http, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(http, ISC_LOG_ERROR,
"http '%s' is duplicated: "
"also defined at %s:%u",
name, file, line);
const cfg_obj_t *ep = cfg_listelt_value(elt);
const char *path = cfg_obj_asstring(ep);
if (!isc_nm_http_path_isvalid(path)) {
- cfg_obj_log(eps, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(eps, ISC_LOG_ERROR,
"endpoint '%s' is not a "
"valid absolute HTTP path",
path);
}
static isc_result_t
-check_httpservers(const cfg_obj_t *config, isc_log_t *logctx, isc_mem_t *mctx) {
+check_httpservers(const cfg_obj_t *config, isc_mem_t *mctx) {
isc_result_t result, tresult;
const cfg_obj_t *obj = NULL;
const cfg_listelt_t *elt = NULL;
for (elt = cfg_list_first(obj); elt != NULL; elt = cfg_list_next(elt)) {
obj = cfg_listelt_value(elt);
- tresult = check_httpserver(obj, logctx, symtab);
+ tresult = check_httpserver(obj, symtab);
if (result == ISC_R_SUCCESS) {
result = tresult;
}
static isc_result_t
check_tls_defintion(const cfg_obj_t *tlsobj, const char *name,
- isc_log_t *logctx, isc_symtab_t *symtab) {
+ isc_symtab_t *symtab) {
isc_result_t result, tresult;
const cfg_obj_t *tls_proto_list = NULL, *tls_key = NULL,
*tls_cert = NULL, *tls_ciphers = NULL,
if (strcasecmp(name, "ephemeral") == 0 || strcasecmp(name, "none") == 0)
{
- cfg_obj_log(tlsobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(tlsobj, ISC_LOG_ERROR,
"tls clause name '%s' is reserved for internal use",
name);
result = ISC_R_FAILURE;
file = "<unknown file>";
}
- cfg_obj_log(tlsobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(tlsobj, ISC_LOG_ERROR,
"tls clause '%s' is duplicated: "
"also defined at %s:%u",
name, file, line);
if ((tls_key == NULL && tls_cert != NULL) ||
(tls_cert == NULL && tls_key != NULL))
{
- cfg_obj_log(tlsobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(tlsobj, ISC_LOG_ERROR,
"tls '%s': 'cert-file' and 'key-file' must "
"both be specified, or both omitted",
name);
isc_tls_protocol_name_to_version(tls_sver);
if (ver == ISC_TLS_PROTO_VER_UNDEFINED) {
- cfg_obj_log(tls_proto_obj, logctx,
- ISC_LOG_ERROR,
+ cfg_obj_log(tls_proto_obj, ISC_LOG_ERROR,
"'%s' is not a valid "
"TLS protocol version",
tls_sver);
result = ISC_R_FAILURE;
continue;
} else if (!isc_tls_protocol_supported(ver)) {
- cfg_obj_log(tls_proto_obj, logctx,
- ISC_LOG_ERROR,
+ cfg_obj_log(tls_proto_obj, ISC_LOG_ERROR,
"'%s' is not "
"supported by the "
"cryptographic library version in "
}
if ((tls_protos & ver) != 0) {
- cfg_obj_log(tls_proto_obj, logctx,
- ISC_LOG_WARNING,
+ cfg_obj_log(tls_proto_obj, ISC_LOG_WARNING,
"'%s' is specified more than once "
"in '%s'",
tls_sver, name);
}
if (tls_protos == 0) {
- cfg_obj_log(tlsobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(tlsobj, ISC_LOG_ERROR,
"tls '%s' does not contain any valid "
"TLS protocol versions definitions",
name);
if (tresult == ISC_R_SUCCESS) {
const char *ciphers = cfg_obj_asstring(tls_ciphers);
if (!isc_tls_cipherlist_valid(ciphers)) {
- cfg_obj_log(tls_ciphers, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(tls_ciphers, ISC_LOG_ERROR,
"'ciphers' in the 'tls' clause '%s' is "
"not a "
"valid cipher list string",
const char *cipher_suites = cfg_obj_asstring(tls_cipher_suites);
if (!isc_tls_cipher_suites_valid(cipher_suites)) {
cfg_obj_log(
- tls_cipher_suites, logctx, ISC_LOG_ERROR,
+ tls_cipher_suites, ISC_LOG_ERROR,
"'cipher-suites' in the 'tls' clause '%s' is "
"not a valid cipher suites string",
name);
}
static isc_result_t
-check_tls_definitions(const cfg_obj_t *config, isc_log_t *logctx,
- isc_mem_t *mctx) {
+check_tls_definitions(const cfg_obj_t *config, isc_mem_t *mctx) {
isc_result_t result, tresult;
const cfg_obj_t *obj = NULL;
const cfg_listelt_t *elt = NULL;
const char *name;
obj = cfg_listelt_value(elt);
name = cfg_obj_asstring(cfg_map_getname(obj));
- tresult = check_tls_defintion(obj, name, logctx, symtab);
+ tresult = check_tls_defintion(obj, name, symtab);
if (result == ISC_R_SUCCESS) {
result = tresult;
}
static isc_result_t
validate_remotes(const char *list, const cfg_obj_t *obj,
- const cfg_obj_t *config, uint32_t *countp, isc_log_t *logctx,
- isc_mem_t *mctx) {
+ const cfg_obj_t *config, uint32_t *countp, isc_mem_t *mctx) {
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
uint32_t count = 0;
tresult = dns_name_fromstring(
nm, str, dns_rootname, 0, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"'%s' is not a valid name",
str);
if (result == ISC_R_SUCCESS) {
tresult = dns_name_fromstring(
nm, str, dns_rootname, 0, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(tls, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(tls, ISC_LOG_ERROR,
"'%s' is not a valid name",
str);
if (result == ISC_R_SUCCESS) {
str);
if (tlsmap == NULL) {
cfg_obj_log(
- tls, logctx,
- ISC_LOG_ERROR,
+ tls, ISC_LOG_ERROR,
"tls '%s' is not "
"defined",
cfg_obj_asstring(tls));
continue;
}
if (!cfg_obj_isvoid(key)) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
- "unexpected token '%s'",
+ cfg_obj_log(key, ISC_LOG_ERROR, "unexpected token '%s'",
cfg_obj_asstring(key));
if (result == ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
}
if (!cfg_obj_isvoid(tls)) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
- "unexpected token '%s'",
+ cfg_obj_log(key, ISC_LOG_ERROR, "unexpected token '%s'",
cfg_obj_asstring(tls));
if (result == ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
if (result == ISC_R_SUCCESS) {
result = tresult;
}
- cfg_obj_log(addr, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(addr, ISC_LOG_ERROR,
"unable to find %s list '%s'", list,
listname);
continue;
}
static isc_result_t
-check_update_policy(const cfg_obj_t *policy, isc_log_t *logctx) {
+check_update_policy(const cfg_obj_t *policy) {
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
const cfg_listelt_t *element;
tresult = dns_ssu_mtypefromstring(cfg_obj_asstring(matchtype),
&mtype);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(identity, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(identity, ISC_LOG_ERROR,
"has a bad match-type");
}
str = cfg_obj_asstring(identity);
tresult = dns_name_fromstring(id, str, dns_rootname, 1, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(identity, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(identity, ISC_LOG_ERROR,
"'%s' is not a valid name", str);
result = tresult;
}
tresult = dns_name_fromstring(name, str, dns_rootname,
0, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(dname, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(dname, ISC_LOG_ERROR,
"'%s' is not a valid name", str);
result = tresult;
}
mtype == dns_ssumatchtype_wildcard &&
!dns_name_iswildcard(name))
{
- cfg_obj_log(identity, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(identity, ISC_LOG_ERROR,
"'%s' is not a wildcard", str);
result = ISC_R_FAILURE;
}
(!dns_name_equal(id, name) &&
!dns_name_equal(dns_rootname, name)))
{
- cfg_obj_log(identity, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(identity, ISC_LOG_ERROR,
"identity and name fields are not "
"the same");
result = ISC_R_FAILURE;
if (tresult == ISC_R_SUCCESS &&
!dns_name_equal(dns_rootname, name))
{
- cfg_obj_log(identity, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(identity, ISC_LOG_ERROR,
"name field not set to "
"placeholder value '.'");
result = ISC_R_FAILURE;
tresult = dns_rdatatype_fromtext(&type, &r);
}
if (tresult == ISC_R_SUCCESS) {
- cfg_obj_log(identity, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(identity, ISC_LOG_ERROR,
"missing name field type '%s' "
"found",
str);
if (max > 0xffff || end[0] != /*(*/ ')' ||
end[1] != 0)
{
- cfg_obj_log(typeobj, logctx,
- ISC_LOG_ERROR,
+ cfg_obj_log(typeobj, ISC_LOG_ERROR,
"'%s' is not a valid count",
bracket);
result = DNS_R_SYNTAX;
tresult = dns_rdatatype_fromtext(&type, &r);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(typeobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(typeobj, ISC_LOG_ERROR,
"'%.*s' is not a valid type",
(int)r.length, r.base);
result = tresult;
} optionstable;
static isc_result_t
-check_nonzero(const cfg_obj_t *options, isc_log_t *logctx) {
+check_nonzero(const cfg_obj_t *options) {
isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *obj = NULL;
unsigned int i;
if (cfg_map_get(options, nonzero[i], &obj) == ISC_R_SUCCESS &&
cfg_obj_asuint32(obj) == 0)
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
- "'%s' must not be zero", nonzero[i]);
+ cfg_obj_log(obj, ISC_LOG_ERROR, "'%s' must not be zero",
+ nonzero[i]);
result = ISC_R_FAILURE;
}
}
* mirror zone. Return true if it is; return false otherwise.
*/
static bool
-check_mirror_zone_notify(const cfg_obj_t *zoptions, const char *znamestr,
- isc_log_t *logctx) {
+check_mirror_zone_notify(const cfg_obj_t *zoptions, const char *znamestr) {
bool notify_configuration_ok = true;
const cfg_obj_t *obj = NULL;
}
if (!notify_configuration_ok) {
- cfg_obj_log(zoptions, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zoptions, ISC_LOG_ERROR,
"zone '%s': mirror zones can only be used with "
"'notify no;' or 'notify explicit;'",
znamestr);
*/
static bool
check_recursion(const cfg_obj_t *config, const cfg_obj_t *voptions,
- const cfg_obj_t *goptions, isc_log_t *logctx,
- cfg_aclconfctx_t *actx, isc_mem_t *mctx) {
+ const cfg_obj_t *goptions, cfg_aclconfctx_t *actx,
+ isc_mem_t *mctx) {
dns_acl_t *acl = NULL;
const cfg_obj_t *obj;
isc_result_t result;
result = cfg_map_get(goptions, "allow-recursion", &obj);
}
if (result == ISC_R_SUCCESS) {
- result = cfg_acl_fromconfig(obj, config, logctx, actx, mctx, 0,
- &acl);
+ result = cfg_acl_fromconfig(obj, config, actx, mctx, 0, &acl);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
static isc_result_t
check_keydir(const cfg_obj_t *config, const cfg_obj_t *zconfig,
dns_name_t *zname, const char *name, const char *keydir,
- isc_symtab_t *keydirs, isc_log_t *logctx, isc_mem_t *mctx) {
+ isc_symtab_t *keydirs, isc_mem_t *mctx) {
const char *dir = keydir;
const cfg_listelt_t *element;
isc_result_t ret, result = ISC_R_SUCCESS;
element = cfg_list_next(element))
{
cfg_obj_t *kcfg = cfg_listelt_value(element);
- (void)cfg_keystore_fromconfig(kcfg, mctx, logctx, &kslist,
- NULL);
+ (void)cfg_keystore_fromconfig(kcfg, mctx, &kslist, NULL);
}
- (void)cfg_keystore_fromconfig(NULL, mctx, logctx, &kslist, NULL);
+ (void)cfg_keystore_fromconfig(NULL, mctx, &kslist, NULL);
/*
* Look for the dnssec-policy by name, which is the dnssec-policy
continue;
}
- ret = cfg_kasp_fromconfig(kconfig, NULL, false, mctx, logctx,
- &kslist, &kasplist, &kasp);
+ ret = cfg_kasp_fromconfig(kconfig, NULL, false, mctx, &kslist,
+ &kasplist, &kasp);
if (ret != ISC_R_SUCCESS) {
kasp = NULL;
}
ret = keydirexist(zconfig,
keystore ? "key-store directory"
: "key-directory",
- zname, dir, name, keydirs, logctx, mctx);
+ zname, dir, name, keydirs, mctx);
if (ret != ISC_R_SUCCESS) {
result = ret;
}
check:
if (!done) {
ret = keydirexist(zconfig, "key-directory", zname, dir, name,
- keydirs, logctx, mctx);
+ keydirs, mctx);
if (ret != ISC_R_SUCCESS) {
result = ret;
}
const cfg_obj_t *config, isc_symtab_t *symtab,
isc_symtab_t *files, isc_symtab_t *keydirs, isc_symtab_t *inview,
const char *viewname, dns_rdataclass_t defclass,
- cfg_aclconfctx_t *actx, isc_log_t *logctx, isc_mem_t *mctx) {
+ cfg_aclconfctx_t *actx, isc_mem_t *mctx) {
const char *znamestr;
const char *typestr = NULL;
const char *target = NULL;
obj = NULL;
(void)cfg_map_get(zoptions, "type", &obj);
if (obj == NULL) {
- cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"zone '%s': type not present", znamestr);
return (ISC_R_FAILURE);
}
} else if (strcasecmp(typestr, "redirect") == 0) {
ztype = CFG_ZONE_REDIRECT;
} else {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"zone '%s': invalid type %s", znamestr,
typestr);
return (ISC_R_FAILURE);
}
if (ztype == CFG_ZONE_REDIRECT && strcmp(znamestr, ".") != 0) {
- cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"redirect zones must be called \".\"");
return (ISC_R_FAILURE);
}
r.length = strlen(r.base);
result = dns_rdataclass_fromtext(&zclass, &r);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"zone '%s': invalid class %s", znamestr,
r.base);
return (ISC_R_FAILURE);
}
if (zclass != defclass) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"zone '%s': class '%s' does not "
"match view/default class",
znamestr, r.base);
tresult = dns_name_fromtext(dns_fixedname_name(&fixedname), &b,
dns_rootname, DNS_NAME_DOWNCASE, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"zone '%s': is not a valid name", znamestr);
result = ISC_R_FAILURE;
} else {
: 3,
symtab,
"zone '%s': already exists previous definition: %s:%u",
- logctx, mctx);
+ mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
case CFG_ZONE_INVIEW:
tresult = isc_symtab_lookup(inview, key, 0, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(inviewobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(inviewobj, ISC_LOG_ERROR,
"'in-view' zone '%s' "
"does not exist in view '%s', "
"or view '%s' is not yet defined",
maxopts++;
}
if (cfg_map_count(zoptions) > maxopts) {
- cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"zone '%s': 'in-view' used "
"with incompatible zone options",
znamestr);
/*
* Check if value is zero.
*/
- if (check_nonzero(zoptions, logctx) != ISC_R_SUCCESS) {
+ if (check_nonzero(zoptions) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
}
if (!has_dnssecpolicy) {
- cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"zone '%s': option "
"'dnssec-policy %s' has no "
"matching dnssec-policy config",
(void)cfg_map_get(goptions, "max-zone-ttl", &obj);
}
if (obj != NULL) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"zone '%s': option 'max-zone-ttl' "
"cannot be used together with "
"'dnssec-policy'",
if (cfg_map_get(zoptions, option, &obj) == ISC_R_SUCCESS &&
obj != NULL && !cfg_clause_validforzone(option, ztype))
{
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"option '%s' is not allowed "
"in '%s' zone '%s'",
option, typestr, znamestr);
*/
for (i = 0; i < ARRAY_SIZE(acls); i++) {
tresult = checkacl(acls[i], actx, zconfig, voptions, config,
- logctx, mctx);
+ mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
* at the zone level for mirror zones.
*/
if (ztype == CFG_ZONE_MIRROR &&
- !check_mirror_zone_notify(zoptions, znamestr, logctx))
+ !check_mirror_zone_notify(zoptions, znamestr))
{
result = ISC_R_FAILURE;
}
obj = NULL;
tresult = cfg_map_get(zoptions, "also-notify", &obj);
if (tresult == ISC_R_SUCCESS && !donotify) {
- cfg_obj_log(zoptions, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(zoptions, ISC_LOG_WARNING,
"zone '%s': 'also-notify' set but "
"'notify' is disabled",
znamestr);
if (tresult == ISC_R_SUCCESS && donotify) {
uint32_t count;
tresult = validate_remotes("primaries", obj, config,
- &count, logctx, mctx);
+ &count, mctx);
if (tresult != ISC_R_SUCCESS && result == ISC_R_SUCCESS)
{
result = tresult;
/* ...bug if it was set, "masters" must not be. */
(void)cfg_map_get(zoptions, "masters", &obj2);
if (obj2 != NULL) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'primaries' and 'masters' cannot "
"both be used in the same zone");
result = ISC_R_FAILURE;
}
}
if (obj == NULL) {
- cfg_obj_log(zoptions, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zoptions, ISC_LOG_ERROR,
"zone '%s': missing 'primaries' entry",
znamestr);
result = ISC_R_FAILURE;
} else {
uint32_t count;
tresult = validate_remotes("primaries", obj, config,
- &count, logctx, mctx);
+ &count, mctx);
if (tresult != ISC_R_SUCCESS && result == ISC_R_SUCCESS)
{
result = tresult;
}
if (tresult == ISC_R_SUCCESS && count == 0) {
- cfg_obj_log(zoptions, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zoptions, ISC_LOG_ERROR,
"zone '%s': "
"empty 'primaries' entry",
znamestr);
in_port_t port =
isc_sockaddr_getport(cfg_obj_assockaddr(obj));
if (port == dnsport) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'%s' cannot specify the "
"DNS listener port (%d)",
sources[i], port);
result = ISC_R_FAILURE;
} else if (port != 0) {
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"'%s': specifying a port is "
"not recommended",
sources[i]);
if (obj != NULL) {
uint32_t count;
tresult = validate_remotes("parental-agents", obj,
- config, &count, logctx,
- mctx);
+ config, &count, mctx);
if (tresult != ISC_R_SUCCESS && result == ISC_R_SUCCESS)
{
result = tresult;
}
if (tresult == ISC_R_SUCCESS && count == 0) {
- cfg_obj_log(zoptions, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zoptions, ISC_LOG_ERROR,
"zone '%s': "
"empty 'parental-agents' entry",
znamestr);
* contradicts the purpose of the former.
*/
if (ztype == CFG_ZONE_MIRROR &&
- !check_recursion(config, voptions, goptions, logctx, actx, mctx))
+ !check_recursion(config, voptions, goptions, actx, mctx))
{
- cfg_obj_log(zoptions, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zoptions, ISC_LOG_ERROR,
"zone '%s': mirror zones cannot be used if "
"recursion is disabled",
znamestr);
obj = NULL;
res2 = cfg_map_get(zoptions, "update-policy", &obj);
if (res1 == ISC_R_SUCCESS && res2 == ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"zone '%s': 'allow-update' is ignored "
"when 'update-policy' is present",
znamestr);
result = ISC_R_FAILURE;
} else if (res2 == ISC_R_SUCCESS) {
- res3 = check_update_policy(obj, logctx);
+ res3 = check_update_policy(obj);
if (res3 != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
ddns = true;
} else if (res1 == ISC_R_SUCCESS) {
dns_acl_t *acl = NULL;
- res1 = cfg_acl_fromconfig(au, config, logctx, actx,
- mctx, 0, &acl);
+ res1 = cfg_acl_fromconfig(au, config, actx, mctx, 0,
+ &acl);
if (res1 != ISC_R_SUCCESS) {
- cfg_obj_log(au, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(au, ISC_LOG_ERROR,
"acl expansion failed: %s",
isc_result_totext(result));
result = ISC_R_FAILURE;
if (has_dnssecpolicy) {
if (!ddns && !signing) {
- cfg_obj_log(kasp, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(kasp, ISC_LOG_ERROR,
"'inline-signing yes;' must also "
"be configured explicitly for "
"zones using dnssec-policy%s. See "
if (res1 == ISC_R_SUCCESS) {
uint32_t type = cfg_obj_asuint32(obj);
if (type < 0xff00U || type > 0xffffU) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"sig-signing-type: %u out of "
"range [%u..%u]",
type, 0xff00U, 0xffffU);
if (res1 == ISC_R_SUCCESS && ztype == CFG_ZONE_SECONDARY &&
!signing)
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-loadkeys-interval: requires "
"inline-signing when used in secondary "
"zone");
continue;
}
if ((dialups[i].allowed & ztype) == 0) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dialup type '%s' is not "
"allowed in '%s' "
"zone '%s'",
break;
}
if (i == sizeof(dialups) / sizeof(dialups[0])) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"invalid dialup type '%s' in zone "
"'%s'",
str, znamestr);
(void)cfg_map_get(goptions, "forwarders", &obj);
}
}
- if (check_forward(config, zoptions, obj, logctx) != ISC_R_SUCCESS) {
+ if (check_forward(config, zoptions, obj) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
if (obj == NULL ||
strcasecmp(cfg_obj_asstring(obj), "first") == 0)
{
- cfg_obj_log(zconfig, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(zconfig, ISC_LOG_WARNING,
"inherited 'forward first;' for "
"%s zone '%s' - did you want "
"'forward only;'?",
isc_netaddr_fromsockaddr(&na, &sa);
if (isc_netaddr_getzone(&na) != 0) {
result = ISC_R_FAILURE;
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"scoped address is not allowed "
"for static stub "
"server-addresses");
tresult = dns_name_fromtext(sname, &b2, dns_rootname, 0,
NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"server-name '%s' is not a valid "
"name",
snamestr);
result = ISC_R_FAILURE;
} else if (dns_name_issubdomain(sname, zname)) {
- cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"server-name '%s' must not be a "
"subdomain of zone name '%s'",
snamestr, znamestr);
case ISC_R_SUCCESS:
break;
case ISC_R_FILENOTFOUND:
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"key-directory: '%s' does not exist", dir);
break;
case ISC_R_INVALIDFILE:
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"key-directory: '%s' is not a directory",
dir);
break;
default:
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"key-directory: '%s' %s", dir,
isc_result_totext(tresult));
result = tresult;
if (zname != NULL) {
if (has_dnssecpolicy) {
tresult = check_keydir(config, zconfig, zname, kaspname,
- dir, keydirs, logctx, mctx);
+ dir, keydirs, mctx);
} else {
tresult = keydirexist(zconfig, "key-directory", zname,
- dir, kaspname, keydirs, logctx,
- mctx);
+ dir, kaspname, keydirs, mctx);
}
if (tresult != ISC_R_SUCCESS) {
result = tresult;
/*
* Check various options.
*/
- tresult = check_options(zoptions, config, false, logctx, mctx,
- optlevel_zone);
+ tresult = check_options(zoptions, config, false, mctx, optlevel_zone);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
obj = NULL;
tresult = cfg_map_get(zoptions, "database", &obj);
if (dlz && tresult == ISC_R_SUCCESS) {
- cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"zone '%s': cannot specify both 'dlz' "
"and 'database'",
znamestr);
(ztype == CFG_ZONE_SECONDARY && res1 == ISC_R_SUCCESS &&
cfg_obj_asboolean(obj)))))
{
- cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zconfig, ISC_LOG_ERROR,
"zone '%s': missing 'file' entry",
znamestr);
result = tresult;
ztype == CFG_ZONE_MIRROR || ddns ||
has_dnssecpolicy))
{
- tresult = fileexist(fileobj, files, true, logctx);
+ tresult = fileexist(fileobj, files, true);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
(ztype == CFG_ZONE_PRIMARY ||
ztype == CFG_ZONE_HINT))
{
- tresult = fileexist(fileobj, files, false, logctx);
+ tresult = fileexist(fileobj, files, false);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
} algorithmtable;
isc_result_t
-isccfg_check_key(const cfg_obj_t *key, isc_log_t *logctx) {
+isccfg_check_key(const cfg_obj_t *key) {
const cfg_obj_t *algobj = NULL;
const cfg_obj_t *secretobj = NULL;
const char *keyname = cfg_obj_asstring(cfg_map_getname(key));
(void)cfg_map_get(key, "algorithm", &algobj);
(void)cfg_map_get(key, "secret", &secretobj);
if (secretobj == NULL || algobj == NULL) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"key '%s' must have both 'secret' and "
"'algorithm' defined",
keyname);
isc_buffer_init(&buf, secretbuf, sizeof(secretbuf));
result = isc_base64_decodestring(cfg_obj_asstring(secretobj), &buf);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(secretobj, logctx, ISC_LOG_ERROR, "bad secret '%s'",
+ cfg_obj_log(secretobj, ISC_LOG_ERROR, "bad secret '%s'",
isc_result_totext(result));
return (result);
}
}
}
if (algorithms[i].name == NULL) {
- cfg_obj_log(algobj, logctx, ISC_LOG_ERROR,
- "unknown algorithm '%s'", algorithm);
+ cfg_obj_log(algobj, ISC_LOG_ERROR, "unknown algorithm '%s'",
+ algorithm);
return (ISC_R_NOTFOUND);
}
if (algorithm[len] == '-') {
if (result == ISC_R_RANGE ||
digestbits > algorithms[i].size)
{
- cfg_obj_log(algobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(algobj, ISC_LOG_ERROR,
"key '%s' digest-bits too large "
"[%u..%u]",
keyname, algorithms[i].size / 2,
return (ISC_R_RANGE);
}
if ((digestbits % 8) != 0) {
- cfg_obj_log(algobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(algobj, ISC_LOG_ERROR,
"key '%s' digest-bits not multiple"
" of 8",
keyname);
if ((digestbits < (algorithms[i].size / 2U) ||
(digestbits < 80U)))
{
- cfg_obj_log(algobj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(algobj, ISC_LOG_WARNING,
"key '%s' digest-bits too small "
"[<%u]",
keyname, algorithms[i].size / 2);
}
} else {
- cfg_obj_log(algobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(algobj, ISC_LOG_ERROR,
"key '%s': unable to parse digest-bits",
keyname);
return (result);
}
static isc_result_t
-fileexist(const cfg_obj_t *obj, isc_symtab_t *symtab, bool writeable,
- isc_log_t *logctx) {
+fileexist(const cfg_obj_t *obj, isc_symtab_t *symtab, bool writeable) {
isc_result_t result;
isc_symvalue_t symvalue;
unsigned int line;
if (writeable) {
file = cfg_obj_file(symvalue.as_cpointer);
line = cfg_obj_line(symvalue.as_cpointer);
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"writeable file '%s': already in use: "
"%s:%u",
cfg_obj_asstring(obj), file, line);
if (result == ISC_R_SUCCESS) {
file = cfg_obj_file(symvalue.as_cpointer);
line = cfg_obj_line(symvalue.as_cpointer);
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"writeable file '%s': already in use: "
"%s:%u",
cfg_obj_asstring(obj), file, line);
static isc_result_t
keydirexist(const cfg_obj_t *zcfg, const char *optname, dns_name_t *zname,
const char *dirname, const char *kaspnamestr, isc_symtab_t *symtab,
- isc_log_t *logctx, isc_mem_t *mctx) {
+ isc_mem_t *mctx) {
isc_result_t result;
isc_symvalue_t symvalue;
char *symkey;
keydir += strlen(keydir);
n = snprintf(keydir, len, "/%s", (dirname == NULL) ? "." : dirname);
if (n > len) {
- cfg_obj_log(zcfg, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(zcfg, ISC_LOG_WARNING,
"%s '%s' truncated because too long, may cause "
"false positives in key directory in use checks",
optname, (dirname == NULL) ? "." : dirname);
return (ISC_R_SUCCESS);
}
- cfg_obj_log(zcfg, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zcfg, ISC_LOG_ERROR,
"%s '%s' already in use by zone %s with "
"policy %s: %s:%u",
optname, keydir,
* Check the key contents for validity.
*/
static isc_result_t
-check_keylist(const cfg_obj_t *keys, isc_symtab_t *symtab, isc_mem_t *mctx,
- isc_log_t *logctx) {
+check_keylist(const cfg_obj_t *keys, isc_symtab_t *symtab, isc_mem_t *mctx) {
char namebuf[DNS_NAME_FORMATSIZE];
dns_fixedname_t fname;
dns_name_t *name;
isc_buffer_add(&b, strlen(keyid));
tresult = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"key '%s': bad key name", keyid);
result = tresult;
continue;
}
- tresult = isccfg_check_key(key, logctx);
+ tresult = isccfg_check_key(key);
if (tresult != ISC_R_SUCCESS) {
return (tresult);
}
if (file == NULL) {
file = "<unknown file>";
}
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"key '%s': already exists "
"previous definition: %s:%u",
keyid, file, line);
static isc_result_t
check_servers(const cfg_obj_t *config, const cfg_obj_t *voptions,
- isc_symtab_t *symtab, isc_mem_t *mctx, isc_log_t *logctx) {
+ isc_symtab_t *symtab, isc_mem_t *mctx) {
dns_fixedname_t fname;
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
if (tresult != ISC_R_SUCCESS) {
INSIST(tresult == ISC_R_FAILURE);
isc_netaddr_format(&n1, buf, sizeof(buf));
- cfg_obj_log(v1, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(v1, ISC_LOG_ERROR,
"server '%s/%u': invalid prefix "
"(extra bits specified)",
buf, p1);
(void)cfg_map_get(v1, xfr, &obj);
if (obj != NULL) {
isc_netaddr_format(&n1, buf, sizeof(buf));
- cfg_obj_log(v1, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(v1, ISC_LOG_ERROR,
"server '%s/%u': %s not legal", buf,
p1, xfr);
result = ISC_R_FAILURE;
cfg_obj_assockaddr(obj);
in_port_t port = isc_sockaddr_getport(sa);
if (port == dnsport) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'%s' cannot specify the "
"DNS listener port (%d)",
xfr, port);
}
isc_netaddr_format(&n2, buf, sizeof(buf));
- cfg_obj_log(v2, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(v2, ISC_LOG_ERROR,
"server '%s/%u': already exists "
"previous definition: %s:%u",
buf, p2, file, line);
tresult = dns_name_fromtext(keyname, &b, dns_rootname,
0, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(keys, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(keys, ISC_LOG_ERROR,
"bad key name '%s'", keyval);
result = ISC_R_FAILURE;
continue;
dns_name_format(keyname, namebuf, sizeof(namebuf));
tresult = isc_symtab_lookup(symtab, namebuf, 1, NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(keys, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(keys, ISC_LOG_ERROR,
"unknown key '%s'", keyval);
result = ISC_R_FAILURE;
}
tresult = (bools[i].set)(
peer, cfg_obj_asboolean(opt));
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(opt, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(opt, ISC_LOG_ERROR,
"setting server option "
"'%s' failed: %s",
bools[i].name,
#define ROOT_KSK_2017 0x08
static isc_result_t
-check_trust_anchor(const cfg_obj_t *key, bool managed, unsigned int *flagsp,
- isc_log_t *logctx) {
+check_trust_anchor(const cfg_obj_t *key, bool managed, unsigned int *flagsp) {
const char *str = NULL, *namestr = NULL;
dns_fixedname_t fkeyname;
dns_name_t *keyname = NULL;
isc_buffer_add(&b, strlen(namestr));
result = dns_name_fromtext(keyname, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(key, logctx, ISC_LOG_WARNING, "bad key name: %s\n",
+ cfg_obj_log(key, ISC_LOG_WARNING, "bad key name: %s\n",
isc_result_totext(result));
result = ISC_R_FAILURE;
}
} else if (strcasecmp(atstr, "initial-ds") == 0) {
anchortype = INIT_DS;
} else {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"key '%s': "
"invalid initialization method '%s'",
namestr, atstr);
case STATIC_DNSKEY:
case TRUSTED:
if (rdata1 > 0xffff) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
- "flags too big: %u", rdata1);
+ cfg_obj_log(key, ISC_LOG_ERROR, "flags too big: %u",
+ rdata1);
result = ISC_R_RANGE;
}
if (rdata1 & DNS_KEYFLAG_REVOKE) {
- cfg_obj_log(key, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(key, ISC_LOG_WARNING,
"key flags revoke bit set");
}
if (rdata2 > 0xff) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
- "protocol too big: %u", rdata2);
+ cfg_obj_log(key, ISC_LOG_ERROR, "protocol too big: %u",
+ rdata2);
result = ISC_R_RANGE;
}
if (rdata3 > 0xff) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"algorithm too big: %u\n", rdata3);
result = ISC_R_RANGE;
}
tresult = isc_base64_decodestring(str, &b);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR, "%s",
+ cfg_obj_log(key, ISC_LOG_ERROR, "%s",
isc_result_totext(tresult));
result = ISC_R_FAILURE;
} else {
if ((rdata3 == DST_ALG_RSASHA1) && r.length > 1 &&
r.base[0] == 1 && r.base[1] == 3)
{
- cfg_obj_log(key, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(key, ISC_LOG_WARNING,
"%s '%s' has a weak exponent",
atstr, namestr);
}
case INIT_DS:
case STATIC_DS:
if (rdata1 > 0xffff) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
- "key tag too big: %u", rdata1);
+ cfg_obj_log(key, ISC_LOG_ERROR, "key tag too big: %u",
+ rdata1);
result = ISC_R_RANGE;
}
if (rdata2 > 0xff) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"algorithm too big: %u\n", rdata2);
result = ISC_R_RANGE;
}
if (rdata3 > 0xff) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(key, ISC_LOG_ERROR,
"digest type too big: %u", rdata3);
result = ISC_R_RANGE;
}
tresult = isc_hex_decodestring(str, &b);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR, "%s",
+ cfg_obj_log(key, ISC_LOG_ERROR, "%s",
isc_result_totext(tresult));
result = ISC_R_FAILURE;
}
static isc_result_t
record_static_keys(isc_symtab_t *symtab, isc_mem_t *mctx,
- const cfg_obj_t *keylist, isc_log_t *logctx,
- bool autovalidation) {
+ const cfg_obj_t *keylist, bool autovalidation) {
isc_result_t result, ret = ISC_R_SUCCESS;
const cfg_listelt_t *elt;
dns_fixedname_t fixed;
}
if (autovalidation && dns_name_equal(name, dns_rootname)) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"static trust anchor for root zone "
"cannot be used with "
"'dnssec-validation auto'.");
}
static isc_result_t
-check_initializing_keys(isc_symtab_t *symtab, const cfg_obj_t *keylist,
- isc_log_t *logctx) {
+check_initializing_keys(isc_symtab_t *symtab, const cfg_obj_t *keylist) {
isc_result_t result, ret = ISC_R_SUCCESS;
const cfg_listelt_t *elt;
dns_fixedname_t fixed;
if (file == NULL) {
file = "<unknown file>";
}
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"static and initializing keys "
"cannot be used for the "
"same domain. "
static isc_result_t
check_ta_conflicts(const cfg_obj_t *global_ta, const cfg_obj_t *view_ta,
const cfg_obj_t *global_tkeys, const cfg_obj_t *view_tkeys,
- bool autovalidation, isc_mem_t *mctx, isc_log_t *logctx) {
+ bool autovalidation, isc_mem_t *mctx) {
isc_result_t result, tresult;
const cfg_listelt_t *elt = NULL;
const cfg_obj_t *keylist = NULL;
elt = cfg_list_next(elt))
{
keylist = cfg_listelt_value(elt);
- tresult = record_static_keys(statictab, mctx, keylist, logctx,
+ tresult = record_static_keys(statictab, mctx, keylist,
autovalidation);
if (result == ISC_R_SUCCESS) {
result = tresult;
elt = cfg_list_next(elt))
{
keylist = cfg_listelt_value(elt);
- tresult = record_static_keys(statictab, mctx, keylist, logctx,
+ tresult = record_static_keys(statictab, mctx, keylist,
autovalidation);
if (result == ISC_R_SUCCESS) {
result = tresult;
elt = cfg_list_next(elt))
{
keylist = cfg_listelt_value(elt);
- tresult = record_static_keys(statictab, mctx, keylist, logctx,
+ tresult = record_static_keys(statictab, mctx, keylist,
autovalidation);
if (result == ISC_R_SUCCESS) {
result = tresult;
elt = cfg_list_next(elt))
{
keylist = cfg_listelt_value(elt);
- tresult = record_static_keys(statictab, mctx, keylist, logctx,
+ tresult = record_static_keys(statictab, mctx, keylist,
autovalidation);
if (result == ISC_R_SUCCESS) {
result = tresult;
elt = cfg_list_next(elt))
{
keylist = cfg_listelt_value(elt);
- tresult = check_initializing_keys(statictab, keylist, logctx);
+ tresult = check_initializing_keys(statictab, keylist);
if (result == ISC_R_SUCCESS) {
result = tresult;
}
elt = cfg_list_next(elt))
{
keylist = cfg_listelt_value(elt);
- tresult = check_initializing_keys(statictab, keylist, logctx);
+ tresult = check_initializing_keys(statictab, keylist);
if (result == ISC_R_SUCCESS) {
result = tresult;
}
static isc_result_t
check_rpz_catz(const char *rpz_catz, const cfg_obj_t *rpz_obj,
- const char *viewname, isc_symtab_t *symtab, isc_log_t *logctx,
+ const char *viewname, isc_symtab_t *symtab,
special_zonetype_t specialzonetype) {
const cfg_listelt_t *element;
const cfg_obj_t *obj, *nameobj, *zoneobj;
if (specialzonetype == special_zonetype_rpz) {
if (++num_zones > 64) {
- cfg_obj_log(nameobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(nameobj, ISC_LOG_ERROR,
"more than 64 response policy "
"zones in view '%s'",
viewname);
tresult = dns_name_fromstring(name, zonename, dns_rootname, 0,
NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(nameobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(nameobj, ISC_LOG_ERROR,
"bad domain name '%s'", zonename);
if (result == ISC_R_SUCCESS) {
result = tresult;
strcasecmp(zonetype, "secondary") != 0 &&
strcasecmp(zonetype, "slave") != 0)
{
- cfg_obj_log(nameobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(nameobj, ISC_LOG_ERROR,
"%s '%s'%s%s is not a primary or secondary "
"zone",
rpz_catz, zonename, forview, viewname);
}
static isc_result_t
-check_rpz(const cfg_obj_t *rpz_obj, isc_log_t *logctx) {
+check_rpz(const cfg_obj_t *rpz_obj) {
const cfg_listelt_t *element;
const cfg_obj_t *obj, *nameobj, *edeobj;
const char *zonename;
tresult = dns_name_fromstring(name, zonename, dns_rootname, 0,
NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
- "bad domain name '%s'", zonename);
+ cfg_obj_log(obj, ISC_LOG_ERROR, "bad domain name '%s'",
+ zonename);
if (result == ISC_R_SUCCESS) {
result = tresult;
continue;
const char *str = cfg_obj_asstring(edeobj);
if (dns_rpz_str2ede(str) == UINT16_MAX) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"unsupported EDE type '%s'", str);
result = ISC_R_FAILURE;
}
}
static isc_result_t
-check_catz(const cfg_obj_t *catz_obj, const char *viewname, isc_mem_t *mctx,
- isc_log_t *logctx) {
+check_catz(const cfg_obj_t *catz_obj, const char *viewname, isc_mem_t *mctx) {
const cfg_listelt_t *element;
const cfg_obj_t *obj, *nameobj, *primariesobj;
const char *zonename;
tresult = dns_name_fromstring(name, zonename, dns_rootname, 0,
NULL);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
- "bad domain name '%s'", zonename);
+ cfg_obj_log(obj, ISC_LOG_ERROR, "bad domain name '%s'",
+ zonename);
if (result == ISC_R_SUCCESS) {
result = tresult;
continue;
dns_name_format(name, namebuf, sizeof(namebuf));
tresult = exists(nameobj, namebuf, 1, symtab,
"catalog zone '%s': already added here %s:%u",
- logctx, mctx);
+ mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
continue;
if (primariesobj != NULL &&
cfg_obj_istuple(primariesobj))
{
- cfg_obj_log(nameobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(nameobj, ISC_LOG_ERROR,
"catalog zone '%s'%s%s: "
"'default-primaries' and "
"'default-masters' can not be both "
*/
struct check_one_plugin_data {
isc_mem_t *mctx;
- isc_log_t *lctx;
cfg_aclconfctx_t *actx;
isc_result_t *check_result;
};
result = ns_plugin_expandpath(plugin_path, full_path,
sizeof(full_path));
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, data->lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"%s: plugin check failed: "
"unable to get full plugin path: %s",
plugin_path, isc_result_totext(result));
result = ns_plugin_check(full_path, parameters, config,
cfg_obj_file(obj), cfg_obj_line(obj),
- data->mctx, data->lctx, data->actx);
+ data->mctx, data->actx);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, data->lctx, ISC_LOG_ERROR,
- "%s: plugin check failed: %s", full_path,
- isc_result_totext(result));
+ cfg_obj_log(obj, ISC_LOG_ERROR, "%s: plugin check failed: %s",
+ full_path, isc_result_totext(result));
*data->check_result = result;
}
}
static isc_result_t
-check_dnstap(const cfg_obj_t *voptions, const cfg_obj_t *config,
- isc_log_t *logctx) {
+check_dnstap(const cfg_obj_t *voptions, const cfg_obj_t *config) {
#ifdef HAVE_DNSTAP
const cfg_obj_t *options = NULL;
const cfg_obj_t *obj = NULL;
(void)cfg_map_get(options, "dnstap", &obj);
}
if (obj != NULL) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"'dnstap-output' must be set if 'dnstap' "
"is set");
return (ISC_R_FAILURE);
#else /* ifdef HAVE_DNSTAP */
UNUSED(voptions);
UNUSED(config);
- UNUSED(logctx);
return (ISC_R_SUCCESS);
#endif /* ifdef HAVE_DNSTAP */
check_viewconf(const cfg_obj_t *config, const cfg_obj_t *voptions,
const char *viewname, dns_rdataclass_t vclass,
isc_symtab_t *files, isc_symtab_t *keydirs, unsigned int flags,
- isc_symtab_t *inview, isc_log_t *logctx, isc_mem_t *mctx) {
+ isc_symtab_t *inview, isc_mem_t *mctx) {
const cfg_obj_t *zones = NULL;
const cfg_obj_t *view_tkeys = NULL, *global_tkeys = NULL;
const cfg_obj_t *view_mkeys = NULL, *global_mkeys = NULL;
tresult = check_zoneconf(zone, voptions, config, symtab, files,
keydirs, inview, viewname, vclass,
- actx, logctx, mctx);
+ actx, mctx);
if (tresult != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
if ((cfg_map_get(opts, "response-policy", &obj) ==
ISC_R_SUCCESS) &&
(check_rpz_catz("response-policy zone", obj, viewname,
- symtab, logctx,
+ symtab,
special_zonetype_rpz) != ISC_R_SUCCESS))
{
result = ISC_R_FAILURE;
if ((cfg_map_get(opts, "catalog-zones", &obj) ==
ISC_R_SUCCESS) &&
(check_rpz_catz("catalog zone", obj, viewname, symtab,
- logctx,
+
special_zonetype_catz) != ISC_R_SUCCESS))
{
result = ISC_R_FAILURE;
obj = NULL;
if ((cfg_map_get(opts, "response-policy", &obj) ==
ISC_R_SUCCESS) &&
- (check_rpz(obj, logctx) != ISC_R_SUCCESS))
+ (check_rpz(obj) != ISC_R_SUCCESS))
{
result = ISC_R_FAILURE;
}
obj = NULL;
if ((cfg_map_get(opts, "catalog-zones", &obj) ==
ISC_R_SUCCESS) &&
- (check_catz(obj, viewname, mctx, logctx) != ISC_R_SUCCESS))
+ (check_catz(obj, viewname, mctx) != ISC_R_SUCCESS))
{
result = ISC_R_FAILURE;
}
/*
* Check that forwarding is reasonable.
*/
- if (opts != NULL &&
- check_forward(config, opts, NULL, logctx) != ISC_R_SUCCESS)
+ if (opts != NULL && check_forward(config, opts, NULL) != ISC_R_SUCCESS)
{
result = ISC_R_FAILURE;
}
/*
* Check non-zero options at the global and view levels.
*/
- if (options != NULL && check_nonzero(options, logctx) != ISC_R_SUCCESS)
- {
+ if (options != NULL && check_nonzero(options) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
- if (voptions != NULL &&
- check_nonzero(voptions, logctx) != ISC_R_SUCCESS)
- {
+ if (voptions != NULL && check_nonzero(voptions) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
/*
* Check that dual-stack-servers is reasonable.
*/
- if (opts != NULL && check_dual_stack(opts, logctx) != ISC_R_SUCCESS) {
+ if (opts != NULL && check_dual_stack(opts) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
/*
* Check that rrset-order is reasonable.
*/
- if (opts != NULL && check_order(opts, logctx) != ISC_R_SUCCESS) {
+ if (opts != NULL && check_order(opts) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
}
(void)cfg_map_get(config, "key", &keys);
- tresult = check_keylist(keys, symtab, mctx, logctx);
+ tresult = check_keylist(keys, symtab, mctx);
if (tresult == ISC_R_EXISTS) {
result = ISC_R_FAILURE;
} else if (tresult != ISC_R_SUCCESS) {
if (voptions != NULL) {
keys = NULL;
(void)cfg_map_get(voptions, "key", &keys);
- tresult = check_keylist(keys, symtab, mctx, logctx);
+ tresult = check_keylist(keys, symtab, mctx);
if (tresult == ISC_R_EXISTS) {
result = ISC_R_FAILURE;
} else if (tresult != ISC_R_SUCCESS) {
/*
* Global servers can refer to keys in views.
*/
- if (check_servers(config, voptions, symtab, mctx, logctx) !=
- ISC_R_SUCCESS)
- {
+ if (check_servers(config, voptions, symtab, mctx) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
element2 = cfg_list_next(element2))
{
obj = cfg_listelt_value(element2);
- tresult = check_trust_anchor(
- obj, false, &taflags, logctx);
+ tresult = check_trust_anchor(obj, false,
+ &taflags);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
}
if ((taflags & ROOT_KSK_STATIC) != 0) {
- cfg_obj_log(check_keys[i], logctx,
- ISC_LOG_WARNING,
+ cfg_obj_log(check_keys[i], ISC_LOG_WARNING,
"trusted-keys entry for the root "
"zone WILL FAIL after key "
"rollover - use trust-anchors "
{
keys = (view_mkeys != NULL) ? view_mkeys : global_mkeys;
- cfg_obj_log(keys, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(keys, ISC_LOG_ERROR,
"use of managed-keys is not allowed when "
"trust-anchors is also in use");
result = ISC_R_FAILURE;
element2 = cfg_list_next(element2))
{
obj = cfg_listelt_value(element2);
- tresult = check_trust_anchor(
- obj, true, &taflags, logctx);
+ tresult = check_trust_anchor(obj, true,
+ &taflags);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
}
if ((taflags & ROOT_KSK_STATIC) != 0) {
- cfg_obj_log(check_keys[i], logctx,
- ISC_LOG_WARNING,
+ cfg_obj_log(check_keys[i], ISC_LOG_WARNING,
"static entry for the root "
"zone WILL FAIL after key "
"rollover - use trust-anchors "
if ((taflags & ROOT_KSK_2010) != 0 &&
(taflags & ROOT_KSK_2017) == 0)
{
- cfg_obj_log(check_keys[i], logctx,
- ISC_LOG_WARNING,
+ cfg_obj_log(check_keys[i], ISC_LOG_WARNING,
"initial-key entry for the root "
"zone uses the 2010 key without "
"the updated 2017 key");
if ((tflags & ROOT_KSK_ANY) != 0 && (dflags & ROOT_KSK_ANY) != 0) {
keys = (view_ta != NULL) ? view_ta : global_ta;
- cfg_obj_log(keys, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(keys, ISC_LOG_WARNING,
"both trusted-keys and trust-anchors "
"for the root zone are present");
}
if ((dflags & ROOT_KSK_ANY) == ROOT_KSK_ANY) {
keys = (view_ta != NULL) ? view_ta : global_ta;
- cfg_obj_log(keys, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(keys, ISC_LOG_WARNING,
"both initial and static entries for the "
"root zone are present");
}
if (global_ta == NULL && view_ta == NULL &&
global_tkeys == NULL && view_tkeys == NULL)
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"the 'dnssec-validation yes' "
"option requires configured "
"'trust-anchors'; consider using "
}
tresult = check_ta_conflicts(global_ta, view_ta, global_tkeys,
- view_tkeys, autovalidation, mctx, logctx);
+ view_tkeys, autovalidation, mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
* Check options.
*/
if (voptions != NULL) {
- tresult = check_options(voptions, NULL, check_algorithms,
- logctx, mctx, optlevel_view);
+ tresult = check_options(voptions, NULL, check_algorithms, mctx,
+ optlevel_view);
} else {
- tresult = check_options(config, config, check_algorithms,
- logctx, mctx, optlevel_config);
+ tresult = check_options(config, config, check_algorithms, mctx,
+ optlevel_config);
}
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
- tresult = check_dnstap(voptions, config, logctx);
+ tresult = check_dnstap(voptions, config);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
- tresult = check_viewacls(actx, voptions, config, logctx, mctx);
+ tresult = check_viewacls(actx, voptions, config, mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
- tresult = check_recursionacls(actx, voptions, viewname, config, logctx,
- mctx);
+ tresult = check_recursionacls(actx, voptions, viewname, config, mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
- tresult = check_dns64(actx, voptions, config, logctx, mctx);
+ tresult = check_dns64(actx, voptions, config, mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
- tresult = check_ratelimit(actx, voptions, config, logctx, mctx);
+ tresult = check_ratelimit(actx, voptions, config, mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
- tresult = check_fetchlimit(voptions, config, logctx);
+ tresult = check_fetchlimit(voptions, config);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
{
struct check_one_plugin_data check_one_plugin_data = {
.mctx = mctx,
- .lctx = logctx,
.actx = actx,
.check_result = &tresult,
};
- (void)cfg_pluginlist_foreach(config, plugin_list, logctx,
+ (void)cfg_pluginlist_foreach(config, plugin_list,
check_one_plugin,
&check_one_plugin_data);
if (tresult != ISC_R_SUCCESS) {
"default_debug", "null", NULL };
static isc_result_t
-check_logging(const cfg_obj_t *config, isc_log_t *logctx, isc_mem_t *mctx) {
+check_logging(const cfg_obj_t *config, isc_mem_t *mctx) {
const cfg_obj_t *categories = NULL;
const cfg_obj_t *category;
const cfg_obj_t *channels = NULL;
i++;
}
if (i != 1) {
- cfg_obj_log(channel, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(channel, ISC_LOG_ERROR,
"channel '%s': exactly one of file, "
"syslog, "
"null, and stderr must be present",
{
category = cfg_listelt_value(element);
catname = cfg_obj_asstring(cfg_tuple_get(category, "name"));
- if (isc_log_categorybyname(logctx, catname) == NULL) {
- cfg_obj_log(category, logctx, ISC_LOG_ERROR,
+ if (isc_log_categorybyname(catname) == NULL) {
+ cfg_obj_log(category, ISC_LOG_ERROR,
"undefined category: '%s'", catname);
result = ISC_R_FAILURE;
}
tresult = isc_symtab_lookup(symtab, channelname, 1,
&symvalue);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(channel, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(channel, ISC_LOG_ERROR,
"undefined channel: '%s'",
channelname);
result = tresult;
}
static isc_result_t
-check_controlskeys(const cfg_obj_t *control, const cfg_obj_t *keylist,
- isc_log_t *logctx) {
+check_controlskeys(const cfg_obj_t *control, const cfg_obj_t *keylist) {
isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *control_keylist;
const cfg_listelt_t *element;
keyval = cfg_obj_asstring(key);
if (!rndckey_exists(keylist, keyval)) {
- cfg_obj_log(key, logctx, ISC_LOG_ERROR,
- "unknown key '%s'", keyval);
+ cfg_obj_log(key, ISC_LOG_ERROR, "unknown key '%s'",
+ keyval);
result = ISC_R_NOTFOUND;
}
}
}
static isc_result_t
-check_controls(const cfg_obj_t *config, isc_log_t *logctx, isc_mem_t *mctx) {
+check_controls(const cfg_obj_t *config, isc_mem_t *mctx) {
isc_result_t result = ISC_R_SUCCESS, tresult;
cfg_aclconfctx_t *actx = NULL;
const cfg_listelt_t *element, *element2;
control = cfg_listelt_value(element2);
allow = cfg_tuple_get(control, "allow");
- tresult = cfg_acl_fromconfig(allow, config, logctx,
- actx, mctx, 0, &acl);
+ tresult = cfg_acl_fromconfig(allow, config, actx, mctx,
+ 0, &acl);
if (acl != NULL) {
dns_acl_detach(&acl);
}
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
- tresult = check_controlskeys(control, keylist, logctx);
+ tresult = check_controlskeys(control, keylist);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
obj, socktext, 1, symtab,
"inet control socket '%s': already defined, "
"previous definition: %s:%u",
- logctx, mctx);
+ mctx);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
{
control = cfg_listelt_value(element2);
path = cfg_obj_asstring(cfg_tuple_get(control, "path"));
- cfg_obj_log(control, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(control, ISC_LOG_ERROR,
"unix control '%s': not supported", path);
result = ISC_R_FAMILYNOSUPPORT;
}
isc_result_t
isccfg_check_namedconf(const cfg_obj_t *config, unsigned int flags,
- isc_log_t *logctx, isc_mem_t *mctx) {
+ isc_mem_t *mctx) {
const cfg_obj_t *options = NULL;
const cfg_obj_t *views = NULL;
const cfg_obj_t *acls = NULL;
(void)cfg_map_get(config, "options", &options);
if (options != NULL &&
- check_options(options, config, check_algorithms, logctx, mctx,
+ check_options(options, config, check_algorithms, mctx,
optlevel_options) != ISC_R_SUCCESS)
{
result = ISC_R_FAILURE;
}
- if (check_logging(config, logctx, mctx) != ISC_R_SUCCESS) {
+ if (check_logging(config, mctx) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
- if (check_controls(config, logctx, mctx) != ISC_R_SUCCESS) {
+ if (check_controls(config, mctx) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
- if (check_primarylists(config, logctx, mctx) != ISC_R_SUCCESS) {
+ if (check_primarylists(config, mctx) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
- if (check_parentalagentlists(config, logctx, mctx) != ISC_R_SUCCESS) {
+ if (check_parentalagentlists(config, mctx) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
#if HAVE_LIBNGHTTP2
- if (check_httpservers(config, logctx, mctx) != ISC_R_SUCCESS) {
+ if (check_httpservers(config, mctx) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
#endif /* HAVE_LIBNGHTTP2 */
- if (check_tls_definitions(config, logctx, mctx) != ISC_R_SUCCESS) {
+ if (check_tls_definitions(config, mctx) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
(void)cfg_map_get(config, "view", &views);
if (views != NULL && options != NULL) {
- if (check_dual_stack(options, logctx) != ISC_R_SUCCESS) {
+ if (check_dual_stack(options) != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
/*
if (views == NULL) {
tresult = check_viewconf(config, NULL, NULL, dns_rdataclass_in,
- files, keydirs, flags, inview, logctx,
- mctx);
+ files, keydirs, flags, inview, mctx);
if (result == ISC_R_SUCCESS && tresult != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
(void)cfg_map_get(config, "zone", &zones);
if (zones != NULL) {
- cfg_obj_log(zones, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(zones, ISC_LOG_ERROR,
"when using 'view' statements, "
"all zones must be in views");
result = ISC_R_FAILURE;
(void)cfg_map_get(config, "plugin", &plugins);
if (plugins != NULL) {
- cfg_obj_log(plugins, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(plugins, ISC_LOG_ERROR,
"when using 'view' statements, "
"all plugins must be defined in views");
result = ISC_R_FAILURE;
r.length = strlen(r.base);
tresult = dns_rdataclass_fromtext(&vclass, &r);
if (tresult != ISC_R_SUCCESS) {
- cfg_obj_log(vclassobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(vclassobj, ISC_LOG_ERROR,
"view '%s': invalid class %s",
cfg_obj_asstring(vname), r.base);
}
ISC_R_SUCCESS);
file = cfg_obj_file(symvalue.as_cpointer);
line = cfg_obj_line(symvalue.as_cpointer);
- cfg_obj_log(view, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(view, ISC_LOG_ERROR,
"view '%s': already exists "
"previous definition: %s:%u",
key, file, line);
(strcasecmp(key, "_default") == 0 &&
vclass == dns_rdataclass_in))
{
- cfg_obj_log(view, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(view, ISC_LOG_ERROR,
"attempt to redefine builtin view "
"'%s'",
key);
if (tresult == ISC_R_SUCCESS) {
tresult = check_viewconf(config, voptions, key, vclass,
files, keydirs, flags, inview,
- logctx, mctx);
+ mctx);
}
if (tresult != ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
{
if (strcasecmp(aclname, builtin[i]) == 0) {
{
- cfg_obj_log(acl, logctx,
- ISC_LOG_ERROR,
+ cfg_obj_log(acl, ISC_LOG_ERROR,
"attempt to "
"redefine "
"builtin acl '%s'",
file = "<unknown file>";
}
- cfg_obj_log(acl2, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(acl2, ISC_LOG_ERROR,
"attempt to redefine "
"acl '%s' previous "
"definition: %s:%u",
isc_result_t
cfg_acl_fromconfig(const cfg_obj_t *caml, const cfg_obj_t *cctx,
- isc_log_t *lctx, cfg_aclconfctx_t *ctx, isc_mem_t *mctx,
+ cfg_aclconfctx_t *ctx, isc_mem_t *mctx,
unsigned int nest_level, dns_acl_t **target);
/*
* Construct a new dns_acl_t from configuration data in 'caml' and
*/
isc_result_t
-cfg_parser_create(isc_mem_t *mctx, isc_log_t *lctx, cfg_parser_t **ret);
+cfg_parser_create(isc_mem_t *mctx, cfg_parser_t **ret);
/*%<
* Create a configuration file parser. Any warning and error
- * messages will be logged to 'lctx'.
+ * messages will be logged.
*
* The parser object returned can be used for a single call
* to cfg_parse_file() or cfg_parse_buffer(). It must not
*/
void
-cfg_obj_log(const cfg_obj_t *obj, isc_log_t *lctx, int level, const char *fmt,
- ...) ISC_FORMAT_PRINTF(4, 5);
+cfg_obj_log(const cfg_obj_t *obj, int level, const char *fmt, ...)
+ ISC_FORMAT_PRINTF(3, 4);
/*%<
* Log a message concerning configuration object 'obj' to the logging
* channel of 'pctx', at log level 'level'. The message will be prefixed
isc_result_t
cfg_pluginlist_foreach(const cfg_obj_t *config, const cfg_obj_t *list,
- isc_log_t *lctx, pluginlist_cb_t *callback,
- void *callback_data);
+ pluginlist_cb_t *callback, void *callback_data);
/*%<
* For every "plugin" stanza present in 'list' (which in turn is a part of
* 'config'), invoke the given 'callback', passing 'callback_data' to it along
* with a fixed set of arguments (see the definition of the #pluginlist_cb_t
- * type). Use logging context 'lctx' for logging error messages. Interrupt
- * processing if 'callback' returns something else than #ISC_R_SUCCESS for any
- * element of 'list'.
+ * type). Interrupt processing if 'callback' returns something else than
+ * #ISC_R_SUCCESS for any element of 'list'.
*
* Requires:
*
isc_result_t
isccfg_check_namedconf(const cfg_obj_t *config, unsigned int flags,
- isc_log_t *logctx, isc_mem_t *mctx);
+ isc_mem_t *mctx);
/*%<
* Check the syntactic validity of a configuration parse tree generated from
* a named.conf file.
*/
isc_result_t
-isccfg_check_key(const cfg_obj_t *config, isc_log_t *logctx);
+isccfg_check_key(const cfg_obj_t *config);
/*%<
* Same as isccfg_check_namedconf(), but for a single 'key' statement.
*/
/*% The parser object. */
struct cfg_parser {
isc_mem_t *mctx;
- isc_log_t *lctx;
isc_lex_t *lexer;
unsigned int errors;
unsigned int warnings;
isc_result_t
cfg_kasp_fromconfig(const cfg_obj_t *config, dns_kasp_t *default_kasp,
- bool check_algorithms, isc_mem_t *mctx, isc_log_t *logctx,
+ bool check_algorithms, isc_mem_t *mctx,
dns_keystorelist_t *keystorelist, dns_kasplist_t *kasplist,
dns_kasp_t **kaspp);
/*%<
isc_result_t
cfg_keystore_fromconfig(const cfg_obj_t *config, isc_mem_t *mctx,
- isc_log_t *logctx, dns_keystorelist_t *keystorelist,
- dns_keystore_t **kspp);
+ dns_keystorelist_t *keystorelist,
+ dns_keystore_t **kspp);
/*%<
* Create and configure a key store. If a 'keystorelist' is provided, a lookup
* happens and if a keystore already exists with the same name, no new one is
ISC_LANG_BEGINDECLS
void
-cfg_log_init(isc_log_t *lctx);
+cfg_log_init(void);
/*%<
* Make the libisccfg categories and modules available for use with the
* ISC logging library.
*
* Requires:
- *\li lctx is a valid logging context.
- *
*\li cfg_log_init() is called only once.
*
* Ensures:
*/
static isc_result_t
cfg_kaspkey_fromconfig(const cfg_obj_t *config, dns_kasp_t *kasp,
- bool check_algorithms, isc_log_t *logctx,
- dns_keystorelist_t *keystorelist,
+ bool check_algorithms, dns_keystorelist_t *keystorelist,
uint32_t ksk_min_lifetime, uint32_t zsk_min_lifetime) {
isc_result_t result;
dns_kasp_key_t *key = NULL;
result = dns_keystorelist_find(keystorelist, keydir,
&key->keystore);
if (result == ISC_R_NOTFOUND) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-policy: keystore %s does not exist",
keydir);
result = ISC_R_FAILURE;
goto cleanup;
} else if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-policy: bad keystore %s", keydir);
result = ISC_R_FAILURE;
goto cleanup;
}
if (key->lifetime > 0) {
if (key->lifetime < 30 * (24 * 3600)) {
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"dnssec-policy: key lifetime is "
"shorter than 30 days");
}
error = true;
}
if (error) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-policy: key lifetime is "
"shorter than the time it takes to "
"do a rollover");
result = dns_secalg_fromtext(&key->algorithm,
(isc_textregion_t *)&alg);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-policy: bad algorithm %s",
alg.base);
result = DNS_R_BADALG;
(key->algorithm == DNS_KEYALG_RSASHA1 ||
key->algorithm == DNS_KEYALG_NSEC3RSASHA1))
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-policy: algorithm %s not supported "
"in FIPS mode",
alg.base);
if (check_algorithms &&
!dst_algorithm_supported(key->algorithm))
{
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-policy: algorithm %s not supported",
alg.base);
result = DNS_R_BADALG;
min = DNS_KEYALG_RSASHA512 ? 1024 : 512;
}
if (size < min || size > 4096) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-policy: key with "
"algorithm %s has invalid "
"key length %u",
case DNS_KEYALG_ECDSA384:
case DNS_KEYALG_ED25519:
case DNS_KEYALG_ED448:
- cfg_obj_log(obj, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(obj, ISC_LOG_WARNING,
"dnssec-policy: key algorithm %s "
"has predefined length; ignoring "
"length value %u",
}
static isc_result_t
-cfg_nsec3param_fromconfig(const cfg_obj_t *config, dns_kasp_t *kasp,
- isc_log_t *logctx) {
+cfg_nsec3param_fromconfig(const cfg_obj_t *config, dns_kasp_t *kasp) {
dns_kasp_key_t *kkey;
unsigned int min_keysize = 4096;
const cfg_obj_t *obj = NULL;
char algstr[DNS_SECALG_FORMATSIZE];
dns_secalg_format((dns_secalg_t)badalg, algstr, sizeof(algstr));
cfg_obj_log(
- obj, logctx, ISC_LOG_ERROR,
+ obj, ISC_LOG_ERROR,
"dnssec-policy: cannot use nsec3 with algorithm '%s'",
algstr);
return (DNS_R_NSEC3BADALG);
}
if (iter != DEFAULT_NSEC3PARAM_ITER) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-policy: nsec3 iterations value %u "
"not allowed, must be zero",
iter);
saltlen = cfg_obj_asuint32(obj);
}
if (saltlen > 0xff) {
- cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"dnssec-policy: nsec3 salt length %u too high",
saltlen);
return (DNS_R_NSEC3SALTRANGE);
}
static isc_result_t
-add_digest(dns_kasp_t *kasp, const cfg_obj_t *digest, isc_log_t *logctx) {
+add_digest(dns_kasp_t *kasp, const cfg_obj_t *digest) {
isc_result_t result = ISC_R_SUCCESS;
isc_textregion_t r;
dns_dsdigest_t alg;
r.length = strlen(str);
result = dns_dsdigest_fromtext(&alg, &r);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(digest, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(digest, ISC_LOG_ERROR,
"dnssec-policy: bad cds digest-type %s", str);
result = DNS_R_BADALG;
} else if (!dst_ds_digest_supported(alg)) {
- cfg_obj_log(digest, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(digest, ISC_LOG_ERROR,
"dnssec-policy: unsupported cds "
"digest-type %s",
str);
isc_result_t
cfg_kasp_fromconfig(const cfg_obj_t *config, dns_kasp_t *default_kasp,
- bool check_algorithms, isc_mem_t *mctx, isc_log_t *logctx,
+ bool check_algorithms, isc_mem_t *mctx,
dns_keystorelist_t *keystorelist, dns_kasplist_t *kasplist,
dns_kasp_t **kaspp) {
isc_result_t result;
kaspname = cfg_obj_asstring(cfg_tuple_get(config, "name"));
INSIST(kaspname != NULL);
- cfg_obj_log(config, logctx, ISC_LOG_DEBUG(1),
- "dnssec-policy: load policy '%s'", kaspname);
+ cfg_obj_log(config, ISC_LOG_DEBUG(1), "dnssec-policy: load policy '%s'",
+ kaspname);
result = dns_kasplist_find(kasplist, kaspname, &kasp);
if (result == ISC_R_SUCCESS) {
cfg_obj_log(
- config, logctx, ISC_LOG_ERROR,
+ config, ISC_LOG_ERROR,
"dnssec-policy: duplicately named policy found '%s'",
kaspname);
dns_kasp_detach(&kasp);
DNS_KASP_SIG_VALIDITY_DNSKEY);
if (sigrefresh >= (sigvalidity * 0.9)) {
cfg_obj_log(
- config, logctx, ISC_LOG_ERROR,
+ config, ISC_LOG_ERROR,
"dnssec-policy: policy '%s' signatures-refresh must be "
"at most 90%% of the signatures-validity-dnskey",
kaspname);
if (sigjitter > sigvalidity) {
cfg_obj_log(
- config, logctx, ISC_LOG_ERROR,
+ config, ISC_LOG_ERROR,
"dnssec-policy: policy '%s' signatures-jitter cannot "
"be larger than signatures-validity-dnskey",
kaspname);
DNS_KASP_SIG_VALIDITY);
if (sigrefresh >= (sigvalidity * 0.9)) {
cfg_obj_log(
- config, logctx, ISC_LOG_ERROR,
+ config, ISC_LOG_ERROR,
"dnssec-policy: policy '%s' signatures-refresh must be "
"at most 90%% of the signatures-validity",
kaspname);
if (sigjitter > sigvalidity) {
cfg_obj_log(
- config, logctx, ISC_LOG_ERROR,
+ config, ISC_LOG_ERROR,
"dnssec-policy: policy '%s' signatures-jitter cannot "
"be larger than signatures-validity",
kaspname);
for (element = cfg_list_first(cds); element != NULL;
element = cfg_list_next(element))
{
- result = add_digest(kasp, cfg_listelt_value(element),
- logctx);
+ result = add_digest(kasp, cfg_listelt_value(element));
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
{
cfg_obj_t *kobj = cfg_listelt_value(element);
result = cfg_kaspkey_fromconfig(
- kobj, kasp, check_algorithms, logctx,
- keystorelist, ksk_min_lifetime,
- zsk_min_lifetime);
+ kobj, kasp, check_algorithms, keystorelist,
+ ksk_min_lifetime, zsk_min_lifetime);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(kobj, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(kobj, ISC_LOG_ERROR,
"dnssec-policy: failed to "
"configure keys (%s)",
isc_result_totext(result));
if (role[i] !=
(DNS_KASP_KEY_ROLE_ZSK | DNS_KASP_KEY_ROLE_KSK))
{
- cfg_obj_log(keys, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(keys, ISC_LOG_ERROR,
"dnssec-policy: algorithm %zu "
"requires both KSK and ZSK roles",
i);
result = ISC_R_FAILURE;
}
if (warn[i][0]) {
- cfg_obj_log(keys, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(keys, ISC_LOG_WARNING,
"dnssec-policy: algorithm %zu has "
"multiple keys with ZSK role",
i);
}
if (warn[i][1]) {
- cfg_obj_log(keys, logctx, ISC_LOG_WARNING,
+ cfg_obj_log(keys, ISC_LOG_WARNING,
"dnssec-policy: algorithm %zu has "
"multiple keys with KSK role",
i);
new_key = NULL;
result = dns_kasp_key_create(kasp, &new_key);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(config, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(config, ISC_LOG_ERROR,
"dnssec-policy: failed to "
"configure keys (%s)",
isc_result_totext(result));
keystorelist, DNS_KEYSTORE_KEYDIRECTORY,
&new_key->keystore);
if (result != ISC_R_SUCCESS) {
- cfg_obj_log(config, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(config, ISC_LOG_ERROR,
"dnssec-policy: failed to "
"find keystore (%s)",
isc_result_totext(result));
}
} else {
dns_kasp_setnsec3(kasp, true);
- result = cfg_nsec3param_fromconfig(nsec3, kasp, logctx);
+ result = cfg_nsec3param_fromconfig(nsec3, kasp);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
isc_result_t
cfg_keystore_fromconfig(const cfg_obj_t *config, isc_mem_t *mctx,
- isc_log_t *logctx, dns_keystorelist_t *keystorelist,
+ dns_keystorelist_t *keystorelist,
dns_keystore_t **kspp) {
isc_result_t result;
const cfg_obj_t *maps[2];
result = dns_keystorelist_find(keystorelist, name, &keystore);
if (result == ISC_R_SUCCESS) {
- cfg_obj_log(config, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(config, ISC_LOG_ERROR,
"key-store: duplicate key-store found '%s'", name);
dns_keystore_detach(&keystore);
return (ISC_R_EXISTS);
}
if (result != ISC_R_NOTFOUND) {
- cfg_obj_log(config, logctx, ISC_LOG_ERROR,
+ cfg_obj_log(config, ISC_LOG_ERROR,
"key-store: lookup '%s' failed: %s", name,
isc_result_totext(result));
return (result);
isc_logmodule_t cfg_modules[] = { { "isccfg/parser", 0 }, { NULL, 0 } };
void
-cfg_log_init(isc_log_t *lctx) {
- isc_log_registercategories(lctx, cfg_categories);
- isc_log_registermodules(lctx, cfg_modules);
+cfg_log_init(void) {
+ isc_log_registercategories(cfg_categories);
+ isc_log_registermodules(cfg_modules);
}
&cfg_rep_list, &cfg_type_qstring };
isc_result_t
-cfg_parser_create(isc_mem_t *mctx, isc_log_t *lctx, cfg_parser_t **ret) {
+cfg_parser_create(isc_mem_t *mctx, cfg_parser_t **ret) {
isc_result_t result;
cfg_parser_t *pctx;
isc_lexspecials_t specials;
isc_refcount_init(&pctx->references, 1);
- pctx->lctx = lctx;
pctx->lexer = NULL;
pctx->seen_eof = false;
pctx->ungotten = false;
} else {
tokenbuf[0] = '\0';
}
- isc_log_write(pctx->lctx, CAT, MOD, level, "%s%s%s%s", where, message,
- prep, tokenbuf);
+ isc_log_write(CAT, MOD, level, "%s%s%s%s", where, message, prep,
+ tokenbuf);
}
void
-cfg_obj_log(const cfg_obj_t *obj, isc_log_t *lctx, int level, const char *fmt,
- ...) {
+cfg_obj_log(const cfg_obj_t *obj, int level, const char *fmt, ...) {
va_list ap;
char msgbuf[2048];
REQUIRE(obj != NULL);
REQUIRE(fmt != NULL);
- if (!isc_log_wouldlog(lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
va_end(ap);
if (obj->file != NULL) {
- isc_log_write(lctx, CAT, MOD, level, "%s:%u: %s", obj->file,
+ isc_log_write(CAT, MOD, level, "%s:%u: %s", obj->file,
obj->line, msgbuf);
} else {
- isc_log_write(lctx, CAT, MOD, level, "%s", msgbuf);
+ isc_log_write(CAT, MOD, level, "%s", msgbuf);
}
}
isc_result_t
cfg_pluginlist_foreach(const cfg_obj_t *config, const cfg_obj_t *list,
- isc_log_t *lctx, pluginlist_cb_t *callback,
- void *callback_data) {
+ pluginlist_cb_t *callback, void *callback_data) {
isc_result_t result = ISC_R_SUCCESS;
const cfg_listelt_t *element;
/* Only query plugins are supported currently. */
if (strcasecmp(type, "query") != 0) {
- cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
+ cfg_obj_log(obj, ISC_LOG_ERROR,
"unsupported plugin type");
return (ISC_R_FAILURE);
}
} else {
loglevel = ISC_LOG_DEBUG(1);
}
- wouldlog = isc_log_wouldlog(ns_lctx, loglevel);
+ wouldlog = isc_log_wouldlog(loglevel);
rrl_result = dns_rrl(client->view, NULL, &client->peeraddr,
TCP_CLIENT(client), dns_rdataclass_in,
dns_rdatatype_none, NULL, result,
client->view->proxyacl,
false) != ISC_R_SUCCESS)
{
- if (isc_log_wouldlog(ns_lctx, log_level)) {
+ if (isc_log_wouldlog(log_level)) {
isc_sockaddr_format(&real_peer, fmtbuf,
sizeof(fmtbuf));
ns_client_log(
client->view->proxyonacl,
true) != ISC_R_SUCCESS)
{
- if (isc_log_wouldlog(ns_lctx, log_level)) {
+ if (isc_log_wouldlog(log_level)) {
isc_sockaddr_format(&real_local, fmtbuf,
sizeof(fmtbuf));
ns_client_log(
snprintf(peerbuf, sizeof(peerbuf), "(no-peer)");
}
- isc_log_write(ns_lctx, category, module, level,
+ isc_log_write(category, module, level,
"client @%p %s%s%s%s%s%s%s%s: %s", client, peerbuf, sep1,
signer, sep2, qname, sep3, sep4, viewname, msgbuf);
}
isc_logmodule_t *module, int level, const char *fmt, ...) {
va_list ap;
- if (!isc_log_wouldlog(ns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
int len = 1024;
isc_result_t result;
- if (!isc_log_wouldlog(ns_lctx, ISC_LOG_DEBUG(1))) {
+ if (!isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
return;
}
if (errmsg == NULL) {
errmsg = "returned function pointer is NULL";
}
- isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL,
- NS_LOGMODULE_HOOKS, ISC_LOG_ERROR,
+ isc_log_write(NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
+ ISC_LOG_ERROR,
"failed to look up symbol %s in "
"plugin '%s': %s",
symbol_name, modpath, errmsg);
if (errmsg == NULL) {
errmsg = "unknown error";
}
- isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL,
- NS_LOGMODULE_HOOKS, ISC_LOG_ERROR,
+ isc_log_write(NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
+ ISC_LOG_ERROR,
"failed to dlopen() plugin '%s': %s", modpath,
errmsg);
CHECK(ISC_R_FAILURE);
if (version < (NS_PLUGIN_VERSION - NS_PLUGIN_AGE) ||
version > NS_PLUGIN_VERSION)
{
- isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL,
- NS_LOGMODULE_HOOKS, ISC_LOG_ERROR,
+ isc_log_write(NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
+ ISC_LOG_ERROR,
"plugin API version mismatch: %d/%d", version,
NS_PLUGIN_VERSION);
CHECK(ISC_R_FAILURE);
return (ISC_R_SUCCESS);
cleanup:
- isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
- ISC_LOG_ERROR,
+ isc_log_write(NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS, ISC_LOG_ERROR,
"failed to dynamically load plugin '%s': %s", modpath,
isc_result_totext(result));
plugin = *pluginp;
*pluginp = NULL;
- isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
+ isc_log_write(NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
ISC_LOG_DEBUG(1), "unloading plugin '%s'",
plugin->modpath);
isc_result_t
ns_plugin_register(const char *modpath, const char *parameters, const void *cfg,
const char *cfg_file, unsigned long cfg_line,
- isc_mem_t *mctx, isc_log_t *lctx, void *actx,
- dns_view_t *view) {
+ isc_mem_t *mctx, void *actx, dns_view_t *view) {
isc_result_t result;
ns_plugin_t *plugin = NULL;
REQUIRE(mctx != NULL);
- REQUIRE(lctx != NULL);
REQUIRE(view != NULL);
- isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
- ISC_LOG_INFO, "loading plugin '%s'", modpath);
+ isc_log_write(NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS, ISC_LOG_INFO,
+ "loading plugin '%s'", modpath);
CHECK(load_plugin(mctx, modpath, &plugin));
- isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
- ISC_LOG_INFO, "registering plugin '%s'", modpath);
+ isc_log_write(NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS, ISC_LOG_INFO,
+ "registering plugin '%s'", modpath);
CHECK(plugin->register_func(parameters, cfg, cfg_file, cfg_line, mctx,
- lctx, actx, view->hooktable,
- &plugin->inst));
+ actx, view->hooktable, &plugin->inst));
ISC_LIST_APPEND(*(ns_plugins_t *)view->plugins, plugin, link);
isc_result_t
ns_plugin_check(const char *modpath, const char *parameters, const void *cfg,
const char *cfg_file, unsigned long cfg_line, isc_mem_t *mctx,
- isc_log_t *lctx, void *actx) {
+ void *actx) {
isc_result_t result;
ns_plugin_t *plugin = NULL;
CHECK(load_plugin(mctx, modpath, &plugin));
result = plugin->check_func(parameters, cfg, cfg_file, cfg_line, mctx,
- lctx, actx);
+ actx);
cleanup:
if (plugin != NULL) {
typedef isc_result_t
ns_plugin_register_t(const char *parameters, const void *cfg, const char *file,
- unsigned long line, isc_mem_t *mctx, isc_log_t *lctx,
- void *actx, ns_hooktable_t *hooktable, void **instp);
+ unsigned long line, isc_mem_t *mctx, void *actx,
+ ns_hooktable_t *hooktable, void **instp);
/*%<
* Called when registering a new plugin.
*
typedef isc_result_t
ns_plugin_check_t(const char *parameters, const void *cfg, const char *file,
- unsigned long line, isc_mem_t *mctx, isc_log_t *lctx,
- void *actx);
+ unsigned long line, isc_mem_t *mctx, void *actx);
/*%<
* Check the validity of 'parameters'.
*/
isc_result_t
ns_plugin_register(const char *modpath, const char *parameters, const void *cfg,
const char *cfg_file, unsigned long cfg_line,
- isc_mem_t *mctx, isc_log_t *lctx, void *actx,
- dns_view_t *view);
+ isc_mem_t *mctx, void *actx, dns_view_t *view);
/*%<
* Load the plugin module specified from the file 'modpath', and
* register an instance using 'parameters'.
isc_result_t
ns_plugin_check(const char *modpath, const char *parameters, const void *cfg,
const char *cfg_file, unsigned long cfg_line, isc_mem_t *mctx,
- isc_log_t *lctx, void *actx);
+ void *actx);
/*%<
* Open the plugin module at 'modpath' and check the validity of
* 'parameters', logging any errors or warnings found, then
#include <isc/log.h>
#include <isc/types.h>
-extern isc_log_t *ns_lctx;
extern isc_logcategory_t ns_categories[];
extern isc_logmodule_t ns_modules[];
#define NS_LOGMODULE_HOOKS (&ns_modules[7])
void
-ns_log_init(isc_log_t *lctx);
+ns_log_init(void);
/*%<
* Make the libns categories and modules available for use with the
* ISC logging library.
#define IFMGR_MAGIC ISC_MAGIC('I', 'F', 'M', 'G')
#define NS_INTERFACEMGR_VALID(t) ISC_MAGIC_VALID(t, IFMGR_MAGIC)
-#define IFMGR_COMMON_LOGARGS \
- ns_lctx, NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR
-
/*% nameserver interface manager structure */
struct ns_interfacemgr {
unsigned int magic; /*%< Magic number */
struct MSGHDR *rtm = NULL;
size_t rtmlen;
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_DEBUG(9), "route_recv: %s",
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_DEBUG(9), "route_recv: %s",
isc_result_totext(eresult));
if (handle == NULL) {
case ISC_R_SUCCESS:
break;
default:
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_ERROR,
"automatic interface scanning terminated: %s",
isc_result_totext(eresult));
FALLTHROUGH;
#ifdef RTM_VERSION
if (rtm->rtm_version != RTM_VERSION) {
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_ERROR,
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_ERROR,
"automatic interface rescanning disabled: "
"rtm->rtm_version mismatch (%u != %u) "
"recompile required",
route_connected(isc_nmhandle_t *handle, isc_result_t eresult, void *arg) {
ns_interfacemgr_t *mgr = (ns_interfacemgr_t *)arg;
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_DEBUG(9),
- "route_connected: %s", isc_result_totext(eresult));
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_DEBUG(9), "route_connected: %s",
+ isc_result_totext(eresult));
if (eresult != ISC_R_SUCCESS) {
ns_interfacemgr_detach(&mgr);
isc_result_t result = isc_nm_routeconnect(mgr->nm, route_connected,
mgr);
if (result != ISC_R_SUCCESS) {
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_INFO,
- "unable to open route socket: %s",
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_INFO, "unable to open route socket: %s",
isc_result_totext(result));
ns_interfacemgr_unref(mgr);
}
ifp, ns__client_tcpconn, ifp, ifp->mgr->backlog,
&ifp->mgr->sctx->tcpquota, NULL, proxy, &ifp->tcplistensocket);
if (result != ISC_R_SUCCESS) {
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_ERROR,
- "creating TCP socket: %s",
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_ERROR, "creating TCP socket: %s",
isc_result_totext(result));
}
*/
result = ns__client_tcpconn(NULL, ISC_R_SUCCESS, ifp);
if (result != ISC_R_SUCCESS) {
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_ERROR,
- "connecting TCP socket: %s",
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_ERROR, "connecting TCP socket: %s",
isc_result_totext(result));
}
&ifp->tlslistensocket);
if (result != ISC_R_SUCCESS) {
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_ERROR,
- "creating TLS socket: %s",
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_ERROR, "creating TLS socket: %s",
isc_result_totext(result));
return (result);
}
*/
result = ns__client_tcpconn(NULL, ISC_R_SUCCESS, ifp);
if (result != ISC_R_SUCCESS) {
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_ERROR,
- "updating TCP stats: %s",
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_ERROR, "updating TCP stats: %s",
isc_result_totext(result));
}
}
if (result != ISC_R_SUCCESS) {
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_ERROR,
- "creating %s socket: %s",
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_ERROR, "creating %s socket: %s",
sslctx ? "HTTPS" : "HTTP",
isc_result_totext(result));
return (result);
*/
result = ns__client_tcpconn(NULL, ISC_R_SUCCESS, ifp);
if (result != ISC_R_SUCCESS) {
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_ERROR,
- "updating TCP stats: %s",
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_ERROR, "updating TCP stats: %s",
isc_result_totext(result));
}
log_interface_shutdown(const ns_interface_t *ifp) {
char sabuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&ifp->addr, sabuf, sizeof(sabuf));
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_INFO,
- "no longer listening on %s", sabuf);
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_INFO, "no longer listening on %s", sabuf);
}
/*%
}
if (result != ISC_R_SUCCESS) {
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_WARNING,
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_WARNING,
"omitting IPv4 interface %s from "
"localnets ACL: %s",
interface->name, isc_result_totext(result));
}
if (prefixlen == 0U) {
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_WARNING,
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_WARNING,
"omitting %s interface %s from localnets ACL: "
"zero prefix length detected",
(netaddr->family == AF_INET) ? "IPv4" : "IPv6",
char sabuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&ifp->addr, sabuf, sizeof(sabuf));
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_INFO,
- "updating TLS context on %s", sabuf);
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_INFO, "updating TLS context on %s", sabuf);
if (ifp->tlslistensocket != NULL) {
isc_nmsocket_set_tlsctx(ifp->tlslistensocket, newctx);
} else if (ifp->http_secure_listensocket != NULL) {
if (isc_net_probeipv6() == ISC_R_SUCCESS) {
scan_ipv6 = true;
} else if ((mgr->sctx->options & NS_SERVER_DISABLE6) == 0) {
- isc_log_write(IFMGR_COMMON_LOGARGS,
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
verbose ? ISC_LOG_INFO : ISC_LOG_DEBUG(1),
"no IPv6 interfaces found");
}
if (isc_net_probeipv4() == ISC_R_SUCCESS) {
scan_ipv4 = true;
} else if ((mgr->sctx->options & NS_SERVER_DISABLE4) == 0) {
- isc_log_write(IFMGR_COMMON_LOGARGS,
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
verbose ? ISC_LOG_INFO : ISC_LOG_DEBUG(1),
"no IPv4 interfaces found");
}
}
}
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_INFO,
+ isc_log_write(NS_LOGCATEGORY_NETWORK,
+ NS_LOGMODULE_INTERFACEMGR, ISC_LOG_INFO,
"listening on IPv6 "
"interfaces, port %u",
le->port);
if (result == ISC_R_SUCCESS) {
ifp->flags |= NS_INTERFACEFLAG_ANYADDR;
} else {
- isc_log_write(IFMGR_COMMON_LOGARGS,
+ isc_log_write(NS_LOGCATEGORY_NETWORK,
+ NS_LOGMODULE_INTERFACEMGR,
ISC_LOG_ERROR,
"listening on all IPv6 "
"interfaces failed");
if (log_explicit && family == AF_INET6 &&
listenon_is_ip6_any(le))
{
- isc_log_write(IFMGR_COMMON_LOGARGS,
+ isc_log_write(NS_LOGCATEGORY_NETWORK,
+ NS_LOGMODULE_INTERFACEMGR,
verbose ? ISC_LOG_INFO
: ISC_LOG_DEBUG(1),
"IPv6 socket API is "
}
isc_sockaddr_format(&listen_sockaddr, sabuf,
sizeof(sabuf));
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_INFO,
+ isc_log_write(NS_LOGCATEGORY_NETWORK,
+ NS_LOGMODULE_INTERFACEMGR, ISC_LOG_INFO,
"listening on %s interface "
"%s, %s",
(family == AF_INET) ? "IPv4" : "IPv6",
}
if (result != ISC_R_SUCCESS) {
- isc_log_write(
- IFMGR_COMMON_LOGARGS, ISC_LOG_ERROR,
- "creating %s interface "
- "%s failed; interface ignored",
- (family == AF_INET) ? "IPv4" : "IPv6",
- interface.name);
+ isc_log_write(NS_LOGCATEGORY_NETWORK,
+ NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_ERROR,
+ "creating %s interface "
+ "%s failed; interface ignored",
+ (family == AF_INET) ? "IPv4"
+ : "IPv6",
+ interface.name);
}
/* Continue. */
}
continue;
ignore_interface:
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_ERROR,
- "ignoring %s interface %s: %s",
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_ERROR, "ignoring %s interface %s: %s",
(family == AF_INET) ? "IPv4" : "IPv6",
interface.name, isc_result_totext(result));
continue;
* Warn if we are not listening on any interface.
*/
if (ISC_LIST_EMPTY(mgr->interfaces)) {
- isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_WARNING,
+ isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
+ ISC_LOG_WARNING,
"not listening on any interfaces");
}
if (!isc_tlsctx_load_dhparams(
sslctx, tls_params->dhparam_file))
{
- isc_log_write(ns_lctx,
- NS_LOGCATEGORY_GENERAL,
+ isc_log_write(NS_LOGCATEGORY_GENERAL,
NS_LOGMODULE_INTERFACEMGR,
ISC_LOG_ERROR,
"loading of dhparam-file "
{ "ns/notify", 0 }, { "ns/hooks", 0 }, { NULL, 0 }
};
-isc_log_t *ns_lctx = NULL;
-
void
-ns_log_init(isc_log_t *lctx) {
- isc_log_registercategories(lctx, ns_categories);
- isc_log_registermodules(lctx, ns_modules);
+ns_log_init(void) {
+ isc_log_registercategories(ns_categories);
+ isc_log_registermodules(ns_modules);
}
static void
client_trace(ns_client_t *client, int level, const char *message) {
if (client != NULL && client->query.qname != NULL) {
- if (isc_log_wouldlog(ns_lctx, level)) {
+ if (isc_log_wouldlog(level)) {
char qbuf[DNS_NAME_FORMATSIZE];
char tbuf[DNS_RDATATYPE_FORMATSIZE];
dns_name_format(client->query.qname, qbuf,
sizeof(qbuf));
dns_rdatatype_format(client->query.qtype, tbuf,
sizeof(tbuf));
- isc_log_write(ns_lctx, NS_LOGCATEGORY_CLIENT,
- NS_LOGMODULE_QUERY, level,
+ isc_log_write(NS_LOGCATEGORY_CLIENT, NS_LOGMODULE_QUERY,
+ level,
"query client=%p thread=0x%" PRIxPTR
"(%s/%s): %s",
client, isc_thread_self(), qbuf, tbuf,
message);
}
} else {
- isc_log_write(ns_lctx, NS_LOGCATEGORY_CLIENT,
- NS_LOGMODULE_QUERY, level,
+ isc_log_write(NS_LOGCATEGORY_CLIENT, NS_LOGMODULE_QUERY, level,
"query client=%p thread=0x%" PRIxPTR
"(<unknown-query>): %s",
client, isc_thread_self(), message);
*/
client->query.attributes |= NS_QUERYATTR_CACHEACLOK;
if (!options.nolog &&
- isc_log_wouldlog(ns_lctx, ISC_LOG_DEBUG(3)))
+ isc_log_wouldlog(ISC_LOG_DEBUG(3)))
{
ns_client_aclmsg("query (cache)", name, qtype,
client->view->rdclass, msg,
if (!options.nolog) {
char msg[NS_CLIENT_ACLMSGSIZE("query")];
if (result == ISC_R_SUCCESS) {
- if (isc_log_wouldlog(ns_lctx, ISC_LOG_DEBUG(3))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
ns_client_aclmsg("query", name, qtype,
client->view->rdclass, msg,
sizeof(msg));
}
}
- if (!isc_log_wouldlog(ns_lctx, DNS_RPZ_INFO_LEVEL)) {
+ if (!isc_log_wouldlog(DNS_RPZ_INFO_LEVEL)) {
return;
}
const char *rpztypestr1;
const char *rpztypestr2;
- if (!isc_log_wouldlog(ns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
* logging is disabled for some policy zones.
*/
if (st->popt.no_log == 0 &&
- isc_log_wouldlog(ns_lctx, DNS_RPZ_DEBUG_LEVEL2))
+ isc_log_wouldlog(DNS_RPZ_DEBUG_LEVEL2))
{
dns_name_format(client->query.qname, qnamebuf,
sizeof(qnamebuf));
}
if (dbfind_stale) {
- isc_log_write(ns_lctx, NS_LOGCATEGORY_SERVE_STALE,
- NS_LOGMODULE_QUERY, ISC_LOG_INFO,
+ isc_log_write(NS_LOGCATEGORY_SERVE_STALE, NS_LOGMODULE_QUERY,
+ ISC_LOG_INFO,
"%s %s resolver failure, stale answer %s (%s)",
namebuf, typebuf,
stale_found ? "used" : "unavailable",
* A recent lookup failed, so during this time window we are
* allowed to return stale data immediately.
*/
- isc_log_write(ns_lctx, NS_LOGCATEGORY_SERVE_STALE,
- NS_LOGMODULE_QUERY, ISC_LOG_INFO,
+ isc_log_write(NS_LOGCATEGORY_SERVE_STALE, NS_LOGMODULE_QUERY,
+ ISC_LOG_INFO,
"%s %s query within stale refresh time, stale "
"answer %s (%s)",
namebuf, typebuf,
* resolver fetch to refresh the data in cache.
*/
isc_log_write(
- ns_lctx, NS_LOGCATEGORY_SERVE_STALE,
+ NS_LOGCATEGORY_SERVE_STALE,
NS_LOGMODULE_QUERY, ISC_LOG_INFO,
"%s %s stale answer used, an attempt "
"to refresh the RRset will still be "
} else {
errorloglevel = ISC_LOG_DEBUG(4);
}
- if (isc_log_wouldlog(ns_lctx, errorloglevel)) {
- dns_resolver_logfetch(fetch, ns_lctx,
- logcategory,
+ if (isc_log_wouldlog(errorloglevel)) {
+ dns_resolver_logfetch(fetch, logcategory,
NS_LOGMODULE_QUERY,
errorloglevel, false);
}
if (((flags & NS_FAILCACHE_CD) != 0) ||
((qctx->client->message->flags & DNS_MESSAGEFLAG_CD) == 0))
{
- if (isc_log_wouldlog(ns_lctx, ISC_LOG_DEBUG(1))) {
+ if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
char namebuf[DNS_NAME_FORMATSIZE];
char typebuf[DNS_RDATATYPE_FORMATSIZE];
qctx->client->query.attributes |= NS_QUERYATTR_RRL_CHECKED;
- wouldlog = isc_log_wouldlog(ns_lctx, DNS_RRL_LOG_DROP);
+ wouldlog = isc_log_wouldlog(DNS_RRL_LOG_DROP);
constname = qctx->fname;
if (result == DNS_R_NXDOMAIN) {
/*
char *tags = NULL;
size_t taglen = 0;
- if (!isc_log_wouldlog(ns_lctx, ISC_LOG_INFO)) {
+ if (!isc_log_wouldlog(ISC_LOG_INFO)) {
return;
}
}
}
- isc_log_write(ns_lctx, NS_LOGCATEGORY_TAT, NS_LOGMODULE_QUERY,
- ISC_LOG_INFO, "trust-anchor-telemetry '%s/%s' from %s%s",
- namebuf, classbuf, clientbuf, tags != NULL ? tags : "");
+ isc_log_write(NS_LOGCATEGORY_TAT, NS_LOGMODULE_QUERY, ISC_LOG_INFO,
+ "trust-anchor-telemetry '%s/%s' from %s%s", namebuf,
+ classbuf, clientbuf, tags != NULL ? tags : "");
if (tags != NULL) {
isc_mem_put(client->manager->mctx, tags, taglen);
}
dns_rdataset_t *rdataset;
int level = ISC_LOG_INFO;
- if (!isc_log_wouldlog(ns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
const char *namep, *typep, *classp, *sep1, *sep2;
dns_rdataset_t *rdataset;
- if (!isc_log_wouldlog(ns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
default: \
break; \
} \
- if (isc_log_wouldlog(ns_lctx, LOGLEVEL_PROTOCOL)) { \
+ if (isc_log_wouldlog(LOGLEVEL_PROTOCOL)) { \
char _nbuf[DNS_NAME_FORMATSIZE]; \
dns_name_format(name, _nbuf, sizeof(_nbuf)); \
update_log(client, zone, LOGLEVEL_PROTOCOL, \
default: \
break; \
} \
- if (isc_log_wouldlog(ns_lctx, LOGLEVEL_PROTOCOL)) { \
+ if (isc_log_wouldlog(LOGLEVEL_PROTOCOL)) { \
char _nbuf[DNS_NAME_FORMATSIZE]; \
char _tbuf[DNS_RDATATYPE_FORMATSIZE]; \
dns_name_format(name, _nbuf, sizeof(_nbuf)); \
return;
}
- if (!isc_log_wouldlog(ns_lctx, level)) {
+ if (!isc_log_wouldlog(level)) {
return;
}
msg_result = dns_message_reply(client->message, true);
if (msg_result != ISC_R_SUCCESS) {
- isc_log_write(ns_lctx, NS_LOGCATEGORY_UPDATE,
- NS_LOGMODULE_UPDATE, ISC_LOG_ERROR,
+ isc_log_write(NS_LOGCATEGORY_UPDATE, NS_LOGMODULE_UPDATE,
+ ISC_LOG_ERROR,
"could not create update response message: %s",
isc_result_totext(msg_result));
ns_client_drop(client, msg_result);
}
}
- if (isc_log_wouldlog(ns_lctx, LOGLEVEL_PROTOCOL)) {
+ if (isc_log_wouldlog(LOGLEVEL_PROTOCOL)) {
char namestr[DNS_NAME_FORMATSIZE];
char typestr[DNS_RDATATYPE_FORMATSIZE];
char rdstr[2048];
}
} else if (update_class == dns_rdataclass_any) {
if (rdata.type == dns_rdatatype_any) {
- if (isc_log_wouldlog(ns_lctx,
- LOGLEVEL_PROTOCOL))
- {
+ if (isc_log_wouldlog(LOGLEVEL_PROTOCOL)) {
char namestr[DNS_NAME_FORMATSIZE];
dns_name_format(name, namestr,
sizeof(namestr));
"or NS records ignored");
continue;
} else {
- if (isc_log_wouldlog(ns_lctx,
- LOGLEVEL_PROTOCOL))
- {
+ if (isc_log_wouldlog(LOGLEVEL_PROTOCOL)) {
char namestr[DNS_NAME_FORMATSIZE];
char typestr[DNS_RDATATYPE_FORMATSIZE];
dns_name_format(name, namestr,
* - IXFR over UDP
*/
-#define XFROUT_COMMON_LOGARGS \
- ns_lctx, DNS_LOGCATEGORY_XFER_OUT, NS_LOGMODULE_XFER_OUT
+#define XFROUT_PROTOCOL_LOGARGS \
+ DNS_LOGCATEGORY_XFER_OUT, NS_LOGMODULE_XFER_OUT, ISC_LOG_INFO
-#define XFROUT_PROTOCOL_LOGARGS XFROUT_COMMON_LOGARGS, ISC_LOG_INFO
+#define XFROUT_DEBUG_LOGARGS(n) \
+ DNS_LOGCATEGORY_XFER_OUT, NS_LOGMODULE_XFER_OUT, ISC_LOG_DEBUG(n)
-#define XFROUT_DEBUG_LOGARGS(n) XFROUT_COMMON_LOGARGS, ISC_LOG_DEBUG(n)
-
-#define XFROUT_RR_LOGARGS XFROUT_COMMON_LOGARGS, XFROUT_RR_LOGLEVEL
+#define XFROUT_RR_LOGARGS \
+ DNS_LOGCATEGORY_XFER_OUT, NS_LOGMODULE_XFER_OUT, XFROUT_RR_LOGLEVEL
#define XFROUT_RR_LOGLEVEL ISC_LOG_DEBUG(8)
*/
result = isc_quota_acquire(&client->manager->sctx->xfroutquota);
if (result != ISC_R_SUCCESS) {
- isc_log_write(XFROUT_COMMON_LOGARGS, ISC_LOG_WARNING,
- "%s request denied: %s", mnemonic,
- isc_result_totext(result));
+ isc_log_write(DNS_LOGCATEGORY_XFER_OUT, NS_LOGMODULE_XFER_OUT,
+ ISC_LOG_WARNING, "%s request denied: %s",
+ mnemonic, isc_result_totext(result));
goto max_quota;
}
break;
}
- if (isc_log_wouldlog(ns_lctx, XFROUT_RR_LOGLEVEL)) {
+ if (isc_log_wouldlog(XFROUT_RR_LOGLEVEL)) {
log_rr(name, rdata, ttl); /* XXX */
}
#define ZIPF 0
#if VERBOSE
-#define TRACE(fmt, ...) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_QP, \
- ISC_LOG_DEBUG(7), "%s:%d:%s():t%d: " fmt, __FILE__, \
+#define TRACE(fmt, ...) \
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_QP, \
+ ISC_LOG_DEBUG(7), "%s:%d:%s():t%d: " fmt, __FILE__, \
__LINE__, __func__, isc_tid(), ##__VA_ARGS__)
#else
#define TRACE(...)
isc_result_t result;
isc_logdestination_t destination;
isc_logconfig_t *logconfig = NULL;
- isc_log_t *lctx = NULL;
- dns_log_init(lctx);
+ dns_log_init();
- logconfig = isc_logconfig_get(lctx);
+ logconfig = isc_logconfig_get();
destination.file.stream = stderr;
destination.file.name = NULL;
destination.file.versions = ISC_LOG_ROLLNEVER;
ISC_LOG_PRINTPREFIX | ISC_LOG_PRINTTIME |
ISC_LOG_ISO8601);
#if VERBOSE
- isc_log_setdebuglevel(lctx, 7);
+ isc_log_setdebuglevel(7);
#endif
result = isc_log_usechannel(logconfig, "stderr",
#define TRANSACTION_COUNT 1234
#if VERBOSE
-#define TRACE(fmt, ...) \
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_QP, \
- ISC_LOG_DEBUG(7), "%s:%d:%s(): " fmt, __FILE__, \
+#define TRACE(fmt, ...) \
+ isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_QP, \
+ ISC_LOG_DEBUG(7), "%s:%d:%s(): " fmt, __FILE__, \
__LINE__, __func__, ##__VA_ARGS__)
#else
#define TRACE(...)
isc_logdestination_t destination;
isc_logconfig_t *logconfig = NULL;
- dns_log_init(lctx);
+ dns_log_init();
- logconfig = isc_logconfig_get(lctx);
+ logconfig = isc_logconfig_get();
destination.file.stream = stderr;
destination.file.name = NULL;
destination.file.versions = ISC_LOG_ROLLNEVER;
ISC_LOG_ISO8601);
#if VERBOSE
- isc_log_setdebuglevel(lctx, 7);
+ isc_log_setdebuglevel(7);
#endif
result = isc_log_usechannel(logconfig, "stderr",
#include <isc/uv.h>
extern isc_mem_t *mctx;
-extern isc_log_t *lctx;
extern isc_loop_t *mainloop;
extern isc_loopmgr_t *loopmgr;
extern isc_nm_t *netmgr;
isc_logdestination_t destination;
isc_logconfig_t *logconfig = NULL;
- isc_log_registercategories(lctx, categories);
+ isc_log_registercategories(categories);
- logconfig = isc_logconfig_get(lctx);
+ logconfig = isc_logconfig_get();
destination.file.stream = stderr;
destination.file.name = NULL;
destination.file.versions = ISC_LOG_ROLLNEVER;
isc_buffer_add(&buf1, strlen(conf) - 1);
/* Parse with default line numbering */
- result = cfg_parser_create(mctx, lctx, &p1);
+ result = cfg_parser_create(mctx, &p1);
assert_int_equal(result, ISC_R_SUCCESS);
result = cfg_parse_buffer(p1, &buf1, "text1", 0,
isc_logdestination_t destination;
isc_logconfig_t *logconfig = NULL;
- isc_log_registercategories(lctx, categories);
+ isc_log_registercategories(categories);
- logconfig = isc_logconfig_get(lctx);
+ logconfig = isc_logconfig_get();
destination.file.stream = stderr;
destination.file.name = NULL;
destination.file.versions = ISC_LOG_ROLLNEVER;
char buf[1024];
/* Parse with default line numbering */
- result = cfg_parser_create(mctx, lctx, &p);
+ result = cfg_parser_create(mctx, &p);
assert_int_equal(result, ISC_R_SUCCESS);
for (size_t i = 0; i < ARRAY_SIZE(tests); i++) {
isc_buffer_add(&buf1, sizeof(text) - 1);
/* Parse with default line numbering */
- result = cfg_parser_create(mctx, lctx, &p1);
+ result = cfg_parser_create(mctx, &p1);
assert_int_equal(result, ISC_R_SUCCESS);
result = cfg_parse_buffer(p1, &buf1, "text1", 0, &cfg_type_namedconf, 0,
isc_buffer_add(&buf2, sizeof(text) - 1);
/* Parse with changed line number */
- result = cfg_parser_create(mctx, lctx, &p2);
+ result = cfg_parser_create(mctx, &p2);
assert_int_equal(result, ISC_R_SUCCESS);
result = cfg_parse_buffer(p2, &buf2, "text2", 100, &cfg_type_namedconf,
#include <tests/isc.h>
isc_mem_t *mctx = NULL;
-isc_log_t *lctx = NULL;
isc_loop_t *mainloop = NULL;
isc_loopmgr_t *loopmgr = NULL;
isc_nm_t *netmgr = NULL;
projects / thirdparty / bind9.git / commitdiff
