src/lib/failures.c

	failures.c revision 397e389715d49a8abfe078e3f7141f63960d412d
2ronwalf/* Copyright (c) 2002-2009 Dovecot authors, see the included COPYING file */
2ronwalf
2ronwalf#include "lib.h"
2ronwalf#include "ioloop.h"
2ronwalf#include "str.h"
2ronwalf#include "hostpid.h"
2ronwalf#include "network.h"
2ronwalf#include "backtrace-string.h"
2ronwalf#include "printf-format-fix.h"
2ronwalf#include "write-full.h"
2ronwalf#include "fd-close-on-exec.h"
2ronwalf
2ronwalf#include <stdlib.h>
2ronwalf#include <unistd.h>
2ronwalf#include <fcntl.h>
2ronwalf#include <syslog.h>
2ronwalf#include <time.h>
2ronwalf
2ronwalfconst char *failure_log_type_prefixes[LOG_TYPE_COUNT] = {
2ronwalf    "Debug: ",
2ronwalf    "Info: ",
2ronwalf    "Warning: ",
2ronwalf    "Error: ",
2ronwalf    "Fatal: ",
2ronwalf    "Panic: "
2ronwalf};
2ronwalf
2ronwalf/* Initialize working defaults */
2ronwalfstatic fatal_failure_callback_t *fatal_handler ATTR_NORETURN =
2ronwalf    default_fatal_handler;
2ronwalfstatic failure_callback_t *error_handler = default_error_handler;
2ronwalfstatic failure_callback_t *info_handler = default_error_handler;
2ronwalfstatic failure_callback_t *debug_handler = default_error_handler;
2ronwalfstatic void (*failure_exit_callback)(int *) = NULL;
2ronwalf
2ronwalfstatic int log_fd = STDERR_FILENO, log_info_fd = STDERR_FILENO,
2ronwalf       log_debug_fd = STDERR_FILENO;
2ronwalfstatic char *log_prefix = NULL, *log_stamp_format = NULL;
2ronwalfstatic bool failure_ignore_errors = FALSE;
2ronwalf
2ronwalfstatic void ATTR_FORMAT(2, 0)
2ronwalfi_internal_error_handler(enum log_type type, const char *fmt, va_list args);
2ronwalf
2ronwalf/* kludgy .. we want to trust log_stamp_format with -Wformat-nonliteral */
2ronwalfstatic const char *get_log_stamp_format(const char *unused)
2ronwalf    ATTR_FORMAT_ARG(1);
2ronwalf
2ronwalfstatic const char *get_log_stamp_format(const char *unused ATTR_UNUSED)
2ronwalf{
2ronwalf    return log_stamp_format;
2ronwalf}
2ronwalf
2ronwalfvoid failure_exit(int status)
2ronwalf{
2ronwalf    if (failure_exit_callback != NULL)
2ronwalf        failure_exit_callback(&status);
2ronwalf    exit(status);
2ronwalf}
2ronwalf
2ronwalfstatic void log_prefix_add(string_t *str)
2ronwalf{
2ronwalf    struct tm *tm;
2ronwalf    char buf[256];
2ronwalf    time_t now;
2ronwalf
2ronwalf    if (log_stamp_format != NULL) {
2ronwalf        now = time(NULL);
2ronwalf        tm = localtime(&now);
2ronwalf
2ronwalf        if (strftime(buf, sizeof(buf),
2ronwalf                 get_log_stamp_format("unused"), tm) > 0)
2ronwalf            str_append(str, buf);
2ronwalf    }
2ronwalf    if (log_prefix != NULL)
2ronwalf        str_append(str, log_prefix);
2ronwalf}
2ronwalf
2ronwalfstatic void log_fd_flush_stop(struct ioloop *ioloop)
2ronwalf{
2ronwalf    io_loop_stop(ioloop);
2ronwalf}
2ronwalf
2ronwalfstatic int log_fd_write(int fd, const unsigned char *data, unsigned int len)
2ronwalf{
2ronwalf    struct ioloop *ioloop;
2ronwalf    struct io *io;
2ronwalf    ssize_t ret;
2ronwalf    unsigned int eintr_count = 0;
2ronwalf
2ronwalf    while ((ret = write(fd, data, len)) != (ssize_t)len) {
2ronwalf        if (ret > 0) {
2ronwalf            /* some was written, continue.. */
2ronwalf            data += ret;
2ronwalf            len -= ret;
2ronwalf            continue;
2ronwalf        }
2ronwalf        if (ret == 0) {
2ronwalf            /* out of disk space? */
2ronwalf            errno = ENOSPC;
2ronwalf            return -1;
2ronwalf        }
2ronwalf        if (errno == EINTR && ++eintr_count < 3) {
2ronwalf            /* we don't want to die because of this.
2ronwalf               try again a couple of times. */
2ronwalf            continue;
2ronwalf        }
2ronwalf        if (errno != EAGAIN)
2ronwalf            return -1;
2ronwalf
2ronwalf        /* wait until we can write more. this can happen at least
2ronwalf           when writing to terminal, even if fd is blocking. */
2ronwalf        ioloop = io_loop_create();
2ronwalf        io = io_add(fd, IO_WRITE, log_fd_flush_stop, ioloop);
2ronwalf        io_loop_run(ioloop);
2ronwalf        io_remove(&io);
2ronwalf        io_loop_destroy(&ioloop);
2ronwalf    }
2ronwalf    return 0;
2ronwalf}
2ronwalf
2ronwalfstatic int ATTR_FORMAT(3, 0)
2ronwalfdefault_handler(const char *prefix, int fd, const char *format, va_list args)
2ronwalf{
2ronwalf    static int recursed = 0;
2ronwalf    int ret;
2ronwalf
2ronwalf    if (recursed >= 2) {
2ronwalf        /* we're being called from some signal handler or we ran
2ronwalf           out of memory */
2ronwalf        return -1;
2ronwalf    }
2ronwalf
2ronwalf    recursed++;
2ronwalf    T_BEGIN {
2ronwalf        string_t *str = t_str_new(256);
2ronwalf        log_prefix_add(str);
2ronwalf        str_append(str, prefix);
2ronwalf
2ronwalf        /* make sure there's no %n in there and fix %m */
2ronwalf        str_vprintfa(str, printf_format_fix(format), args);
2ronwalf        str_append_c(str, '\n');
2ronwalf
2ronwalf        ret = log_fd_write(fd, str_data(str), str_len(str));
2ronwalf    } T_END;
2ronwalf
2ronwalf    if (ret < 0 && failure_ignore_errors)
2ronwalf        ret = 0;
2ronwalf
2ronwalf    recursed--;
2ronwalf    return ret;
2ronwalf}
2ronwalf
2ronwalfstatic void ATTR_NORETURN
2ronwalfdefault_fatal_finish(enum log_type type, int status)
2ronwalf{
2ronwalf    const char *backtrace;
2ronwalf
2ronwalf    if (type == LOG_TYPE_PANIC || status == FATAL_OUTOFMEM) {
2ronwalf        if (backtrace_get(&backtrace) == 0)
2ronwalf            i_error("Raw backtrace: %s", backtrace);
2ronwalf    }
2ronwalf
2ronwalf    if (type == LOG_TYPE_PANIC)
2ronwalf        abort();
2ronwalf    else
2ronwalf        failure_exit(status);
2ronwalf}
2ronwalf
2ronwalfvoid default_fatal_handler(enum log_type type, int status,
2ronwalf               const char *format, va_list args)
2ronwalf{
2ronwalf    if (default_handler(failure_log_type_prefixes[type], log_fd, format,
2ronwalf                args) < 0 && status == FATAL_DEFAULT)
2ronwalf        status = FATAL_LOGWRITE;
2ronwalf
2ronwalf    default_fatal_finish(type, status);
2ronwalf}
2ronwalf
2ronwalfvoid default_error_handler(enum log_type type, const char *format, va_list args)
2ronwalf{
2ronwalf    int fd;
2ronwalf
2ronwalf    switch (type) {
2ronwalf    case LOG_TYPE_DEBUG:
2ronwalf        fd = log_debug_fd;
2ronwalf        break;
2ronwalf    case LOG_TYPE_INFO:
2ronwalf        fd = log_info_fd;
2ronwalf        break;
2ronwalf    default:
2ronwalf        fd = log_fd;
2ronwalf    }
2ronwalf
2ronwalf    if (default_handler(failure_log_type_prefixes[type],
2ronwalf                fd, format, args) < 0) {
2ronwalf        if (fd == log_fd)
2ronwalf            failure_exit(FATAL_LOGWRITE);
2ronwalf        /* we failed to log to info/debug log, try to log the
2ronwalf           write error to error log - maybe that'll work. */
2ronwalf        i_fatal_status(FATAL_LOGWRITE, "write() failed to %s log: %m",
2ronwalf                   fd == log_info_fd ? "info" : "debug");
2ronwalf    }
2ronwalf}
2ronwalf
2ronwalfvoid i_log_type(enum log_type type, const char *format, ...)
2ronwalf{
2ronwalf    va_list args;
2ronwalf
2ronwalf    va_start(args, format);
2ronwalf
2ronwalf    switch (type) {
2ronwalf    case LOG_TYPE_DEBUG:
2ronwalf        debug_handler(type, format, args);
2ronwalf        break;
2ronwalf    case LOG_TYPE_INFO:
2ronwalf        info_handler(type, format, args);
2ronwalf        break;
2ronwalf    default:
2ronwalf        error_handler(type, format, args);
2ronwalf    }
2ronwalf
2ronwalf    va_end(args);
2ronwalf}
2ronwalf
2ronwalfvoid i_panic(const char *format, ...)
2ronwalf{
2ronwalf    va_list args;
2ronwalf
2ronwalf    va_start(args, format);
2ronwalf    fatal_handler(LOG_TYPE_PANIC, 0, format, args);
2ronwalf    va_end(args);
2ronwalf}
2ronwalf
2ronwalfvoid i_fatal(const char *format, ...)
2ronwalf{
2ronwalf    va_list args;
2ronwalf
2ronwalf    va_start(args, format);
2ronwalf    fatal_handler(LOG_TYPE_FATAL, FATAL_DEFAULT, format, args);
2ronwalf    va_end(args);
2ronwalf}
2ronwalf
2ronwalfvoid i_fatal_status(int status, const char *format, ...)
2ronwalf{
2ronwalf    va_list args;
2ronwalf
2ronwalf    va_start(args, format);
2ronwalf    fatal_handler(LOG_TYPE_FATAL, status, format, args);
2ronwalf    va_end(args);
2ronwalf}
2ronwalf
2ronwalfvoid i_error(const char *format, ...)
2ronwalf{
2ronwalf    int old_errno = errno;
2ronwalf    va_list args;
2ronwalf
2ronwalf    va_start(args, format);
2ronwalf    error_handler(LOG_TYPE_ERROR, format, args);
2ronwalf    va_end(args);
2ronwalf
2ronwalf    errno = old_errno;
2ronwalf}
2ronwalf
2ronwalfvoid i_warning(const char *format, ...)
2ronwalf{
2ronwalf    int old_errno = errno;
2ronwalf    va_list args;
2ronwalf
2ronwalf    va_start(args, format);
2ronwalf    error_handler(LOG_TYPE_WARNING, format, args);
2ronwalf    va_end(args);
2ronwalf
2ronwalf    errno = old_errno;
2ronwalf}
2ronwalf
2ronwalfvoid i_info(const char *format, ...)
2ronwalf{
2ronwalf    int old_errno = errno;
2ronwalf    va_list args;
2ronwalf
2ronwalf    va_start(args, format);
2ronwalf    info_handler(LOG_TYPE_INFO, format, args);
2ronwalf    va_end(args);
2ronwalf
2ronwalf    errno = old_errno;
2ronwalf}
2ronwalf
2ronwalfvoid i_debug(const char *format, ...)
2ronwalf{
2ronwalf    int old_errno = errno;
2ronwalf    va_list args;
2ronwalf
2ronwalf    va_start(args, format);
2ronwalf    debug_handler(LOG_TYPE_DEBUG, format, args);
2ronwalf    va_end(args);
2ronwalf
2ronwalf    errno = old_errno;
2ronwalf}
2ronwalf
2ronwalfvoid i_set_fatal_handler(fatal_failure_callback_t *callback ATTR_NORETURN)
2ronwalf{
2ronwalf    if (callback == NULL)
2ronwalf        callback = default_fatal_handler;
2ronwalf        fatal_handler = callback;
2ronwalf}
2ronwalf
2ronwalfvoid i_set_error_handler(failure_callback_t *callback)
2ronwalf{
2ronwalf    if (callback == NULL)
2ronwalf        callback = default_error_handler;
2ronwalf    error_handler = callback;
2ronwalf}
2ronwalf
2ronwalfvoid i_set_info_handler(failure_callback_t *callback)
2ronwalf{
2ronwalf    if (callback == NULL)
2ronwalf        callback = default_error_handler;
2ronwalf    info_handler = callback;
2ronwalf}
2ronwalf
2ronwalfvoid i_set_debug_handler(failure_callback_t *callback)
2ronwalf{
2ronwalf    if (callback == NULL)
2ronwalf        callback = default_error_handler;
2ronwalf    debug_handler = callback;
2ronwalf}
2ronwalf
2ronwalfvoid i_get_failure_handlers(fatal_failure_callback_t **fatal_callback_r,
2ronwalf                failure_callback_t **error_callback_r,
2ronwalf                failure_callback_t **info_callback_r,
2ronwalf                failure_callback_t **debug_callback_r)
2ronwalf{
2ronwalf    *fatal_callback_r = fatal_handler;
2ronwalf    *error_callback_r = error_handler;
2ronwalf    *info_callback_r = info_handler;
2ronwalf    *debug_callback_r = debug_handler;
2ronwalf}
2ronwalf
2ronwalfstatic int ATTR_FORMAT(3, 0)
2ronwalfsyslog_handler(int level, enum log_type type, const char *format, va_list args)
2ronwalf{
2ronwalf    static int recursed = 0;
2ronwalf
2ronwalf    if (recursed >= 2)
2ronwalf        return -1;
2ronwalf    recursed++;
2ronwalf
2ronwalf    /* syslogs don't generatelly bother to log the level in any way,
2ronwalf       so make sure fatals and panics are shown clearly */
2ronwalf    T_BEGIN {
2ronwalf        syslog(level, "%s%s%s",
2ronwalf               log_prefix == NULL ? "" : log_prefix,
2ronwalf               type == LOG_TYPE_FATAL || type == LOG_TYPE_PANIC ?
2ronwalf               failure_log_type_prefixes[type] : "",
2ronwalf               t_strdup_vprintf(format, args));
2ronwalf    } T_END;
2ronwalf    recursed--;
2ronwalf    return 0;
2ronwalf}
2ronwalf
2ronwalfvoid i_syslog_fatal_handler(enum log_type type, int status,
2ronwalf                const char *fmt, va_list args)
2ronwalf{
2ronwalf    if (syslog_handler(LOG_CRIT, type, fmt, args) < 0 &&
2ronwalf        status == FATAL_DEFAULT)
2ronwalf        status = FATAL_LOGERROR;
2ronwalf
2ronwalf    default_fatal_finish(type, status);
2ronwalf}
2ronwalf
2ronwalfvoid i_syslog_error_handler(enum log_type type, const char *fmt, va_list args)
2ronwalf{
2ronwalf    int level = LOG_ERR;
2ronwalf
2ronwalf    switch (type) {
2ronwalf    case LOG_TYPE_DEBUG:
2ronwalf        level = LOG_DEBUG;
2ronwalf        break;
2ronwalf    case LOG_TYPE_INFO:
2ronwalf        level = LOG_INFO;
2ronwalf        break;
2ronwalf    case LOG_TYPE_WARNING:
2ronwalf        level = LOG_WARNING;
2ronwalf        break;
2ronwalf    case LOG_TYPE_ERROR:
2ronwalf        level = LOG_ERR;
2ronwalf        break;
2ronwalf    case LOG_TYPE_FATAL:
2ronwalf    case LOG_TYPE_PANIC:
2ronwalf        level = LOG_CRIT;
2ronwalf        break;
2ronwalf    case LOG_TYPE_COUNT:
2ronwalf    case LOG_TYPE_OPTION:
2ronwalf        i_unreached();
2ronwalf    }
2ronwalf
2ronwalf    if (syslog_handler(level, type, fmt, args) < 0)
2ronwalf        failure_exit(FATAL_LOGERROR);
2ronwalf}
2ronwalf
2ronwalfvoid i_set_failure_syslog(const char *ident, int options, int facility)
2ronwalf{
2ronwalf    openlog(ident, options, facility);
2ronwalf
2ronwalf    i_set_fatal_handler(i_syslog_fatal_handler);
2ronwalf    i_set_error_handler(i_syslog_error_handler);
2ronwalf    i_set_info_handler(i_syslog_error_handler);
2ronwalf    i_set_debug_handler(i_syslog_error_handler);
2ronwalf}
2ronwalf
2ronwalfstatic void open_log_file(int *fd, const char *path)
2ronwalf{
2ronwalf    char buf[PATH_MAX];
2ronwalf
2ronwalf    if (*fd != STDERR_FILENO) {
2ronwalf        if (close(*fd) < 0) {
2ronwalf            i_snprintf(buf, sizeof(buf),
2ronwalf                   "close(%d) failed: %m", *fd);
2ronwalf            (void)write_full(STDERR_FILENO, buf, strlen(buf));
2ronwalf        }
2ronwalf    }
2ronwalf
2ronwalf    if (path == NULL || strcmp(path, "/dev/stderr") == 0)
2ronwalf        *fd = STDERR_FILENO;
2ronwalf    else {
2ronwalf        *fd = open(path, O_CREAT | O_APPEND | O_WRONLY, 0600);
2ronwalf        if (*fd == -1) {
2ronwalf            *fd = STDERR_FILENO;
2ronwalf            i_snprintf(buf, sizeof(buf),
2ronwalf                   "Can't open log file %s: %m\n", path);
2ronwalf            (void)write_full(STDERR_FILENO, buf, strlen(buf));
2ronwalf            if (fd == &log_fd)
2ronwalf                failure_exit(FATAL_LOGOPEN);
2ronwalf            else
2ronwalf                i_fatal_status(FATAL_LOGOPEN, "%s", buf);
2ronwalf        }
2ronwalf        fd_close_on_exec(*fd, TRUE);
2ronwalf    }
2ronwalf}
2ronwalf
2ronwalfvoid i_set_failure_file(const char *path, const char *prefix)
2ronwalf{
2ronwalf    i_set_failure_prefix(prefix);
2ronwalf
2ronwalf    if (log_info_fd != STDERR_FILENO && log_info_fd != log_fd) {
2ronwalf        if (close(log_info_fd) < 0)
2ronwalf            i_error("close(%d) failed: %m", log_info_fd);
2ronwalf    }
2ronwalf
2ronwalf    if (log_debug_fd != STDERR_FILENO && log_debug_fd != log_info_fd &&
2ronwalf        log_debug_fd != log_fd) {
2ronwalf        if (close(log_debug_fd) < 0)
2ronwalf            i_error("close(%d) failed: %m", log_debug_fd);
2ronwalf    }
2ronwalf
2ronwalf    open_log_file(&log_fd, path);
2ronwalf    /* if info/debug logs are elsewhere, i_set_info/debug_file()
2ronwalf       overrides these later. */
2ronwalf    log_info_fd = log_fd;
2ronwalf    log_debug_fd = log_fd;
2ronwalf
2ronwalf    i_set_fatal_handler(NULL);
2ronwalf    i_set_error_handler(NULL);
2ronwalf    i_set_info_handler(NULL);
2ronwalf    i_set_debug_handler(NULL);
2ronwalf}
2ronwalf
2ronwalfstatic void i_failure_send_option(const char *key, const char *value)
2ronwalf{
2ronwalf    const char *str;
2ronwalf
2ronwalf    if (error_handler != i_internal_error_handler)
2ronwalf        return;
2ronwalf
2ronwalf    str = t_strdup_printf("\001%c%s %s=%s\n", LOG_TYPE_OPTION+1,
2ronwalf                  my_pid, key, value);
2ronwalf    (void)write_full(2, str, strlen(str));
2ronwalf}
2ronwalf
2ronwalfvoid i_set_failure_prefix(const char *prefix)
2ronwalf{
2ronwalf    i_free(log_prefix);
2ronwalf    log_prefix = i_strdup(prefix);
2ronwalf
2ronwalf    i_failure_send_option("prefix", prefix);
2ronwalf}

