/*
 * 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 (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "nscd_switch.h"
#include "nscd_log.h"

/*
 * nscd_nsw_state_t list for each nss database. Protected
 * by the readers/writer lock nscd_nsw_state_base_lock.
 */
nscd_nsw_state_base_t **nscd_nsw_state_base;
static rwlock_t nscd_nsw_state_base_lock = DEFAULTRWLOCK;

static void
_nscd_free_nsw_state(
        nscd_nsw_state_t        *s)
{

        int                     i;
        char                    *me = "_nscd_free_nsw_state";

        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
        (me, "freeing nsw state = %p\n", s);

        if (s == NULL)
                return;

        if (s->nsw_cfg_p != NULL)
                /*
                 * an nsw state without base does not reference
                 * count the nsw config data (ie not using a
                 * shared one), so the one created for it should
                 * be freed
                 */
                if ((*s->nsw_cfg_p)->nobase != 1)
                        _nscd_release((nscd_acc_data_t *)s->nsw_cfg_p);
                else
                        (void) _nscd_set((nscd_acc_data_t *)s->nsw_cfg_p, NULL);

        if (s->be_db_pp != NULL) {
                for (i = 0; i < s->max_src; i++) {
                        if (s->be_db_pp[i] == NULL)
                                continue;
                        _nscd_release((nscd_acc_data_t *)s->be_db_pp[i]);
                        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                        (me, "release db be ptr %p\n", s->be_db_pp[i]);
                }
                free(s->be_db_pp);
        }

        if (s->be != NULL) {
                for (i = 0; i < s->max_src; i++) {
                        if (s->be[i] == NULL)
                                continue;
                        if (s->getent == 1)
                                (void) NSS_INVOKE_DBOP(s->be[i],
                                    NSS_DBOP_ENDENT, 0);
                        (void) NSS_INVOKE_DBOP(s->be[i],
                            NSS_DBOP_DESTRUCTOR, 0);
                }
                free(s->be);
        }

        if (s->be_constr != NULL)
                free(s->be_constr);

        if (s->be_version_p != NULL)
                free(s->be_version_p);

        /* remove reference to the nsw state base */
        if (s->base != NULL) {
                _nscd_release((nscd_acc_data_t *)s->base);
                s->base = NULL;
        }

        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
        (me, "nsw state %p freed \n", s);

        free(s);
}

static void
_nscd_free_nsw_state_base(
        nscd_acc_data_t         *data)
{
        nscd_nsw_state_base_t   *base = (nscd_nsw_state_base_t *)data;
        nscd_nsw_state_t        *s, *ts;
        int                     i;
        char                    *me = "_nscd_free_nsw_state_base";

        _NSCD_LOG(NSCD_LOG_NSW_STATE | NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "freeing db state base %p\n", base);

        if (base == NULL)
                return;

        for (i = 0; i < 2; i++) {
                if (i == 1)
                        s = base->nsw_state.first;
                else
                        s = base->nsw_state_thr.first;

                while (s != NULL) {
                        ts = s->next;
                        _nscd_free_nsw_state(s);
                        s = ts;
                }
        }

        _NSCD_LOG(NSCD_LOG_NSW_STATE | NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "nsw state base %p freed \n", base);
}

void
_nscd_free_all_nsw_state_base()
{
        nscd_nsw_state_base_t   *base;
        int                     i;
        char                    *me = "_nscd_free_all_nsw_state_base";

        _NSCD_LOG(NSCD_LOG_NSW_STATE | NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "freeing all db state base\n");

        (void) rw_wrlock(&nscd_nsw_state_base_lock);
        for (i = 0; i < NSCD_NUM_DB; i++) {

                base = nscd_nsw_state_base[i];
                _NSCD_LOG(NSCD_LOG_NSW_STATE | NSCD_LOG_CONFIG,
                    NSCD_LOG_LEVEL_DEBUG)
                (me, "freeing db state base (%d) %p \n", i, base);

                if (base == NULL)
                        continue;

                nscd_nsw_state_base[i] = (nscd_nsw_state_base_t *)
                    _nscd_set((nscd_acc_data_t *)base, NULL);
        }
        (void) rw_unlock(&nscd_nsw_state_base_lock);
}

