mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-22 01:59:26 +00:00
Code Issues Releases Wiki Activity

Remove logging context (isc_log_t) from the public namespace

Browse Source 
Now that the logging uses single global context, remove the isc_log_t
from the public namespace.
This commit is contained in:
Ondřej Surý 2024-08-13 18:20:26 +02:00
parent 043f11de3f
commit 8506102216
129 changed files with 2215 additions and 2552 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
bin/check/check-tool.c
View File

@ -549,17 +549,16 @@ checksrv(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
}
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;
@ -570,7 +569,6 @@ setup_logging(isc_mem_t *mctx ISC_ATTR_UNUSED, FILE *errout, isc_log_t **logp) {
RUNTIME_CHECK(isc_log_usechannel(logconfig, "stderr", NULL, NULL) ==
ISC_R_SUCCESS);
*logp = log;
return (ISC_R_SUCCESS);
}

2
bin/check/check-tool.h
View File

@ -29,7 +29,7 @@
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,

10
bin/check/named-checkconf.c
View File

@ -44,8 +44,6 @@
static const char *program = "named-checkconf";
isc_log_t *logc = NULL;
#define CHECK(r) \
do { \
result = (r); \
@ -83,7 +81,7 @@ directory_callback(const char *clausename, const cfg_obj_t *obj, void *arg) {
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);
@ -725,9 +723,9 @@ main(int argc, char **argv) {
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);
@ -735,7 +733,7 @@ main(int argc, char **argv) {
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));
}

4
bin/check/named-checkzone.c
View File

@ -95,7 +95,6 @@ main(int argc, char **argv) {
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;
@ -525,8 +524,7 @@ main(int argc, char **argv) {
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++];

25
bin/delv/delv.c
View File

@ -94,7 +94,6 @@
/* 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;
@ -301,14 +300,14 @@ delv_log(int level, const char *fmt, ...) {
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);
}
@ -322,12 +321,12 @@ setup_logging(FILE *errout) {
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;
@ -336,7 +335,7 @@ setup_logging(FILE *errout) {
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",
@ -814,14 +813,14 @@ key_fromconfig(const cfg_obj_t *key, dns_client_t *client, dns_view_t *toview) {
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;
@ -876,7 +875,7 @@ setup_dnsseckeys(dns_client_t *client, dns_view_t *toview) {
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) {

9
bin/dig/dighost.c
View File

@ -99,7 +99,6 @@ bool port_set = false;
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;
@ -1096,7 +1095,7 @@ read_confkey(void) {
return (ISC_R_FILENOTFOUND);
}
result = cfg_parser_create(mctx, NULL, &pctx);
result = cfg_parser_create(mctx, &pctx);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
@ -1361,14 +1360,14 @@ setup_libs(void) {
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);

6
bin/dnssec/dnssec-cds.c
View File

@ -63,7 +63,6 @@ const char *program = "dnssec-cds";
/*
* Infrastructure
*/
static isc_log_t *lctx = NULL;
static isc_mem_t *mctx = NULL;
/*
@ -1070,9 +1069,6 @@ cleanup(void) {
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);
@ -1173,7 +1169,7 @@ main(int argc, char *argv[]) {
dtype[0] = DNS_DSDIGEST_SHA256;
}
setup_logging(mctx, &lctx);
setup_logging();
if (ds_path == NULL) {
fatal("missing -d DS pathname");

4
bin/dnssec/dnssec-dsfromkey.c
View File

@ -368,7 +368,6 @@ main(int argc, char **argv) {
bool usekeyset = false;
bool showall = false;
isc_result_t result;
isc_log_t *log = NULL;
dns_rdataset_t rdataset;
dns_rdata_t rdata;
@ -489,7 +488,7 @@ main(int argc, char **argv) {
fatal("extraneous arguments");
}
setup_logging(mctx, &log);
setup_logging();
dns_rdataset_init(&rdataset);
@ -542,7 +541,6 @@ main(int argc, char **argv) {
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
cleanup_logging(&log);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}

4
bin/dnssec/dnssec-importkey.c
View File

@ -299,7 +299,6 @@ main(int argc, char **argv) {
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();
@ -408,7 +407,7 @@ main(int argc, char **argv) {
fatal("extraneous arguments");
}
setup_logging(mctx, &log);
setup_logging();
dns_rdataset_init(&rdataset);
@ -452,7 +451,6 @@ main(int argc, char **argv) {
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
cleanup_logging(&log);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}

4
bin/dnssec/dnssec-keyfromlabel.c
View File

@ -125,7 +125,6 @@ main(int argc, char **argv) {
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;
@ -332,7 +331,7 @@ main(int argc, char **argv) {
}
}
setup_logging(mctx, &log);
setup_logging();
if (predecessor == NULL) {
if (label == NULL) {
@ -723,7 +722,6 @@ main(int argc, char **argv) {
dst_key_free(&prevkey);
}
cleanup_logging(&log);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}

11
bin/dnssec/dnssec-keygen.c
View File

@ -72,8 +72,6 @@ const char *program = "dnssec-keygen";
static int min_rsa = 1024;
static int min_dh = 128;
isc_log_t *lctx = NULL;
ISC_NORETURN static void
usage(void);
@ -1145,7 +1143,7 @@ main(int argc, char **argv) {
min_rsa = min_dh = 2048;
}
setup_logging(mctx, &lctx);
setup_logging();
ctx.rdclass = strtoclass(classname);
@ -1225,7 +1223,7 @@ main(int argc, char **argv) {
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,
@ -1236,8 +1234,8 @@ main(int argc, char **argv) {
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);
@ -1281,7 +1279,6 @@ main(int argc, char **argv) {
keygen(&ctx, mctx, argc, argv);
}
cleanup_logging(&lctx);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}

7
bin/dnssec/dnssec-ksr.c
View File

@ -39,7 +39,6 @@ const char *program = "dnssec-ksr";
/*
* Infrastructure
*/
static isc_log_t *lctx = NULL;
static isc_mem_t *mctx = NULL;
/*
* The domain we are working on
@ -164,14 +163,14 @@ getkasp(ksr_ctx_t *ksr, dns_kasp_t **kasp) {
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);
}
@ -1272,7 +1271,7 @@ main(int argc, char *argv[]) {
min_rsa = min_dh = 2048;
}
setup_logging(mctx, &lctx);
setup_logging();
if (set_fips_mode) {
#if OPENSSL_VERSION_NUMBER >= 0x30000000L

4
bin/dnssec/dnssec-settime.c
View File

@ -226,7 +226,6 @@ main(int argc, char **argv) {
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;
@ -245,7 +244,7 @@ main(int argc, char **argv) {
isc_mem_create(&mctx);
setup_logging(mctx, &log);
setup_logging();
isc_commandline_errprint = false;
@ -947,7 +946,6 @@ main(int argc, char **argv) {
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}
cleanup_logging(&log);
isc_mem_free(mctx, directory);
isc_mem_destroy(&mctx);

4
bin/dnssec/dnssec-signzone.c
View File

@ -3350,7 +3350,6 @@ main(int argc, char *argv[]) {
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;
@ -3745,7 +3744,7 @@ main(int argc, char *argv[]) {
}
}
setup_logging(mctx, &log);
setup_logging();
argc -= isc_commandline_index;
argv += isc_commandline_index;
@ -4116,7 +4115,6 @@ main(int argc, char *argv[]) {
dns_master_styledestroy(&dsstyle, mctx);
cleanup_logging(&log);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}

4
bin/dnssec/dnssec-verify.c
View File

@ -168,7 +168,6 @@ main(int argc, char *argv[]) {
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;
@ -276,7 +275,7 @@ main(int argc, char *argv[]) {
rdclass = strtoclass(classname);
setup_logging(mctx, &log);
setup_logging();
argc -= isc_commandline_index;
argv += isc_commandline_index;
@ -326,7 +325,6 @@ main(int argc, char *argv[]) {
dns_db_closeversion(gdb, &gversion, false);
dns_db_detach(&gdb);
cleanup_logging(&log);
if (verbose > 10) {
isc_mem_stats(mctx, stdout);
}

34
bin/dnssec/dnssectool.c
View File

@ -128,10 +128,9 @@ sig_format(dns_rdata_rrsig_t *sig, char *cp, unsigned int size) {
}
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) {
@ -153,9 +152,9 @@ setup_logging(isc_mem_t *mctx ISC_ATTR_UNUSED, isc_log_t **logp) {
break;
}
dns_log_init(log);
dns_log_init();
logconfig = isc_logconfig_get(log);
logconfig = isc_logconfig_get();
isc_log_settag(logconfig, program);
@ -175,20 +174,6 @@ setup_logging(isc_mem_t *mctx ISC_ATTR_UNUSED, isc_log_t **logp) {
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
@ -598,8 +583,8 @@ cleanup:
}
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;
@ -618,8 +603,7 @@ kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, isc_log_t *lctx,
{
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")),
@ -628,7 +612,7 @@ kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, isc_log_t *lctx,
}
/* 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 */
@ -648,8 +632,8 @@ kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, isc_log_t *lctx,
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")),

9
bin/dnssec/dnssectool.h
View File

@ -75,10 +75,7 @@ sig_format(dns_rdata_rrsig_t *sig, char *cp, unsigned int size);
(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);
@ -118,5 +115,5 @@ void
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);

15
bin/named/config.c
View File

@ -451,8 +451,8 @@ named_config_getclass(const cfg_obj_t *classobj, dns_rdataclass_t defclass,
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);
}
@ -471,8 +471,8 @@ named_config_gettype(const cfg_obj_t *typeobj, dns_rdatatype_t deftype,
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);
}
@ -663,7 +663,7 @@ newlist:
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;
@ -718,7 +718,7 @@ resume:
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);
@ -890,8 +890,7 @@ named_config_getport(const cfg_obj_t *config, const char *type,
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);
}

14
bin/named/control.c
View File

