/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdlib.h>
#include <locale.h>
#include <limits.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/varargs.h>
#include <synch.h>
#include <thread.h>
#include <string.h>
#include <unistd.h>
#include "nscd_log.h"
#include "nscd_config.h"
#include "nscd_switch.h"
#include "cache.h"

/*
 * old nscd debug levels
 */
#define	DBG_OFF		0
#define	DBG_CANT_FIND	2
#define	DBG_NETLOOKUPS	4
#define	DBG_ALL		6

/* max. chars in a nscd log entry */
#define	LOGBUFLEN	1024

/* configuration for the nscd log component */
int		_nscd_log_comp = 0x0;
int		_nscd_log_level = 0x0;
static char	_nscd_logfile[PATH_MAX] = { 0 };

#define	NSCD_DEBUG_NONE		'0'
#define	NSCD_DEBUG_OPEN		'1'
#define	NSCD_DEBUG_CLOSE	'2'

static char	_nscd_debug = NSCD_DEBUG_NONE;
static char	_nscd_logfile_d[PATH_MAX] = { 0 };
static char	_nscd_logfile_s[PATH_MAX] = { 0 };

/* statistics data */
static nscd_cfg_stat_global_log_t logstats = {
	NSCD_CFG_STAT_GROUP_INFO_GLOBAL_LOG, 0 };

/* if no log file specified, log entry goes to stderr */
int _logfd = 2;


/* close old log file and open a new one */
static nscd_rc_t
_nscd_set_lf(
	char	*lf)
{
	int	newlogfd;
	char	*me = "_nscd_set_lf";

	/*
	 *  don't try and open the log file /dev/null
	 */
	if (lf == NULL || *lf == 0) {
		/* ignore empty log file specs */
		return (NSCD_SUCCESS);
	} else if (strcmp(lf, "/dev/null") == 0) {
		(void) strlcpy(_nscd_logfile, lf, PATH_MAX);
		if (_logfd >= 0)
			(void) close(_logfd);
		_logfd = -1;
		return (NSCD_SUCCESS);
	} else if (strcmp(lf, "stderr") == 0) {
		(void) strlcpy(_nscd_logfile, lf, PATH_MAX);
		if (_logfd != -1 && _logfd != 2)
			(void) close(_logfd);
		_logfd = 2;
		return (NSCD_SUCCESS);
	} else {

		/*
		 * In order to open this file securely, we'll try a few tricks
		 */

		if ((newlogfd = open(lf, O_EXCL|O_WRONLY|O_CREAT, 0644)) < 0) {
			/*
			 * File already exists... now we need to get cute
			 * since opening a file in a world-writeable directory
			 * safely is hard = it could be a hard link or a
			 * symbolic link to a system file.
			 */
			struct stat before;

			if (lstat(lf, &before) < 0) {
				if (_nscd_debug == NSCD_DEBUG_NONE)
					_nscd_logit(me, "Cannot open new "
					    "logfile \"%s\": %sn",
					    lf, strerror(errno));
				return (NSCD_CFG_FILE_OPEN_ERROR);
			}

			if (S_ISREG(before.st_mode) && /* no symbolic links */
			    (before.st_nlink == 1) && /* no hard links */
			    (before.st_uid == 0)) {   /* owned by root */
				if ((newlogfd =
				    open(lf, O_APPEND|O_WRONLY, 0644)) < 0) {
					if (_nscd_debug == NSCD_DEBUG_NONE)
						_nscd_logit(me,
						    "Cannot open new "\
						    "logfile \"%s\": %s\n", lf,
						    strerror(errno));
					return (NSCD_CFG_FILE_OPEN_ERROR);
				}
			} else {
				if (_nscd_debug == NSCD_DEBUG_NONE)
					_nscd_logit(me, "Cannot use specified "
					    "logfile \"%s\": "\
					    "file is/has links or isn't "
					    "owned by root\n", lf);
				return (NSCD_CFG_FILE_OPEN_ERROR);
			}
		}

		(void) close(_logfd);
		(void) strlcpy(_nscd_logfile, lf, PATH_MAX);
		_logfd = newlogfd;
		if (_nscd_debug == NSCD_DEBUG_NONE)
			_nscd_logit(me, "Start of new logfile %s\n", lf);
	}
	return (NSCD_SUCCESS);
}