static nscd_nsw_state_t *
_nscd_create_nsw_state(
        nscd_nsw_params_t       *params)
{
        nscd_nsw_state_t        *s;
        nscd_nsw_config_t       *nsw_cfg;
        nscd_db_t               **be_db_p, *be_db;
        int                     i, nobe = 1;
        char                    *me = "_nscd_create_nsw_state";


        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
        (me, "creating nsw state...\n");

        s = calloc(1, sizeof (nscd_nsw_state_t));
        if (s == NULL) {
                if ((*s->nsw_cfg_p)->nobase  != 1)
                        _nscd_release((nscd_acc_data_t *)params->nswcfg);
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_ERROR)
                (me, "not able to allocate a nsw state\n");
                return (NULL);
        } else
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "nsw state %p allocated\n", s);

        s->dbi = params->dbi;
        s->next = NULL;

        nsw_cfg = *params->nswcfg;

        s->nsw_cfg_p = params->nswcfg;
        s->config = nsw_cfg->nsw_config;
        s->max_src = nsw_cfg->max_src;
        s->p = params->p;

        s->be = calloc(s->max_src, sizeof (nss_backend_t **));
        if (s->be == NULL) {
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_ERROR)
                (me, "not able to allocate s->be\n");

                _nscd_free_nsw_state(s);
                return (NULL);
        } else {
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "db be array %p allocated\n", s->be);
        }

        s->be_constr = (nss_backend_constr_t *)calloc(s->max_src,
            sizeof (nss_backend_constr_t));
        if (s->be_constr == NULL) {
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_ERROR)
                (me, "not able to allocate s->be_constr\n");

                _nscd_free_nsw_state(s);
                return (NULL);
        } else {
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "db be constructor array %p allocated\n", s->be_constr);
        }

        s->be_version_p = (void **)calloc(s->max_src, sizeof (void *));
        if (s->be_version_p == NULL) {
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_ERROR)
                (me, "not able to allocate s->be_version_p\n");

                _nscd_free_nsw_state(s);
                return (NULL);
        } else {
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "db be version ptr array %p allocated\n", s->be_version_p);
        }

        s->be_db_pp = calloc(s->max_src, sizeof (nscd_db_t ***));
        if (s->be_db_pp == NULL) {
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_ERROR)
                (me, "not able to allocate s->be_db_pp\n");
                _nscd_free_nsw_state(s);
                return (NULL);
        } else {
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "be_db_pp array %p allocated\n", s->be_db_pp);
        }

        /* create the source:database backends */
        for (i = 0;  i < s->max_src;  i++) {
                nss_backend_t           *be;
                int                     srci;
                char                    *srcn;
                const char              *dbn;
                struct __nsw_lookup_v1  *lkp;
                const nscd_db_entry_t   *dbe;
                nscd_be_info_t          *be_info;

                if (i == 0)
                        lkp = s->config->lookups;
                else
                        lkp = lkp->next;
                if (lkp == NULL) {
                        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_ERROR)
                        (me, "error: lkp is NULL\n");
                        _nscd_free_nsw_state(s);
                        return (NULL);
                }

                srci = nsw_cfg->src_idx[i];
                srcn = lkp->service_name;
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "source name = %s, index = %d\n", srcn, srci);

                be_db_p = (nscd_db_t **)_nscd_get(
                    (nscd_acc_data_t *)nscd_src_backend_db[srci]);
                if (be_db_p == NULL) {
                        _nscd_free_nsw_state(s);
                        return (NULL);
                }
                be_db = *be_db_p;
                s->be_db_pp[i] = be_db_p;
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "be db ptr array %p referenced\n", be_db_p);

                be_info = NULL;
                be = NULL;
                dbn = params->p.name;
                dbe = _nscd_get_db_entry(be_db, NSCD_DATA_BACKEND_INFO,
                    (const char *)dbn, NSCD_GET_FIRST_DB_ENTRY, 0);
                if (dbe != NULL)
                        be_info = (nscd_be_info_t *)*(dbe->data_array);

                if (be_info == NULL || be_info->be_constr == NULL) {
                        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                        (me, "no backend info or be_constr is NULL "
                            "for <%s : %s>\n", NSCD_NSW_SRC_NAME(srci),
                            dbn);
                } else {
                        s->be_constr[i] = be_info->be_constr;
                        be = (be_info->be_constr)(dbn,
                            NSCD_NSW_SRC_NAME(srci), 0);
                        if (be == NULL)
                                s->recheck_be = nscd_true;
                }

                if (be == NULL) {
                        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_ERROR)
                        (me, "not able to init be for <%s : %s>\n",
                            NSCD_NSW_SRC_NAME(srci), dbn);

                        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                        (me, "releasing db be ptr %p\n", be_db_p);

                        _nscd_release((nscd_acc_data_t *)be_db_p);
                        s->be_db_pp[i] = NULL;

                        continue;
                }

                s->be[i] = be;
                s->be_version_p[i] = be_info->be_version;
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "backend version is %p\n", be_info->be_version);
                nobe = 0;
        }

        if (nobe == 1) {
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "NO backend found, returning NULL\n");

                _nscd_free_nsw_state(s);
                return (NULL);
        }

        return (s);
}