@ -135,7 +135,7 @@ named_control_docommand(isccc_sexpr_t *message, bool readonly,
!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'",
@ -144,9 +144,9 @@ named_control_docommand(isccc_sexpr_t *message, bool readonly,
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
@ -203,7 +203,7 @@ named_control_docommand(isccc_sexpr_t *message, bool readonly,
{
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);
@ -238,7 +238,7 @@ named_control_docommand(isccc_sexpr_t *message, bool readonly,
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);
@ -287,7 +287,7 @@ named_control_docommand(isccc_sexpr_t *message, bool readonly,
} 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;

84
bin/named/controlconf.c
View File

@ -225,9 +225,9 @@ shutdown_listener(controllistener_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_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);
@ -272,7 +272,7 @@ control_senddone(isc_nmhandle_t *handle, isc_result_t result, void *arg) {
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));
@ -291,9 +291,8 @@ log_invalid(isccc_ccmsg_t *ccmsg, isc_result_t 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));
}
@ -588,9 +587,8 @@ conn_free(controlconnection_t *conn) {
}
#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));
@ -601,7 +599,7 @@ static void
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));
@ -609,9 +607,8 @@ newconnection(controllistener_t *listener, isc_nmhandle_t *handle) {
}
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,
@ -648,7 +645,7 @@ control_newconn(isc_nmhandle_t *handle, isc_result_t result, void *arg) {
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);
@ -760,7 +757,7 @@ register_keys(const cfg_obj_t *control, const cfg_obj_t *keylist,
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);
@ -783,8 +780,7 @@ register_keys(const cfg_obj_t *control, const cfg_obj_t *keylist,
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",
@ -799,8 +795,7 @@ register_keys(const cfg_obj_t *control, const cfg_obj_t *keylist,
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,
@ -834,14 +829,14 @@ get_rndckey(isc_mem_t *mctx, controlkeylist_t *keyids) {
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));
@ -857,7 +852,7 @@ get_rndckey(isc_mem_t *mctx, controlkeylist_t *keyids) {
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);
@ -868,7 +863,7 @@ get_rndckey(isc_mem_t *mctx, controlkeylist_t *keyids) {
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",
@ -881,7 +876,7 @@ get_rndckey(isc_mem_t *mctx, controlkeylist_t *keyids) {
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;
@ -1009,12 +1004,12 @@ update_listener(named_controls_t *cp, controllistener_t **listenerp,
* 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",
@ -1027,9 +1022,8 @@ update_listener(named_controls_t *cp, controllistener_t **listenerp,
*/
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);
}
@ -1049,12 +1043,12 @@ update_listener(named_controls_t *cp, controllistener_t **listenerp,
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",
@ -1101,8 +1095,8 @@ add_listener(named_controls_t *cp, controllistener_t **listenerp,
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)) {
@ -1128,7 +1122,7 @@ add_listener(named_controls_t *cp, controllistener_t **listenerp,
} 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));
@ -1146,9 +1140,9 @@ add_listener(named_controls_t *cp, controllistener_t **listenerp,
&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;
@ -1159,11 +1153,11 @@ cleanup:
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));
@ -1208,8 +1202,7 @@ named_controls_configure(named_controls_t *cp, const cfg_obj_t *config,
(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);
@ -1245,8 +1238,7 @@ named_controls_configure(named_controls_t *cp, const cfg_obj_t *config,
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",

2
bin/named/dlz_dlopen_driver.c
View File

@ -80,7 +80,7 @@ static void
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);
}

20
bin/named/geoip.c
View File

@ -39,8 +39,8 @@ open_geoip2(const char *dir, const char *dbfile, MMDB_s *mmdb) {
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);
@ -48,14 +48,14 @@ open_geoip2(const char *dir, const char *dbfile, MMDB_s *mmdb) {
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);
@ -79,9 +79,9 @@ named_geoip_load(char *dir) {
#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);

1
bin/named/include/named/globals.h
View File

@ -86,7 +86,6 @@ EXTERN named_server_t *named_g_server INIT(NULL);
/*
* 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);

3
bin/named/include/named/log.h
View File

@ -79,6 +79,3 @@ named_log_setunmatchedcategory(isc_logconfig_t *lcfg);
/*%
* Set up "category unmatched" to go to the right places.
*/
void
named_log_shutdown(void) __attribute__((__deprecated__));

27
bin/named/log.c
View File

@ -55,18 +55,14 @@ named_log_init(bool safe) {
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()
@ -75,7 +71,7 @@ named_log_init(bool safe) {
* hygiene.
*/
rcu_read_lock();
lcfg = isc_logconfig_get(named_g_lctx);
lcfg = isc_logconfig_get();
if (safe) {
named_log_setsafechannels(lcfg);
} else {
@ -138,7 +134,7 @@ named_log_setdefaultchannels(isc_logconfig_t *lcfg) {
/*
* Set the initial debug level.
*/
isc_log_setdebuglevel(named_g_lctx, named_g_debuglevel);
isc_log_setdebuglevel(named_g_debuglevel);
}
void
@ -153,9 +149,9 @@ named_log_setsafechannels(isc_logconfig_t *lcfg) {
* 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) {
@ -247,8 +243,3 @@ named_log_setunmatchedcategory(isc_logconfig_t *lcfg) {
NULL);
return (result);
}
void
named_log_shutdown(void) {
/* no-op */
}

8
bin/named/logconf.c
View File

@ -50,9 +50,9 @@ category_fromconf(const cfg_obj_t *ccat, isc_logconfig_t *logconfig) {
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.
@ -76,7 +76,7 @@ category_fromconf(const cfg_obj_t *ccat, isc_logconfig_t *logconfig) {
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));
@ -127,7 +127,7 @@ channel_fromconf(const cfg_obj_t *channel, isc_logconfig_t *logconfig) {
}
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);

249
bin/named/main.c
View File

@ -161,10 +161,9 @@ named_main_earlywarning(const char *format, ...) {
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);
@ -179,12 +178,11 @@ named_main_earlyfatal(const char *format, ...) {
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);
@ -208,21 +206,20 @@ assertion_failed(const char *file, int line, isc_assertiontype_t type,
* 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,
@ -247,21 +244,20 @@ library_fatal_error(const char *file, int line, const char *func,
* 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);
@ -288,14 +284,13 @@ library_unexpected_error(const char *file, int line, const char *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);
@ -510,9 +505,8 @@ list_hmac_algorithms(isc_buffer_t *b) {
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));
}
@ -657,7 +651,7 @@ printversion(bool verbose) {
#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));
@ -1017,11 +1011,11 @@ create_managers(void) {
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);
@ -1101,141 +1095,129 @@ setup(void) {
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,
"----------------------------------------------------");
/*
@ -1367,9 +1349,8 @@ cleanup(void) {
*/
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;

8
bin/named/os.c
View File

@ -626,8 +626,8 @@ named_os_adjustnofile(void) {
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,
@ -641,8 +641,8 @@ named_os_adjustnofile(void) {
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,

976
bin/named/server.c
View File

File diff suppressed because it is too large Load Diff

101
bin/named/statschannel.c
View File

@ -936,9 +936,8 @@ dump_counters(isc_statsformat_t type, void *arg, const char *category,
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 */
}
@ -999,9 +998,8 @@ rdtypestat_dump(dns_rdatastatstype_t type, uint64_t val, void *arg) {
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 */
@ -1088,9 +1086,8 @@ rdatasetstats_dump(dns_rdatastatstype_t type, uint64_t val, void *arg) {
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 */
}
@ -1143,9 +1140,8 @@ opcodestat_dump(dns_opcode_t code, uint64_t val, void *arg) {
#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 */
@ -1199,9 +1195,8 @@ rcodestat_dump(dns_rcode_t code, uint64_t val, void *arg) {
#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 */
@ -1256,9 +1251,8 @@ dnssecsignstat_dump(uint32_t kval, uint64_t val, void *arg) {
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 */
@ -1452,9 +1446,8 @@ zone_xmlrender(dns_zone_t *zone, void *arg) {
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);
}
@ -1725,9 +1718,8 @@ cleanup:
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);
}
@ -2134,9 +2126,8 @@ generatexml(named_server_t *server, uint32_t flags, int *buflen,
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);
}
@ -2173,9 +2164,8 @@ render_xml(uint32_t flags, void *arg, unsigned int *retcode,
*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);
@ -3376,9 +3366,8 @@ render_json(uint32_t flags, void *arg, unsigned int *retcode,
*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);
@ -3534,9 +3523,9 @@ static void
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);
}
@ -3565,9 +3554,9 @@ client_ok(const isc_sockaddr_t *fromaddr, void *arg) {
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);
}
@ -3605,9 +3594,8 @@ add_listener(named_server_t *server, named_statschannel_t **listenerp,
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);
}
@ -3689,9 +3677,9 @@ add_listener(named_server_t *server, named_statschannel_t **listenerp,
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);
@ -3733,9 +3721,8 @@ update_listener(named_server_t *server, named_statschannel_t **listenerp,
*/
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);
}
@ -3749,7 +3736,7 @@ update_listener(named_server_t *server, named_statschannel_t **listenerp,
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));
@ -3786,20 +3773,20 @@ named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
*/
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 */
@ -3838,8 +3825,7 @@ named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
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 "
@ -3870,7 +3856,6 @@ named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
if (r != ISC_R_SUCCESS) {
cfg_obj_log(
listen_params,
named_g_lctx,
ISC_LOG_WARNING,
"couldn't allocate "
"statistics channel"

6
bin/named/tkeyconf.c
View File

@ -38,9 +38,9 @@
} 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,

6
bin/named/transportconf.c
View File

@ -133,8 +133,7 @@ add_doh_transports(const cfg_obj_t *transportlist, dns_transport_list_t *list) {
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);
@ -187,8 +186,7 @@ add_tls_transports(const cfg_obj_t *transportlist, dns_transport_list_t *list) {
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);

6
bin/named/tsigconf.c
View File

@ -85,7 +85,7 @@ add_initial_keys(const cfg_obj_t *list, dns_tsigkeyring_t *ring,
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);
@ -129,8 +129,8 @@ failure:
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);
}