static int internal_send_split(string_t *full_str, unsigned int prefix_len)
{
    string_t *str;
    unsigned int max_text_len, pos = prefix_len;

    str = t_str_new(PIPE_BUF);
    str_append_n(str, str_c(full_str), prefix_len);
    max_text_len = PIPE_BUF - prefix_len - 1;

    while (pos < str_len(full_str)) {
        str_truncate(str, prefix_len);
        str_append_n(str, str_c(full_str) + pos, max_text_len);
        str_append_c(str, '\n');
        if (log_fd_write(2, str_data(str), str_len(str)) < 0)
            return -1;
        pos += max_text_len;
    }
    return 0;
}

static int ATTR_FORMAT(2, 0)
internal_handler(enum log_type log_type, const char *format, va_list args)
{
    static int recursed = 0;
    int ret;

    if (recursed >= 2) {
        /* we're being called from some signal handler or we ran
           out of memory */
        return -1;
    }

    recursed++;
    T_BEGIN {
        string_t *str;
        unsigned int prefix_len;

        str = t_str_new(512);
        str_printfa(str, "\001%c%s ", log_type + 1, my_pid);
        prefix_len = str_len(str);

        str_vprintfa(str, format, args);
        str_append_c(str, '\n');
        if (str_len(str) <= PIPE_BUF)
            ret = log_fd_write(2, str_data(str), str_len(str));
        else
            ret = internal_send_split(str, prefix_len);
    } T_END;

    if (ret < 0 && failure_ignore_errors)
        ret = 0;

    recursed--;
    return ret;
}