/*
 * Try to initialize the backend instances one more time
 * in case the dependencies the backend libraries depend
 * on are now available
 */
static void
check_be_array(
        nscd_nsw_state_t        *s)
{
        int                     i;
        char                    *dbn;
        char                    *srcn;
        struct __nsw_lookup_v1  *lkp;

        dbn = NSCD_NSW_DB_NAME(s->dbi);

        s->recheck_be = nscd_false;
        for (i = 0;  i < s->max_src;  i++) {

                if (i == 0)
                        lkp = s->config->lookups;
                else
                        lkp = lkp->next;
                if (lkp == NULL)
                        return;

                srcn = lkp->service_name;

                /*
                 * it is possible that 's->be[i]' could not be
                 * initialized earlier due to a dependency not
                 * yet available (e.g., nis on domain name),
                 * try to initialize one more time
                 */
                if (s->be[i] == NULL && s->be_constr[i] != NULL) {
                        s->be[i] = (s->be_constr[i])(dbn, srcn, 0);
                        if (s->be[i] == NULL)
                                s->recheck_be = nscd_true;
                }
        }
}

static nscd_rc_t
_get_nsw_state_int(
        nss_db_root_t           *rootp,
        nscd_nsw_params_t       *params,
        thread_t                *tid)
{

        nscd_nsw_state_t        *ret = NULL;
        nscd_nsw_config_t       **nswcfg;
        nscd_nsw_state_base_t   *base;
        nscd_state_ctrl_t       *ctrl_p;
        int                     thread_only = 0, wait_cond = 0;
        char                    *me = "_get_nsw_state_int";
        int                     dbi;
        nscd_rc_t               rc;

        dbi = params->dbi;

        /*
         * no nsw state will be reused, if asked to use
         * default config. So create the new structures
         * used by the switch engine and the new nsw state
         */
        if (params->p.flags & NSS_USE_DEFAULT_CONFIG) {
                rc = _nscd_create_sw_struct(dbi, -1, (char *)params->p.name,
                    (char *)params->p.default_config, NULL, params);
                if (rc != NSCD_SUCCESS)
                        return (rc);

                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "no base nsw config created for %s (sources: %s)\n",
                    params->p.name, params->p.default_config);

                ret = _nscd_create_nsw_state(params);
                if (ret == NULL)
                        return (NSCD_CREATE_NSW_STATE_FAILED);
                rootp->s = (struct nss_db_state *)ret;
                return (NSCD_SUCCESS);
        }

        /*
         * if getting a nsw state for a request from the compat
         * backend, create the new switch structures if this
         * is the first time around for a passwd, shadow, group,
         * or user_attr database
         */
        if (params->compati != -1) {

                nscd_nsw_config_t       **nswcfg1, **nswcfg2;
                int                     i = params->compati;

                dbi = i;

                /*
                 * retrieve the pointer space which contains a
                 * pointer pointing to the nsswitch config
                 * structure for the compat backend
                 */
                nswcfg = (nscd_nsw_config_t **)_nscd_get(
                    (nscd_acc_data_t *)nscd_nsw_config[i]);

                /*
                 * If nsswitch config structure not created yet,
                 * get the config string from the passwd_compat
                 * or group_compat DB and create the structure.
                 */
                if (*nswcfg == NULL) {
                        /* Wait first if it's being created. */
                        nswcfg2 = (nscd_nsw_config_t **)_nscd_mutex_lock(
                            (nscd_acc_data_t *)nscd_nsw_config[i]);

                        /* still not created yet */
                        if (*nswcfg2 == NULL) {
                                /*
                                 * get the nsswitch config string specified
                                 * for passwd_compat or group_compat
                                 */
                                nswcfg1 = (nscd_nsw_config_t **)_nscd_get(
                                    (nscd_acc_data_t *)
                                    nscd_nsw_config[params->cfgdbi]);
                                if (nswcfg1 == NULL) {
                                        _NSCD_LOG(NSCD_LOG_NSW_STATE,
                                            NSCD_LOG_LEVEL_ERROR)
                                        (me, "no nsw config for %s\n",
                                            params->p.name);

                                        (void) _nscd_mutex_unlock(
                                            (nscd_acc_data_t *)nswcfg2);
                                        _nscd_release((nscd_acc_data_t *)
                                            nswcfg);

                                        return (NSCD_CREATE_NSW_STATE_FAILED);
                                }

                                rc = _nscd_create_sw_struct(i, params->cfgdbi,
                                    params->p.name, (*nswcfg1)->nsw_cfg_str,
                                    NULL, params);
                                _nscd_release((nscd_acc_data_t *)nswcfg1);

                                if (rc == NSCD_SUCCESS) {
                                        _NSCD_LOG(NSCD_LOG_NSW_STATE,
                                            NSCD_LOG_LEVEL_DEBUG)
                                        (me, "nsw config created for %s (%s)\n",
                                            params->p.name,
                                            (*nswcfg1)->nsw_cfg_str);
                                } else {
                                        (void) _nscd_mutex_unlock(
                                            (nscd_acc_data_t *)nswcfg2);
                                        _nscd_release((nscd_acc_data_t *)
                                            nswcfg);
                                        return (rc);
                                }
                        }
                        (void) _nscd_mutex_unlock((nscd_acc_data_t *)nswcfg2);
                }
                _nscd_release((nscd_acc_data_t *)nswcfg);
        }

        (void) rw_rdlock(&nscd_nsw_state_base_lock);
        base = nscd_nsw_state_base[dbi];
        (void) rw_unlock(&nscd_nsw_state_base_lock);
        if (base == NULL)
                assert(base != NULL);

        /*
         * If list is not empty, return the first one on list.
         * Otherwise, create and return a new db state if the
         * limit is not reached. if reacehed, wait for the 'one
         * is available' signal.
         */
        assert(base == (nscd_nsw_state_base_t *)_nscd_mutex_lock(
            (nscd_acc_data_t *)base));

        if (tid == NULL) {
                ctrl_p = &base->nsw_state;
        } else {
                thread_only = 1;
                ctrl_p = &base->nsw_state_thr;

                _NSCD_LOG_IF(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG) {
                        _nscd_logit(me, "per thread nsw state info: \n");
                        _nscd_logit(me, "tid = %d\n", *tid);
                        _nscd_logit(me, "tid in base = %d\n", base->tid);
                        _nscd_logit(me, "number of free nsw_state = %d\n",
                            ctrl_p->free);
                        _nscd_logit(me, "number of nsw state allocated = %d\n",
                            ctrl_p->allocated);
                        _nscd_logit(me, "first nsw state on list = %p\n",
                            ctrl_p->first);
                        _nscd_logit(me, "number of waiter = %d\n",
                            ctrl_p->waiter);

                }
        }

        if (ctrl_p->first == NULL && ctrl_p->allocated == ctrl_p->max)
                wait_cond = 1;
        else if (thread_only && base->used_by_thr && base->tid != *tid)
                wait_cond = 1;

        if (wait_cond) {

                ctrl_p->waiter++;

                while (wait_cond) {
                        if (!thread_only)
                                _NSCD_LOG(NSCD_LOG_NSW_STATE,
                                    NSCD_LOG_LEVEL_DEBUG)
                                (me, "waiting for nsw state signal\n");
                        else
                                _NSCD_LOG(NSCD_LOG_NSW_STATE,
                                    NSCD_LOG_LEVEL_DEBUG)
                                (me, "waiting for per thread "
                                    "nsw state signal\n");

                        if (thread_only) {
                                _nscd_cond_wait((nscd_acc_data_t *)base,
                                    &base->thr_cond);

                                if (base->used_by_thr == 0 &&
                                    ctrl_p->first != NULL)
                                        wait_cond = 0;
                        } else {
                                _nscd_cond_wait((nscd_acc_data_t *)base, NULL);

                                if (ctrl_p->first != NULL)
                                        wait_cond = 0;
                        }

                        if (!thread_only)
                                _NSCD_LOG(NSCD_LOG_NSW_STATE,
                                    NSCD_LOG_LEVEL_DEBUG)
                                (me, "woke from cond wait ...wait_cond = %d\n",
                                    wait_cond);
                        else

                                _NSCD_LOG(NSCD_LOG_NSW_STATE,
                                    NSCD_LOG_LEVEL_DEBUG)
                                (me, "woke from cond wait (per thread) "
                                    "...wait_cond = %d\n", wait_cond);

                }

                ctrl_p->waiter--;
        }

        if (ctrl_p->first == NULL) {
                int     geti;

                /*
                 * for lookup calls from the compat backend
                 * uses the switch policy for passwd_compat
                 * or group_compat
                 */
                if (params->compati != -1)
                        geti = params->compati;
                else
                        geti = params->dbi;

                params->nswcfg = (nscd_nsw_config_t **)_nscd_get(
                    (nscd_acc_data_t *)nscd_nsw_config[geti]);
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "got a nsw config %p for index %d\n",
                    params->nswcfg, geti);

                ctrl_p->first = _nscd_create_nsw_state(params);
                if (ctrl_p->first != NULL) {
                        if (tid == NULL) {
                                _NSCD_LOG(NSCD_LOG_NSW_STATE,
                                    NSCD_LOG_LEVEL_DEBUG)
                                (me, "got a new nsw_state %p\n", ctrl_p->first);
                        } else {
                                _NSCD_LOG(NSCD_LOG_NSW_STATE,
                                    NSCD_LOG_LEVEL_DEBUG)
                                (me, "got a new per thread nsw_state %p\n",
                                    ctrl_p->first);
                        }
                        ctrl_p->allocated++;
                        ctrl_p->free++;
                } else {
                        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_ERROR)
                                (me, "error: unable to obtain a nsw state\n");
                        _nscd_mutex_unlock((nscd_acc_data_t *)base);
                        return (NSCD_CREATE_NSW_STATE_FAILED);
                }
        }

        ret = ctrl_p->first;
        if (ret->recheck_be == nscd_true)
                check_be_array(ret);
        ctrl_p->first = ret->next;
        ret->next = NULL;
        ctrl_p->free--;
        if (thread_only) {
                base->tid = *tid;
                base->used_by_thr = 1;

                _NSCD_LOG_IF(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG) {
                        _nscd_logit(me, "\t\t\tgot a per thread nsw "
                            "state %p: \n", ret);
                        _nscd_logit(me, "tid = %d\n", *tid);
                        _nscd_logit(me, "tid in base = %d\n", base->tid);
                        _nscd_logit(me, "number of free nsw_state = %d\n",
                            ctrl_p->free);
                        _nscd_logit(me, "number od nsw state allocated = %d\n",
                            ctrl_p->allocated);
                        _nscd_logit(me, "first nsw state on list = %p\n",
                            ctrl_p->first);
                        _nscd_logit(me, "number of waiter = %d\n",
                            ctrl_p->waiter);
                }
        }
        else
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "got old nsw state %p\n", ret);

        /*
         * reference count the nsswitch state base bfore handing out
         * the nsswitch state
         */
        ret->base = (nscd_nsw_state_base_t *)
            _nscd_get((nscd_acc_data_t *)base);

        _nscd_mutex_unlock((nscd_acc_data_t *)base);

        rootp->s = (struct nss_db_state *)ret;

        return (NSCD_SUCCESS);
}