/* log an entry to the configured nscd log file */
void
_nscd_logit(
	char		*funcname,
	char		*format,
	...)
{
	static mutex_t	loglock = DEFAULTMUTEX;
	struct timeval	tv;
	char		tid_buf[32];
	char		pid_buf[32];
	char		buffer[LOGBUFLEN];
	int		safechars, offset;
	va_list		ap;

	if (_logfd < 0)
		return;

	if (_nscd_debug == NSCD_DEBUG_OPEN) {
		(void) mutex_lock(&loglock);
		if (_nscd_debug == NSCD_DEBUG_OPEN &&
		    *_nscd_logfile_d != '\0' &&
		    (strcmp(_nscd_logfile, "/dev/null") == 0 ||
		    strcmp(_nscd_logfile, "stderr") == 0)) {
			(void) strlcpy(_nscd_logfile_s,
			    _nscd_logfile, PATH_MAX);
			(void) _nscd_set_lf(_nscd_logfile_d);
		}
		_nscd_debug = NSCD_DEBUG_NONE;
		(void) mutex_unlock(&loglock);
	} else if (_nscd_debug == NSCD_DEBUG_CLOSE) {
		(void) mutex_lock(&loglock);
		if (_nscd_debug == NSCD_DEBUG_CLOSE)
			(void) _nscd_set_lf(_nscd_logfile_s);
		_nscd_debug = NSCD_DEBUG_NONE;
		(void) mutex_unlock(&loglock);
	}

	va_start(ap, format);

	if (gettimeofday(&tv, NULL) != 0 ||
	    ctime_r(&tv.tv_sec, buffer, LOGBUFLEN) == NULL) {
		(void) snprintf(buffer, LOGBUFLEN,
		    "<time conversion failed>\t");
	} else {
		(void) sprintf(tid_buf, "--%d", thr_self());
		(void) sprintf(pid_buf, "--%ld", getpid());
		/*
		 * ctime_r() includes some stuff we don't want;
		 * adjust length to overwrite " YYYY\n" and
		 * include tid string length.
		 */
		offset = strlen(buffer) - 6;
		safechars = LOGBUFLEN - (offset - 1);
		(void) snprintf(buffer + offset,
		    safechars, ".%.4ld%s%s\t%s:\n\t\t",
		    tv.tv_usec/100, tid_buf, pid_buf,
		    funcname);
	}
	offset = strlen(buffer);
	safechars = LOGBUFLEN - (offset - 1);
	/*LINTED: E_SEC_PRINTF_VAR_FMT*/
	if (vsnprintf(buffer + offset, safechars, format, ap) >
	    safechars) {
		(void) strncat(buffer, "...\n", LOGBUFLEN);
	}

	(void) mutex_lock(&loglock);
	(void) write(_logfd, buffer, strlen(buffer));
	logstats.entries_logged++;
	(void) mutex_unlock(&loglock);

	va_end(ap);
}

/*
 * Map old nscd debug level (0 -10) to log level:
 *      -- >= 6: DBG_ALL 		--> NSCD_LOG_LEVEL_ALL
 *      -- >= 4: DBG_DBG_NETLOOKUPS 	--> NSCD_LOG_LEVEL_CANT_FIND
 *      -- >= 2: DBG_CANT_FIND 		--> NSCD_LOG_LEVEL_CANT_FIND
 *      -- >= 0: DBG_OFF 		--> NSCD_LOG_LEVEL_NONE
 */
