#include <stdarg.h>

#include <stdio.h>

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/socket.h>

#include <sys/un.h>

#include "log.h"

#include "util.h"

#include "macro.h"

#define SYSLOG_TIMEOUT_USEC (5*USEC_PER_SEC)

#define LOG_BUFFER_MAX 1024

static LogTarget log_target = LOG_TARGET_CONSOLE;

static int log_max_level = LOG_DEBUG;

static int console_fd = STDERR_FILENO;

static int syslog_fd = -1;

static int kmsg_fd = -1;

static char *log_abort_msg = NULL;

void log_close_console(void) {

if (console_fd < 0)

return;

if (getpid() == 1) {

if (console_fd >= 3)

close_nointr_nofail(console_fd);

console_fd = -1;

}

}

static int log_open_console(void) {

if (console_fd >= 0)

return 0;

if (getpid() == 1) {

if ((console_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC)) < 0) {

log_error("Failed to open /dev/console for logging: %s", strerror(-console_fd));

return console_fd;

}

log_info("Succesfully opened /dev/console for logging.");

} else

console_fd = STDERR_FILENO;

return 0;

}

void log_close_kmsg(void) {

if (kmsg_fd < 0)

return;

close_nointr_nofail(kmsg_fd);

kmsg_fd = -1;

}

static int log_open_kmsg(void) {

if (kmsg_fd >= 0)

return 0;

if ((kmsg_fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC)) < 0) {

log_info("Failed to open /dev/kmsg for logging: %s", strerror(errno));

return -errno;

}

log_info("Succesfully opened /dev/kmsg for logging.");

return 0;

}

void log_close_syslog(void) {

if (syslog_fd < 0)

return;

close_nointr_nofail(syslog_fd);

syslog_fd = -1;

}

