* even in case of not having any work to do. */
ret = kr_cache_check_health(&engine->resolver.cache, 5000);
if (ret != 0) {
- kr_log_error(LOG_GRP_CACHE, "[cache] periodic health check failed (ignored): %s\n",
+ kr_log_error(LOG_GRP_CACHE, "periodic health check failed (ignored): %s\n",
kr_strerror(ret));
}
{
int ret = engine_pcall(L, argc);
if (ret != 0) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] error: %s\n", lua_tostring(L, -1));
+ kr_log_error(LOG_GRP_SYSTEM, "error: %s\n", lua_tostring(L, -1));
}
/* Clear the stack, there may be event a/o enything returned */
lua_settop(L, 0);
if (ret == 0) return true; /* success */
if (is_unix) {
- kr_log_error(LOG_GRP_NETWORK, "[network] bind to '%s' (UNIX): %s\n",
+ kr_log_error(LOG_GRP_NETWORK, "bind to '%s' (UNIX): %s\n",
str, kr_strerror(ret));
} else if (flags.xdp) {
const char *err_str = knot_strerror(ret);
/* Notable OK strerror: KNOT_EPERM Operation not permitted */
if (nic_queue == -1) {
- kr_log_error(LOG_GRP_NETWORK, "[network] failed to initialize XDP for '%s@%d'"
+ kr_log_error(LOG_GRP_NETWORK, "failed to initialize XDP for '%s@%d'"
" (nic_queue = <auto>): %s\n",
str, port, err_str);
} else {
- kr_log_error(LOG_GRP_NETWORK, "[network] failed to initialize XDP for '%s@%d'"
+ kr_log_error(LOG_GRP_NETWORK, "failed to initialize XDP for '%s@%d'"
" (nic_queue = %d): %s\n",
str, port, nic_queue, err_str);
}
} else {
const char *stype = flags.sock_type == SOCK_DGRAM ? "UDP" : "TCP";
- kr_log_error(LOG_GRP_NETWORK, "[network] bind to '%s@%d' (%s): %s\n",
+ kr_log_error(LOG_GRP_NETWORK, "bind to '%s@%d' (%s): %s\n",
str, port, stype, kr_strerror(ret));
}
return false; /* failure */
ok_ca = memcmp(newcfg->pins.at[i], oldcfg->pins.at[i], TLS_SHA256_RAW_LEN) == 0;
const bool ok_insecure = newcfg->insecure == oldcfg->insecure;
if (!(ok_h && ok_ca && ok_pins && ok_insecure)) {
- kr_log_warning(LOG_GRP_TLSCLIENT, "[tls_client] "
+ kr_log_warning(LOG_GRP_TLSCLIENT,
"warning: re-defining TLS authentication parameters for %s\n",
addr_str);
}
/* Init environment */
int ret = luaL_dofile(engine->L, LIBDIR "/sandbox.lua");
if (ret != 0) {
- fprintf(stderr, "[system] error %s\n", lua_tostring(engine->L, -1));
+ kr_log_error(LOG_GRP_SYSTEM, "error %s\n", lua_tostring(engine->L, -1));
lua_pop(engine->L, 1);
return kr_error(ENOEXEC);
}
int ret = luaL_dofile(engine->L, config_path);
if (ret != 0) {
- fprintf(stderr, "[system] error while loading config: "
+ kr_log_error(LOG_GRP_SYSTEM, "error while loading config: "
"%s (workdir '%s')\n", lua_tostring(engine->L, -1), cwd);
lua_pop(engine->L, 1);
}
ret = engine_pcall(L, 1);
}
if (kr_fails_assert(ret == 0)) { /* probably not critical, but weird */
- kr_log_error(LOG_GRP_SYSTEM, "[system] internal error when loading C module %s: %s\n",
+ kr_log_error(LOG_GRP_SYSTEM, "internal error when loading C module %s: %s\n",
module->name, lua_tostring(L, -1));
lua_pop(L, 1);
}
/* No luck with C module, so try to load and .init() lua module. */
ret = ffimodule_register_lua(engine, module, name);
if (ret != 0) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] failed to load module '%s'\n", name);
+ kr_log_error(LOG_GRP_SYSTEM, "failed to load module '%s'\n", name);
}
} else if (ret == kr_error(ENOTSUP)) {
/* Print a more helpful message when module is linked against an old resolver ABI. */
- kr_log_error(LOG_GRP_SYSTEM, "[system] module '%s' links to unsupported ABI, please rebuild it\n", name);
+ kr_log_error(LOG_GRP_SYSTEM, "module '%s' links to unsupported ABI, please rebuild it\n", name);
}
if (ret != 0) {
lua_pushpointer(L, module);
if (lua_pcall(L, 2, 0, 0) == 0)
return kr_ok();
- kr_log_error(LOG_GRP_SYSTEM, "[system] error: %s\n", lua_tostring(L, -1));
+ kr_log_error(LOG_GRP_SYSTEM, "error: %s\n", lua_tostring(L, -1));
lua_pop(L, 1);
return kr_error(1);
}
int state = ctx->req->state;
if (ret) { /* Exception or another lua problem. */
state = KR_STATE_FAIL;
- kr_log_error(LOG_GRP_SYSTEM, "[system] error: %s\n", lua_tostring(L, -1));
+ kr_log_error(LOG_GRP_SYSTEM, "error: %s\n", lua_tostring(L, -1));
} else if (lua_isnumber(L, -1)) { /* Explicitly returned state. */
state = lua_tointeger(L, -1);
if (!kr_state_consistent(state)) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] error: nonsense state returned from lua module layer: %d\n",
+ kr_log_error(LOG_GRP_SYSTEM, "error: nonsense state returned from lua module layer: %d\n",
state);
state = KR_STATE_FAIL;
}
} else { /* Nonsense returned. */
state = KR_STATE_FAIL;
- kr_log_error(LOG_GRP_SYSTEM, "[system] error: nonsense returned from lua module layer: %s\n",
+ kr_log_error(LOG_GRP_SYSTEM, "error: nonsense returned from lua module layer: %s\n",
lua_tostring(L, -1));
/* Unfortunately we can't easily get name of the module/function here. */
}
lua_getglobal(L, "require");
lua_pushfstring(L, "kres_modules.%s", name);
if (lua_pcall(L, 1, LUA_MULTRET, 0) != 0) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] error: %s\n", lua_tostring(L, -1));
+ kr_log_error(LOG_GRP_SYSTEM, "error: %s\n", lua_tostring(L, -1));
lua_pop(L, 1);
return kr_error(ENOENT);
}
required += sizeof(uint16_t);
if (required > remaining) {
- kr_log_error(LOG_GRP_DOH, "[http] insufficient space in buffer\n");
+ kr_log_error(LOG_GRP_DOH, "insufficient space in buffer\n");
ctx->incomplete_stream = -1;
return NGHTTP2_ERR_CALLBACK_FAILURE;
}
int omit = IP_PMTUDISC_OMIT;
if (type == SOCK_DGRAM && addr->sa_family == AF_INET
&& setsockopt(fd, IPPROTO_IP, IP_MTU_DISCOVER, &omit, sizeof(omit))) {
- kr_log_error(LOG_GRP_IO, "[ io ]"
+ kr_log_error(LOG_GRP_IO,
"failed to disable Path MTU discovery for %s UDP: %s\n",
kr_straddr(addr), strerror(errno));
}
int socklen = sizeof(union inaddr);
ret = uv_udp_getsockname(handle, session_get_sockname(s), &socklen);
if (ret) {
- kr_log_error(LOG_GRP_IO, "[ io ] ERROR: getsockname failed: %s\n", uv_strerror(ret));
+ kr_log_error(LOG_GRP_IO, "ERROR: getsockname failed: %s\n", uv_strerror(ret));
abort(); /* It might be nontrivial not to leak something here. */
}
#if ENABLE_DOH2
connection = https_accept;
#else
- kr_log_error(LOG_GRP_IO, "[ io ] kresd was compiled without libnghttp2 support\n");
+ kr_log_error(LOG_GRP_IO, "kresd was compiled without libnghttp2 support\n");
return kr_error(ENOPROTOOPT);
#endif
} else if (has_tls) {
#ifdef TCP_DEFER_ACCEPT
val = KR_CONN_RTT_MAX/1000;
if (setsockopt(fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &val, sizeof(val))) {
- kr_log_error(LOG_GRP_IO, "[ io ] listen TCP (defer_accept): %s\n", strerror(errno));
+ kr_log_error(LOG_GRP_IO, "listen TCP (defer_accept): %s\n", strerror(errno));
}
#endif
val = 1; /* Accepts on/off */
#endif
if (setsockopt(fd, IPPROTO_TCP, TCP_FASTOPEN, &val, sizeof(val))) {
- kr_log_error(LOG_GRP_IO, "[ io ] listen TCP (fastopen): %s%s\n", strerror(errno),
+ kr_log_error(LOG_GRP_IO, "listen TCP (fastopen): %s%s\n", strerror(errno),
(errno != EPERM ? "" :
". This may be caused by TCP Fast Open being disabled in the OS."));
}
if (data->mode == io_mode_binary) {
/* Leader expects length field in all cases */
if (!message || len_s > UINT32_MAX) {
- kr_log_error(LOG_GRP_IO, "[ io ] unrepresentable respose on control socket, "
+ kr_log_error(LOG_GRP_IO, "unrepresentable respose on control socket, "
"sending back empty block (command '%s')\n", cmd);
len_s = 0;
}
{
const int XDP_RX_BATCH_SIZE = 64;
if (status < 0) {
- kr_log_error(LOG_GRP_XDP, "[xdp] poll status %d: %s\n", status, uv_strerror(status));
+ kr_log_error(LOG_GRP_XDP, "poll status %d: %s\n", status, uv_strerror(status));
return;
}
if (events != UV_READABLE) {
- kr_log_error(LOG_GRP_XDP, "[xdp] poll unexpected events: %d\n", events);
+ kr_log_error(LOG_GRP_XDP, "poll unexpected events: %d\n", events);
return;
}
if (kr_fails_assert(ret == KNOT_EOK)) {
/* ATM other error codes can only be returned when called incorrectly */
- kr_log_error(LOG_GRP_XDP, "[xdp] knot_xdp_recv(): %d, %s\n", ret, knot_strerror(ret));
+ kr_log_error(LOG_GRP_XDP, "knot_xdp_recv(): %d, %s\n", ret, knot_strerror(ret));
return;
}
- kr_log_verbose("[xdp] poll triggered, processing a batch of %d packets\n", (int)rcvd);
+ kr_log_verbose("poll triggered, processing a batch of %d packets\n", (int)rcvd);
kr_require(rcvd <= XDP_RX_BATCH_SIZE);
for (int i = 0; i < rcvd; ++i) {
const knot_xdp_msg_t *msg = &msgs[i];
const unsigned if_index = if_nametoindex(ifname);
if (!if_index) {
- kr_log_warning(LOG_GRP_XDP, "[xdp] warning: interface %s, unexpected error when converting its name: %s\n",
+ kr_log_warning(LOG_GRP_XDP, "warning: interface %s, unexpected error when converting its name: %s\n",
ifname, strerror(errno));
return;
}
case KNOT_XDP_MODE_FULL:
return;
case KNOT_XDP_MODE_EMUL:
- kr_log_warning(LOG_GRP_XDP, "[xdp] warning: interface %s running only with XDP emulation\n",
+ kr_log_warning(LOG_GRP_XDP, "warning: interface %s running only with XDP emulation\n",
ifname);
return;
case KNOT_XDP_MODE_NONE: // enum warnings from compiler
break;
}
- kr_log_warning(LOG_GRP_XDP, "[xdp] warning: interface %s running in unexpected XDP mode %d\n",
+ kr_log_warning(LOG_GRP_XDP, "warning: interface %s running in unexpected XDP mode %d\n",
ifname, (int)mode);
}
int io_listen_xdp(uv_loop_t *loop, struct endpoint *ep, const char *ifname)
case UV_NAMED_PIPE: /* echo 'quit()' | kresd ... */
break;
default:
- kr_log_error(LOG_GRP_SYSTEM, "[system] "
+ kr_log_error(LOG_GRP_SYSTEM,
"error: standard input is not a terminal or pipe; "
"use '-n' if you want non-interactive mode. "
"Commands can be simply added to your configuration file or sent over the control socket.\n"
}
free(sa);
if (ret != 0) {
- kr_log_error(LOG_GRP_NETWORK, "[network] bind to '%s'%s: %s\n",
+ kr_log_error(LOG_GRP_NETWORK, "bind to '%s'%s: %s\n",
addrs->at[i], tls ? " (TLS)" : "", kr_strerror(ret));
has_error = true;
}
/* TODO: try logging address@port. It's not too important,
* because typical problems happen during binding already.
* (invalid address, permission denied) */
- kr_log_error(LOG_GRP_NETWORK, "[network] listen on fd=%d: %s\n",
+ kr_log_error(LOG_GRP_NETWORK, "listen on fd=%d: %s\n",
ffd->fd, kr_strerror(ret));
/* Continue printing all of these before exiting. */
} else {
/* Apply. */
if (capng_apply(CAPNG_SELECT_BOTH) < 0) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] failed to set process capabilities: %s\n",
+ kr_log_error(LOG_GRP_SYSTEM, "failed to set process capabilities: %s\n",
strerror(errno));
} else {
kr_log_verbose("[system] all capabilities dropped\n");
int main(int argc, char **argv)
{
if (setvbuf(stdout, NULL, _IONBF, 0) || setvbuf(stderr, NULL, _IONBF, 0)) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] failed to to set output buffering (ignored): %s\n",
+ kr_log_error(LOG_GRP_SYSTEM, "failed to to set output buffering (ignored): %s\n",
strerror(errno));
fflush(stderr);
}
/* FIXME: access isn't a good way if we start as root and drop privileges later */
if (access(the_args->rundir, W_OK) != 0
|| chdir(the_args->rundir) != 0) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] rundir '%s': %s\n",
+ kr_log_error(LOG_GRP_SYSTEM, "rundir '%s': %s\n",
the_args->rundir, strerror(errno));
return EXIT_FAILURE;
}
} else if (access(config, R_OK) != 0) {
char cwd[PATH_MAX];
get_workdir(cwd, sizeof(cwd));
- kr_log_error(LOG_GRP_SYSTEM, "[system] config '%s' (workdir '%s'): %s\n",
+ kr_log_error(LOG_GRP_SYSTEM, "config '%s' (workdir '%s'): %s\n",
config, cwd, strerror(errno));
return EXIT_FAILURE;
}
ret = setrlimit(RLIMIT_NOFILE, &rlim);
}
if (ret) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] failed to get or set file-descriptor limit: %s\n",
+ kr_log_error(LOG_GRP_SYSTEM, "failed to get or set file-descriptor limit: %s\n",
strerror(errno));
} else if (rlim.rlim_cur < 512*1024) {
- kr_log_warning(LOG_GRP_SYSTEM, "[system] warning: hard limit for number of file-descriptors is only %ld but recommended value is 524288\n",
+ kr_log_warning(LOG_GRP_SYSTEM, "warning: hard limit for number of file-descriptors is only %ld but recommended value is 524288\n",
(long)rlim.rlim_cur);
}
static struct engine engine;
ret = engine_init(&engine, &pool);
if (ret != 0) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] failed to initialize engine: %s\n", kr_strerror(ret));
+ kr_log_error(LOG_GRP_SYSTEM, "failed to initialize engine: %s\n", kr_strerror(ret));
return EXIT_FAILURE;
}
/* Initialize the worker */
ret = worker_init(&engine, the_args->forks);
if (ret != 0) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] failed to initialize worker: %s\n", kr_strerror(ret));
+ kr_log_error(LOG_GRP_SYSTEM, "failed to initialize worker: %s\n", kr_strerror(ret));
return EXIT_FAILURE;
}
}
}
if (ret) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] failed to set up signal handlers: %s\n",
+ kr_log_error(LOG_GRP_SYSTEM, "failed to set up signal handlers: %s\n",
strerror(abs(errno)));
ret = EXIT_FAILURE;
goto cleanup;
* (of the usual type) may skew results, e.g. epoll_pwait() taking lots of time. */
ret = uv_loop_configure(loop, UV_LOOP_BLOCK_SIGNAL, SIGPROF);
if (ret) {
- kr_log_info(LOG_GRP_SYSTEM, "[system] failed to block SIGPROF in event loop, ignoring: %s\n",
+ kr_log_info(LOG_GRP_SYSTEM, "failed to block SIGPROF in event loop, ignoring: %s\n",
uv_strerror(ret));
}
ret = udp_queue_init_global(loop);
if (ret) {
- kr_log_error(LOG_GRP_SYSTEM, "[system] failed to initialize UDP queue: %s\n",
+ kr_log_error(LOG_GRP_SYSTEM, "failed to initialize UDP queue: %s\n",
kr_strerror(ret));
ret = EXIT_FAILURE;
goto cleanup;
void **pp = trie_get_try(net->endpoint_kinds, ep->flags.kind,
strlen(ep->flags.kind));
if (!pp && net->missing_kind_is_error) {
- kr_log_error(LOG_GRP_NETWORK, "[network] error: network socket kind '%s' not handled when opening '%s",
+ kr_log_error(LOG_GRP_NETWORK, "error: network socket kind '%s' not handled when opening '%s",
ep->flags.kind, log_addr);
if (ep->family != AF_UNIX)
kr_log_error(LOG_GRP_NETWORK, "#%d", ep->port);
lua_pushfstring(L, "%s#%d", log_addr, ep->port);
}
if (lua_pcall(L, 3, 0, 0)) {
- kr_log_error(LOG_GRP_NETWORK, "[network] error opening %s: %s\n", log_addr, lua_tostring(L, -1));
+ kr_log_error(LOG_GRP_NETWORK, "error opening %s: %s\n", log_addr, lua_tostring(L, -1));
return kr_error(ENOSYS); /* TODO: better value? */
}
ep->engaged = true;
void **pp = trie_get_try(net->endpoint_kinds, ep->flags.kind,
strlen(ep->flags.kind));
if (!pp && net->missing_kind_is_error) {
- kr_log_error(LOG_GRP_NETWORK, "[network] internal error: missing kind '%s' in endpoint registry\n",
+ kr_log_error(LOG_GRP_NETWORK, "internal error: missing kind '%s' in endpoint registry\n",
ep->flags.kind);
return;
}
lua_pushpointer(L, ep);
lua_pushstring(L, "FIXME:endpoint-identifier");
if (lua_pcall(L, 3, 0, 0)) {
- kr_log_error(LOG_GRP_NETWORK, "[nework] failed to close FIXME:endpoint-identifier: %s\n",
+ kr_log_error(LOG_GRP_NETWORK, "failed to close FIXME:endpoint-identifier: %s\n",
lua_tostring(L, -1));
}
}
socklen_t addr_len = sizeof(sa);
if (getsockname(ep->fd, (struct sockaddr *)&sa, &addr_len)
|| unlink(sa.sun_path)) {
- kr_log_error(LOG_GRP_NETWORK, "[network] error (ignored) when closing unix socket (fd = %d): %s\n",
+ kr_log_error(LOG_GRP_NETWORK, "error (ignored) when closing unix socket (fd = %d): %s\n",
ep->fd, strerror(errno));
return;
}
if (ep->family == AF_UNIX) {
/* Some parts of connection handling would need more work,
* so let's support AF_UNIX only with .kind != NULL for now. */
- kr_log_error(LOG_GRP_NETWORK, "[network] AF_UNIX only supported with set { kind = '...' }\n");
+ kr_log_error(LOG_GRP_NETWORK, "AF_UNIX only supported with set { kind = '...' }\n");
ret = EAFNOSUPPORT;
goto finish_ret;
/*
if (newcreds) {
tls_credentials_release(net->tls_credentials);
net->tls_credentials = newcreds;
- kr_log_info(LOG_GRP_TLS, "[tls] Updated ephemeral X.509 cert with new hostname\n");
+ kr_log_info(LOG_GRP_TLS, "Updated ephemeral X.509 cert with new hostname\n");
} else {
- kr_log_error(LOG_GRP_TLS, "[tls] Failed to update ephemeral X.509 cert with new hostname, using existing one\n");
+ kr_log_error(LOG_GRP_TLS, "Failed to update ephemeral X.509 cert with new hostname, using existing one\n");
}
}
}
return 0;
}
#else
- kr_log_error(LOG_GRP_NETWORK, "[network] SO_ATTACH_BPF socket option doesn't supported\n");
+ kr_log_error(LOG_GRP_NETWORK, "SO_ATTACH_BPF socket option doesn't supported\n");
(void)net;
(void)bpf_fd;
return 0;
kr_require(sockfd != -1);
if (setsockopt(sockfd, SOL_SOCKET, SO_DETACH_BPF, NULL, 0) != 0) {
- kr_log_error(LOG_GRP_NETWORK, "[network] failed to clear SO_DETACH_BPF socket option\n");
+ kr_log_error(LOG_GRP_NETWORK, "failed to clear SO_DETACH_BPF socket option\n");
}
/* Proceed even if setsockopt() failed,
* as we want to process all opened sockets. */
#ifdef SO_DETACH_BPF
map_walk(&net->endpoints, clear_bpf_cb, NULL);
#else
- kr_log_error(LOG_GRP_NETWORK, "[network] SO_DETACH_BPF socket option doesn't supported\n");
+ kr_log_error(LOG_GRP_NETWORK, "SO_DETACH_BPF socket option doesn't supported\n");
(void)net;
#endif
}
const char *errpos = NULL;
int err = gnutls_priority_set_direct(session, priorities, &errpos);
if (err != GNUTLS_E_SUCCESS) {
- kr_log_error(LOG_GRP_TLS, "[tls] setting priority '%s' failed at character %zd (...'%s') with %s (%d)\n",
+ kr_log_error(LOG_GRP_TLS, "setting priority '%s' failed at character %zd (...'%s') with %s (%d)\n",
priorities, errpos - priorities, errpos, gnutls_strerror_name(err), err);
}
return err;
if (!net->tls_credentials) {
net->tls_credentials = tls_get_ephemeral_credentials(worker->engine);
if (!net->tls_credentials) {
- kr_log_error(LOG_GRP_TLS, "[tls] X.509 credentials are missing, and ephemeral credentials failed; no TLS\n");
+ kr_log_error(LOG_GRP_TLS, "X.509 credentials are missing, and ephemeral credentials failed; no TLS\n");
return NULL;
}
- kr_log_info(LOG_GRP_TLS, "[tls] Using ephemeral TLS credentials\n");
+ kr_log_info(LOG_GRP_TLS, "Using ephemeral TLS credentials\n");
tls_credentials_log_pins(net->tls_credentials);
}
if (newcreds) {
tls_credentials_release(net->tls_credentials);
net->tls_credentials = newcreds;
- kr_log_info(LOG_GRP_TLS, "[tls] Renewed expiring ephemeral X.509 cert\n");
+ kr_log_info(LOG_GRP_TLS, "Renewed expiring ephemeral X.509 cert\n");
} else {
- kr_log_error(LOG_GRP_TLS, "[tls] Failed to renew expiring ephemeral X.509 cert, using existing one\n");
+ kr_log_error(LOG_GRP_TLS, "Failed to renew expiring ephemeral X.509 cert, using existing one\n");
}
}
} else {
/* non-ephemeral cert: warn once when certificate expires */
if (now >= net->tls_credentials->valid_until) {
- kr_log_error(LOG_GRP_TLS, "[tls] X.509 certificate has expired!\n");
+ kr_log_error(LOG_GRP_TLS, "X.509 certificate has expired!\n");
net->tls_credentials->valid_until = GNUTLS_X509_NO_WELL_DEFINED_EXPIRATION;
}
}
struct tls_ctx *tls = calloc(1, sizeof(struct tls_ctx));
if (tls == NULL) {
- kr_log_error(LOG_GRP_TLS, "[tls] failed to allocate TLS context\n");
+ kr_log_error(LOG_GRP_TLS, "failed to allocate TLS context\n");
return NULL;
}
int err = gnutls_init(&tls->c.tls_session, GNUTLS_SERVER | GNUTLS_NONBLOCK);
if (err != GNUTLS_E_SUCCESS) {
- kr_log_error(LOG_GRP_TLS, "[tls] gnutls_init(): %s (%d)\n", gnutls_strerror_name(err), err);
+ kr_log_error(LOG_GRP_TLS, "gnutls_init(): %s (%d)\n", gnutls_strerror_name(err), err);
tls_free(tls);
return NULL;
}
err = gnutls_credentials_set(tls->c.tls_session, GNUTLS_CRD_CERTIFICATE,
tls->credentials->credentials);
if (err != GNUTLS_E_SUCCESS) {
- kr_log_error(LOG_GRP_TLS, "[tls] gnutls_credentials_set(): %s (%d)\n", gnutls_strerror_name(err), err);
+ kr_log_error(LOG_GRP_TLS, "gnutls_credentials_set(): %s (%d)\n", gnutls_strerror_name(err), err);
tls_free(tls);
return NULL;
}
index, &certs, &cert_count);
if (err != GNUTLS_E_SUCCESS) {
if (err != GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE) {
- kr_log_error(LOG_GRP_TLS, "[tls] could not get X.509 certificates (%d) %s\n",
+ kr_log_error(LOG_GRP_TLS, "could not get X.509 certificates (%d) %s\n",
err, gnutls_strerror_name(err));
}
return;
char pin[TLS_SHA256_BASE64_BUFLEN] = { 0 };
err = get_oob_key_pin(certs[i], pin, sizeof(pin), false);
if (err != GNUTLS_E_SUCCESS) {
- kr_log_error(LOG_GRP_TLS, "[tls] could not calculate RFC 7858 OOB key-pin from cert %d (%d) %s\n",
+ kr_log_error(LOG_GRP_TLS, "could not calculate RFC 7858 OOB key-pin from cert %d (%d) %s\n",
i, err, gnutls_strerror_name(err));
} else {
- kr_log_info(LOG_GRP_TLS, "[tls] RFC 7858 OOB key-pin (%d): pin-sha256=\"%s\"\n",
+ kr_log_info(LOG_GRP_TLS, "RFC 7858 OOB key-pin (%d): pin-sha256=\"%s\"\n",
i, pin);
}
gnutls_x509_crt_deinit(certs[i]);
time_t ret = GNUTLS_X509_NO_WELL_DEFINED_EXPIRATION;
if ((err = gnutls_certificate_get_crt_raw(creds, 0, 0, &data)) != GNUTLS_E_SUCCESS) {
- kr_log_error(LOG_GRP_TLS, "[tls] failed to get cert to check expiration: (%d) %s\n",
+ kr_log_error(LOG_GRP_TLS, "failed to get cert to check expiration: (%d) %s\n",
err, gnutls_strerror_name(err));
goto done;
}
if ((err = gnutls_x509_crt_init(&cert)) != GNUTLS_E_SUCCESS) {
- kr_log_error(LOG_GRP_TLS, "[tls] failed to initialize cert: (%d) %s\n",
+ kr_log_error(LOG_GRP_TLS, "failed to initialize cert: (%d) %s\n",
err, gnutls_strerror_name(err));
goto done;
}
if ((err = gnutls_x509_crt_import(cert, &data, GNUTLS_X509_FMT_DER)) != GNUTLS_E_SUCCESS) {
- kr_log_error(LOG_GRP_TLS, "[tls] failed to construct cert while checking expiration: (%d) %s\n",
+ kr_log_error(LOG_GRP_TLS, "failed to construct cert while checking expiration: (%d) %s\n",
err, gnutls_strerror_name(err));
goto done;
}
int err = 0;
if ((err = gnutls_certificate_allocate_credentials(&tls_credentials->credentials)) != GNUTLS_E_SUCCESS) {
- kr_log_error(LOG_GRP_TLS, "[tls] gnutls_certificate_allocate_credentials() failed: (%d) %s\n",
+ kr_log_error(LOG_GRP_TLS, "gnutls_certificate_allocate_credentials() failed: (%d) %s\n",
err, gnutls_strerror_name(err));
tls_credentials_free(tls_credentials);
return kr_error(ENOMEM);
}
if ((err = gnutls_certificate_set_x509_system_trust(tls_credentials->credentials)) < 0) {
if (err != GNUTLS_E_UNIMPLEMENTED_FEATURE) {
- kr_log_warning(LOG_GRP_TLS, "[tls] warning: gnutls_certificate_set_x509_system_trust() failed: (%d) %s\n",
+ kr_log_warning(LOG_GRP_TLS, "warning: gnutls_certificate_set_x509_system_trust() failed: (%d) %s\n",
err, gnutls_strerror_name(err));
tls_credentials_free(tls_credentials);
return err;
if ((err = gnutls_certificate_set_x509_key_file(tls_credentials->credentials,
tls_cert, tls_key, GNUTLS_X509_FMT_PEM)) != GNUTLS_E_SUCCESS) {
tls_credentials_free(tls_credentials);
- kr_log_error(LOG_GRP_TLS, "[tls] gnutls_certificate_set_x509_key_file(%s,%s) failed: %d (%s)\n",
+ kr_log_error(LOG_GRP_TLS, "gnutls_certificate_set_x509_key_file(%s,%s) failed: %d (%s)\n",
tls_cert, tls_key, err, gnutls_strerror_name(err));
return kr_error(EINVAL);
}
e->refs = 1;
int ret = gnutls_certificate_allocate_credentials(&e->credentials);
if (ret != GNUTLS_E_SUCCESS) {
- kr_log_error(LOG_GRP_TLSCLIENT, "[tls_client] error: gnutls_certificate_allocate_credentials() fails (%s)\n",
+ kr_log_error(LOG_GRP_TLSCLIENT, "error: gnutls_certificate_allocate_credentials() fails (%s)\n",
gnutls_strerror_name(ret));
free(e);
return NULL;
params->pins.len);
}
- kr_log_error(LOG_GRP_TLSCLIENT, "[tls_client] no pin matched: %zu pins * %d certificates\n",
+ kr_log_error(LOG_GRP_TLSCLIENT, "no pin matched: %zu pins * %d certificates\n",
params->pins.len, cert_list_size);
return GNUTLS_E_CERTIFICATE_ERROR;
#else /* TLS_CAN_USE_PINS */
- kr_log_error(LOG_GRP_TLSCLIENT, "[tls_client] internal inconsistency: TLS_CAN_USE_PINS\n");
+ kr_log_error(LOG_GRP_TLSCLIENT, "internal inconsistency: TLS_CAN_USE_PINS\n");
kr_assert(false);
return GNUTLS_E_CERTIFICATE_ERROR;
#endif
static int client_verify_certchain(gnutls_session_t tls_session, const char *hostname)
{
if (kr_fails_assert(hostname)) {
- kr_log_error(LOG_GRP_TLSCLIENT, "[tls_client] internal config inconsistency: no hostname set\n");
+ kr_log_error(LOG_GRP_TLSCLIENT, "internal config inconsistency: no hostname set\n");
return GNUTLS_E_CERTIFICATE_ERROR;
}
ret = gnutls_certificate_verification_status_print(
status, gnutls_certificate_type_get(tls_session), &msg, 0);
if (ret == GNUTLS_E_SUCCESS) {
- kr_log_error(LOG_GRP_TLSCLIENT, "[tls_client] failed to verify peer certificate: "
+ kr_log_error(LOG_GRP_TLSCLIENT, "failed to verify peer certificate: "
"%s\n", msg.data);
gnutls_free(msg.data);
} else {
- kr_log_error(LOG_GRP_TLSCLIENT, "[tls_client] failed to verify peer certificate: "
+ kr_log_error(LOG_GRP_TLSCLIENT, "failed to verify peer certificate: "
"unable to print reason: %s (%s)\n",
gnutls_strerror(ret), gnutls_strerror_name(ret));
} /* gnutls_certificate_verification_status_print end */
} else {
- kr_log_error(LOG_GRP_TLSCLIENT, "[tls_client] failed to verify peer certificate: "
+ kr_log_error(LOG_GRP_TLSCLIENT, "failed to verify peer certificate: "
"gnutls_certificate_verify_peers3 error: %s (%s)\n",
gnutls_strerror(ret), gnutls_strerror_name(ret));
} /* gnutls_certificate_verify_peers3 end */
gnutls_certificate_type_t cert_type = gnutls_certificate_type_get(tls_session);
if (cert_type != GNUTLS_CRT_X509) {
- kr_log_error(LOG_GRP_TLSCLIENT, "[tls_client] invalid certificate type %i has been received\n",
+ kr_log_error(LOG_GRP_TLSCLIENT, "invalid certificate type %i has been received\n",
cert_type);
return GNUTLS_E_CERTIFICATE_ERROR;
}
const gnutls_datum_t *cert_list =
gnutls_certificate_get_peers(tls_session, &cert_list_size);
if (cert_list == NULL || cert_list_size == 0) {
- kr_log_error(LOG_GRP_TLSCLIENT, "[tls_client] empty certificate list\n");
+ kr_log_error(LOG_GRP_TLSCLIENT, "empty certificate list\n");
return GNUTLS_E_CERTIFICATE_ERROR;
}
* with a shared cache don't both create the same privkey: */
lock = _lock_filename(EPHEMERAL_PRIVKEY_FILENAME ".lock");
if (_lock_is_invalid(lock)) {
- kr_log_error(LOG_GRP_TLS, "[tls] unable to lock lockfile " EPHEMERAL_PRIVKEY_FILENAME ".lock\n");
+ kr_log_error(LOG_GRP_TLS, "unable to lock lockfile " EPHEMERAL_PRIVKEY_FILENAME ".lock\n");
goto done;
}
if ((err = gnutls_x509_privkey_init (&privkey)) < 0) {
- kr_log_error(LOG_GRP_TLS, "[tls] gnutls_x509_privkey_init() failed: %d (%s)\n",
+ kr_log_error(LOG_GRP_TLS, "gnutls_x509_privkey_init() failed: %d (%s)\n",
err, gnutls_strerror_name(err));
goto done;
}
struct stat stat;
ssize_t bytes_read;
if (fstat(datafd, &stat)) {
- kr_log_error(LOG_GRP_TLS, "[tls] unable to stat ephemeral private key " EPHEMERAL_PRIVKEY_FILENAME "\n");
+ kr_log_error(LOG_GRP_TLS, "unable to stat ephemeral private key " EPHEMERAL_PRIVKEY_FILENAME "\n");
goto bad_data;
}
data.data = gnutls_malloc(stat.st_size);
if (data.data == NULL) {
- kr_log_error(LOG_GRP_TLS, "[tls] unable to allocate memory for reading ephemeral private key\n");
+ kr_log_error(LOG_GRP_TLS, "unable to allocate memory for reading ephemeral private key\n");
goto bad_data;
}
data.size = stat.st_size;
bytes_read = read(datafd, data.data, stat.st_size);
if (bytes_read != stat.st_size) {
- kr_log_error(LOG_GRP_TLS, "[tls] unable to read ephemeral private key\n");
+ kr_log_error(LOG_GRP_TLS, "unable to read ephemeral private key\n");
goto bad_data;
}
if ((err = gnutls_x509_privkey_import (privkey, &data, GNUTLS_X509_FMT_PEM)) < 0) {
- kr_log_error(LOG_GRP_TLS, "[tls] gnutls_x509_privkey_import() failed: %d (%s)\n",
+ kr_log_error(LOG_GRP_TLS, "gnutls_x509_privkey_import() failed: %d (%s)\n",
err, gnutls_strerror_name(err));
/* goto bad_data; */
bad_data:
#else
if ((err = gnutls_x509_privkey_generate(privkey, GNUTLS_PK_RSA, gnutls_sec_param_to_pk_bits(GNUTLS_PK_RSA, GNUTLS_SEC_PARAM_MEDIUM), 0)) < 0) {
#endif
- kr_log_error(LOG_GRP_TLS, "[tls] gnutls_x509_privkey_init() failed: %d (%s)\n",
+ kr_log_error(LOG_GRP_TLS, "gnutls_x509_privkey_init() failed: %d (%s)\n",
err, gnutls_strerror_name(err));
gnutls_x509_privkey_deinit(privkey);
goto done;
}
/* ... and save */
- kr_log_info(LOG_GRP_TLS, "[tls] Stashing ephemeral private key in " EPHEMERAL_PRIVKEY_FILENAME "\n");
+ kr_log_info(LOG_GRP_TLS, "Stashing ephemeral private key in " EPHEMERAL_PRIVKEY_FILENAME "\n");
if ((err = gnutls_x509_privkey_export2(privkey, GNUTLS_X509_FMT_PEM, &data)) < 0) {
- kr_log_error(LOG_GRP_TLS, "[tls] gnutls_x509_privkey_export2() failed: %d (%s), not storing\n",
+ kr_log_error(LOG_GRP_TLS, "gnutls_x509_privkey_export2() failed: %d (%s), not storing\n",
err, gnutls_strerror_name(err));
} else {
datafd = open(EPHEMERAL_PRIVKEY_FILENAME, O_WRONLY|O_CREAT, 0600);
if (datafd == -1) {
- kr_log_error(LOG_GRP_TLS, "[tls] failed to open " EPHEMERAL_PRIVKEY_FILENAME " to store the ephemeral key\n");
+ kr_log_error(LOG_GRP_TLS, "failed to open " EPHEMERAL_PRIVKEY_FILENAME " to store the ephemeral key\n");
} else {
ssize_t bytes_written;
bytes_written = write(datafd, data.data, data.size);
if (bytes_written != data.size)
- kr_log_error(LOG_GRP_TLS, "[tls] failed to write %d octets to "
+ kr_log_error(LOG_GRP_TLS, "failed to write %d octets to "
EPHEMERAL_PRIVKEY_FILENAME
" (%zd written)\n",
data.size, bytes_written);
#define gtx(fn, ...) \
if ((err = fn ( __VA_ARGS__ )) != GNUTLS_E_SUCCESS) { \
- kr_log_error(LOG_GRP_TLS, "[tls] " #fn "() failed: %d (%s)\n", \
+ kr_log_error(LOG_GRP_TLS, #fn "() failed: %d (%s)\n", \
err, gnutls_strerror_name(err)); \
goto bad; }
creds = calloc(1, sizeof(*creds));
if (!creds) {
- kr_log_error(LOG_GRP_TLS, "[tls] failed to allocate memory for ephemeral credentials\n");
+ kr_log_error(LOG_GRP_TLS, "failed to allocate memory for ephemeral credentials\n");
return NULL;
}
if ((err = gnutls_certificate_allocate_credentials(&(creds->credentials))) < 0) {
- kr_log_error(LOG_GRP_TLS, "[tls] failed to allocate memory for ephemeral credentials\n");
+ kr_log_error(LOG_GRP_TLS, "failed to allocate memory for ephemeral credentials\n");
goto failure;
}
creds->valid_until = now + EPHEMERAL_CERT_EXPIRATION_SECONDS;
creds->ephemeral_servicename = strdup(engine_get_hostname(engine));
if (creds->ephemeral_servicename == NULL) {
- kr_log_error(LOG_GRP_TLS, "[tls] could not get server's hostname, using '" INVALID_HOSTNAME "' instead\n");
+ kr_log_error(LOG_GRP_TLS, "could not get server's hostname, using '" INVALID_HOSTNAME "' instead\n");
if ((creds->ephemeral_servicename = strdup(INVALID_HOSTNAME)) == NULL) {
- kr_log_error(LOG_GRP_TLS, "[tls] failed to allocate memory for ephemeral credentials\n");
+ kr_log_error(LOG_GRP_TLS, "failed to allocate memory for ephemeral credentials\n");
goto failure;
}
}
goto failure;
}
if ((err = gnutls_certificate_set_x509_key(creds->credentials, &cert, 1, privkey)) < 0) {
- kr_log_error(LOG_GRP_TLS, "[tls] failed to set up ephemeral credentials\n");
+ kr_log_error(LOG_GRP_TLS, "failed to set up ephemeral credentials\n");
goto failure;
}
gnutls_x509_privkey_deinit(privkey);
return NULL;
#if !TLS_SESSION_RESUMPTION_SYNC
if (secret_len) {
- kr_log_error(LOG_GRP_TLS, "[tls] session ticket: secrets were not enabled at compile-time (your GnuTLS version is not supported)\n");
+ kr_log_error(LOG_GRP_TLS, "session ticket: secrets were not enabled at compile-time (your GnuTLS version is not supported)\n");
return NULL; /* ENOTSUP */
}
#endif
/* Compute the current epoch. */
struct timeval now;
if (gettimeofday(&now, NULL)) {
- kr_log_error(LOG_GRP_TLS, "[tls] session ticket: gettimeofday failed, %s\n",
+ kr_log_error(LOG_GRP_TLS, "session ticket: gettimeofday failed, %s\n",
strerror(errno));
return;
}
* for gnutls_session_ticket_enable_server() doesn't say. */
int err = tst_key_update(stst, epoch, force_update);
if (err) {
- kr_log_error(LOG_GRP_TLS, "[tls] session ticket: failed rotation, %s\n",
+ kr_log_error(LOG_GRP_TLS, "session ticket: failed rotation, %s\n",
kr_strerror(err));
if (kr_fails_assert(err != kr_error(EINVAL)))
return;
(uint64_t)epoch, remain_ms);
err = uv_timer_start(timer, &tst_timer_callback, remain_ms, 0);
if (kr_fails_assert(err == 0)) {
- kr_log_error(LOG_GRP_TLS, "[tls] session ticket: failed to schedule, %s\n",
+ kr_log_error(LOG_GRP_TLS, "session ticket: failed to schedule, %s\n",
uv_strerror(err));
return;
}
};
int err = gnutls_session_ticket_enable_server(session, &gd);
if (err) {
- kr_log_error(LOG_GRP_TLS, "[tls] failed to enable session tickets: %s (%d)\n",
+ kr_log_error(LOG_GRP_TLS, "failed to enable session tickets: %s (%d)\n",
gnutls_strerror_name(err), err);
/* but continue without tickets */
}
{
int ret = knot_xdp_send_finish(handle->data);
if (ret != KNOT_EAGAIN && ret != KNOT_EOK)
- kr_log_error(LOG_GRP_XDP, "[xdp] check: ret = %d, %s\n", ret, knot_strerror(ret));
+ kr_log_error(LOG_GRP_XDP, "check: ret = %d, %s\n", ret, knot_strerror(ret));
/* Apparently some drivers need many explicit wake-up calls
* even if we push no additional packets (in case they accumulated a lot) */
if (ret != KNOT_EAGAIN)
KR_DNAME_GET_STR(zone_name_str, z_import->origin);
if (strcmp(".", zone_name_str) != 0) {
- kr_log_error(LOG_GRP_ZIMPORT, "[zimport] unexpected zone name `%s` (root zone expected), fail\n",
+ kr_log_error(LOG_GRP_ZIMPORT, "unexpected zone name `%s` (root zone expected), fail\n",
zone_name_str);
failed = 1;
goto finish;
}
if (z_import->rrset_sorted.len <= 0) {
- kr_log_error(LOG_GRP_ZIMPORT, "[zimport] zone `%s` is empty\n", zone_name_str);
+ kr_log_error(LOG_GRP_ZIMPORT, "zone `%s` is empty\n", zone_name_str);
goto finish;
}
knot_rrset_t *rr_key = map_get(&z_import->rrset_indexed, key);
if (!rr_key) {
/* DNSKEY MUST be here. If not found - fail. */
- kr_log_error(LOG_GRP_ZIMPORT, "[zimport] DNSKEY not found for `%s`, fail\n", zone_name_str);
+ kr_log_error(LOG_GRP_ZIMPORT, "DNSKEY not found for `%s`, fail\n", zone_name_str);
failed = 1;
goto finish;
}
map_t *trust_anchors = &z_import->worker->engine->resolver.trust_anchors;
knot_rrset_t *rr_ta = kr_ta_get(trust_anchors, z_import->origin);
if (!rr_ta) {
- kr_log_error(LOG_GRP_ZIMPORT, "[zimport] error: TA for zone `%s` vanished, fail", zone_name_str);
+ kr_log_error(LOG_GRP_ZIMPORT, "error: TA for zone `%s` vanished, fail", zone_name_str);
failed = 1;
goto finish;
}
if (failed != 0) {
if (ns_imported == 0 && other_imported == 0) {
import_state = -1;
- kr_log_error(LOG_GRP_ZIMPORT, "[zimport] import failed; zone `%s` \n", zone_name_str);
+ kr_log_error(LOG_GRP_ZIMPORT, "import failed; zone `%s` \n", zone_name_str);
} else {
import_state = 1;
}
{
if (s->r_data_length > UINT16_MAX) {
/* Due to knot_rrset_add_rdata(..., const uint16_t size, ...); */
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] line %"PRIu64": rdata is too long\n",
+ kr_log_error(LOG_GRP_ZSCANNER, "line %"PRIu64": rdata is too long\n",
s->line_counter);
return -1;
}
if (knot_dname_size(s->r_owner) != strlen((const char *)(s->r_owner)) + 1) {
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] line %"PRIu64
+ kr_log_error(LOG_GRP_ZSCANNER, "line %"PRIu64
": owner name contains zero byte, skip\n",
s->line_counter);
return 0;
knot_rrset_t *new_rr = knot_rrset_new(s->r_owner, s->r_type, s->r_class,
s->r_ttl, &z_import->pool);
if (!new_rr) {
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] line %"PRIu64": error creating rrset\n",
+ kr_log_error(LOG_GRP_ZSCANNER, "line %"PRIu64": error creating rrset\n",
s->line_counter);
return -1;
}
int res = knot_rrset_add_rdata(new_rr, s->r_data, s->r_data_length,
&z_import->pool);
if (res != KNOT_EOK) {
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] line %"PRIu64": error adding rdata to rrset\n",
+ kr_log_error(LOG_GRP_ZSCANNER, "line %"PRIu64": error adding rdata to rrset\n",
s->line_counter);
return -1;
}
res = kr_rrkey(key, new_rr->rclass, new_rr->owner, new_rr->type,
additional_key_field);
if (res <= 0) {
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] line %"PRIu64": error constructing rrkey\n",
+ kr_log_error(LOG_GRP_ZSCANNER, "line %"PRIu64": error constructing rrkey\n",
s->line_counter);
return -1;
}
res = map_set(&z_import->rrset_indexed, key, new_rr);
}
if (res != 0) {
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] line %"PRIu64": error saving parsed rrset\n",
+ kr_log_error(LOG_GRP_ZSCANNER, "line %"PRIu64": error saving parsed rrset\n",
s->line_counter);
return -1;
}
}
break;
case ZS_STATE_ERROR:
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] line: %"PRIu64
+ kr_log_error(LOG_GRP_ZSCANNER, "line: %"PRIu64
": parse error; code: %i ('%s')\n",
s->line_counter, s->error.code,
zs_strerror(s->error.code));
return -1;
case ZS_STATE_INCLUDE:
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] line: %"PRIu64
+ kr_log_error(LOG_GRP_ZSCANNER, "line: %"PRIu64
": INCLUDE is not supported\n",
s->line_counter);
return -1;
case ZS_STATE_EOF:
case ZS_STATE_STOP:
if (empty) {
- kr_log_error(LOG_GRP_ZIMPORT, "[zimport] empty zone file\n");
+ kr_log_error(LOG_GRP_ZIMPORT, "empty zone file\n");
return -1;
}
if (!((zone_import_ctx_t *) s->process.data)->origin) {
- kr_log_error(LOG_GRP_ZIMPORT, "[zimport] zone file doesn't contain SOA record\n");
+ kr_log_error(LOG_GRP_ZIMPORT, "zone file doesn't contain SOA record\n");
return -1;
}
return (s->error.counter == 0) ? 0 : -1;
default:
- kr_log_error(LOG_GRP_ZSCANNER, "[zimport] line: %"PRIu64
+ kr_log_error(LOG_GRP_ZSCANNER, "line: %"PRIu64
": unexpected parse state: %i\n",
s->line_counter, s->state);
return -1;
zs_scanner_t *s = malloc(sizeof(zs_scanner_t));
if (s == NULL) {
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] error creating instance of zone scanner (malloc() fails)\n");
+ kr_log_error(LOG_GRP_ZSCANNER, "error creating instance of zone scanner (malloc() fails)\n");
return -1;
}
* so don't print error code as it meaningless. */
int res = zs_init(s, origin, rclass, ttl);
if (res != 0) {
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] error initializing zone scanner instance, error: %i (%s)\n",
+ kr_log_error(LOG_GRP_ZSCANNER, "error initializing zone scanner instance, error: %i (%s)\n",
s->error.code, zs_strerror(s->error.code));
free(s);
return -1;
res = zs_set_input_file(s, zone_file);
if (res != 0) {
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] error opening zone file `%s`, error: %i (%s)\n",
+ kr_log_error(LOG_GRP_ZSCANNER, "error opening zone file `%s`, error: %i (%s)\n",
zone_file, s->error.code, zs_strerror(s->error.code));
zs_deinit(s);
free(s);
* Parsing as well error processing will be performed in zi_state_parsing().
* Store pointer to zone import context for further use. */
if (zs_set_processing(s, NULL, NULL, (void *)z_import) != 0) {
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] zs_set_processing() failed for zone file `%s`, "
+ kr_log_error(LOG_GRP_ZSCANNER, "zs_set_processing() failed for zone file `%s`, "
"error: %i (%s)\n",
zone_file, s->error.code, zs_strerror(s->error.code));
zs_deinit(s);
/* For now - fail.
* TODO - query DS and continue after answer had been obtained. */
KR_DNAME_GET_STR(zone_name_str, z_import->origin);
- kr_log_error(LOG_GRP_ZIMPORT, "[zimport] no TA found for `%s`, fail\n", zone_name_str);
+ kr_log_error(LOG_GRP_ZIMPORT, "no TA found for `%s`, fail\n", zone_name_str);
ret = 1;
}
elapsed = kr_now() - z_import->start_timestamp;
free(s);
if (ret != 0) {
- kr_log_error(LOG_GRP_ZSCANNER, "[zscanner] error parsing zone file `%s`\n", zone_file);
+ kr_log_error(LOG_GRP_ZSCANNER, "error parsing zone file `%s`\n", zone_file);
z_import->started = false;
return ret;
}
* Recreate cache and write version key. */
ret = cache_op(cache, count);
if (ret != 0) { /* Log for non-empty cache to limit noise on fresh start. */
- kr_log_info(LOG_GRP_CACHE, "[cache] incompatible cache database detected, purging\n");
+ kr_log_info(LOG_GRP_CACHE, "incompatible cache database detected, purging\n");
if (oldret) {
kr_log_verbose("[cache] reading version returned: %d\n", oldret);
} else if (val.len != sizeof(CACHE_VERSION)) {
if (ret == 0 && opts->maxsize) {
size_t maxsize = cache->api->get_maxsize(cache->db);
if (maxsize > opts->maxsize) kr_log_warning(LOG_GRP_CACHE,
- "[cache] Warning: real cache size is %zu instead of the requested %zu bytes."
+ "Warning: real cache size is %zu instead of the requested %zu bytes."
" To reduce the size you need to remove the file '%s' by hand.\n",
maxsize, opts->maxsize, fpath);
}
ssize_t written = stash_rrset(cache, qry, rr, rr_sigs, qry->timestamp.tv_sec,
entry->rank, nsec_pmap, needs_pkt);
if (written < 0) {
- kr_log_error(LOG_GRP_CACHE, "[%05u.%02u][cach] stash failed, ret = %d\n", qry->request->uid,
+ kr_log_error(LOG_GRP_CACHE, "[%05u.%02u] stash failed, ret = %d\n", qry->request->uid,
qry->uid, ret);
return (int) written;
}
case MDB_TXN_FULL:
return kr_error(ENOSPC);
default:
- kr_log_error(LOG_GRP_CACHE, "[cache] LMDB error: %s\n", mdb_strerror(error));
+ kr_log_error(LOG_GRP_CACHE, "LMDB error: %s\n", mdb_strerror(error));
return kr_error(error);
}
}
env->mapsize = info.me_mapsize;
if (env->mapsize != env->st_size) {
- kr_log_info(LOG_GRP_CACHE, "[cache] suspicious size of cache file '%s'"
+ kr_log_info(LOG_GRP_CACHE, "suspicious size of cache file '%s'"
": file size %zu != LMDB map size %zu\n",
env->mdb_data_path, (size_t)env->st_size, env->mapsize);
}
int cleared;
int ret = mdb_reader_check(env->env, &cleared);
if (ret != MDB_SUCCESS) {
- kr_log_error(LOG_GRP_CACHE, "[cache] failed to clear stale reader locks: "
+ kr_log_error(LOG_GRP_CACHE, "failed to clear stale reader locks: "
"LMDB error %d %s\n", ret, mdb_strerror(ret));
} else if (cleared != 0) {
- kr_log_info(LOG_GRP_CACHE, "[cache] cleared %d stale reader locks\n", cleared);
+ kr_log_info(LOG_GRP_CACHE, "cleared %d stale reader locks\n", cleared);
}
}
}
if (unlikely(ret == MDB_MAP_RESIZED)) {
- kr_log_info(LOG_GRP_CACHE, "[cache] detected size increased by another process\n");
+ kr_log_info(LOG_GRP_CACHE, "detected size increased by another process\n");
ret = refresh_mapsize(env);
if (ret == 0)
goto retry;
if (ret == EINVAL) {
/* POSIX says this can happen when the feature isn't supported by the FS.
* We haven't seen this happen on Linux+glibc but it was reported on FreeBSD.*/
- kr_log_info(LOG_GRP_CACHE, "[cache] space pre-allocation failed and ignored; "
+ kr_log_info(LOG_GRP_CACHE, "space pre-allocation failed and ignored; "
"your (file)system probably doesn't support it.\n");
} else if (ret != 0) {
mdb_txn_abort(txn);
* contrary to methods based on mdb_env_info(). */
if (st.st_size == env->st_size)
return kr_ok();
- kr_log_info(LOG_GRP_CACHE, "[cache] detected size change (by another instance?) of file '%s'"
+ kr_log_info(LOG_GRP_CACHE, "detected size change (by another instance?) of file '%s'"
": file size %zu -> file size %zu\n",
env->mdb_data_path, (size_t)env->st_size, (size_t)st.st_size);
env->st_size = st.st_size; // avoid retrying in cycle even if we fail
return ret;
}
}
- kr_log_info(LOG_GRP_CACHE, "[cache] clearing error, falling back\n");
+ kr_log_info(LOG_GRP_CACHE, "clearing error, falling back\n");
}
/* Fallback: we'll remove the database files and reopen.
* Other instances can continue to use the removed lmdb,
/* Find if we get a lock on lockfile. */
const int lockfile_fd = lockfile_get(lockfile);
if (lockfile_fd < 0) {
- kr_log_error(LOG_GRP_CACHE, "[cache] clearing failed to get ./krcachelock (%s); retry later\n",
+ kr_log_error(LOG_GRP_CACHE, "clearing failed to get ./krcachelock (%s); retry later\n",
kr_strerror(lockfile_fd));
/* As we're out of space (almost certainly - mdb_drop didn't work),
* we will retry on the next failing write operation. */
/* Environment updated, release lockfile. */
int lrerr = lockfile_release(lockfile_fd);
if (lrerr) {
- kr_log_error(LOG_GRP_CACHE, "[cache] failed to release ./krcachelock: %s\n",
+ kr_log_error(LOG_GRP_CACHE, "failed to release ./krcachelock: %s\n",
kr_strerror(lrerr));
}
return ret;
*/
const uint64_t now = kr_now();
if (!ignoring_errors_until) { // First error after a success.
- kr_log_info(LOG_GRP_CACHE, "[cache] LMDB refusing writes (ignored for 5-9s): %s\n",
+ kr_log_info(LOG_GRP_CACHE, "LMDB refusing writes (ignored for 5-9s): %s\n",
kr_strerror(ret));
ignoring_errors_until = now + 5000 + kr_rand_bytes(2)/16;
return kr_error(ret);
kr_strerror(ret));
abort();
case 0:
- kr_log_info(LOG_GRP_CACHE, "[cache] stuck cache cleared\n");
+ kr_log_info(LOG_GRP_CACHE, "stuck cache cleared\n");
ignoring_errors_until = 0;
case -EAGAIN: // fall-through; krcachelock race -> retry later
return kr_error(ENOSPC);
/* Sanity check: we consumed exactly all data. */
int unused_bytes = eh_bound - (uint8_t *)eh->data - data_off - ret;
if (kr_fails_assert(unused_bytes == 0)) {
- kr_log_error(LOG_GRP_CACHE, "[cach] entry2answer ERROR: unused bytes: %d\n",
+ kr_log_error(LOG_GRP_CACHE, "entry2answer ERROR: unused bytes: %d\n",
unused_bytes);
ret = kr_error(EILSEQ);
goto fail; /* to be on the safe side */
const bool flags_ok = kr_dnssec_key_zsk(rdata) && !kr_dnssec_key_revoked(rdata);
if (!flags_ok) {
auto_free char *owner_str = kr_dname_text(owner);
- kr_log_error(LOG_GRP_TA, "[ ta ] refusing to trust %s DNSKEY because of flags %d\n",
+ kr_log_error(LOG_GRP_TA, "refusing to trust %s DNSKEY because of flags %d\n",
owner_str, dnssec_key_get_flags(key));
ret = kr_error(EILSEQ);
goto cleanup;
} else if (!kr_dnssec_key_ksk(rdata)) {
auto_free char *owner_str = kr_dname_text(owner);
int flags = dnssec_key_get_flags(key);
- kr_log_warning(LOG_GRP_TA, "[ ta ] warning: %s DNSKEY is missing the SEP bit; "
+ kr_log_warning(LOG_GRP_TA, "warning: %s DNSKEY is missing the SEP bit; "
"flags %d instead of %d\n",
owner_str, flags, flags + 1/*a little ugly*/);
}
static void kres_gnutls_log(int level, const char *message)
{
- kr_log_debug(LOG_GRP_GNUTLS, "[gnutls] (%d) %s", level, message);
+ kr_log_debug(LOG_GRP_GNUTLS, "(%d) %s", level, message);
}
char *kr_log_level2name(log_level_t level)
|| load_symbol(module->lib, m_prefix, "props")) {
/* In case someone re-compiled against new kresd
* but haven't actually changed the symbols. */
- kr_log_error(LOG_GRP_SYSTEM, "[system] module %s requires upgrade. Please refer to "
+ kr_log_error(LOG_GRP_SYSTEM, "module %s requires upgrade. Please refer to "
"https://knot-resolver.readthedocs.io/en/stable/upgrading.html",
module->name);
return kr_error(ENOTSUP);
projects / thirdparty / knot-resolver.git / commitdiff
