/*

 * Copyright (C) 2002-2003 Ardis Technolgies <roman@ardistech.com>

 *

 * Released under the terms of the GNU GPL v2.0.

 */

#include <ctype.h>

#include <string.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <syslog.h>

#include <signal.h>

#include <errno.h>

#include <sys/shm.h>

#include <sys/ipc.h>

#include <sys/types.h>

#include <sys/types.h>

#include <sys/wait.h>

#include "iscsi_util.h"

#include "log.h"

#define SEMKEY	0xA7L

#define LOGDBG 0

#if LOGDBG

#define logdbg(file, fmt, args...) fprintf(file, fmt, ##args)

#else

#define logdbg(file, fmt, args...) do {} while (0)

#endif

char *log_name;

int log_level = 0;

struct logarea *la = NULL;

static int log_stop_daemon = 0;

static void (*log_func)(int prio, void *priv, const char *fmt, va_list ap);

static void *log_func_priv;

static void free_logarea (void)

{

	int shmid;

	if (!la)

		return;

	if (la->semid != -1)

		semctl(la->semid, 0, IPC_RMID, la->semarg);

	if (la->buff) {

		shmdt(la->buff);

		shmctl(la->shmid_buff, IPC_RMID, NULL);

		la->buff = NULL;

		la->shmid_buff = -1;

	}

	if (la->start) {

		shmdt(la->start);

		shmctl(la->shmid_msg, IPC_RMID, NULL);

		la->start = NULL;

		la->shmid_msg = -1;

	}

	shmid = la->shmid;

	shmdt(la);

	shmctl(shmid, IPC_RMID, NULL);

	la = NULL;

}

static int logarea_init (int size)

{

	int shmid;

	logdbg(stderr,"enter logarea_init\n");

	if ((shmid = shmget(IPC_PRIVATE, sizeof(struct logarea),

			    0600 | IPC_CREAT | IPC_EXCL)) == -1) {

		syslog(LOG_ERR, "shmget logarea failed %d", errno);

		return 1;

	}

	la = shmat(shmid, NULL, 0);

	if (!la) {

		syslog(LOG_ERR, "shmat logarea failed %d", errno);

		shmctl(shmid, IPC_RMID, NULL);

		return 1;

	}

	la->shmid = shmid;

	la->start = NULL;

	la->buff = NULL;

	la->semid = -1;

	if (size < MAX_MSG_SIZE)

		size = DEFAULT_AREA_SIZE;

	if ((shmid = shmget(IPC_PRIVATE, size,

			    0600 | IPC_CREAT | IPC_EXCL)) == -1) {

		syslog(LOG_ERR, "shmget msg failed %d", errno);

		free_logarea();

		return 1;

	}

	la->shmid_msg = shmid;

	la->start = shmat(la->shmid_msg, NULL, 0);

	if (!la->start) {

		syslog(LOG_ERR, "shmat msg failed %d", errno);

		free_logarea();

		return 1;

	}

	memset(la->start, 0, size);

	la->empty = 1;

	la->end = la->start + size;

	la->head = la->start;

	la->tail = la->start;

	if ((shmid = shmget(IPC_PRIVATE, MAX_MSG_SIZE + sizeof(struct logmsg),

			    0600 | IPC_CREAT | IPC_EXCL)) == -1) {

		syslog(LOG_ERR, "shmget logmsg failed %d", errno);

		free_logarea();

		return 1;

	}

	la->buff = shmat(shmid, NULL, 0);

	if (!la->buff) {

		syslog(LOG_ERR, "shmat logmsgfailed %d", errno);

		free_logarea();

		return 1;

	}

	if ((la->semid = semget(SEMKEY, 1, 0600 | IPC_CREAT)) < 0) {

		syslog(LOG_ERR, "semget failed %d", errno);

		free_logarea();

		return 1;

	}

	la->semarg.val=1;

	if (semctl(la->semid, 0, SETVAL, la->semarg) < 0) {

		syslog(LOG_ERR, "semctl failed %d", errno);

		free_logarea();

		return 1;

	}

	la->shmid_buff = shmid;

	la->ops[0].sem_num = 0;

	la->ops[0].sem_flg = 0;

	return 0;

}

#if LOGDBG

static void dump_logarea (void)