static int log_open_syslog(void) {

union {

struct sockaddr sa;

struct sockaddr_un un;

} sa;

struct timeval tv;

int r;

if (syslog_fd >= 0)

return 0;

if ((syslog_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0) {

r = -errno;

goto fail;

}

/* Make sure we don't block for more than 5s when talking to

timeval_store(&tv, SYSLOG_TIMEOUT_USEC);

if (setsockopt(syslog_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0) {

r = -errno;

goto fail;

}

zero(sa);

sa.un.sun_family = AF_UNIX;

strncpy(sa.un.sun_path, "/dev/log", sizeof(sa.un.sun_path));

if (connect(syslog_fd, &sa.sa, sizeof(sa)) < 0) {

r = -errno;

goto fail;

}

log_info("Succesfully opened syslog for logging.");

return 0;

fail:

log_close_syslog();

log_info("Failed to open syslog for logging: %s", strerror(-r));

return r;

}

int log_open(void) {

int r;

/* If we don't use the console we close it here, to not get

if (log_target == LOG_TARGET_NULL) {

log_close_syslog();

log_close_console();

return 0;

}

if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||

log_target == LOG_TARGET_SYSLOG)

if ((r = log_open_syslog()) >= 0) {

log_close_console();

return r;

}

if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||

log_target == LOG_TARGET_KMSG)

if ((r = log_open_kmsg()) >= 0) {

log_close_syslog();

log_close_console();

return r;

}

log_close_syslog();

return log_open_console();

}

void log_set_target(LogTarget target) {

assert(target >= 0);

assert(target < _LOG_TARGET_MAX);

log_target = target;

}

void log_set_max_level(int level) {

assert((level & LOG_PRIMASK) == level);

log_max_level = level;

}

static int write_to_console(

int level,

const char*file,

int line,

const char *func,

const char *buffer) {

char location[64];

struct iovec iovec[5];

unsigned n = 0;

bool highlight;

if (console_fd < 0)

return 0;

snprintf(location, sizeof(location), "(%s:%u) ", file, line);

char_array_0(location);

highlight = LOG_PRI(level) <= LOG_ERR;

zero(iovec);

IOVEC_SET_STRING(iovec[n++], location);

if (highlight)

IOVEC_SET_STRING(iovec[n++], "\x1B[1;31m");

IOVEC_SET_STRING(iovec[n++], buffer);

if (highlight)

IOVEC_SET_STRING(iovec[n++], "\x1B[0m");

IOVEC_SET_STRING(iovec[n++], "\n");

if (writev(console_fd, iovec, n) < 0)

return -errno;

return 1;

}

static int write_to_syslog(

int level,

const char*file,

int line,

const char *func,

const char *buffer) {

char header_priority[16], header_time[64], header_pid[16];

struct iovec iovec[5];

struct msghdr msghdr;

time_t t;

struct tm *tm;

if (syslog_fd < 0)

return 0;

snprintf(header_priority, sizeof(header_priority), "<%i>", LOG_MAKEPRI(LOG_DAEMON, LOG_PRI(level)));

char_array_0(header_priority);

t = (time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC);

if (!(tm = localtime(&t)))

return -EINVAL;

if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)

return -EINVAL;

snprintf(header_pid, sizeof(header_pid), "[%llu]: ", (unsigned long long) getpid());

char_array_0(header_pid);

zero(iovec);

IOVEC_SET_STRING(iovec[0], header_priority);

IOVEC_SET_STRING(iovec[1], header_time);

IOVEC_SET_STRING(iovec[2], program_invocation_short_name);

IOVEC_SET_STRING(iovec[3], header_pid);

IOVEC_SET_STRING(iovec[4], buffer);

zero(msghdr);

msghdr.msg_iov = iovec;

msghdr.msg_iovlen = ELEMENTSOF(iovec);

if (sendmsg(syslog_fd, &msghdr, 0) < 0)

return -errno;

return 1;

}

static int write_to_kmsg(

int level,

const char*file,

int line,

const char *func,

const char *buffer) {

char header_priority[16], header_pid[16];

struct iovec iovec[5];

if (kmsg_fd < 0)

return 0;

snprintf(header_priority, sizeof(header_priority), "<%i>", LOG_PRI(level));

char_array_0(header_priority);

snprintf(header_pid, sizeof(header_pid), "[%llu]: ", (unsigned long long) getpid());

char_array_0(header_pid);

zero(iovec);

IOVEC_SET_STRING(iovec[0], header_priority);

IOVEC_SET_STRING(iovec[1], program_invocation_short_name);

IOVEC_SET_STRING(iovec[2], header_pid);

IOVEC_SET_STRING(iovec[3], buffer);

IOVEC_SET_STRING(iovec[4], "\n");

if (writev(kmsg_fd, iovec, ELEMENTSOF(iovec)) < 0)

return -errno;

return 1;

}

static int log_dispatch(

int level,

const char*file,

int line,

const char *func,

char *buffer) {

int r = 0;

if (log_target == LOG_TARGET_NULL)

return 0;

do {

char *e;

int k;

buffer += strspn(buffer, NEWLINE);

if (buffer[0] == 0)

break;

if ((e = strpbrk(buffer, NEWLINE)))

*(e++) = 0;

if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||

log_target == LOG_TARGET_SYSLOG) {

if ((r = write_to_syslog(level, file, line, func, buffer)) < 0) {

log_close_syslog();

log_open_kmsg();

} else if (r > 0)

r++;

}

if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||

log_target == LOG_TARGET_KMSG) {

if ((r = write_to_kmsg(level, file, line, func, buffer)) < 0) {

log_close_kmsg();

log_open_console();

} else if (r > 0)

r++;

}

if ((k = write_to_console(level, file, line, func, buffer)) < 0)

return k;

buffer = e;

} while (buffer);

return r;

}

int log_dump_internal(

int level,

const char*file,

int line,

const char *func,

char *buffer) {

int saved_errno, r;

/* This modifies the buffer... */

if (_likely_(LOG_PRI(level) > log_max_level))

return 0;

saved_errno = errno;

r = log_dispatch(level, file, line, func, buffer);

errno = saved_errno;

return r;

}

int log_meta(

int level,

const char*file,

int line,

const char *func,

const char *format, ...) {

char buffer[LOG_BUFFER_MAX];

int saved_errno, r;

va_list ap;

if (_likely_(LOG_PRI(level) > log_max_level))

return 0;

saved_errno = errno;

va_start(ap, format);

vsnprintf(buffer, sizeof(buffer), format, ap);

va_end(ap);

char_array_0(buffer);

r = log_dispatch(level, file, line, func, buffer);

errno = saved_errno;

return r;

}

void log_assert(

const char*file,

int line,

const char *func,

const char *format, ...) {

static char buffer[LOG_BUFFER_MAX];

int saved_errno = errno;

va_list ap;

va_start(ap, format);

vsnprintf(buffer, sizeof(buffer), format, ap);

va_end(ap);

char_array_0(buffer);

log_abort_msg = buffer;

log_dispatch(LOG_CRIT, file, line, func, buffer);

abort();

/* If the user chose to ignore this SIGABRT, we are happy to go on, as if nothing happened. */

errno = saved_errno;

}

int log_set_target_from_string(const char *e) {

LogTarget t;

if ((t = log_target_from_string(e)) < 0)

return -EINVAL;

log_set_target(t);

return 0;

}

int log_set_max_level_from_string(const char *e) {

int t;

if ((t = log_level_from_string(e)) < 0)

return -EINVAL;

log_set_max_level(t);

return 0;

}

void log_parse_environment(void) {

const char *e;

if ((e = getenv("SYSTEMD_LOG_TARGET")))

if (log_set_target_from_string(e) < 0)

log_warning("Failed to parse log target %s. Ignoring.", e);

if ((e = getenv("SYSTEMD_LOG_LEVEL")))

if (log_set_max_level_from_string(e) < 0)

log_warning("Failed to parse log level %s. Ignoring.", e);

}

LogTarget log_get_target(void) {

return log_target;

}

int log_get_max_level(void) {

return log_max_level;

}

static const char *const log_target_table[] = {

[LOG_TARGET_CONSOLE] = "console",

[LOG_TARGET_SYSLOG] = "syslog",

[LOG_TARGET_KMSG] = "kmsg",

[LOG_TARGET_SYSLOG_OR_KMSG] = "syslog-or-kmsg",

[LOG_TARGET_NULL] = "null"

};

DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);