src/doveadm/doveadm-log.c

	doveadm-log.c revision 4338c7b02e15779efaee5cedd4a355c946d9d4c2
c25356d5978632df6203437e1953bcb29e0c736fTimo Sirainen/* Copyright (c) 2010 Dovecot authors, see the included COPYING file */
c25356d5978632df6203437e1953bcb29e0c736fTimo Sirainen
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen#include "lib.h"
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen#include "ioloop.h"
bf72c930996df0691932fb1143f360d260f27a06Timo Sirainen#include "hash.h"
c49a19168dab6fda80aee16ad799a8a56d3bc18fTimo Sirainen#include "str.h"
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen#include "istream.h"
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen#include "master-service-private.h"
ad004e44be109684521494b5af2ad1da39b8bb27Timo Sirainen#include "master-service-settings.h"
ad004e44be109684521494b5af2ad1da39b8bb27Timo Sirainen#include "doveadm.h"
64e244defe74f513ce94f33d000a048ddbe2ea23Timo Sirainen
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen#include <stdio.h>
12cf3d0e03fc70fb0c8b91bc8fd83b4e14d7cdefTimo Sirainen#include <unistd.h>
8222ce68120b51353a3b31d3073b5f845d0e9f53Timo Sirainen#include <fcntl.h>
bf72c930996df0691932fb1143f360d260f27a06Timo Sirainen#include <dirent.h>
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen#include <signal.h>
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen#include <sys/stat.h>
c49a19168dab6fda80aee16ad799a8a56d3bc18fTimo Sirainen
2a90d8a14b0e7cc1508814bc87d3dfa598ef46a8Timo Sirainen#define LAST_LOG_TYPE LOG_TYPE_PANIC
c49a19168dab6fda80aee16ad799a8a56d3bc18fTimo Sirainen#define TEST_LOG_MSG_PREFIX "This is Dovecot's "
2a90d8a14b0e7cc1508814bc87d3dfa598ef46a8Timo Sirainen
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainenstatic void cmd_log_test(int argc ATTR_UNUSED, char *argv[] ATTR_UNUSED)
c49a19168dab6fda80aee16ad799a8a56d3bc18fTimo Sirainen{
bf72c930996df0691932fb1143f360d260f27a06Timo Sirainen    unsigned int i;
02ccba3d3be96444abd15b5254864c9151bbeb30Timo Sirainen
02ccba3d3be96444abd15b5254864c9151bbeb30Timo Sirainen    master_service->flags |= MASTER_SERVICE_FLAG_DONT_LOG_TO_STDERR;
bf72c930996df0691932fb1143f360d260f27a06Timo Sirainen    master_service_init_log(master_service, "doveadm: ");
c49a19168dab6fda80aee16ad799a8a56d3bc18fTimo Sirainen
c49a19168dab6fda80aee16ad799a8a56d3bc18fTimo Sirainen    for (i = 0; i < LAST_LOG_TYPE; i++) {
c49a19168dab6fda80aee16ad799a8a56d3bc18fTimo Sirainen        const char *prefix = failure_log_type_prefixes[i];
02ccba3d3be96444abd15b5254864c9151bbeb30Timo Sirainen
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen        /* add timestamp so that syslog won't just write
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen           "repeated message" text */
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen        i_log_type(i, TEST_LOG_MSG_PREFIX"%s log (%u)",
ad004e44be109684521494b5af2ad1da39b8bb27Timo Sirainen               t_str_lcase(t_strcut(prefix, ':')),
ad004e44be109684521494b5af2ad1da39b8bb27Timo Sirainen               (unsigned int)ioloop_time);
6ef7e31619edfaa17ed044b45861d106a86191efTimo Sirainen    }
64e244defe74f513ce94f33d000a048ddbe2ea23Timo Sirainen}
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen
ad004e44be109684521494b5af2ad1da39b8bb27Timo Sirainenstatic void cmd_log_reopen(int argc ATTR_UNUSED, char *argv[] ATTR_UNUSED)
ad004e44be109684521494b5af2ad1da39b8bb27Timo Sirainen{
68a4946b12583b88fa802e52ebee45cd96056772Timo Sirainen    doveadm_master_send_signal(SIGUSR1);
ad004e44be109684521494b5af2ad1da39b8bb27Timo Sirainen}
9439bed2f07d6475febd8a247cd2f0990fb32a13Timo Sirainen
c49a19168dab6fda80aee16ad799a8a56d3bc18fTimo Sirainenstruct log_find_file {
2a90d8a14b0e7cc1508814bc87d3dfa598ef46a8Timo Sirainen    const char *path;
71f1783adc89b4fe3588c72b23e059b320da8fadTimo Sirainen    uoff_t size;
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainen    /* 1 << enum log_type */
caea325346da6fb1cf503b35a619467a997acbfaTimo Sirainen    unsigned int mask;
caea325346da6fb1cf503b35a619467a997acbfaTimo Sirainen};
caea325346da6fb1cf503b35a619467a997acbfaTimo Sirainen
c0a708fa3f7b8f4fbca32052da5faf7a0125189dTimo Sirainenstruct log_find_context {
    pool_t pool;
    struct hash_table *files;
};

