/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2012 Milan Jurik. All rights reserved.
 */

#include <stdlib.h>
#include <locale.h>
#include <string.h>
#include "cache.h"
#include "nscd_door.h"
#include "nscd_log.h"
#include "nscd_admin.h"

extern nsc_ctx_t	*cache_ctx_p[];
extern char 		*cache_name[];

static nscd_admin_t	admin_c = { 0 };
static nscd_admin_mod_t	admin_mod = { 0 };
static mutex_t		mod_lock = DEFAULTMUTEX;

/*ARGSUSED*/
int
_nscd_door_getadmin(void *outbuf)
{
	int			i;
	int			data_size = NSCD_N2N_DOOR_BUF_SIZE(admin_c);
	nss_pheader_t		*phdr = (nss_pheader_t *)outbuf;
	nscd_cfg_cache_t	cfg_default = NSCD_CFG_CACHE_DEFAULTS;

	/*
	 * if size of buffer is not big enough, tell the caller to
	 * increase it to the size returned
	 */
	if (phdr->pbufsiz < data_size)
		return (sizeof (admin_c));

	NSCD_SET_STATUS_SUCCESS(phdr);
	phdr->data_off = sizeof (nss_pheader_t);
	phdr->data_len = sizeof (admin_c);

	for (i = 0; i < CACHE_CTX_COUNT; i++) {
		if (cache_ctx_p[i] != NULL) {
			(void) rw_rdlock(&cache_ctx_p[i]->cfg_rwlp);
			admin_c.cache_cfg[i] = cache_ctx_p[i]->cfg;
			(void) rw_unlock(&cache_ctx_p[i]->cfg_rwlp);

			(void) mutex_lock(&cache_ctx_p[i]->stats_mutex);
			admin_c.cache_stats[i] = cache_ctx_p[i]->stats;
			(void) mutex_unlock(&cache_ctx_p[i]->stats_mutex);
		} else {
			admin_c.cache_cfg[i] = cfg_default;
			(void) memset(&admin_c.cache_stats[i], 0,
			    sizeof (admin_c.cache_stats[0]));
		}
	}
	(void) memcpy(((char *)outbuf) + phdr->data_off,
	    &admin_c, sizeof (admin_c));

	return (0);
}

void
_nscd_client_showstats()
{
	(void) printf("nscd configuration:\n\n");
	(void) printf("%10d  server debug level\n", admin_c.debug_level);
	(void) printf("\"%s\"  is server log file\n", admin_c.logfile);

	(void) nsc_info(NULL, NULL, admin_c.cache_cfg, admin_c.cache_stats);
}