{

	struct logmsg * msg;

	logdbg(stderr, "\n==== area: start addr = %p, end addr = %p ====\n",

		la->start, la->end);

	logdbg(stderr, "|addr     |next     |prio|msg\n");

	for (msg = (struct logmsg *)la->head; (void *)msg != la->tail;

	     msg = msg->next)

		logdbg(stderr, "|%p |%p |%i   |%s\n", (void *)msg, msg->next,

				msg->prio, (char *)&msg->str);

	logdbg(stderr, "|%p |%p |%i   |%s\n", (void *)msg, msg->next,

			msg->prio, (char *)&msg->str);

	logdbg(stderr, "\n\n");

}

#endif

int log_enqueue (int prio, const char * fmt, va_list ap)

{

	int len, fwd;

	char buff[MAX_MSG_SIZE];

	struct logmsg * msg;

	struct logmsg * lastmsg;

	lastmsg = (struct logmsg *)la->tail;

	if (!la->empty) {

		fwd = sizeof(struct logmsg) +

		      strlen((char *)&lastmsg->str) * sizeof(char) + 1;

		la->tail += fwd;

	}

	vsnprintf(buff, MAX_MSG_SIZE, fmt, ap);

	len = strlen(buff) * sizeof(char) + 1;

	/* not enough space on tail : rewind */

	if (la->head <= la->tail &&

	    (long)(len + sizeof(struct logmsg)) > (la->end - la->tail)) {

		logdbg(stderr, "enqueue: rewind tail to %p\n", la->tail);

			la->tail = la->start;

			if (la->empty)

				la->head = lastmsg = la->tail;

	}

	/* not enough space on head : drop msg */

	if (la->head > la->tail &&

	    (long)(len + sizeof(struct logmsg)) > (la->head - la->tail)) {

		logdbg(stderr, "enqueue: log area overrun, drop msg\n");

		if (!la->empty)

			la->tail = lastmsg;

		return 1;

	}

	/* ok, we can stage the msg in the area */

	la->empty = 0;

	msg = (struct logmsg *)la->tail;

	msg->prio = prio;

	memcpy((void *)&msg->str, buff, len);

	lastmsg->next = la->tail;

	msg->next = la->head;

	logdbg(stderr, "enqueue: %p, %p, %i, %s\n", (void *)msg, msg->next,

		msg->prio, (char *)&msg->str);

#if LOGDBG

	dump_logarea();

#endif

	return 0;

}

int log_dequeue (void * buff)

{

	struct logmsg * src = (struct logmsg *)la->head;

	struct logmsg * dst = (struct logmsg *)buff;

	struct logmsg * lst = (struct logmsg *)la->tail;

	int len;

	if (la->empty)

		return 0;

	len = strlen((char *)&src->str) * sizeof(char) +

	      sizeof(struct logmsg) + 1;

	dst->prio = src->prio;

	memcpy(dst, src,  len);

	if (la->tail == la->head)

		la->empty = 1; /* purge the last log msg */

	else {

		la->head = src->next;

		lst->next = la->head;

	}

	logdbg(stderr, "dequeue: %p, %p, %i, %s\n",

	       (void *)src, src->next, src->prio, (char *)&src->str);

	memset((void *)src, 0, len);

	return len;

}

/*

 * this one can block under memory pressure

 */

static void log_syslog (void * buff)

{

	struct logmsg * msg = (struct logmsg *)buff;

	syslog(msg->prio, "%s", (char *)&msg->str);

}

void log_do_log_daemon(int prio,

		       __attribute__((unused))void *priv,

		       const char *fmt,

		       va_list ap)

{

	struct sembuf ops[1];

	ops[0].sem_num = la->ops[0].sem_num;

	ops[0].sem_flg = la->ops[0].sem_flg;

	ops[0].sem_op = -1;

	if (semop(la->semid, ops, 1) < 0) {

		syslog(LOG_ERR, "semop down failed %d", errno);

		return;

	}

	log_enqueue(prio, fmt, ap);

	ops[0].sem_op = 1;

	if (semop(la->semid, ops, 1) < 0)

		syslog(LOG_ERR, "semop up failed");

}

void log_do_log_std(int prio,

		    __attribute__((unused))void *priv,

		    const char *fmt,

		    va_list ap)

{

	if (prio == LOG_INFO) {

		vfprintf(stdout, fmt, ap);

		fprintf(stdout, "\n");

	} else {

		fprintf(stderr, "%s: ", log_name);

		vfprintf(stderr, fmt, ap);

		fprintf(stderr, "\n");

		fflush(stderr);

	}

}

void log_warning(const char *fmt, ...)

{

	va_list ap;

	va_start(ap, fmt);

	log_func(LOG_WARNING, log_func_priv, fmt, ap);

	va_end(ap);

}