static void cmd_log_find_add(struct log_find_context *ctx,
                 const char *path, enum log_type type)
{
    struct log_find_file *file;
    char *key;

    file = hash_table_lookup(ctx->files, path);
    if (file == NULL) {
        file = p_new(ctx->pool, struct log_find_file, 1);
        file->path = key = p_strdup(ctx->pool, path);
        hash_table_insert(ctx->files, key, file);
    }

    file->mask |= 1 << type;
}

static void
cmd_log_find_syslog_files(struct log_find_context *ctx, const char *path)
{
    struct log_find_file *file;
    DIR *dir;
    struct dirent *d;
    struct stat st;
    char *key;
    string_t *full_path;
    unsigned int dir_len;

    dir = opendir(path);
    if (dir == NULL) {
        i_error("opendir(%s) failed: %m", path);
        return;
    }

    full_path = t_str_new(256);
    str_append(full_path, path);
    str_append_c(full_path, '/');
    dir_len = str_len(full_path);

    while ((d = readdir(dir)) != NULL) {
        if (d->d_name[0] == '.')
            continue;

        str_truncate(full_path, dir_len);
        str_append(full_path, d->d_name);
        if (stat(str_c(full_path), &st) < 0)
            continue;

        if (S_ISDIR(st.st_mode)) {
            /* recursively go through all subdirectories */
            cmd_log_find_syslog_files(ctx, str_c(full_path));
        } else if (hash_table_lookup(ctx->files,
                         str_c(full_path)) == NULL) {
            file = p_new(ctx->pool, struct log_find_file, 1);
            file->size = st.st_size;
            file->path = key =
                p_strdup(ctx->pool, str_c(full_path));
            hash_table_insert(ctx->files, key, file);
        }
    }

    (void)closedir(dir);
}

static bool log_type_find(const char *str, enum log_type *type_r)
{
    unsigned int i, len = strlen(str);

    for (i = 0; i < LAST_LOG_TYPE; i++) {
        if (strncasecmp(str, failure_log_type_prefixes[i], len) == 0 &&
            failure_log_type_prefixes[i][len] == ':') {
            *type_r = i;
            return TRUE;
        }
    }
    return FALSE;
}

static void cmd_log_find_syslog_file_messages(struct log_find_file *file)
{
    struct istream *input;
    const char *line, *p;
    enum log_type type;
    int fd;

    fd = open(file->path, O_RDONLY);
    if (fd == -1)
        return;

    input = i_stream_create_fd(fd, 1024, TRUE);
    i_stream_seek(input, file->size);
    while ((line = i_stream_read_next_line(input)) != NULL) {
        p = strstr(line, TEST_LOG_MSG_PREFIX);
        if (p == NULL)
            continue;
        p += strlen(TEST_LOG_MSG_PREFIX);

        /* <type> log */
        T_BEGIN {
            if (log_type_find(t_strcut(p, ' '), &type))
                file->mask |= 1 << type;
        } T_END;
    }
    i_stream_destroy(&input);
}