nscd_rc_t
_nscd_get_nsw_state(
        nss_db_root_t           *rootp,
        nscd_nsw_params_t       *params)
{
        return (_get_nsw_state_int(rootp, params, NULL));
}

nscd_rc_t
_nscd_get_nsw_state_thread(
        nss_db_root_t           *rootp,
        nscd_nsw_params_t       *params)
{
        thread_t        tid = thr_self();
        return (_get_nsw_state_int(rootp, params, &tid));
}


static void
_put_nsw_state_int(
        nscd_nsw_state_t        *s,
        thread_t                *tid)
{

        nscd_nsw_state_base_t   *base;
        nscd_state_ctrl_t       *ctrl_p;
        int                     thread_only = 0;
        char                    *me = "_put_nsw_state_int";

        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
        (me, "put back a nsw state\n");

        if (s == NULL) {
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "nsw state is NULL, nothing to put back\n");
                return;
        }

        /*
         * no need to put back if the nsw state is not on any base
         * but need to free the resources used
         */
        if ((*s->nsw_cfg_p)->nobase  == 1) {
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "no base nsw state, freeing resources ...\n");

                _nscd_free_nsw_state(s);
                return;
        }

        if (tid != NULL)
                thread_only = 1;

        base = s->base;

        if (_nscd_mutex_lock((nscd_acc_data_t *)base) == NULL) {
                /* base has been freed or no longer valid, free the nsw state */
                _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
                (me, "nsw state base gone or no longer valid, freeing %p\n", s);
                _nscd_free_nsw_state(s);
                return;
        }

        if (thread_only)
                ctrl_p = &base->nsw_state_thr;
        else
                ctrl_p = &base->nsw_state;

        _NSCD_LOG_IF(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG) {
                _nscd_logit(me, "before returning the nsw state: \n");
                _nscd_logit(me, "tid = %d\n", (tid == NULL) ? -1 : *tid);
                _nscd_logit(me, "tid in base = %d\n", base->tid);
                _nscd_logit(me, "number of free nsw_state = %d\n",
                    ctrl_p->free);
                _nscd_logit(me, "number od nsw state allocated = %d\n",
                    ctrl_p->allocated);
                _nscd_logit(me, "first nsw state on list = %p\n",
                    ctrl_p->first);
                _nscd_logit(me, "number of waiter = %d\n", ctrl_p->waiter);
        }

        if (ctrl_p->first != NULL) {
                s->next = ctrl_p->first;
                ctrl_p->first = s;
        } else {
                ctrl_p->first = s;
                s->next = NULL;
        }
        ctrl_p->free++;

        /*
         * Remove reference to the nsswitch state base.
         */
        _nscd_release((nscd_acc_data_t *)base);
        s->base = NULL;

        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
        (me, "signaling waiter thread_only = %d..\n", thread_only);

        if (thread_only && ctrl_p->free == ctrl_p->allocated) {
                assert(ctrl_p->first != NULL);
                base->used_by_thr = 0;
                if (ctrl_p->waiter > 0) {
                        (void) cond_signal(&base->thr_cond);
                }
        }

        if (!thread_only && ctrl_p->waiter > 0) {

                _nscd_cond_signal((nscd_acc_data_t *)base);
        }

        _NSCD_LOG_IF(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG) {
                _nscd_logit(me, "after the nsw state is returned: \n");
                _nscd_logit(me, "tid = %d\n", (tid == NULL) ? -1 : *tid);
                _nscd_logit(me, "tid in base = %d\n", base->tid);
                _nscd_logit(me, "number of free nsw_state = %d\n",
                    ctrl_p->free);
                _nscd_logit(me, "number od nsw state allocated = %d\n",
                    ctrl_p->allocated);
                _nscd_logit(me, "first nsw state on list = %p\n",
                    ctrl_p->first);
                _nscd_logit(me, "tnumber of waiter = %d\n", ctrl_p->waiter);
        }

        _NSCD_LOG(NSCD_LOG_NSW_STATE, NSCD_LOG_LEVEL_DEBUG)
        (me, "done putting back nsw state %p, thread_only = %d\n",
            s, thread_only);

        _nscd_mutex_unlock((nscd_acc_data_t *)base);

}