50
bin/named/zoneconf.c
View File

@ -175,8 +175,8 @@ configure_zone_acl(const cfg_obj_t *zconfig, const cfg_obj_t *vconfig,
}
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);
}
@ -262,7 +262,7 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
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;
}
@ -278,8 +278,7 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
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;
}
@ -315,8 +314,7 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
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,
@ -330,8 +328,7 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
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));
@ -357,7 +354,7 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
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",
@ -415,14 +412,14 @@ configure_staticstub_serveraddrs(const cfg_obj_t *zconfig, dns_zone_t *zone,
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");
@ -508,14 +505,14 @@ configure_staticstub_servernames(const cfg_obj_t *zconfig, dns_zone_t *zone,
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);
@ -602,8 +599,8 @@ configure_staticstub(const cfg_obj_t *zconfig, dns_zone_t *zone,
* 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);
@ -854,7 +851,7 @@ process_notifytype(dns_notifytype_t ntype, dns_zonetype_t ztype,
* 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);
@ -975,7 +972,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
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",
@ -1018,9 +1015,9 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
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);
}
@ -1049,7 +1046,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
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'",
@ -1233,8 +1230,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
&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);
@ -1360,7 +1356,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
} 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",
@ -1505,7 +1501,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
} 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",
@ -1546,7 +1542,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
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",

19
bin/nsupdate/nsupdate.c
View File