static void cmd_log_find_syslog_messages(struct log_find_context *ctx)
{
    struct hash_iterate_context *iter;
    struct stat st;
    void *key, *value;

    iter = hash_table_iterate_init(ctx->files);
    while (hash_table_iterate(iter, &key, &value)) {
        struct log_find_file *file = value;

        if (stat(file->path, &st) < 0 ||
            (uoff_t)st.st_size <= file->size)
            continue;

        cmd_log_find_syslog_file_messages(file);
    }
    hash_table_iterate_deinit(&iter);
}

static void
cmd_log_find_syslog(struct log_find_context *ctx, int argc, char *argv[])
{
    const char *log_dir;
    struct stat st;

    if (argc > 1)
        log_dir = argv[1];
    else if (stat("/var/log", &st) == 0 && S_ISDIR(st.st_mode))
        log_dir = "/var/log";
    else if (stat("/var/adm", &st) == 0 && S_ISDIR(st.st_mode))
        log_dir = "/var/adm";
    else
        return;

    printf("Looking for log files from %s\n", log_dir);
    cmd_log_find_syslog_files(ctx, log_dir);
    cmd_log_test(0, NULL);

    /* give syslog some time to write the messages to files */
    sleep(1);
    cmd_log_find_syslog_messages(ctx);
}

static void cmd_log_find(int argc, char *argv[])
{
    const struct master_service_settings *set;
    const char *log_file_path;
    struct log_find_context ctx;
    unsigned int i;

    memset(&ctx, 0, sizeof(ctx));
    ctx.pool = pool_alloconly_create("log file", 1024*32);
    ctx.files = hash_table_create(default_pool, ctx.pool, 0,
                      str_hash, (hash_cmp_callback_t *)strcmp);

    /* first get the paths that we know are used */
    set = master_service_settings_get(master_service);
    log_file_path = set->log_path;
    if (strcmp(log_file_path, "syslog") == 0)
        log_file_path = "";
    if (*log_file_path != '\0') {
        cmd_log_find_add(&ctx, log_file_path, LOG_TYPE_WARNING);
        cmd_log_find_add(&ctx, log_file_path, LOG_TYPE_ERROR);
        cmd_log_find_add(&ctx, log_file_path, LOG_TYPE_FATAL);
    }

    if (strcmp(set->info_log_path, "syslog") != 0) {
        if (*set->info_log_path != '\0')
            log_file_path = set->info_log_path;
        if (*log_file_path != '\0')
            cmd_log_find_add(&ctx, log_file_path, LOG_TYPE_INFO);
    }

    if (strcmp(set->debug_log_path, "syslog") != 0) {
        if (*set->debug_log_path != '\0')
            log_file_path = set->debug_log_path;
        if (*log_file_path != '\0')
            cmd_log_find_add(&ctx, log_file_path, LOG_TYPE_DEBUG);
    }

    if (*set->log_path == '\0' ||
        strcmp(set->log_path, "syslog") == 0 ||
        strcmp(set->info_log_path, "syslog") == 0 ||
        strcmp(set->debug_log_path, "syslog") == 0) {
        /* at least some logs were logged via syslog */
        cmd_log_find_syslog(&ctx, argc, argv);
    }

    /* print them */
    for (i = 0; i < LAST_LOG_TYPE; i++) {
        struct hash_iterate_context *iter;
        void *key, *value;
        bool found = FALSE;

        iter = hash_table_iterate_init(ctx.files);
        while (hash_table_iterate(iter, &key, &value)) {
            struct log_find_file *file = value;

            if ((file->mask & (1 << i)) != 0) {
                printf("%s%s\n", failure_log_type_prefixes[i],
                       file->path);
                found = TRUE;
            }
        }
        hash_table_iterate_deinit(&iter);

        if (!found)
            printf("%sNot found\n", failure_log_type_prefixes[i]);
    }
}

struct doveadm_cmd doveadm_cmd_log[] = {
    { cmd_log_test, "log test", "", NULL },
    { cmd_log_reopen, "log reopen", "", NULL },
    { cmd_log_find, "log find", "[<dir>]", NULL }
};

void doveadm_register_log_commands(void)
{
    unsigned int i;

    for (i = 0; i < N_ELEMENTS(doveadm_cmd_log); i++)
        doveadm_register_cmd(&doveadm_cmd_log[i]);
}