static bool line_is_ok(const char *line)
{
    if (*line != 1)
        return FALSE;

    if (line[1] == '\0') {
        i_warning("Broken log line follows (type=NUL)");
        return FALSE;
    }

    if (line[1]-1 > LOG_TYPE_OPTION) {
        i_warning("Broken log line follows (type=%d)", line[1]-1);
        return FALSE;
    }
    return TRUE;
}

void i_failure_parse_line(const char *line, struct failure_line *failure)
{
    memset(failure, 0, sizeof(*failure));
    if (!line_is_ok(line)) {
        failure->log_type = LOG_TYPE_ERROR;
        failure->text = line;
        return;
    }
    failure->log_type = line[1] - 1;

    line += 2;
    failure->text = line;
    while (*line >= '0' && *line <= '9') {
        failure->pid = failure->pid*10 + (*line - '0');
        line++;
    }
    if (*line != ' ') {
        /* some old protocol? */
        failure->pid = 0;
        return;
    }
    failure->text = line + 1;
}

static void ATTR_NORETURN ATTR_FORMAT(3, 0)
i_internal_fatal_handler(enum log_type type, int status,
             const char *fmt, va_list args)
{
    if (internal_handler(type, fmt, args) < 0 &&
        status == FATAL_DEFAULT)
        status = FATAL_LOGERROR;

    default_fatal_finish(type, status);
}