static int
debug_to_log_level(
	int	level)
{
	if (level >= 0 && level <= 10) {
		if (level >= DBG_ALL)
			return (NSCD_LOG_LEVEL_ALL);
		else if (level >= DBG_NETLOOKUPS)
			return (NSCD_LOG_LEVEL_CANT_FIND);
		else if (level >= DBG_CANT_FIND)
			return (NSCD_LOG_LEVEL_CANT_FIND);
		else if (level >= DBG_OFF)
			return (NSCD_LOG_LEVEL_NONE);
	}
	return (level);
}

/* ARGSUSED */
nscd_rc_t
_nscd_cfg_log_notify(
	void				*data,
	struct nscd_cfg_param_desc	*pdesc,
	nscd_cfg_id_t			*nswdb,
	nscd_cfg_flag_t			dflag,
	nscd_cfg_error_t		**errorp,
	void				*cookie)
{

	nscd_cfg_global_log_t		*logcfg;
	int				off;

	/*
	 * At init time, the whole group of config params are received.
	 * At update time, group or individual parameter value could
	 * be received.
	 */

	if (_nscd_cfg_flag_is_set(dflag, NSCD_CFG_DFLAG_GROUP)) {

		logcfg = (nscd_cfg_global_log_t *)data;

		_nscd_log_comp = logcfg->debug_comp;
		_nscd_log_level = logcfg->debug_level;

		/*
		 * logcfg->logfile should have been opened
		 * by _nscd_cfg_log_verify()
		 */

		return (NSCD_SUCCESS);
	}

	/*
	 * individual config parameter
	 */
	off = offsetof(nscd_cfg_global_log_t, debug_comp);
	if (pdesc->p_offset == off) {
		_nscd_log_comp = *(nscd_cfg_bitmap_t *)data;
		return (NSCD_SUCCESS);
	}

	off = offsetof(nscd_cfg_global_log_t, debug_level);
	if (pdesc->p_offset == off)
		_nscd_log_level = *(nscd_cfg_bitmap_t *)data;

	/*
	 * logcfg->logfile should have been opened
	 * by _nscd_cfg_log_verify()
	 */

	return (NSCD_SUCCESS);
}

/* ARGSUSED */
nscd_rc_t
_nscd_cfg_log_verify(
	void				*data,
	struct	nscd_cfg_param_desc	*pdesc,
	nscd_cfg_id_t			*nswdb,
	nscd_cfg_flag_t			dflag,
	nscd_cfg_error_t		**errorp,
	void				**cookie)
{
	nscd_cfg_global_log_t		*logcfg;
	nscd_cfg_bitmap_t		bt;
	int				off;

	/*
	 * There is no switch db specific config params
	 * for the nscd log component. It is a bug if
	 * the input param description is global.
	 */
	if (_nscd_cfg_flag_is_not_set(pdesc->pflag, NSCD_CFG_PFLAG_GLOBAL))
		return (NSCD_CFG_PARAM_DESC_ERROR);

	/*
	 * At init time, the whole group of config params are received.
	 * At update time, group or individual parameter value could
	 * be received.
	 */

	if (_nscd_cfg_flag_is_set(dflag, NSCD_CFG_DFLAG_GROUP)) {

		logcfg = (nscd_cfg_global_log_t *)data;

		if (_nscd_cfg_bitmap_valid(logcfg->debug_comp,
		    NSCD_LOG_ALL) == 0)
			return (NSCD_CFG_SYNTAX_ERROR);

		if (_nscd_cfg_bitmap_valid(logcfg->debug_level,
		    NSCD_LOG_LEVEL_ALL) == 0)
			return (NSCD_CFG_SYNTAX_ERROR);

		if (logcfg->logfile != NULL)
			return (_nscd_set_lf(logcfg->logfile));

		return (NSCD_SUCCESS);
	}

	/*
	 * individual config parameter
	 */

	off = offsetof(nscd_cfg_global_log_t, debug_comp);
	if (pdesc->p_offset == off) {

		bt = *(nscd_cfg_bitmap_t *)data;
		if (_nscd_cfg_bitmap_valid(bt, NSCD_LOG_ALL) == 0)
			return (NSCD_CFG_SYNTAX_ERROR);

		return (NSCD_SUCCESS);
	}

	off = offsetof(nscd_cfg_global_log_t, debug_level);
	if (pdesc->p_offset == off) {

		bt = *(nscd_cfg_bitmap_t *)data;
		if (_nscd_cfg_bitmap_valid(bt, NSCD_LOG_LEVEL_ALL) == 0)
			return (NSCD_CFG_SYNTAX_ERROR);

		return (NSCD_SUCCESS);
	}

	off = offsetof(nscd_cfg_global_log_t, logfile);
	if (pdesc->p_offset == off) {
		if (data != NULL)
			return (_nscd_set_lf((char *)data));
		else
			return (NSCD_SUCCESS);
	}

	return (NSCD_CFG_PARAM_DESC_ERROR);
}