void log_error(const char *fmt, ...)

{

	va_list ap;

	va_start(ap, fmt);

	log_func(LOG_ERR, log_func_priv, fmt, ap);

	va_end(ap);

}

void log_debug(int level, const char *fmt, ...)

{

	if (log_level > level) {

		va_list ap;

		va_start(ap, fmt);

		log_func(LOG_DEBUG, log_func_priv, fmt, ap);

		va_end(ap);

	}

}

void log_info(const char *fmt, ...)

{

	va_list ap;

	va_start(ap, fmt);

	log_func(LOG_INFO, log_func_priv, fmt, ap);

	va_end(ap);

}

#if 0 /* Unused */

static void __dump_line(int level, unsigned char *buf, int *cp)

{

	char line[16*3+5], *lp = line;

	int i, cnt;

	cnt = *cp;

	if (!cnt)

		return;

	for (i = 0; i < 16; i++) {

		if (i < cnt)

			lp += sprintf(lp, " %02x", buf[i]);

		else

			lp += sprintf(lp, "   ");

		if ((i % 4) == 3)

			lp += sprintf(lp, " |");

		if (i >= cnt || !isprint(buf[i]))

			buf[i] =  ' ';

	}

	log_debug(level, "%s %.16s |", line, buf);

	*cp = 0;

}

static void __dump_char(int level, unsigned char *buf, int *cp, int ch)

{

	int cnt = (*cp)++;

	buf[cnt] = ch;

	if (cnt == 15)

		__dump_line(level, buf, cp);

}

#define dump_line() __dump_line(level, char_buf, &char_cnt)

#define dump_char(ch) __dump_char(level, char_buf, &char_cnt, ch)

#endif /* Unused */

static void log_flush(void)

{

	int msglen;

	struct sembuf ops[1];

	ops[0].sem_num = la->ops[0].sem_num;

	ops[0].sem_flg = la->ops[0].sem_flg;

	while (!la->empty) {

		ops[0].sem_op = -1;

		if (semop(la->semid, ops, 1) < 0) {

			syslog(LOG_ERR, "semop down failed %d", errno);

			exit(1);

		}

		msglen = log_dequeue(la->buff);

		ops[0].sem_op = 1;

		if (semop(la->semid, ops, 1) < 0) {

			syslog(LOG_ERR, "semop up failed");

			exit(1);

		}

		if (msglen)

			log_syslog(la->buff);

	}

}

static void catch_signal(int signo)

{

	switch (signo) {

	case SIGSEGV:

		log_flush();

		break;

	case SIGTERM:

		log_stop_daemon = 1;

		break;

	}

	log_debug(1, "pid %d caught signal -%d", getpid(), signo);

}

static void __log_close(void)

{

	if (log_func == log_do_log_daemon) {

		log_flush();

		closelog();

		free_logarea();

	}

}

int log_init(char *program_name, int size,

	void (*func)(int prio, void *priv, const char *fmt, va_list ap),

	void *priv)

{

	logdbg(stderr,"enter log_init\n");

	log_name = program_name;

	log_func = func;

	log_func_priv = priv;

	if (log_func == log_do_log_daemon) {

		struct sigaction sa_old;

		struct sigaction sa_new;

		pid_t pid;

		openlog(log_name, 0, LOG_DAEMON);

		setlogmask (LOG_UPTO (LOG_DEBUG));

		if (logarea_init(size)) {

			syslog(LOG_ERR, "logarea init failed");

			return -1;

		}

		pid = fork();

		if (pid < 0) {

			syslog(LOG_ERR, "starting logger failed");

			exit(1);

		} else if (pid) {

			syslog(LOG_WARNING,

			       "iSCSI logger with pid=%d started!", pid);

			return pid;

		}

		daemon_init();

		/* flush on daemon's crash */

		sa_new.sa_handler = (void*)catch_signal;

		sigemptyset(&sa_new.sa_mask);

		sa_new.sa_flags = 0;

		sigaction(SIGSEGV, &sa_new, &sa_old );

		sigaction(SIGTERM, &sa_new, &sa_old );

		while(1) {

			log_flush();

			sleep(1);

			if (log_stop_daemon)

				break;

		}

		__log_close();

		exit(0);

	}

	return 0;

}

void log_close(pid_t pid)

{

	int status;

	if (log_func != log_do_log_daemon || pid < 0) {

		__log_close();

		return;

	}

	if (pid > 0) {

		kill(pid, SIGTERM);

		waitpid(pid, &status, 0);

	}

}