@ -123,7 +123,6 @@ static bool usegsstsig = false;
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;
@ -559,7 +558,7 @@ failure:
* 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;
@ -575,7 +574,7 @@ read_sessionkey(isc_mem_t *mctx, isc_log_t *lctx) {
return (ISC_R_FILENOTFOUND);
}
result = cfg_parser_create(mctx, lctx, &pctx);
result = cfg_parser_create(mctx, &pctx);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
@ -622,7 +621,7 @@ 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;
@ -639,7 +638,7 @@ setup_keyfile(isc_mem_t *mctx, isc_log_t *lctx) {
/* 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;
}
@ -812,13 +811,13 @@ setup_system(void *arg ISC_ATTR_UNUSED) {
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) {
@ -971,13 +970,13 @@ setup_system(void *arg ISC_ATTR_UNUSED) {
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);

33
bin/plugins/filter-a.c
View File

@ -231,8 +231,7 @@ parse_filter_a_on(const cfg_obj_t *param_obj, const char *param_name,
}
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;
@ -243,20 +242,20 @@ check_syntax(cfg_obj_t *fmap, const void *cfg, isc_mem_t *mctx, isc_log_t *lctx,
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");
@ -274,28 +273,28 @@ cleanup:
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, &param_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 {
@ -327,13 +326,12 @@ cleanup:
*/
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");
@ -344,7 +342,7 @@ plugin_register(const char *parameters, const void *cfg, const char *cfg_file,
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);
@ -367,21 +365,20 @@ cleanup:
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, &param_obj));
CHECK(check_syntax(param_obj, cfg, mctx, lctx, actx));
CHECK(check_syntax(param_obj, cfg, mctx, actx));
cleanup:
if (param_obj != NULL) {

33
bin/plugins/filter-aaaa.c
View File

@ -232,8 +232,7 @@ parse_filter_aaaa_on(const cfg_obj_t *param_obj, const char *param_name,
}
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;
@ -244,20 +243,20 @@ check_syntax(cfg_obj_t *fmap, const void *cfg, isc_mem_t *mctx, isc_log_t *lctx,
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");
@ -275,21 +274,21 @@ cleanup:
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, &param_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));
@ -298,7 +297,7 @@ parse_parameters(filter_instance_t *inst, const char *parameters,
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 {
@ -330,13 +329,12 @@ cleanup:
*/
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");
@ -348,7 +346,7 @@ plugin_register(const char *parameters, const void *cfg, const char *cfg_file,
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);
@ -371,21 +369,20 @@ cleanup:
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, &param_obj));
CHECK(check_syntax(param_obj, cfg, mctx, lctx, actx));
CHECK(check_syntax(param_obj, cfg, mctx, actx));
cleanup:
if (param_obj != NULL) {

11
bin/rndc/rndc.c
View File

@ -526,8 +526,8 @@ rndc_start(void *arg) {
}
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;
@ -570,7 +570,7 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
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.
@ -806,7 +806,6 @@ int
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;
@ -954,7 +953,7 @@ main(int argc, char **argv) {
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;
@ -966,7 +965,7 @@ main(int argc, char **argv) {
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);

4
bin/tests/system/dyndb/driver/log.c
View File

@ -38,7 +38,7 @@ log_write(int level, const char *format, ...) {
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);
}

16
bin/tests/system/hooks/driver/test-async.c
View File

@ -54,7 +54,6 @@ typedef struct async_instance {
isc_mem_t *mctx;
isc_ht_t *ht;
isc_mutex_t hlock;
isc_log_t *lctx;
} async_instance_t;
typedef struct state {
@ -106,8 +105,8 @@ logmsg(const char *fmt, ...) {
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);
}
@ -126,16 +125,15 @@ logmsg(const char *fmt, ...) {
*/
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);
@ -158,14 +156,12 @@ plugin_register(const char *parameters, const void *cfg, const char *cfg_file,
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);

7
bin/tests/system/makejournal.c
View File

@ -30,7 +30,6 @@
#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.
@ -92,10 +91,10 @@ main(int argc, char **argv) {
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;

5
bin/tests/system/rsabigexponent/bigkey.c
View File

@ -46,7 +46,6 @@ dns_fixedname_t fname;
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;
@ -106,9 +105,9 @@ main(int argc, char **argv) {
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;

15
bin/tools/named-journalprint.c
View File

@ -36,15 +36,14 @@ usage(void) {
/*
* 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;
@ -54,9 +53,6 @@ setup_logging(isc_mem_t *mctx ISC_ATTR_UNUSED, FILE *errout, isc_log_t **logp) {
RUNTIME_CHECK(isc_log_usechannel(logconfig, "stderr", NULL, NULL) ==
ISC_R_SUCCESS);
*logp = log;
return (ISC_R_SUCCESS);
}
int
@ -64,7 +60,6 @@ main(int argc, char **argv) {
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;
@ -108,7 +103,7 @@ main(int argc, char **argv) {
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;

33
doc/dev/dev.md
View File

@ -1047,20 +1047,15 @@ for the category at all.
##### 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.
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 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()`.
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
@ -1088,18 +1083,16 @@ the following steps need to be taken to initialize it.
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.
@ -1164,14 +1157,14 @@ There are three additional functions you might find useful in your program
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.

8
doc/misc/cfg_test.c
View File

@ -59,7 +59,6 @@ int
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;
@ -76,7 +75,7 @@ main(int argc, char **argv) {
/*
* 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;
@ -90,7 +89,7 @@ main(int argc, char **argv) {
/*
* Set the initial debug level.
*/
isc_log_setdebuglevel(lctx, 2);
isc_log_setdebuglevel(2);
if (argc < 3) {
usage();
@ -156,8 +155,7 @@ main(int argc, char **argv) {
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);

9
lib/dns/adb.c
View File

@ -480,8 +480,8 @@ DP(int level, const char *format, ...) {
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);
}
@ -1463,8 +1463,7 @@ log_quota(dns_adbentry_t *entry, const char *fmt, ...) {
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);
@ -1968,7 +1967,7 @@ dns_adb_createfind(dns_adb_t *adb, isc_loop_t *loop, isc_job_cb cb, void *cbarg,
REQUIRE(loop != NULL);
}
if (isc_log_wouldlog(dns_lctx, DEF_LEVEL)) {
if (isc_log_wouldlog(DEF_LEVEL)) {
dns_name_format(name, namebuf, sizeof(namebuf));
}

6
lib/dns/callbacks.c
View File

@ -54,8 +54,7 @@ isclog_error_callback(dns_rdatacallbacks_t *callbacks, const char *fmt, ...) {
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);
}
@ -68,8 +67,7 @@ isclog_warn_callback(dns_rdatacallbacks_t *callbacks, const char *fmt, ...) {
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);
}

129
lib/dns/catz.c
View File

@ -565,8 +565,8 @@ dns__catz_zones_merge(dns_catz_zone_t *catz, dns_catz_zone_t *newcatz) {
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,
@ -598,7 +598,7 @@ dns__catz_zones_merge(dns_catz_zone_t *catz, dns_catz_zone_t *newcatz) {
{
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' "
@ -608,7 +608,7 @@ dns__catz_zones_merge(dns_catz_zone_t *catz, dns_catz_zone_t *newcatz) {
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' "
@ -641,7 +641,7 @@ dns__catz_zones_merge(dns_catz_zone_t *catz, dns_catz_zone_t *newcatz) {
* 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 "
@ -655,7 +655,7 @@ dns__catz_zones_merge(dns_catz_zone_t *catz, dns_catz_zone_t *newcatz) {
}
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",
@ -695,8 +695,8 @@ dns__catz_zones_merge(dns_catz_zone_t *catz, dns_catz_zone_t *newcatz) {
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);
@ -716,8 +716,8 @@ dns__catz_zones_merge(dns_catz_zone_t *catz, dns_catz_zone_t *newcatz) {
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));
@ -732,8 +732,8 @@ dns__catz_zones_merge(dns_catz_zone_t *catz, dns_catz_zone_t *newcatz) {
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));
@ -855,8 +855,8 @@ dns__catz_timer_start(dns_catz_zone_t *catz) {
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",
@ -897,7 +897,7 @@ dns_catz_zone_add(dns_catz_zones_t *catzs, const dns_name_t *name,
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);
@ -1187,8 +1187,8 @@ catz_process_coo(dns_catz_zone_t *catz, dns_label_t *mhash,
}
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;
@ -1246,8 +1246,8 @@ catz_process_zones_entry(dns_catz_zone_t *catz, dns_rdataset_t *value,
}
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;
@ -1307,8 +1307,8 @@ catz_process_version(dns_catz_zone_t *catz, dns_rdataset_t *value) {
}
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;
@ -1359,8 +1359,8 @@ catz_process_version(dns_catz_zone_t *catz, dns_rdataset_t *value) {
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;
@ -1572,8 +1572,8 @@ catz_process_apl(dns_catz_zone_t *catz, isc_buffer_t **aclbp,
}
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");
}
@ -1713,8 +1713,8 @@ catz_entry_add_or_mod(dns_catz_zone_t *catz, isc_ht_t *ht, unsigned char *key,
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));
}
@ -1811,8 +1811,8 @@ dns__catz_update_process(dns_catz_zone_t *catz, const dns_name_t *src_name,
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);
@ -1998,7 +1998,7 @@ dns_catz_generate_zonecfg(dns_catz_zone_t *catz, dns_catz_entry_t *entry,
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)",
@ -2093,8 +2093,8 @@ dns__catz_timer_cb(void *arg) {
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;
@ -2106,7 +2106,7 @@ dns__catz_timer_cb(void *arg) {
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);
@ -2175,8 +2175,8 @@ dns_catz_dbupdate_callback(dns_db_t *db, void *fn_arg) {
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) {
@ -2269,16 +2269,16 @@ dns__catz_update_cb(void *data) {
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;
@ -2287,22 +2287,22 @@ dns__catz_update_cb(void *data) {
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;
@ -2318,8 +2318,8 @@ dns__catz_update_cb(void *data) {
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;
@ -2328,8 +2328,8 @@ dns__catz_update_cb(void *data) {
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));
@ -2350,7 +2350,7 @@ dns__catz_update_cb(void *data) {
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));
@ -2373,7 +2373,7 @@ dns__catz_update_cb(void *data) {
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));
@ -2417,7 +2417,7 @@ dns__catz_update_cb(void *data) {
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 "
@ -2443,7 +2443,7 @@ dns__catz_update_cb(void *data) {
}
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));
@ -2455,13 +2455,13 @@ dns__catz_update_cb(void *data) {
? 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);
@ -2472,8 +2472,8 @@ dns__catz_update_cb(void *data) {
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);
@ -2488,15 +2488,14 @@ dns__catz_update_cb(void *data) {
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");
@ -2526,7 +2525,7 @@ dns__catz_done_cb(void *data) {
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));
@ -2572,7 +2571,7 @@ dns_catz_postreconfig(dns_catz_zones_t *catzs) {
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);

4
lib/dns/db.c
View File

@ -158,8 +158,8 @@ dns_db_create(isc_mem_t *mctx, const char *db_type, const dns_name_t *origin,
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);
}

18
lib/dns/diff.c
View File

@ -42,9 +42,6 @@
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)
@ -346,7 +343,8 @@ diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver, bool warn) {
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 "
@ -428,7 +426,8 @@ diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver, bool warn) {
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",
@ -465,7 +464,8 @@ diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver, bool warn) {
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",
@ -557,7 +557,8 @@ dns_diff_load(dns_diff_t *diff, dns_rdatacallbacks_t *callbacks) {
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");
@ -707,7 +708,8 @@ dns_diff_print(dns_diff_t *diff, FILE *file) {
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);
}

24
lib/dns/dispatch.c
View File

@ -250,7 +250,7 @@ mgr_log(dns_dispatchmgr_t *mgr, int level, const char *fmt, ...) {
char msgbuf[2048];
va_list ap;
if (!isc_log_wouldlog(dns_lctx, level)) {
if (!isc_log_wouldlog(level)) {
return;
}
@ -258,9 +258,8 @@ mgr_log(dns_dispatchmgr_t *mgr, int level, const char *fmt, ...) {
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
@ -287,7 +286,7 @@ dispatch_log(dns_dispatch_t *disp, int level, const char *fmt, ...) {
va_list ap;
int r;
if (!isc_log_wouldlog(dns_lctx, level)) {
if (!isc_log_wouldlog(level)) {
return;
}
@ -301,9 +300,8 @@ dispatch_log(dns_dispatch_t *disp, int level, const char *fmt, ...) {
}
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
@ -316,7 +314,7 @@ dispentry_log(dns_dispentry_t *resp, int level, const char *fmt, ...) {
va_list ap;
int r;
if (!isc_log_wouldlog(dns_lctx, level)) {
if (!isc_log_wouldlog(level)) {
return;
}
@ -536,7 +534,7 @@ udp_recv(isc_nmhandle_t *handle, isc_result_t eresult, isc_region_t *region,
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));
@ -1195,7 +1193,7 @@ dns_dispatch_createtcp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *localaddr,
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,
@ -1331,7 +1329,7 @@ dispatch_createudp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *localaddr,
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,
@ -1794,7 +1792,7 @@ tcp_connected(isc_nmhandle_t *handle, isc_result_t eresult, void *arg) {
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) {

31
lib/dns/dlz.c
View File

@ -177,9 +177,8 @@ dns_dlzcreate(isc_mem_t *mctx, const char *dlzname, const char *drivername,
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);
@ -189,8 +188,8 @@ dns_dlzcreate(isc_mem_t *mctx, const char *dlzname, const char *drivername,
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);
@ -221,12 +220,12 @@ dns_dlzcreate(isc_mem_t *mctx, const char *dlzname, const char *drivername,
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. */
@ -241,7 +240,7 @@ dns_dlzdestroy(dns_dlzdb_t **dbp) {
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.");
/*
@ -277,7 +276,7 @@ dns_dlzregister(const char *drivername, const dns_dlzmethods_t *methods,
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);
@ -307,8 +306,8 @@ dns_dlzregister(const char *drivername, const dns_dlzmethods_t *methods,
*/
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);
@ -365,7 +364,7 @@ dns_dlzunregister(dns_dlzimplementation_t **dlzimp) {
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.");
/*
@ -431,8 +430,8 @@ dns_dlz_writeablezone(dns_view_t *view, dns_dlzdb_t *dlzdb,
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);
@ -518,8 +517,8 @@ dns_dlz_ssumatch(dns_dlzdb_t *dlzdatabase, const dns_name_t *signer,
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);
}

36
lib/dns/dnsrps.c
View File

@ -120,8 +120,8 @@ dnsrps_log_fnc(librpz_log_level_t level, void *ctxt, const char *buf) {
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);
}
/*
@ -150,12 +150,10 @@ dns_dnsrps_server_create(const char *librpz_path) {
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);
@ -175,8 +173,8 @@ dns_dnsrps_server_destroy(void) {
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;
@ -192,14 +190,14 @@ isc_result_t
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);
@ -224,20 +222,20 @@ dns_dnsrps_connect(dns_rpz_zones_t *rpzs) {
* 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);

46
lib/dns/dnssec.c
View File

@ -562,8 +562,8 @@ again:
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);
@ -1307,7 +1307,7 @@ findmatchingkeys(const char *directory, char *namebuf, unsigned int len,
}
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",
@ -1659,7 +1659,7 @@ dns_dnssec_keylistfromrdataset(const dns_name_t *origin, dns_kasp_t *kasp,
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",
@ -1861,8 +1861,8 @@ add_cds(dns_dnsseckey_t *key, dns_rdata_t *keyrdata, const char *keystr,
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);
@ -1873,8 +1873,8 @@ add_cds(dns_dnsseckey_t *key, dns_rdata_t *keyrdata, const char *keystr,
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);
@ -1901,8 +1901,8 @@ delete_cds(dns_dnsseckey_t *key, dns_rdata_t *keyrdata, const char *keystr,
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);
@ -1962,7 +1962,7 @@ dns_dnssec_syncupdate(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *rmkeys,
!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);
@ -1990,8 +1990,7 @@ dns_dnssec_syncupdate(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *rmkeys,
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 "
@ -2037,7 +2036,7 @@ dns_dnssec_syncupdate(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *rmkeys,
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);
@ -2080,7 +2079,7 @@ dns_dnssec_syncdelete(dns_rdataset_t *cds, dns_rdataset_t *cdnskey,
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",
@ -2090,7 +2089,7 @@ dns_dnssec_syncdelete(dns_rdataset_t *cds, dns_rdataset_t *cdnskey,
} 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",
@ -2103,7 +2102,7 @@ dns_dnssec_syncdelete(dns_rdataset_t *cds, dns_rdataset_t *cdnskey,
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",
@ -2114,7 +2113,7 @@ dns_dnssec_syncdelete(dns_rdataset_t *cds, dns_rdataset_t *cdnskey,
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",
@ -2236,7 +2235,7 @@ dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
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,
@ -2245,7 +2244,6 @@ dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
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,
@ -2276,7 +2274,7 @@ dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
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,
@ -2299,7 +2297,7 @@ dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
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",
@ -2332,7 +2330,7 @@ dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
{
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")
@ -2341,7 +2339,7 @@ dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
!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,

20
lib/dns/dnstap.c
View File

@ -153,7 +153,7 @@ dns_dt_create(isc_mem_t *mctx, dns_dtmode_t mode, const char *path,
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);
@ -204,8 +204,8 @@ dns_dt_create(isc_mem_t *mctx, dns_dtmode_t mode, const char *path,
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);
@ -324,7 +324,7 @@ dns_dt_reopen(dns_dtenv_t *env, int roll) {
/*
* 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);
@ -357,8 +357,8 @@ dns_dt_reopen(dns_dtenv_t *env, int roll) {
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);
}
@ -474,7 +474,7 @@ dns_dt_getstats(dns_dtenv_t *env, isc_stats_t **statsp) {
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;
@ -815,9 +815,9 @@ dns_dt_send(dns_view_t *view, dns_dtmsgtype_t msgtype, isc_sockaddr_t *qaddr,
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;
}

4
lib/dns/dst_parse.c
View File

@ -620,8 +620,8 @@ dst__privstruct_writefile(const dst_key_t *key, const dst_private_t *priv,
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.",

30
lib/dns/dyndb.c
View File

@ -94,8 +94,8 @@ load_symbol(uv_lib_t *handle, const char *filename, const char *symbol_name,
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);
@ -121,7 +121,7 @@ load_library(isc_mem_t *mctx, const char *filename, const char *instname,
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);
@ -140,8 +140,8 @@ load_library(isc_mem_t *mctx, const char *filename, const char *instname,
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);
@ -155,8 +155,8 @@ load_library(isc_mem_t *mctx, const char *filename, const char *instname,
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);
@ -172,7 +172,7 @@ load_library(isc_mem_t *mctx, const char *filename, const char *instname,
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",
@ -250,9 +250,9 @@ dns_dyndb_cleanup(bool exiting) {
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);
@ -266,9 +266,9 @@ dns_dyndb_cleanup(bool exiting) {
}
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);
@ -277,7 +277,6 @@ dns_dyndb_createctx(isc_mem_t *mctx, const void *hashinit, isc_log_t *lctx,
*dctx = (dns_dyndbctx_t){
.loopmgr = loopmgr,
.hashinit = hashinit,
.lctx = lctx,
};
if (view != NULL) {
@ -313,7 +312,6 @@ dns_dyndb_destroyctx(dns_dyndbctx_t **dctxp) {
dns_zonemgr_detach(&dctx->zmgr);
}
dctx->loopmgr = NULL;
dctx->lctx = NULL;
isc_mem_putanddetach(&dctx->mctx, dctx, sizeof(*dctx));
}

2
lib/dns/gssapictx.c
View File

@ -959,7 +959,7 @@ gss_log(int level, const char *fmt, ...) {
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);
}

2
lib/dns/hmac_link.c
View File

@ -104,7 +104,7 @@
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", \

7
lib/dns/include/dns/dyndb.h
View File

@ -36,7 +36,6 @@ struct dns_dyndbctx {
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;
@ -131,9 +130,9 @@ dns_dyndb_cleanup(bool exiting);
*/
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

3
lib/dns/include/dns/log.h
View File

@ -19,7 +19,6 @@
#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[];
@ -85,7 +84,7 @@ 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.

5
lib/dns/include/dns/resolver.h
View File

@ -365,9 +365,8 @@ dns_resolver_destroyfetch(dns_fetch_t **fetchp);
*/
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.

134
lib/dns/journal.c
View File

@ -81,11 +81,6 @@
* 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
@ -417,8 +412,8 @@ journal_seek(dns_journal_t *j, uint32_t offset) {
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);
}
@ -435,8 +430,8 @@ journal_read(dns_journal_t *j, void *mem, size_t nbytes) {
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);
}
@ -450,8 +445,8 @@ journal_write(dns_journal_t *j, void *mem, size_t nbytes) {
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);
}
@ -465,15 +460,15 @@ journal_fsync(dns_journal_t *j) {
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);
}
@ -573,8 +568,8 @@ journal_file_create(isc_mem_t *mctx, bool downgrade, const char *filename) {
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);
}
@ -595,8 +590,8 @@ journal_file_create(isc_mem_t *mctx, bool downgrade, const char *filename) {
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);
@ -607,8 +602,8 @@ journal_file_create(isc_mem_t *mctx, bool downgrade, const char *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);
@ -636,7 +631,8 @@ journal_open(isc_mem_t *mctx, const char *filename, bool writable, bool create,
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);
@ -650,8 +646,8 @@ journal_open(isc_mem_t *mctx, const char *filename, bool writable, bool create,
}
}
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);
}
@ -689,7 +685,8 @@ journal_open(isc_mem_t *mctx, const char *filename, bool writable, bool create,
*/
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);
}
@ -870,7 +867,8 @@ maybe_fixup_xhdr(dns_journal_t *j, journal_xhdr_t *xhdr, uint32_t serial,
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;
@ -881,7 +879,8 @@ maybe_fixup_xhdr(dns_journal_t *j, journal_xhdr_t *xhdr, uint32_t serial,
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;
@ -901,7 +900,8 @@ maybe_fixup_xhdr(dns_journal_t *j, journal_xhdr_t *xhdr, uint32_t serial,
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;
@ -911,7 +911,8 @@ maybe_fixup_xhdr(dns_journal_t *j, journal_xhdr_t *xhdr, uint32_t serial,
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;
@ -976,7 +977,8 @@ journal_next(dns_journal_t *j, journal_pos_t *pos) {
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);
@ -991,8 +993,9 @@ journal_next(dns_journal_t *j, journal_pos_t *pos) {
: 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);
}
@ -1198,7 +1201,8 @@ dns_journal_writediff(dns_journal_t *j, dns_diff_t *diff) {
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);
/*
@ -1222,7 +1226,8 @@ dns_journal_writediff(dns_journal_t *j, dns_diff_t *diff) {
}
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);
@ -1306,13 +1311,15 @@ dns_journal_commit(dns_journal_t *j) {
* 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);
@ -1320,7 +1327,8 @@ dns_journal_commit(dns_journal_t *j) {
}
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",
@ -1335,7 +1343,8 @@ dns_journal_commit(dns_journal_t *j) {
*/
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);
@ -1561,7 +1570,8 @@ dns_journal_rollforward(dns_journal_t *j, dns_db_t *db, unsigned int options) {
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);
@ -1578,7 +1588,8 @@ dns_journal_rollforward(dns_journal_t *j, dns_db_t *db, unsigned int options) {
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);
@ -1593,7 +1604,8 @@ dns_journal_rollforward(dns_journal_t *j, dns_db_t *db, unsigned int options) {
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);
@ -1639,11 +1651,12 @@ dns_journal_print(isc_mem_t *mctx, uint32_t flags, const char *filename,
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);
}
@ -1703,7 +1716,8 @@ dns_journal_print(isc_mem_t *mctx, uint32_t flags, const char *filename,
}
}
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);
@ -1752,8 +1766,9 @@ dns_journal_print(isc_mem_t *mctx, uint32_t flags, const char *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) {
@ -1957,7 +1972,8 @@ read_one_rr(dns_journal_t *j) {
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);
@ -1972,7 +1988,8 @@ read_one_rr(dns_journal_t *j) {
*/
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);
@ -1986,7 +2003,8 @@ read_one_rr(dns_journal_t *j) {
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,
@ -2009,7 +2027,8 @@ read_one_rr(dns_journal_t *j) {
* 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);
@ -2051,7 +2070,8 @@ read_one_rr(dns_journal_t *j) {
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);
@ -2400,7 +2420,9 @@ dns_db_diffx(dns_diff_t *diff, dns_db_t *dba, dns_dbversion_t *dbvera,
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));
}
@ -2629,7 +2651,8 @@ dns_journal_compact(isc_mem_t *mctx, char *filename, uint32_t serial,
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",
@ -2663,7 +2686,8 @@ dns_journal_compact(isc_mem_t *mctx, char *filename, uint32_t serial,
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",

99
lib/dns/keymgr.c
View File

@ -53,10 +53,10 @@
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 " \
@ -90,10 +90,9 @@ static void
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);
}
/*
@ -382,7 +381,7 @@ keymgr_key_retire(dns_dnsseckey_t *key, dns_kasp_t *kasp, isc_stdtime_t now) {
}
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));
}
@ -491,7 +490,7 @@ keymgr_createkey(dns_kasp_key_t *kkey, const dns_name_t *origin,
}
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));
@ -1216,7 +1215,7 @@ keymgr_transition_allowed(dns_dnsseckeylist_t *keyring, dns_dnsseckey_t *key,
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));
@ -1229,7 +1228,7 @@ keymgr_transition_allowed(dns_dnsseckeylist_t *keyring, dns_dnsseckey_t *key,
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) "
@ -1470,7 +1469,7 @@ transition:
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",
@ -1485,7 +1484,7 @@ transition:
* 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 "
@ -1496,7 +1495,7 @@ transition:
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?",
@ -1510,7 +1509,7 @@ transition:
{
/* 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 "
@ -1529,7 +1528,7 @@ transition:
{
/* 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 "
@ -1547,7 +1546,7 @@ transition:
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 "
@ -1562,7 +1561,7 @@ transition:
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!",
@ -1716,11 +1715,11 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
/* 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));
@ -1733,11 +1732,11 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
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 "
@ -1756,11 +1755,11 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
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",
@ -1770,9 +1769,9 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
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)",
@ -1785,7 +1784,7 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
*/
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",
@ -1793,11 +1792,11 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
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));
}
@ -1912,7 +1911,7 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
/* 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",
@ -1988,8 +1987,8 @@ keymgr_purge_keyfile(dst_key_t *key, int type) {
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),
@ -2000,8 +1999,8 @@ keymgr_purge_keyfile(dst_key_t *key, int type) {
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);
@ -2036,11 +2035,11 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
*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)",
@ -2051,7 +2050,7 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
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));
@ -2060,7 +2059,7 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
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));
@ -2100,7 +2099,7 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
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",
@ -2130,7 +2129,7 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
/* 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 "
@ -2193,7 +2192,6 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
dst_key_format(dnskey->key, keystr,
sizeof(keystr));
isc_log_write(
dns_lctx,
DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC,
ISC_LOG_DEBUG(1),
@ -2249,11 +2247,11 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
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",
@ -2275,12 +2273,11 @@ failure:
}
}
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);
}
@ -2343,14 +2340,14 @@ keymgr_checkds(dns_kasp_t *kasp, dns_dnsseckeylist_t *keyring,
}
}
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);

12
lib/dns/keystore.c
View File

@ -217,8 +217,8 @@ dns_keystore_keygen(dns_keystore_t *keystore, const dns_name_t *origin,
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));
@ -232,15 +232,15 @@ dns_keystore_keygen(dns_keystore_t *keystore, const dns_name_t *origin,
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,

8
lib/dns/log.c
View File

@ -53,10 +53,8 @@ isc_logmodule_t dns_modules[] = {
{ "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);
}

20
lib/dns/masterdump.c
View File

@ -1448,12 +1448,12 @@ flushandsync(FILE *f, isc_result_t result, const char *temp) {
}
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));
@ -1466,12 +1466,12 @@ flushandsync(FILE *f, isc_result_t result, const char *temp) {
}
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));
@ -1496,8 +1496,8 @@ closeandrename(FILE *f, isc_result_t result, const char *temp,
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;
@ -1508,8 +1508,8 @@ closeandrename(FILE *f, isc_result_t result, const char *temp,
(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));
}
@ -1852,8 +1852,8 @@ opentmp(isc_mem_t *mctx, const char *file, char **tempp, FILE **fp) {
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;

11
lib/dns/message.c
View File

@ -1843,8 +1843,8 @@ dns_message_parse(dns_message_t *msg, isc_buffer_t *source,
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);
}
@ -4695,7 +4695,7 @@ logfmtpacket(dns_message_t *message, const char *description,
int len = 1024;
isc_result_t result;
if (!isc_log_wouldlog(dns_lctx, level)) {
if (!isc_log_wouldlog(level)) {
return;
}
@ -4718,9 +4718,8 @@ logfmtpacket(dns_message_t *message, const char *description,
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);

13
lib/dns/nta.c
View File

@ -385,9 +385,8 @@ delete_expired(void *arg) {
{
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);
@ -584,12 +583,12 @@ dns__nta_shutdown_cb(void *arg) {
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);

10
lib/dns/qp.c
View File

@ -69,8 +69,8 @@ static atomic_uint_fast64_t rollback_time;
#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(...)
@ -83,8 +83,8 @@ static atomic_uint_fast64_t rollback_time;
*/
#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, \
@ -998,7 +998,7 @@ squash_twigs(dns_qp_t *qp, dns_qpref_t twigs, dns_qpweight_t size) {
* 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, "

21
lib/dns/qpcache.c
View File

@ -571,11 +571,11 @@ static void
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);
}
@ -588,7 +588,7 @@ delete_node(qpcache_t *qpdb, qpcnode_t *node) {
*/
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",
@ -603,8 +603,8 @@ delete_node(qpcache_t *qpdb, qpcnode_t *node) {
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));
@ -2487,9 +2487,8 @@ free_qpdb(qpcache_t *qpdb, bool log) {
} 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);
@ -2595,7 +2594,7 @@ qpdb_destroy(dns_db_t *arg) {
} 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);
@ -2780,7 +2779,7 @@ detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
} 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);