/* ARGSUSED */
nscd_rc_t
_nscd_cfg_log_get_stat(
	void				**stat,
	struct nscd_cfg_stat_desc	*sdesc,
	nscd_cfg_id_t			*nswdb,
	nscd_cfg_flag_t			*dflag,
	void				(**free_stat)(void *stat),
	nscd_cfg_error_t		**errorp)
{

	*(nscd_cfg_stat_global_log_t **)stat = &logstats;

	/* indicate the statistics are static, i.e., do not free */
	*dflag = _nscd_cfg_flag_set(*dflag, NSCD_CFG_DFLAG_STATIC_DATA);

	return (NSCD_SUCCESS);
}

/*
 * set the name of the current log file and make it current.
 */
nscd_rc_t
_nscd_set_log_file(
	char			*name)
{
	nscd_rc_t		rc;
	nscd_cfg_handle_t	*h;

	rc = _nscd_cfg_get_handle("logfile", NULL, &h, NULL);
	if (rc != NSCD_SUCCESS)
		return (rc);

	rc = _nscd_cfg_set(h, name, NULL);
	_nscd_cfg_free_handle(h);
	if (rc != NSCD_SUCCESS)
		exit(rc);

	return (NSCD_SUCCESS);
}

/* Set debug level to the new one and make it current */
nscd_rc_t
_nscd_set_debug_level(
	int			level)
{
	nscd_rc_t		rc;
	nscd_cfg_handle_t	*h;
	int			l = 0;
	int			c = -1;

	/* old nscd debug level is 1 to 10, map it to log_level and log_comp */
	if (level >= 0 && level <= 10) {
		l = debug_to_log_level(level);
		c = NSCD_LOG_CACHE;
	} else
		l = level;

	if (level < 0)
		c = -1 * level / 1000000;

	if (c != -1) {
		rc = _nscd_cfg_get_handle("debug-components", NULL, &h, NULL);
		if (rc != NSCD_SUCCESS)
			return (rc);

		rc = _nscd_cfg_set(h, &c, NULL);
		_nscd_cfg_free_handle(h);
		if (rc != NSCD_SUCCESS)
			exit(rc);
	}

	rc = _nscd_cfg_get_handle("debug-level", NULL, &h, NULL);
	if (rc != NSCD_SUCCESS)
		return (rc);

	if (level < 0)
		l = -1 * level % 1000000;

	rc = _nscd_cfg_set(h, &l, NULL);
	_nscd_cfg_free_handle(h);
	if (rc != NSCD_SUCCESS)
		exit(rc);

	return (NSCD_SUCCESS);
}

void
_nscd_get_log_info(
	char	*level,
	int	llen,
	char	*file,
	int	flen)
{
	if (_nscd_log_level != 0)
		(void) snprintf(level, llen, "%d", _nscd_log_level);
	if (*_nscd_logfile != '\0')
		(void) strlcpy(file, _nscd_logfile, flen);
}