/*
 * 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));
}