/*
 * Soft:        Keepalived is a failover program for the LVS project
 *              <www.linuxvirtualserver.org>. It monitor & manipulate
 *              a loadbalanced server pool using multi-layer checks.
 *
 * Part:        logging facility.
 *
 * Author:      Alexandre Cassen, <acassen@linux-vs.org>
 *
 *              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.
 *
 *              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.
 *
 * Copyright (C) 2001-2017 Alexandre Cassen, <acassen@gmail.com>
 */

#include "config.h"

#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <memory.h>
#ifndef HAVE_SIGNALFD
#include <signal.h>
#endif

#include "logger.h"
#include "bitops.h"
#include "utils.h"

/* Boolean flag - send messages to console as well as syslog */
static bool log_console = false;

#ifdef ENABLE_LOG_TO_FILE
/* File to write log messages to */
const char *log_file_name;
static FILE *log_file;
bool always_flush_log_file;
#endif

void
enable_console_log(void)
{
	log_console = true;
}

#ifdef ENABLE_LOG_TO_FILE
void
set_flush_log_file(void)
{
	always_flush_log_file = true;
}

void
close_log_file(void)
{
	if (log_file) {
		fclose(log_file);
		log_file = NULL;
	}
}

void
open_log_file(const char *name, const char *prog, const char *namespace, const char *instance)
{
	const char *file_name;

	if (log_file) {
		fclose(log_file);
		log_file = NULL;
	}

	if (!name)
		return;

	file_name = make_file_name(name, prog, namespace, instance);

	log_file = fopen_safe(file_name, "a");
	if (log_file) {
		int n = fileno(log_file);
		if (fcntl(n, F_SETFD, FD_CLOEXEC | fcntl(n, F_GETFD)) == -1)
			log_message(LOG_INFO, "Failed to set CLOEXEC on log file %s", file_name);
		if (fcntl(n, F_SETFL, O_NONBLOCK | fcntl(n, F_GETFL)) == -1)
			log_message(LOG_INFO, "Failed to set NONBLOCK on log file %s", file_name);
	}

	FREE_CONST(file_name);
}

void
flush_log_file(void)
{
	if (log_file)
		fflush(log_file);
}

void
update_log_file_perms(mode_t umask_bits)
{
	if (log_file)
		fchmod(fileno(log_file), (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) & ~umask_bits);
}
#endif

#ifndef HAVE_SIGNALFD
static inline bool
block_signals(sigset_t *cur_set)
{
	sigset_t block_set;

	sigfillset(&block_set);
	if (!sigprocmask(SIG_BLOCK, &block_set, cur_set))
		return false;

	/* Yes, we are logging without disabling signals,
	 * but it would be useful to know that sigprocmask has
	 * failed. The only error that could occur according
	 * to sigprocmask(2) is EFAULT, which would be very
	 * strange since the sigsets are on the stack. */
	syslog(LOG_ERR, "%s", "sigprocmask failed in block_signals()");

	return true;
}
#endif

void
vlog_message(int facility, const char* format, va_list args)
{
#ifndef HAVE_SIGNALFD
	sigset_t cur_set;
	bool restore_signals = false;
#endif
#if !HAVE_VSYSLOG
	char buf[MAX_LOG_MSG+1];
#endif

	/* Don't write syslog if testing configuration */
	if (__test_bit(CONFIG_TEST_BIT, &debug))
		return;

#if !HAVE_VSYSLOG
	vsnprintf(buf, sizeof(buf), format, args);
#endif

	if (
#ifdef ENABLE_LOG_TO_FILE
	    log_file ||
#endif
			(__test_bit(DONT_FORK_BIT, &debug) && log_console)) {
#if HAVE_VSYSLOG
		va_list args1;
		char buf[2 * MAX_LOG_MSG + 1];

		va_copy(args1, args);
		vsnprintf(buf, sizeof(buf), format, args1);
		va_end(args1);
#endif

		/* timestamp setup */
#ifdef ENABLE_LOG_TO_FILE
		struct timespec ts;
		time_t t;
		char *p;

		clock_gettime(CLOCK_REALTIME, &ts);
		t = ts.tv_sec;
#else
		time_t t = time(NULL);
#endif
		struct tm tm;
		char timestamp[64];

		localtime_r(&t, &tm);

		if (log_console && __test_bit(DONT_FORK_BIT, &debug)) {
#ifndef HAVE_SIGNALFD
			if (!block_signals(&cur_set))
				restore_signals = true;
#endif

			strftime(timestamp, sizeof(timestamp), "%c", &tm);
			fprintf(stderr, "%s: %s\n", timestamp, buf);
		}
#ifdef ENABLE_LOG_TO_FILE
		if (log_file) {
			p = timestamp;
			p += strftime(timestamp, sizeof(timestamp), "%a %b %T", &tm);
			p += snprintf(p, timestamp + sizeof(timestamp) - p, ".%9.9ld", ts.tv_nsec);
			strftime(p, timestamp + sizeof(timestamp) - p, " %Y", &tm);
#ifndef HAVE_SIGNALFD
			if (!restore_signals && !block_signals(&cur_set))
				restore_signals = true;
#endif
			fprintf(log_file, "%s: %s\n", timestamp, buf);
			if (always_flush_log_file)
				fflush(log_file);
		}
#endif
	}

	if (!__test_bit(NO_SYSLOG_BIT, &debug)) {
#ifndef HAVE_SIGNALFD
		if (!restore_signals && !block_signals(&cur_set))
			restore_signals = true;
#endif

		if (!(facility & LOG_FACMASK))
			facility |= LOG_USER;

#if HAVE_VSYSLOG
		vsyslog(facility, format, args);
#else
		syslog(facility, "%s", buf);
#endif
	}

#ifndef HAVE_SIGNALFD
	if (restore_signals)
		sigprocmask(SIG_SETMASK, &cur_set, NULL);
#endif
}

void
log_message(const int facility, const char *format, ...)
{
	va_list args;

	va_start(args, format);
	vlog_message(facility, format, args);
	va_end(args);
}

void
conf_write(FILE *fp, const char *format, ...)
{
	va_list args;

	va_start(args, format);
	if (fp) {
		vfprintf(fp, format, args);
		fprintf(fp, "\n");
	}
	else
		vlog_message(LOG_INFO, format, args);

	va_end(args);
}