11
lib/dns/qpzone.c
View File

@ -456,9 +456,8 @@ free_qpdb(qpzonedb_t *qpdb, bool log) {
} 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);
@ -518,7 +517,7 @@ qpdb_destroy(dns_db_t *arg) {
} 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);
@ -2960,7 +2959,7 @@ previous_closest_nsec(dns_rdatatype_t type, qpz_search_t *search,
* 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));
@ -3882,7 +3881,7 @@ detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
} 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);

8
lib/dns/rbt-zonedb.c
View File

@ -772,7 +772,7 @@ previous_closest_nsec(dns_rdatatype_t type, rbtdb_search_t *search,
* 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));
@ -1644,8 +1644,8 @@ loadnode(dns_rbtdb_t *rbtdb, const dns_name_t *name, dns_rbtnode_t **nodep,
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;
@ -1658,7 +1658,7 @@ loadnode(dns_rbtdb_t *rbtdb, const dns_name_t *name, dns_rbtnode_t **nodep,
*/
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 "

27
lib/dns/rbtdb.c
View File

@ -434,8 +434,8 @@ adjust_quantum(unsigned int old, isc_time_t *start) {
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);
}
@ -525,9 +525,8 @@ free_rbtdb(dns_rbtdb_t *rbtdb, bool log) {
} 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);
@ -654,7 +653,7 @@ dns__rbtdb_destroy(dns_db_t *arg) {
} 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);
@ -1051,10 +1050,10 @@ delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
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)),
@ -1081,7 +1080,7 @@ delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
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",
@ -1091,7 +1090,7 @@ delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
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",
@ -1108,8 +1107,8 @@ delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
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));
@ -2300,7 +2299,7 @@ dns__rbtdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
} 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);