static void
i_internal_error_handler(enum log_type type, const char *fmt, va_list args)
{
    if (internal_handler(type, fmt, args) < 0)
        failure_exit(FATAL_LOGERROR);
}

void i_set_failure_internal(void)
{
    i_set_fatal_handler(i_internal_fatal_handler);
    i_set_error_handler(i_internal_error_handler);
    i_set_info_handler(i_internal_error_handler);
    i_set_debug_handler(i_internal_error_handler);
}

void i_set_failure_ignore_errors(bool ignore)
{
    failure_ignore_errors = ignore;
}

void i_set_info_file(const char *path)
{
    if (log_info_fd == log_fd)
        log_info_fd = STDERR_FILENO;

    open_log_file(&log_info_fd, path);
        info_handler = default_error_handler;
    /* write debug-level messages to the info_log_path,
      until i_set_debug_file() was called */
    log_debug_fd = log_info_fd;
    i_set_debug_handler(NULL);
}

void i_set_debug_file(const char *path)
{
    if (log_debug_fd == log_fd || log_debug_fd == log_info_fd)
        log_debug_fd = STDERR_FILENO;

    open_log_file(&log_debug_fd, path);
    debug_handler = default_error_handler;
}

void i_set_failure_timestamp_format(const char *fmt)
{
    i_free(log_stamp_format);
        log_stamp_format = i_strdup(fmt);
}

void i_set_failure_ip(const struct ip_addr *ip)
{
    i_failure_send_option("ip", net_ip2addr(ip));
}

void i_set_failure_exit_callback(void (*callback)(int *status))
{
    failure_exit_callback = callback;
}

void failures_deinit(void)
{
    if (log_debug_fd == log_info_fd || log_debug_fd == log_fd)
        log_debug_fd = STDERR_FILENO;

    if (log_info_fd == log_fd)
        log_info_fd = STDERR_FILENO;

    if (log_fd != STDERR_FILENO) {
        (void)close(log_fd);
        log_fd = STDERR_FILENO;
    }

    if (log_info_fd != STDERR_FILENO) {
        (void)close(log_info_fd);
        log_info_fd = STDERR_FILENO;
    }

    if (log_debug_fd != STDERR_FILENO) {
        (void)close(log_debug_fd);
        log_debug_fd = STDERR_FILENO;
    }

    i_free_and_null(log_prefix);
    i_free_and_null(log_stamp_format);
}