void
_nscd_put_nsw_state(
        nscd_nsw_state_t        *s)
{
        _put_nsw_state_int(s, NULL);
}

void
_nscd_put_nsw_state_thread(
        nscd_nsw_state_t        *s)
{
        thread_t                tid = thr_self();
        _put_nsw_state_int(s, &tid);
}

nscd_rc_t
_nscd_init_nsw_state_base(
        int                     dbi,
        int                     compat_basei,
        int                     lock)
{
        int                     cfgdbi;
        nscd_nsw_state_base_t   *base = NULL;
        char                    *me = "_nscd_init_nsw_state_base";

        if (lock)
                (void) rw_rdlock(&nscd_nsw_state_base_lock);

        base = (nscd_nsw_state_base_t *)_nscd_alloc(
            NSCD_DATA_NSW_STATE_BASE,
            sizeof (nscd_nsw_state_base_t),
            _nscd_free_nsw_state_base,
            NSCD_ALLOC_MUTEX | NSCD_ALLOC_COND);

        if (base == NULL) {
                _NSCD_LOG(NSCD_LOG_NSW_STATE | NSCD_LOG_CONFIG,
                    NSCD_LOG_LEVEL_ERROR)
                (me, "not able to allocate a nsw state base\n");
                if (lock)
                        (void) rw_unlock(&nscd_nsw_state_base_lock);
                return (NSCD_NO_MEMORY);
        }
        _NSCD_LOG(NSCD_LOG_NSW_STATE | NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
                (me, "nsw state base %p allocated\n", base);

        /*
         * initialize and activate the new nss_nsw_state base
         */
        base->dbi = dbi;
        if (compat_basei != -1)
                cfgdbi = compat_basei;
        else
                cfgdbi = dbi;

        base->nsw_state.max = NSCD_SW_CFG(cfgdbi).max_nsw_state_per_db;
        base->nsw_state_thr.max = NSCD_SW_CFG(cfgdbi).max_nsw_state_per_thread;

        nscd_nsw_state_base[dbi] = (nscd_nsw_state_base_t *)_nscd_set(
            (nscd_acc_data_t *)nscd_nsw_state_base[dbi],
            (nscd_acc_data_t *)base);

        if (lock)
                (void) rw_unlock(&nscd_nsw_state_base_lock);

        return (NSCD_SUCCESS);
}

nscd_rc_t
_nscd_init_all_nsw_state_base()
{
        int                     i;
        nscd_rc_t               rc;
        char                    *me = "_nscd_init_all_nsw_state_base";

        (void) rw_rdlock(&nscd_nsw_state_base_lock);

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

                rc = _nscd_init_nsw_state_base(i, -1, 0);

                if (rc != NSCD_SUCCESS) {
                        _NSCD_LOG(NSCD_LOG_NSW_STATE | NSCD_LOG_CONFIG,
                            NSCD_LOG_LEVEL_ERROR)
                        (me, "not able to initialize a nsw db state "
                            "base (%d)\n", i);

                        (void) rw_unlock(&nscd_nsw_state_base_lock);
                        return (rc);
                }
        }
        _NSCD_LOG(NSCD_LOG_NSW_STATE | NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "all nsw state base initialized\n");

        (void) rw_unlock(&nscd_nsw_state_base_lock);

        return (NSCD_SUCCESS);
}

nscd_rc_t
_nscd_alloc_nsw_state_base()
{

        (void) rw_rdlock(&nscd_nsw_state_base_lock);

        nscd_nsw_state_base = calloc(NSCD_NUM_DB,
            sizeof (nscd_nsw_state_base_t *));
        if (nscd_nsw_state_base == NULL) {
                (void) rw_unlock(&nscd_nsw_state_base_lock);
                return (NSCD_NO_MEMORY);
        }

        (void) rw_rdlock(&nscd_nsw_state_base_lock);

        return (NSCD_SUCCESS);
}