4
lib/dns/request.c
View File

@ -1055,7 +1055,7 @@ req_log(int level, const char *fmt, ...) {
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);
}

237
lib/dns/resolver.c
View File

@ -75,47 +75,40 @@
#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 { \
@ -1378,7 +1371,7 @@ fcount_logspill(fetchctx_t *fctx, fctxcount_t *counter, bool final) {
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;
}
@ -1396,8 +1389,8 @@ fcount_logspill(fetchctx_t *fctx, fctxcount_t *counter, bool final) {
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)",
@ -1406,8 +1399,8 @@ fcount_logspill(fetchctx_t *fctx, fctxcount_t *counter, bool final) {
: "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)",
@ -1644,7 +1637,7 @@ fctx_sendevents(fetchctx_t *fctx, isc_result_t result) {
}
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);
@ -1686,7 +1679,7 @@ fctx__done(fetchctx_t *fctx, isc_result_t result, const char *func,
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'",
@ -1997,7 +1990,7 @@ fctx_query(fetchctx_t *fctx, dns_adbaddrinfo_t *addrinfo,
/* 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);
@ -2133,14 +2126,14 @@ fctx_query(fetchctx_t *fctx, dns_adbaddrinfo_t *addrinfo,
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));
@ -3118,10 +3111,10 @@ add_bad(fetchctx_t *fctx, dns_message_t *rmessage, dns_adbaddrinfo_t *addrinfo,
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);
}
/*
@ -3273,10 +3266,10 @@ findname(fetchctx_t *fctx, const dns_name_t *name, in_port_t port,
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) {
@ -3288,7 +3281,7 @@ findname(fetchctx_t *fctx, const dns_name_t *name, in_port_t port,
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'",
@ -3333,9 +3326,9 @@ findname(fetchctx_t *fctx, const dns_name_t *name, in_port_t port,
*/
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);
@ -3437,8 +3430,8 @@ fctx_getaddresses(fetchctx_t *fctx, bool badcache) {
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);
@ -3794,7 +3787,7 @@ possibly_mark(fetchctx_t *fctx, dns_adbaddrinfo_t *addr) {
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));
@ -3983,8 +3976,8 @@ fctx_try(fetchctx_t *fctx, bool retrying, bool badcache) {
/* 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),
@ -4057,7 +4050,7 @@ fctx_try(fetchctx_t *fctx, bool retrying, bool badcache) {
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 "
@ -4097,8 +4090,8 @@ fctx_try(fetchctx_t *fctx, bool retrying, bool badcache) {
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;
@ -4219,8 +4212,8 @@ resume_qmin(void *arg) {
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;
@ -4356,8 +4349,8 @@ fctx_expired(void *arg) {
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);
@ -4472,8 +4465,8 @@ log_ns_ttl(fetchctx_t *fctx, const char *where) {
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);
}
@ -4534,8 +4527,8 @@ fctx_create(dns_resolver_t *res, isc_loop_t *loop, const dns_name_t *name,
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 {
@ -4544,8 +4537,8 @@ fctx_create(dns_resolver_t *res, isc_loop_t *loop, const dns_name_t *name,
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);
}
@ -4826,10 +4819,9 @@ log_lame(fetchctx_t *fctx, dns_adbaddrinfo_t *addrinfo) {
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
@ -4844,8 +4836,8 @@ log_formerr(fetchctx_t *fctx, const char *format, ...) {
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);
}
@ -5643,9 +5635,8 @@ fctx_log(void *arg, int level, const char *fmt, ...) {
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
@ -5891,7 +5882,7 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message,
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,
@ -6802,7 +6793,7 @@ is_answeraddress_allowed(dns_view_t *view, dns_name_t *name,
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);
@ -6912,10 +6903,9 @@ is_answertarget_allowed(fetchctx_t *fctx, dns_name_t *qname, dns_name_t *rname,
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);
}
@ -6933,8 +6923,8 @@ trim_ns_ttl(fetchctx_t *fctx, dns_name_t *name, dns_rdataset_t *rdataset) {
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,
@ -7240,9 +7230,8 @@ log_nsid(isc_buffer_t *opt, size_t nsid_len, resquery_t *query, int level,
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);
@ -7406,11 +7395,11 @@ resquery_response(isc_result_t eresult, isc_region_t *region, void *arg) {
* 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);
}
@ -7513,16 +7502,16 @@ resquery_response_continue(void *arg, isc_result_t result) {
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;
@ -7540,9 +7529,7 @@ resquery_response_continue(void *arg, isc_result_t result) {
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(
@ -7551,7 +7538,6 @@ resquery_response_continue(void *arg, isc_result_t result) {
addrbuf,
sizeof(addrbuf));
isc_log_write(
dns_lctx,
DNS_LOGCATEGORY_RESOLVER,
DNS_LOGMODULE_RESOLVER,
ISC_LOG_INFO,
@ -9957,8 +9943,8 @@ spillattimer_countdown(void *arg) {
}
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);
}
}
@ -10072,8 +10058,7 @@ prime_done(void *arg) {
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));
@ -10221,16 +10206,15 @@ log_fetch(const dns_name_t *name, dns_rdatatype_t type) {
* 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
@ -10330,8 +10314,8 @@ fctx_minimize_qname(fetchctx_t *fctx) {
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);
@ -10627,9 +10611,8 @@ dns_resolver_destroyfetch(dns_fetch_t **fetchp) {
}
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));
@ -10641,7 +10624,7 @@ dns_resolver_logfetch(dns_fetch_t *fetch, isc_log_t *lctx,
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 "

27
lib/dns/rootns.c
View File

@ -279,16 +279,15 @@ dns_rootns_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
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",
@ -326,13 +325,13 @@ report(dns_view_t *view, dns_name_t *name, bool missing, dns_rdata_t *rdata) {
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);
@ -521,8 +520,8 @@ dns_root_checkhints(dns_view_t *view, dns_db_t *hints, dns_db_t *db) {
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));
@ -532,8 +531,8 @@ dns_root_checkhints(dns_view_t *view, dns_db_t *hints, dns_db_t *db) {
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));
@ -553,7 +552,7 @@ dns_root_checkhints(dns_view_t *view, dns_db_t *hints, dns_db_t *db) {
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",
@ -581,7 +580,7 @@ dns_root_checkhints(dns_view_t *view, dns_db_t *hints, dns_db_t *db) {
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);

66
lib/dns/rpz.c
View File

@ -610,7 +610,7 @@ fix_qname_skip_recurse(dns_rpz_zones_t *rpzs) {
}
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);
@ -719,11 +719,10 @@ badname(int level, const dns_name_t *name, const char *str1, const char *str2) {
/*
* 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);
}
@ -1012,9 +1011,7 @@ name2ipkey(int log_level, dns_rpz_zone_t *rpz, dns_rpz_type_t rpz_type,
/*
* 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.
@ -1027,8 +1024,8 @@ name2ipkey(int log_level, dns_rpz_zone_t *rpz, dns_rpz_type_t rpz_type,
{
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);
@ -1388,8 +1385,8 @@ add_cidr(dns_rpz_zone_t *rpz, dns_rpz_type_t rpz_type,
* 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;
@ -1647,8 +1644,8 @@ dns_rpz_dbupdate_callback(dns_db_t *db, void *fn_arg) {
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) {
@ -1693,8 +1690,8 @@ dns__rpz_timer_start(dns_rpz_zone_t *rpz) {
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",
@ -1744,7 +1741,7 @@ update_rpz_done_cb(void *data) {
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));
@ -1765,8 +1762,8 @@ update_nodes(dns_rpz_zone_t *rpz, isc_ht_t *newnodes) {
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);
@ -1774,8 +1771,8 @@ update_nodes(dns_rpz_zone_t *rpz, isc_ht_t *newnodes) {
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;
@ -1793,7 +1790,7 @@ update_nodes(dns_rpz_zone_t *rpz, isc_ht_t *newnodes) {
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));
@ -1806,7 +1803,7 @@ update_nodes(dns_rpz_zone_t *rpz, isc_ht_t *newnodes) {
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",
@ -1823,7 +1820,7 @@ update_nodes(dns_rpz_zone_t *rpz, isc_ht_t *newnodes) {
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",
@ -1838,7 +1835,7 @@ update_nodes(dns_rpz_zone_t *rpz, isc_ht_t *newnodes) {
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,
@ -1865,15 +1862,15 @@ update_nodes(dns_rpz_zone_t *rpz, isc_ht_t *newnodes) {
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);
@ -2011,7 +2008,7 @@ dns__rpz_timer_cb(void *arg) {
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);
@ -2363,8 +2360,8 @@ del_name(dns_rpz_zone_t *rpz, dns_rpz_type_t rpz_type,
* "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));
@ -2528,9 +2525,8 @@ dns_rpz_find_ip(dns_rpz_zones_t *rpzs, dns_rpz_type_t rpz_type,
/*
* 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);
}
@ -2592,8 +2588,8 @@ dns_rpz_find_name(dns_rpz_zones_t *rpzs, dns_rpz_type_t rpz_type,
* 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;

64
lib/dns/rrl.c
View File

@ -101,9 +101,9 @@ hash_divisor(unsigned int initial) {
}
} 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);
@ -184,8 +184,8 @@ set_age(dns_rrl_t *rrl, dns_rrl_entry_t *e, isc_stdtime_t now) {
}
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],
@ -224,13 +224,13 @@ expand_entries(dns_rrl_t *rrl, int newsize) {
* 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,
@ -310,13 +310,13 @@ expand_rrl_hash(dns_rrl_t *rrl, isc_stdtime_t now) {
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);
@ -619,7 +619,7 @@ debit_log(const dns_rrl_entry_t *e, int age, const char *action) {
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);
}
@ -662,7 +662,7 @@ debit_rrl_entry(dns_rrl_t *rrl, dns_rrl_entry_t *e, double qps, double scale,
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",
@ -718,7 +718,7 @@ debit_rrl_entry(dns_rrl_t *rrl, dns_rrl_entry_t *e, double qps, double scale,
* 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);
@ -738,7 +738,7 @@ debit_rrl_entry(dns_rrl_t *rrl, dns_rrl_entry_t *e, double qps, double scale,
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",
@ -752,7 +752,7 @@ debit_rrl_entry(dns_rrl_t *rrl, dns_rrl_entry_t *e, double qps, double scale,
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);
@ -761,7 +761,7 @@ debit_rrl_entry(dns_rrl_t *rrl, dns_rrl_entry_t *e, double qps, double scale,
}
}
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);
@ -970,9 +970,8 @@ log_end(dns_rrl_t *rrl, dns_rrl_entry_t *e, bool early, char *log_buf,
: "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;
@ -1067,11 +1066,8 @@ dns_rrl(dns_view_t *view, dns_zone_t *zone, const isc_sockaddr_t *client_addr,
} 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"
@ -1143,7 +1139,7 @@ dns_rrl(dns_view_t *view, dns_zone_t *zone, const isc_sockaddr_t *client_addr,
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().
@ -1151,9 +1147,8 @@ dns_rrl(dns_view_t *view, dns_zone_t *zone, const isc_sockaddr_t *client_addr,
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,
@ -1184,13 +1179,13 @@ dns_rrl(dns_view_t *view, dns_zone_t *zone, const isc_sockaddr_t *client_addr,
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);
@ -1207,7 +1202,7 @@ dns_rrl(dns_view_t *view, dns_zone_t *zone, const isc_sockaddr_t *client_addr,
* 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,
@ -1228,9 +1223,8 @@ dns_rrl(dns_view_t *view, dns_zone_t *zone, const isc_sockaddr_t *client_addr,
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);
}
/*

2
lib/dns/sdlz.c
View File

@ -229,7 +229,7 @@ static void
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);
}

3
lib/dns/ssu.c
View File

@ -373,8 +373,7 @@ dns_ssutable_checkrules(dns_ssutable_t *table, const dns_name_t *signer,
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: "

2
lib/dns/ssu_external.c
View File

@ -45,7 +45,7 @@ ssu_e_log(int level, const char *fmt, ...) {
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);
}

2
lib/dns/tkey.c
View File

@ -70,7 +70,7 @@ tkey_log(const char *fmt, ...) {
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);
}

14
lib/dns/tsig.c
View File

@ -124,7 +124,7 @@ tsig_log(dns_tsigkey_t *key, int level, const char *fmt, ...) {
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) {
@ -143,14 +143,12 @@ tsig_log(dns_tsigkey_t *key, int level, const char *fmt, ...) {
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);
}
}
@ -286,8 +284,8 @@ dns_tsigkey_createfromkey(const dns_name_t *name, dst_algorithm_t algorithm,
{
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);
}

6
lib/dns/update.c
View File

@ -131,7 +131,7 @@
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, \
@ -153,7 +153,7 @@
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)); \
@ -208,7 +208,7 @@ update_log(dns_update_log_t *callback, dns_zone_t *zone, int level,
return;
}
if (!isc_log_wouldlog(dns_lctx, level)) {
if (!isc_log_wouldlog(level)) {
return;
}

6
lib/dns/validator.c
View File

@ -3540,11 +3540,11 @@ validator_logv(dns_validator_t *val, isc_logcategory_t *category,
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);
}
@ -3554,7 +3554,7 @@ static void
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;
}

16
lib/dns/view.c
View File

@ -1864,9 +1864,8 @@ dns_view_setnewzones(dns_view_t *view, bool allow, void *cfgctx,
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);
}
@ -1874,7 +1873,7 @@ dns_view_setnewzones(dns_view_t *view, bool allow, void *cfgctx,
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));
@ -1885,9 +1884,8 @@ dns_view_setnewzones(dns_view_t *view, bool allow, void *cfgctx,
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);
}
@ -2184,8 +2182,8 @@ dns_view_loadnta(dns_view_t *view) {
} 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);
}
}

6
lib/dns/xfrin.c
View File

@ -2121,7 +2121,7 @@ xfrin_log(dns_xfrin_t *xfr, int level, const char *fmt, ...) {
char primarytext[ISC_SOCKADDR_FORMATSIZE];
char msgtext[2048];
if (!isc_log_wouldlog(dns_lctx, level)) {
if (!isc_log_wouldlog(level)) {
return;
}
@ -2131,7 +2131,7 @@ xfrin_log(dns_xfrin_t *xfr, int level, const char *fmt, ...) {
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);
}

42
lib/dns/zone.c
View File

@ -4873,7 +4873,7 @@ zone_postload(dns_zone_t *zone, dns_db_t *db, isc_time_t loadtime,
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 "
@ -6203,7 +6203,7 @@ findzonekeys(dns_zone_t *zone, dns_db_t *db, dns_dbversion_t *ver,
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));
@ -10918,7 +10918,7 @@ zone_refreshkeys(dns_zone_t *zone) {
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));
@ -15740,7 +15740,7 @@ dns_zone_logv(dns_zone_t *zone, isc_logcategory_t *category, int level,
REQUIRE(DNS_ZONE_VALID(zone));
if (!isc_log_wouldlog(dns_lctx, level)) {
if (!isc_log_wouldlog(level)) {
return;
}
@ -15757,8 +15757,8 @@ dns_zone_logv(dns_zone_t *zone, isc_logcategory_t *category, int level,
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);
}
@ -16950,8 +16950,8 @@ save_nsec3param(dns_zone_t *zone, nsec3paramlist_t *nsec3list) {
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);
@ -16986,8 +16986,8 @@ getprivate:
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");
/*
@ -17482,7 +17482,7 @@ zone_replacedb(dns_zone_t *zone, dns_db_t *db, bool dump) {
{
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 "
@ -17507,13 +17507,13 @@ zone_replacedb(dns_zone_t *zone, dns_db_t *db, bool dump) {
* 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 "
@ -20568,8 +20568,8 @@ static void
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);
}
@ -21579,7 +21579,7 @@ nsfetch_done(void *arg) {
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),
@ -21656,7 +21656,7 @@ do_nsfetch(void *arg) {
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,
@ -21727,7 +21727,7 @@ nsfetch_levelup(dns_nsfetch_t *nsfetch) {
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()");
@ -21809,7 +21809,7 @@ zone_checkds(dns_zone_t *zone) {
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()");
@ -22502,7 +22502,7 @@ zone_rekey(dns_zone_t *zone) {
}
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))
{
@ -23798,7 +23798,7 @@ dns_zone_setnsec3param(dns_zone_t *zone, uint8_t hash, uint8_t flags,
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,

4
lib/dns/zt.c
View File

@ -466,8 +466,8 @@ freezezones(dns_zone_t *zone, void *uap) {
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) {

11
lib/isc/backtrace.c
View File

@ -62,8 +62,8 @@ isc_backtrace_symbols_fd(void *const *buffer, int size, int fd) {
}
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;
@ -77,7 +77,7 @@ isc_backtrace_log(isc_log_t *lctx, isc_logcategory_t *category,
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]);
}
}
@ -107,9 +107,8 @@ isc_backtrace_symbols_fd(void *const *buffer, int size, int fd) {
}
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);

2
lib/isc/file.c
View File

@ -370,7 +370,7 @@ isc_file_openuniquemode(char *templet, int mode, FILE **fp) {
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);
}

4
lib/isc/include/isc/backtrace.h
View File

@ -105,8 +105,8 @@ isc_backtrace_symbols_fd(void *const *buffer, int size, int fd);
*/
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.
*/

36
lib/isc/include/isc/log.h
View File

@ -160,7 +160,6 @@ typedef union isc_logdestination {
* 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[];
/*@}*/
@ -185,7 +184,7 @@ 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
@ -227,9 +226,9 @@ isc_logconfig_create(isc_log_t *lctx, isc_logconfig_t **lcfgp);
*/
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.
*
@ -264,7 +263,7 @@ isc_logconfig_destroy(isc_logconfig_t **lcfgp);
*/
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.
*
@ -302,7 +301,7 @@ isc_log_registercategories(isc_log_t *lctx, isc_logcategory_t categories[]);
*/
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.
*
@ -500,10 +499,10 @@ isc_log_usechannel(isc_logconfig_t *lcfg, const char *name,
* 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.
@ -538,14 +537,13 @@ isc_log_write(isc_log_t *lctx, isc_logcategory_t *category,
* 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.
*
@ -560,7 +558,7 @@ isc_log_setdebuglevel(isc_log_t *lctx, unsigned int level);
*/
unsigned int
isc_log_getdebuglevel(isc_log_t *lctx);
isc_log_getdebuglevel(void);
/*%<
* Get the current debugging level.
*
@ -579,7 +577,7 @@ isc_log_getdebuglevel(isc_log_t *lctx);
*/
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.
@ -674,7 +672,7 @@ isc_log_opensyslog(const char *tag, int options, int facility);
*/
void
isc_log_closefilelogs(isc_log_t *lctx);
isc_log_closefilelogs(void);
/*%<
* Close all open files used by #ISC_LOG_TOFILE channels.
*
@ -696,7 +694,7 @@ isc_log_closefilelogs(isc_log_t *lctx);
*/
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.
*
@ -714,7 +712,7 @@ isc_log_categorybyname(isc_log_t *lctx, const char *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.
*

1
lib/isc/include/isc/types.h
View File

@ -49,7 +49,6 @@ typedef void(isc_httpdondestroy_t)(void *); /*%< Callback on destroying httpd */
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 */

70
lib/isc/log.c
View File

@ -50,6 +50,11 @@ static thread_local bool forcelog = false;
*/
#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
@ -189,7 +194,6 @@ static isc_logchannellist_t default_channel;
/*!
* libisc logs to this context.
*/
isc_log_t *isc_lctx __attribute__((__deprecated__)) = NULL;
static isc_log_t *isc__lctx = NULL;
/*!
@ -203,15 +207,14 @@ static void
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);
/*@{*/
/*!
@ -232,8 +235,7 @@ isc_log_doit(isc_log_t *__lctx ISC_ATTR_UNUSED, isc_logcategory_t *category,
****/
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));
@ -287,14 +289,14 @@ isc_logconfig_create(isc_log_t *__lctx ISC_ATTR_UNUSED,
}
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);
@ -308,7 +310,7 @@ isc_logconfig_set(isc_log_t *__lctx ISC_ATTR_UNUSED, isc_logconfig_t *lcfg) {
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) {
@ -388,8 +390,7 @@ isc_logconfig_destroy(isc_logconfig_t **lcfgp) {
}
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);
@ -434,7 +435,7 @@ isc_log_registercategories(isc_log_t *__lctx ISC_ATTR_UNUSED,
}
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));
@ -459,8 +460,7 @@ isc_log_categorybyname(isc_log_t *__lctx ISC_ATTR_UNUSED, const char *name) {
}
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);
@ -505,7 +505,7 @@ isc_log_registermodules(isc_log_t *__lctx ISC_ATTR_UNUSED,
}
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));
@ -650,7 +650,7 @@ isc_log_usechannel(isc_logconfig_t *lcfg, const char *name,
*/
rcu_read_lock();
if (rcu_dereference(lcfg->lctx->logconfig) == lcfg) {
sync_highest_level(lctx, lcfg);
sync_highest_level(lcfg);
}
rcu_read_unlock();
@ -658,8 +658,8 @@ isc_log_usechannel(isc_logconfig_t *lcfg, const char *name,
}
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;
/*
@ -667,22 +667,21 @@ isc_log_write(isc_log_t *__lctx ISC_ATTR_UNUSED, isc_logcategory_t *category,
*/
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);
@ -714,7 +713,7 @@ isc_log_setdebuglevel(isc_log_t *__lctx ISC_ATTR_UNUSED, unsigned int 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));
@ -751,7 +750,7 @@ isc_log_opensyslog(const char *tag, int options, int facility) {
}
void
isc_log_closefilelogs(isc_log_t *__lctx ISC_ATTR_UNUSED) {
isc_log_closefilelogs(void) {
REQUIRE(VALID_CONTEXT(isc__lctx));
rcu_read_lock();
@ -840,7 +839,7 @@ 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) {
atomic_store(&isc__lctx->highest_level, lcfg->highest_level);
atomic_store(&isc__lctx->dynamic, lcfg->dynamic);
}
@ -1297,7 +1296,7 @@ isc_log_open(isc_logchannel_t *channel) {
}
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
@ -1330,9 +1329,8 @@ isc_log_wouldlog(isc_log_t *__lctx ISC_ATTR_UNUSED, int level) {
}
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];
@ -1366,7 +1364,7 @@ isc_log_doit(isc_log_t *__lctx ISC_ATTR_UNUSED, isc_logcategory_t *category,
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;
}
@ -1662,12 +1660,12 @@ isc__log_initialize(void) {
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);