/*ARGSUSED*/
nscd_rc_t
_nscd_server_setadmin(nscd_admin_mod_t *set)
{
	nscd_rc_t		rc = NSCD_ADMIN_FAIL_TO_SET;
	nscd_cfg_handle_t	*h;
	int			i, j;
	char			*group = "param-group-cache";
	char			*dbname;
	nscd_cfg_error_t	*err = NULL;
	char			*me = "_nscd_server_setadmin";

	if (set == NULL)
		set = &admin_mod;

	/* one setadmin at a time */
	(void) mutex_lock(&mod_lock);

	_NSCD_LOG_IF(NSCD_LOG_ADMIN, NSCD_LOG_LEVEL_DEBUG) {

		_nscd_logit(me, "total_size = %d\n", set->total_size);

		_nscd_logit(me, "debug_level_set = %d, debug_level = %d\n",
		    set->debug_level_set, set->debug_level);

		_nscd_logit(me, "logfile_set = %d, logfile = %s\n",
		    set->logfile_set, *set->logfile == '\0' ?
		    "" : set->logfile);

		_nscd_logit(me, "cache_cfg_num = %d\n",
		    set->cache_cfg_num);
		_nscd_logit(me, "cache_flush_num = %d\n",
		    set->cache_flush_num);
	}

	/*
	 *  global admin stuff
	 */

	if (set->debug_level_set == nscd_true) {
		if (_nscd_set_debug_level(set->debug_level)
		    != NSCD_SUCCESS) {

			_NSCD_LOG(NSCD_LOG_ADMIN, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to set debug level %d\n",
			    set->debug_level);

			goto err_exit;
		}
		admin_c.debug_level = set->debug_level;
	}

	if (set->logfile_set == nscd_true) {
		if (_nscd_set_log_file(set->logfile) != NSCD_SUCCESS) {

			_NSCD_LOG(NSCD_LOG_ADMIN, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to set log file %s\n", set->logfile);

			goto err_exit;
		}
		(void) strlcpy(admin_c.logfile, set->logfile,
		    NSCD_LOGFILE_LEN);
	}

	/*
	 *  For caches to be changed
	 */
	if (set->cache_cfg_num > CACHE_CTX_COUNT) {

		_NSCD_LOG(NSCD_LOG_ADMIN, NSCD_LOG_LEVEL_ERROR)
		(me, "number of caches (%d) to change out of bound %s\n",
		    set->cache_cfg_num);

		goto err_exit;
	}

	for (i = 0; i < set->cache_cfg_num; i++) {

		nscd_cfg_cache_t *new_cfg;

		j = set->cache_cfg_set[i];
		new_cfg = &set->cache_cfg[i];
		dbname = cache_name[j];
		if (cache_ctx_p[j] == NULL) {
			_NSCD_LOG(NSCD_LOG_ADMIN, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to find cache context for %s\n",
			    dbname);
		}

		rc = _nscd_cfg_get_handle(group, dbname, &h, NULL);
		if (rc != NSCD_SUCCESS) {
			_NSCD_LOG(NSCD_LOG_ADMIN, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to get handle for < %s : %s >\n",
			    dbname, group);

			goto err_exit;
		}

		rc = _nscd_cfg_set(h, new_cfg, &err);
		if (rc != NSCD_SUCCESS) {
			_NSCD_LOG(NSCD_LOG_ADMIN, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to set admin data for < %s : %s >\n",
			    dbname, group);

			_nscd_cfg_free_handle(h);

			goto err_exit;
		}
		_nscd_cfg_free_handle(h);
	}

	/*
	 *  For caches to be flushed
	 */
	if (set->cache_flush_num > CACHE_CTX_COUNT) {

		_NSCD_LOG(NSCD_LOG_ADMIN, NSCD_LOG_LEVEL_ERROR)
		(me, "number of caches (%d) to flush out of bound %s\n",
		    set->cache_flush_num);

		goto err_exit;
	}

	for (i = 0; i < set->cache_flush_num; i++) {
		int j;

		j = set->cache_flush_set[i];

		if (cache_ctx_p[j] == NULL) {
			_NSCD_LOG(NSCD_LOG_ADMIN, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to find cache context for %s\n",
			    dbname);
		}
		nsc_invalidate(cache_ctx_p[j], NULL, NULL);
	}

	rc = NSCD_SUCCESS;
	err_exit:

	(void) mutex_unlock(&mod_lock);
	return (rc);
}


/*ARGSUSED*/
void
_nscd_door_setadmin(void *buf)
{
	nscd_rc_t	rc;
	nss_pheader_t	*phdr = (nss_pheader_t *)buf;
	char		*me = "_nscd_door_setadmin";

	rc = _nscd_server_setadmin(NSCD_N2N_DOOR_DATA(nscd_admin_mod_t, buf));
	if (rc != NSCD_SUCCESS) {
		_NSCD_LOG(NSCD_LOG_ADMIN, NSCD_LOG_LEVEL_ERROR)
		(me, "SETADMIN call failed\n");

		NSCD_SET_N2N_STATUS(phdr, NSS_NSCD_PRIV, 0, rc);
	} else {
		NSCD_SET_STATUS_SUCCESS(phdr);
	}
}

/*
 * for a database 'dbname', add config value 'val' of option 'opt'
 * to the global admin_mod structure
 */
int
_nscd_add_admin_mod(char *dbname, char opt,
	char *val, char *msg, int msglen) {
	int			i, j;
	nscd_cfg_cache_t	*cfg;
	nscd_cfg_group_info_t	gi = NSCD_CFG_GROUP_INFO_CACHE;
	char			dbn[64], *cp;

	/* set initial admin_mod size; assume no cache config to set */
	if (admin_mod.total_size == 0)
		admin_mod.total_size = sizeof (admin_mod) -
			sizeof (admin_mod.cache_cfg);

	/* global admin stuff */
	if (opt == 'l' || opt == 'd') {
		if (opt == 'l') {
			(void) strlcpy(admin_mod.logfile,
				val, NSCD_LOGFILE_LEN);
			admin_mod.logfile_set = nscd_true;
		} else {
			admin_mod.debug_level = atoi(val);
			admin_mod.debug_level_set = nscd_true;
		}
		return (0);
	}

	/* options to be processed next requires cache name */
	(void) strlcpy(dbn, dbname, sizeof (dbn));
	if ((cp = strchr(dbn, ',')) != NULL)
		*cp = '\0';
	i = get_cache_idx(dbn);
	if (i == -1) {
		(void) snprintf(msg, msglen,
			gettext("invalid cache name \"%s\""), dbn);
		return (-1);
	}

	/* flush cache ? */
	if (opt == 'i') {
		admin_mod.cache_flush_set[admin_mod.cache_flush_num++] = i;
		return (0);
	}

	/* options to be processed next requires a param value */
	if (val == NULL) {
		(void) snprintf(msg, msglen,
			gettext("value missing after \"%s\""), dbn);
		return (-1);
	}

	/* try to use an existing cache_cfg in admin_mod */
	for (j = 0; j < admin_mod.cache_cfg_num; j++) {
		if (admin_mod.cache_cfg_set[j] == i)
			break;
	}

	/* no existing one, set up another one */
	if (j == admin_mod.cache_cfg_num) {
		admin_mod.cache_cfg_set[j] = i;
		admin_mod.cache_cfg_num++;
		admin_mod.total_size += sizeof (admin_mod.cache_cfg[0]);
	}

	cfg = &admin_mod.cache_cfg[j];
	cfg->gi.num_param = gi.num_param;

	switch (opt) {

	case 'e':
		/* enable cache */

		_nscd_cfg_bitmap_set_nth(cfg->gi.bitmap, 0);
		if (strcmp(val, "yes") == 0)
		    cfg->enable = nscd_true;
		else if (strcmp(val, "no") == 0)
		    cfg->enable = nscd_false;
		else {
			(void) snprintf(msg, msglen,
	gettext("\"yes\" or \"no\" not specified after \"%s\""), dbn);
			return (-1);
		}
		break;

	case 'c':
		/* check files */

		_nscd_cfg_bitmap_set_nth(cfg->gi.bitmap, 3);
		if (strcmp(val, "yes") == 0)
		    cfg->check_files = nscd_true;
		else if (strcmp(val, "no") == 0)
		    cfg->check_files = nscd_false;
		else {
			(void) snprintf(msg, msglen,
	gettext("\"yes\" or \"no\" not specified after \"%s\""), dbn);
			return (-1);
		}
		break;

	case 'p':
		/* positive time to live */

		_nscd_cfg_bitmap_set_nth(cfg->gi.bitmap, 5);
		cfg->pos_ttl = atoi(val);
		break;

	case 'n':
		/* negative time to live */

		_nscd_cfg_bitmap_set_nth(cfg->gi.bitmap, 6);
		cfg->neg_ttl = atoi(val);
		break;

	case 'h':
		/* keep hot count */

		_nscd_cfg_bitmap_set_nth(cfg->gi.bitmap, 7);
		cfg->keephot = atoi(val);
		break;
	}

	return (0);
}

int
_nscd_client_getadmin(char opt)
{
	int		callnum;
	nss_pheader_t	phdr;

	if (opt == 'G')
		callnum = NSCD_GETPUADMIN;
	else
		callnum = NSCD_GETADMIN;

	(void) _nscd_doorcall_data(callnum, NULL, sizeof (admin_c),
	    &admin_c, sizeof (admin_c), &phdr);

	if (NSCD_STATUS_IS_NOT_OK(&phdr)) {
		return (1);
	}

	return (0);
}

int
_nscd_client_setadmin()
{
	return (_nscd_doorcall_data(NSCD_SETADMIN, &admin_mod,
	    sizeof (admin_mod), NULL, 0, NULL));
}