/*
* __handler_failure --
* Report the failure of an application-configured event handler.
*/
static void
__handler_failure(WT_SESSION_IMPL *session,
int error, const char *which, int error_handler_failed)
{
WT_EVENT_HANDLER *handler;
WT_SESSION *wt_session;
/*
* !!!
* SECURITY:
* Buffer placed at the end of the stack in case snprintf overflows.
*/
char s[256];
(void)snprintf(s, sizeof(s),
"application %s event handler failed: %s",
which, wiredtiger_strerror(error));
/*
* Use the error handler to report the failure, unless it was the error
* handler that failed. If it was the error handler that failed, or a
* call to the error handler fails, use the default error handler.
*/
wt_session = (WT_SESSION *)session;
handler = session->event_handler;
if (!error_handler_failed &&
handler->handle_error != __handle_error_default &&
handler->handle_error(handler, wt_session, error, s) == 0)
return;
(void)__handle_error_default(NULL, wt_session, error, s);
}
/*
* __wt_eventv --
* Report a message to an event handler.
*/
void
__wt_eventv(WT_SESSION_IMPL *session, int msg_event,
int error,
const char *file_name, int line_number, const char *fmt, va_list ap)
{
WT_EVENT_HANDLER *handler;
const char *prefix1, *prefix2;
char *end, *p;
/*
* !!!
* SECURITY:
* Buffer placed at the end of the stack in case snprintf overflows.
*/
char s[2048];
p = s;
end = s + sizeof(s);
prefix1 = (session->btree != NULL) ? session->btree->name : NULL;
prefix2 = session->name;
if (prefix1 != NULL && prefix2 != NULL && p < end)
p += snprintf(p, (size_t)(end - p),
"%s [%s]: ", prefix1, prefix2);
else if (prefix1 != NULL && p < end)
p += snprintf(p, (size_t)(end - p), "%s: ", prefix1);
else if (prefix2 != NULL && p < end)
p += snprintf(p, (size_t)(end - p), "%s: ", prefix2);
if (file_name != NULL && p < end)
p += snprintf(p, (size_t)(end - p),
"%s, %d: ", file_name, line_number);
if (p < end)
p += vsnprintf(p, (size_t)(end - p), fmt, ap);
if (error != 0 && p < end)
p += snprintf(p,
(size_t)(end - p), ": %s", wiredtiger_strerror(error));
handler = session->event_handler;
if (msg_event)
(void)handler->handle_message(handler, s);
else
handler->handle_error(handler, error, s);
}
/*
* __handler_failure --
* Report the failure of an application-configured event handler.
*/
static void
__handler_failure(WT_SESSION_IMPL *session,
int error, const char *which, bool error_handler_failed)
{
WT_EVENT_HANDLER *handler;
WT_SESSION *wt_session;
/*
* !!!
* SECURITY:
* Buffer placed at the end of the stack in case snprintf overflows.
*/
char s[256];
if (__wt_snprintf(s, sizeof(s),
"application %s event handler failed: %s",
which, __wt_strerror(session, error, NULL, 0)) != 0)
return;
/*
* Use the error handler to report the failure, unless it was the error
* handler that failed. If it was the error handler that failed, or a
* call to the error handler fails, use the default error handler.
*/
wt_session = (WT_SESSION *)session;
handler = session->event_handler;
if (!error_handler_failed &&
handler->handle_error != __handle_error_default &&
handler->handle_error(handler, wt_session, error, s) == 0)
return;
/*
* In case there is a failure in the default error handler, make sure
* we don't recursively try to report *that* error.
*/
session->event_handler = &__event_handler_default;
(void)__handle_error_default(NULL, wt_session, error, s);
session->event_handler = handler;
}
/*
* __wt_eventv --
* Report a message to an event handler.
*/
int
__wt_eventv(WT_SESSION_IMPL *session, bool msg_event, int error,
const char *file_name, int line_number, const char *fmt, va_list ap)
{
WT_EVENT_HANDLER *handler;
WT_DECL_RET;
WT_SESSION *wt_session;
struct timespec ts;
size_t len, remain, wlen;
int prefix_cnt;
const char *err, *prefix;
char *end, *p, tid[128];
/*
* We're using a stack buffer because we want error messages no matter
* what, and allocating a WT_ITEM, or the memory it needs, might fail.
*
* !!!
* SECURITY:
* Buffer placed at the end of the stack in case snprintf overflows.
*/
char s[2048];
/*
* !!!
* This function MUST handle a NULL WT_SESSION_IMPL handle.
*
* Without a session, we don't have event handlers or prefixes for the
* error message. Write the error to stderr and call it a day. (It's
* almost impossible for that to happen given how early we allocate the
* first session, but if the allocation of the first session fails, for
* example, we can end up here without a session.)
*/
if (session == NULL) {
if (fprintf(stderr,
"WiredTiger Error%s%s: ",
error == 0 ? "" : ": ",
error == 0 ? "" :
__wt_strerror(session, error, NULL, 0)) < 0)
ret = EIO;
if (vfprintf(stderr, fmt, ap) < 0)
ret = EIO;
if (fprintf(stderr, "\n") < 0)
ret = EIO;
if (fflush(stderr) != 0)
ret = EIO;
return (ret);
}
p = s;
end = s + sizeof(s);
/*
* We have several prefixes for the error message: a timestamp and the
* process and thread ids, the database error prefix, the data-source's
* name, and the session's name. Write them as a comma-separate list,
* followed by a colon.
*/
prefix_cnt = 0;
if (__wt_epoch(session, &ts) == 0) {
__wt_thread_id(tid, sizeof(tid));
remain = WT_PTRDIFF(end, p);
wlen = (size_t)snprintf(p, remain,
"[%" PRIuMAX ":%" PRIuMAX "][%s]",
(uintmax_t)ts.tv_sec,
(uintmax_t)ts.tv_nsec / WT_THOUSAND, tid);
p = wlen >= remain ? end : p + wlen;
prefix_cnt = 1;
}
if ((prefix = S2C(session)->error_prefix) != NULL) {
remain = WT_PTRDIFF(end, p);
wlen = (size_t)snprintf(p, remain,
"%s%s", prefix_cnt == 0 ? "" : ", ", prefix);
p = wlen >= remain ? end : p + wlen;
prefix_cnt = 1;
}
prefix = session->dhandle == NULL ? NULL : session->dhandle->name;
if (prefix != NULL) {
remain = WT_PTRDIFF(end, p);
wlen = (size_t)snprintf(p, remain,
"%s%s", prefix_cnt == 0 ? "" : ", ", prefix);
p = wlen >= remain ? end : p + wlen;
prefix_cnt = 1;
}
if ((prefix = session->name) != NULL) {
remain = WT_PTRDIFF(end, p);
wlen = (size_t)snprintf(p, remain,
"%s%s", prefix_cnt == 0 ? "" : ", ", prefix);
p = wlen >= remain ? end : p + wlen;
prefix_cnt = 1;
}
if (prefix_cnt != 0) {
remain = WT_PTRDIFF(end, p);
wlen = (size_t)snprintf(p, remain, ": ");
p = wlen >= remain ? end : p + wlen;
}
if (file_name != NULL) {
remain = WT_PTRDIFF(end, p);
wlen = (size_t)
snprintf(p, remain, "%s, %d: ", file_name, line_number);
p = wlen >= remain ? end : p + wlen;
}
remain = WT_PTRDIFF(end, p);
wlen = (size_t)vsnprintf(p, remain, fmt, ap);
p = wlen >= remain ? end : p + wlen;
if (error != 0) {
/*
* When the engine calls __wt_err on error, it often outputs an
* error message including the string associated with the error
* it's returning. We could change the calls to call __wt_errx,
* but it's simpler to not append an error string if all we are
* doing is duplicating an existing error string.
*
* Use strcmp to compare: both strings are nul-terminated, and
* we don't want to run past the end of the buffer.
*/
err = __wt_strerror(session, error, NULL, 0);
len = strlen(err);
if (WT_PTRDIFF(p, s) < len || strcmp(p - len, err) != 0) {
remain = WT_PTRDIFF(end, p);
(void)snprintf(p, remain, ": %s", err);
}
}
/*
* If a handler fails, return the error status: if we're in the process
* of handling an error, any return value we provide will be ignored by
* our caller, our caller presumably already has an error value it will
* be returning.
*
* If an application-specified or default informational message handler
* fails, complain using the application-specified or default error
* handler.
*
* If an application-specified error message handler fails, complain
* using the default error handler. If the default error handler fails,
* there's nothing to do.
*/
wt_session = (WT_SESSION *)session;
handler = session->event_handler;
if (msg_event) {
ret = handler->handle_message(handler, wt_session, s);
if (ret != 0)
__handler_failure(session, ret, "message", false);
} else {
ret = handler->handle_error(handler, wt_session, error, s);
if (ret != 0 && handler->handle_error != __handle_error_default)
__handler_failure(session, ret, "error", true);
}
return (ret);
}