27
lib/isc/loop.c
View File

@ -466,9 +466,9 @@ void
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");
}
@ -488,10 +488,9 @@ isc_loopmgr_pause(isc_loopmgr_t *loopmgr) {
&(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");
}
}
@ -499,20 +498,18 @@ void
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");
}
}

8
lib/isc/net.c
View File

@ -148,11 +148,11 @@ try_proto(int domain) {
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;
@ -160,12 +160,12 @@ try_proto(int domain) {
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.");

2
lib/isc/netmgr/http.c
View File

@ -2028,7 +2028,7 @@ log_server_error_response(const isc_nmsocket_t *socket,
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;
}

31
lib/isc/netmgr/netmgr.c
View File

@ -1947,7 +1947,7 @@ isc__nmsocket_reset(isc_nmsocket_t *sock) {
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));
@ -2550,7 +2550,7 @@ isc__nmsocket_log_tls_session_reuse(isc_nmsocket_t *sock, isc_tls_t *tls) {
REQUIRE(tls != NULL);
if (!isc_log_wouldlog(isc_lctx, log_level)) {
if (!isc_log_wouldlog(log_level)) {
return;
};
@ -2588,7 +2588,7 @@ isc__netmgr_log(const isc_nm_t *netmgr, int level, const char *fmt, ...) {
char msgbuf[2048];
va_list ap;
if (!isc_log_wouldlog(isc_lctx, level)) {
if (!isc_log_wouldlog(level)) {
return;
}
@ -2596,8 +2596,8 @@ isc__netmgr_log(const isc_nm_t *netmgr, int level, const char *fmt, ...) {
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
@ -2605,7 +2605,7 @@ isc__nmsocket_log(const isc_nmsocket_t *sock, int level, const char *fmt, ...) {
char msgbuf[2048];
va_list ap;
if (!isc_log_wouldlog(isc_lctx, level)) {
if (!isc_log_wouldlog(level)) {
return;
}
@ -2613,8 +2613,8 @@ isc__nmsocket_log(const isc_nmsocket_t *sock, int level, const char *fmt, ...) {
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
@ -2623,7 +2623,7 @@ isc__nmhandle_log(const isc_nmhandle_t *handle, int level, const char *fmt,
char msgbuf[2048];
va_list ap;
if (!isc_log_wouldlog(isc_lctx, level)) {
if (!isc_log_wouldlog(level)) {
return;
}
@ -2650,7 +2650,7 @@ isc__nm_received_proxy_header_log(isc_nmhandle_t *handle,
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;
}
@ -2673,9 +2673,8 @@ isc__nm_received_proxy_header_log(isc_nmhandle_t *handle,
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) {
@ -2687,7 +2686,7 @@ isc__nm_received_proxy_header_log(isc_nmhandle_t *handle,
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)",
@ -2715,8 +2714,8 @@ isc__nm_received_proxy_header_log(isc_nmhandle_t *handle,
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,

Some files were not shown because too many files have changed in this diff Show More