/*

    Copyright (C) 2010  ABRT team

    Copyright (C) 2010, 2014  RedHat Inc

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along

    with this program; if not, write to the Free Software Foundation, Inc.,

    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#include <syslog.h>

/* Suppress automatic CODE_* fields as we handle those here */

#define SD_JOURNAL_SUPPRESS_LOCATION

#include <systemd/sd-journal.h>

#include "internal_libreport.h"

void (*g_custom_logger)(const char*);

const char *msg_prefix = "";

const char *msg_eol = "\n";

int logmode = LOGMODE_STDIO;

int xfunc_error_retval = EXIT_FAILURE;

static enum libreport_diemode xfunc_diemode = DIEMODE_EXIT;

int g_verbose;

void set_xfunc_error_retval(int retval)

{

    xfunc_error_retval = retval;

}

void set_xfunc_diemode(enum libreport_diemode mode)

{

    xfunc_diemode = mode;

}

/* [p]error_msg[_and_die] must be safe after fork in multi-threaded programs.

 * Therefore we avoid stdio, fflush(), and use _exit() instead of exit().

 *

 */

void xfunc_die(void)

{

    char *const envmode = getenv("LIBREPORT_DIEMODE");

    if (   xfunc_diemode == DIEMODE_ABORT

        || (envmode != NULL && strcmp("abort", envmode) == 0))

        abort();

    _exit(xfunc_error_retval);

}

static bool should_log(int level)

{

    // LOG_DEBUG = 7, LOG_INFO = 6, LOG_NOTICE = 5, LOG_WARNING = 4, LOG_ERR = 3

    // output only messages with LOG_ERR by default, overridden by g_verbose

    if(

          (g_verbose == 0 && level <= LOG_WARNING) ||

          (g_verbose == 1 && level <= LOG_NOTICE) ||

          (g_verbose == 2 && level <= LOG_INFO) ||

          (g_verbose == 3)

      )

      return true;

    return false;

}

static void log_handler(int level,

                        const char *format,

                        va_list p,

                        const char *strerr, /* perror messages */

                        int flags,

                        const char *file,

                        int line,

                        const char *func)

{

    if (!logmode || !should_log(level))

        return;

    /* This is ugly and costs +60 bytes compared to multiple

     * fprintf's, but is guaranteed to do a single write.

     * This is needed for e.g. when multiple children

     * can produce log messages simultaneously. */

    int prefix_len = msg_prefix[0] ? strlen(msg_prefix) + 2 : 0;

    int strerr_len = strerr ? strlen(strerr) : 0;

    int msgeol_len = strlen(msg_eol);

    int used;

    /* Try to format the message in a fixed buffer.

     * This eliminates malloc.

     * Main reason isn't the speed optimization, but to make

     * short logging safe after fork in multithreaded libraries.

     */

    char buf[1024];

    va_list p2;

    va_copy(p2, p);

    if (prefix_len < sizeof(buf))

        used = vsnprintf(buf + prefix_len, sizeof(buf) - prefix_len, format, p2);

    else

        used = vsnprintf(buf, 0, format, p2);

    va_end(p2);

    char *msg = buf;

    /* +3 is for ": " before strerr and for terminating NUL */

    unsigned total_len = prefix_len + used + strerr_len + msgeol_len + 3;

    if (total_len >= sizeof(buf))

    {

        msg = alloca(total_len);

        used = vsnprintf(msg + prefix_len, total_len - prefix_len, format, p);

    }

    if (prefix_len) {

        char *p;

        used += prefix_len;

        p = stpcpy(msg, msg_prefix);

        p[0] = ':';

        p[1] = ' ';

    }

    if (strerr) {

        if (format[0]) {

            msg[used++] = ':';

            msg[used++] = ' ';

        }

        strcpy(&msg[used], strerr);

        used += strerr_len;

    }

    strcpy(&msg[used], msg_eol);

    if (flags & LOGMODE_STDIO) {

        full_write(STDERR_FILENO, msg, used + msgeol_len);

    }

    msg[used] = '\0'; /* remove msg_eol (usually "\n") */

    if (flags & LOGMODE_SYSLOG) {

        syslog(level, "%s", msg + prefix_len);

    }

    if ((flags & LOGMODE_CUSTOM) && g_custom_logger) {

        g_custom_logger(msg + prefix_len);

    }

    if (flags & LOGMODE_JOURNAL) {

        sd_journal_send("MESSAGE=%s", msg + prefix_len,

                        "PRIORITY=%d", level,

                        "CODE_FILE=%s", file,

                        "CODE_LINE=%d", line,

                        "CODE_FUNC=%s", func,

                        "SYSLOG_FACILITY=1",

                        NULL);

    }

}

void log_wrapper(int level,

                 const char *file,

                 int line,

                 const char *func,

                 bool process_perror,

                 bool use_custom_logger,

                 const char *format,

                 ...)

{

    va_list p;

    va_start(p, format);

    log_handler(level,

                format,

                p,

                (process_perror && errno) ? strerror(errno) : NULL, /* Guard against "<error message>: Success" */

                logmode | (use_custom_logger ? LOGMODE_CUSTOM : 0),

                file,

                line,

                func);

    va_end(p);

}

void log_and_die_wrapper(int level,

                         const char *file,

                         int line,

                         const char *func,

                         bool process_perror,

                         bool use_custom_logger,

                         const char *format,

                         ...)

{

    va_list p;

    va_start(p, format);

    log_handler(level,

                format,

                p,

                (process_perror && errno) ? strerror(errno) : NULL, /* Guard against "<error message>: Success" */

                logmode | (use_custom_logger ? LOGMODE_CUSTOM : 0),

                file,

                line,

                func);

    va_end(p);

    xfunc_die();

}

void die_out_of_memory(void)

{

    error_msg_and_die("Out of memory, exiting");

}