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

#include <nss_common.h>
#include <dlfcn.h>
#include <alloca.h>

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

/*
 * _nscd_nss_finders is used to replace the nss_default_finders in libc
 * to allow nscd to have more control over the dl handles when using
 * dlsym to get the address of the nss backend instance constructors
 */
static nss_backend_constr_t _nscd_per_src_lookup(void *,
        const char *, const char *, void **);
static void _nscd_per_src_delete(void *, nss_backend_constr_t);

static nss_backend_finder_t _nscd_per_src = {
        _nscd_per_src_lookup,
        _nscd_per_src_delete,
        0,
        0 };

nss_backend_finder_t *_nscd_nss_finders = &_nscd_per_src;

/*
 * nscd database for each source. It contains backend
 * info (nscd_be_info_t) for each naming database.
 * Protected by nscd_src_backend_db_lock.
 */
nscd_db_t       ***nscd_src_backend_db;
int             *nscd_src_backend_db_loaded;
static          rwlock_t nscd_src_backend_db_lock = DEFAULTRWLOCK;

/*
 * nsswitch config monitored by nscd. Protected by
 * readers/writer lock nscd_nsw_config_lock
 */
nscd_nsw_config_t ***nscd_nsw_config;
static rwlock_t nscd_nsw_config_lock = DEFAULTRWLOCK;

/*
 * nsswitch source index/name array
 * (allow 32 foreign nsswitch sources/backends)
 */
#define         NSCD_NUM_SRC_FOREIGN 32
nscd_cfg_id_t   *_nscd_cfg_nsw_src_all;
int             _nscd_cfg_num_nsw_src_all;

static void
free_nscd_nsw_config(
        nscd_acc_data_t         *data)
{

        nscd_nsw_config_t       *nsw_cfg = *(nscd_nsw_config_t **)data;
        char                    *me = "free_nscd_nsw_config";

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "freeing nscd nsw config %p \n", nsw_cfg);
        if (nsw_cfg == NULL)
                return;

        if (nsw_cfg->db_name != NULL)
                free(nsw_cfg->db_name);
        if (nsw_cfg->nsw_cfg_str != NULL)
                free(nsw_cfg->nsw_cfg_str);
        if (nsw_cfg->nsw_config != NULL)
                (void) __nsw_freeconfig_v1(nsw_cfg->nsw_config);
        if (nsw_cfg->src_idx != NULL)
                free(nsw_cfg->src_idx);

        free(nsw_cfg);
}


void
_nscd_free_nsw_config(
        nscd_nsw_config_t *nswcfg)
{
        free_nscd_nsw_config((nscd_acc_data_t *)&nswcfg);
}

void
_nscd_free_all_nsw_config()
{

        nscd_nsw_config_t       **nsw_cfg;
        int                     i;
        char                    *me = "_nscd_free_all_nsw_config";

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "freeing all nscd nsw config \n");

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

                if ((nsw_cfg = nscd_nsw_config[i]) == NULL)
                        continue;

                nscd_nsw_config[i] = (nscd_nsw_config_t **)_nscd_set(
                    (nscd_acc_data_t *)nsw_cfg, NULL);
        }
        (void) rw_unlock(&nscd_nsw_config_lock);
}


static void
free_nsw_backend_info_db(nscd_acc_data_t *data)
{

        nscd_db_t       *db = *(nscd_db_t **)data;
        char            *me = "free_nsw_backend_info_db";

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "freeing nsw backend info db %p\n", db);

        if (db == NULL)
                return;

        _nscd_free_db(db);

}

void
_nscd_free_all_nsw_backend_info_db()
{

        nscd_db_t       **db;
        int             i;
        char            *me = " _nscd_free_all_nsw_backend_info_db";

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "freeing all nsw backend info db\n");

        (void) rw_wrlock(&nscd_src_backend_db_lock);
        for (i = 0; i < NSCD_NUM_SRC; i++) {

                if ((db = nscd_src_backend_db[i]) == NULL)
                        continue;

                nscd_src_backend_db[i] = (nscd_db_t **)_nscd_set(
                    (nscd_acc_data_t *)db, NULL);
                nscd_src_backend_db_loaded[i] = 0;
        }
        (void) rw_unlock(&nscd_src_backend_db_lock);
}

/*
 * Populate the backend info db for the 'NSCD_NSW_SRC_NAME(srci)'
 * source.  Create one entry for each source/database pair
 * (e.g., ldap:passwd, nis:hosts, etc).
 */
static nscd_rc_t
_nscd_populate_nsw_backend_info_db(int srci)
{
        nscd_be_info_t          be_info, *bi;
        nss_backend_finder_t    *bf;
        nscd_nsw_config_t       *nsw_cfg;
        int                     i, size;
        nscd_db_entry_t         *db_entry;
        char                    *src = NSCD_NSW_SRC_NAME(srci);
        const char              *dbn;
        char                    *me = "_nscd_populate_nsw_backend_info_db";
        void                    *handle = NULL;
        nss_backend_constr_t    c;
        void                    *be_version = &_nscd_be_version;

        /* get the version number of the backend (if available) */
        if (srci >= _nscd_cfg_num_nsw_src) { /* a foreign backend */
                c = _nscd_per_src_lookup(handle, NULL, src, &handle);
                if (c == NULL)
                        be_version = NULL;
                else
                        be_version = (void *)c;

                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
                (me, "foreign backend: _nss_%s_version = %p ", src, be_version);
        }

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

                /* no nsswitch configuration, no backend info db population */
                if (nscd_nsw_config[i] == NULL || *nscd_nsw_config[i] == NULL)
                        continue;

                nsw_cfg = *nscd_nsw_config[i];
                dbn = NSCD_NSW_DB_NAME(i);
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
                (me, "adding backend info for <%s : %s>\n", src, dbn);

                (void) memset(&be_info, 0, sizeof (be_info));

                for (bf = nsw_cfg->fe_params.finders;  bf != 0; bf = bf->next) {

                        c = (*bf->lookup)(handle, dbn, src, &handle);

                        if (c != 0) {
                                be_info.be_constr = c;
                                be_info.finder = bf;
                                be_info.finder_priv = handle;
                                be_info.be_version = be_version;
                                break;
                        }
                }
                if (be_info.be_constr == NULL) {
                        /*
                         * Couldn't find the backend anywhere.
                         * This is fine, some backend just don't
                         * support certain databases.
                         */
                        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                        (me, "unable to find backend info "
                            "for <%s : %s>\n", src, dbn);
                }

                size = sizeof (nscd_be_info_t);

                db_entry = _nscd_alloc_db_entry(NSCD_DATA_BACKEND_INFO,
                    dbn, size, 1, 1);

                if (db_entry == NULL) {
                        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                        (me, "unable to allocate db entry for "
                            "<%s : %s>\n", src, dbn);
                        return (NSCD_NO_MEMORY);
                }

                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
                (me, "adding be db entry %p for <%s : %s> to db %p: "
                    "constr = %p\n", db_entry, src, dbn,
                    *nscd_src_backend_db[srci], be_info.be_constr);

                bi = (nscd_be_info_t *)*(db_entry->data_array);
                *bi = be_info;

                (void) _nscd_wrlock((nscd_acc_data_t *)
                    nscd_src_backend_db[srci]);
                nscd_src_backend_db_loaded[srci] = 1;
                (void) _nscd_add_db_entry(*nscd_src_backend_db[srci],
                    dbn, db_entry, NSCD_ADD_DB_ENTRY_LAST);
                (void) _nscd_rw_unlock((nscd_acc_data_t *)
                    nscd_src_backend_db[srci]);
        }

        return (NSCD_SUCCESS);
}

/*
 * create data structures (used by the switch engine) based
 * on the input switch policy configuration and database
 * name and indexes
 */
nscd_rc_t
_nscd_create_sw_struct(
        int                             dbi,
        int                             compat_basei,
        const char                      *dbn,
        const char                      *cfgstr,
        void                            *swcfgv1,
        nscd_nsw_params_t               *params)
{
        char                            *me = "_nscd_create_sw_struct";
        nscd_rc_t                       rc = NSCD_SUCCESS;
        nscd_nsw_config_t               *nsw_cfg = NULL;
        nscd_nsw_config_t               **nsw_cfg_p = NULL;
        struct __nsw_switchconfig_v1    *swcfg = NULL;
        struct __nsw_lookup_v1          *lkp;
        enum __nsw_parse_err            err;
        int                             maxsrc;
        int                             *src_idx_a = NULL;
        int                             j, k;

        /*
         * if the nsw config string has been parsed into
         * a struct __nsw_switchconfig_v1, use it. If not,
         * create the struct.
         */
        if (swcfgv1 != NULL)
                swcfg = (struct __nsw_switchconfig_v1 *)swcfgv1;
        else {
                char    *cstr;

                cstr = strdup(cfgstr);
                if (cstr == NULL)
                        return (NSCD_NO_MEMORY);

                /*
                 * parse the nsw config string and create
                 * a struct __nsw_switchconfig_v1
                 */
                swcfg = _nsw_getoneconfig_v1(dbn, cstr, &err);
                free(cstr);
                if (swcfg == NULL) {
                        rc = NSCD_CFG_SYNTAX_ERROR;
                        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                        (me, "error: unable to process nsw config string\n");
                        goto error_exit;
                }
        }

        /* allocate the space for a nscd_nsw_config_t */
        nsw_cfg = calloc(1, sizeof (nscd_nsw_config_t));
        if (nsw_cfg == NULL) {
                rc = NSCD_NO_MEMORY;
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                (me, "error: unable to allocate an nscd_nsw_config_t\n");
                goto error_exit;
        }

        /* need to know how many backends (sources) */
        maxsrc = swcfg->num_lookups;
        nsw_cfg->max_src = maxsrc;

        /*
         * allocate an array to store the index for each
         * backend (source)
         */
        src_idx_a = calloc(1, maxsrc * sizeof (int));
        if (src_idx_a == NULL) {
                rc = NSCD_NO_MEMORY;
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                (me, "error: unable to allocate an array for source index\n");
                goto error_exit;
        }

        /*
         * set the index for each backend (source)
         */
        lkp = swcfg->lookups;
        for (j = 0; j < maxsrc; j++) {
                char *usrc;

                for (k = 0; k < NSCD_NUM_SRC && NSCD_NSW_SRC_NAME(k) != NULL &&
                    strcmp(lkp->service_name, NSCD_NSW_SRC_NAME(k)) != 0;
                    k++) {
                        /* empty */
                }

                if (k < NSCD_NUM_SRC && nscd_src_backend_db_loaded[k] == 0) {
                        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
                        (me, "unknown nsw source name %s\n", lkp->service_name);
                        usrc = strdup(lkp->service_name);
                        if (usrc == NULL) {
                                rc = NSCD_NO_MEMORY;
                                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                                (me, "unable to strdup() source name\n");
                                goto error_exit;
                        }
                        NSCD_NSW_SRC_NAME(k) = usrc;

                        rc = _nscd_populate_nsw_backend_info_db(k);
                        if (rc != NSCD_SUCCESS) {
                                free(usrc);
                                NSCD_NSW_SRC_NAME(k) = NULL;
                                goto error_exit;
                        }
                } else if (NSCD_NSW_SRC_NAME(k) == NULL) {
                        /*
                         * number of user-defined source exceeded
                         */
                        rc = NSCD_CFG_SYNTAX_ERROR;
                        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                        (me, "error: number of user_defined source exceeded\n");

                        goto error_exit;
                }

                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
                (me, "setting source index array [%d] = %d (%s)\n",
                    j, k, lkp->service_name);

                src_idx_a[j] = k;

                lkp = lkp->next;
                if (lkp == NULL) break;

                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
                (me, "number of nsw sources = %d\n", nsw_cfg->max_src);
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
                (me, "next nsw source is %s\n", lkp->service_name);
        }

        /* set it up to reference count the switch policy config */
        nsw_cfg_p = (nscd_nsw_config_t **)_nscd_alloc(NSCD_DATA_NSW_CONFIG,
            sizeof (nscd_nsw_config_t **), free_nscd_nsw_config,
            NSCD_ALLOC_RWLOCK);

        if (nsw_cfg_p == NULL) {
                rc = NSCD_NO_MEMORY;
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                (me, "unable to allocate a new nsw config DB\n");
                goto error_exit;
        }
        *nsw_cfg_p = nsw_cfg;

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "new nsw config DB %p allocated\n", nsw_cfg_p);

        /* save all the data in the new nscd_nsw_config_t */
        nsw_cfg->db_name = strdup(dbn);
        nsw_cfg->nsw_cfg_str = strdup(cfgstr);
        if (nsw_cfg->db_name == NULL || nsw_cfg->nsw_cfg_str == NULL) {
                rc = NSCD_NO_MEMORY;
                goto error_exit;
        }

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "switch policy \"%s\" for database is \"%s\"\n",
            nsw_cfg->db_name, nsw_cfg->nsw_cfg_str);

        nsw_cfg->nsw_config = swcfg;
        nsw_cfg->src_idx = src_idx_a;

        /*
         * set default frontend params and if necessary call initf()
         * to initialize or override
         */
        nsw_cfg->fe_params.max_active_per_src = 10;
        nsw_cfg->fe_params.max_dormant_per_src = 1;
        nsw_cfg->fe_params.finders = _nscd_nss_finders;
        if (params != NULL) {
                nsw_cfg->fe_params = params->p;

                if (params->p.flags & NSS_USE_DEFAULT_CONFIG) {
                        params->nswcfg = nsw_cfg_p;
                        /*
                         * this nsw_cfg is not meant to last long, no need
                         * to set up the nsw state and getent bases, just
                         * exit with NSCD_SUCCESS
                         */
                        nsw_cfg->nobase = 1;
                        goto error_exit;
                }
        } else
                (void) (nscd_nss_db_initf[dbi])(&nsw_cfg->fe_params);

        /*
         * also create a new nsw state base
         */
        if ((rc = _nscd_init_nsw_state_base(dbi, compat_basei, 1)) !=
            NSCD_SUCCESS) {
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                (me, "unable to initialize a nsw state base(%d)\n", dbi);
                goto error_exit;
        }

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "new nsw state base(%d) %p created\n", dbi,
            nscd_nsw_state_base[dbi]);

        /*
         * also create a new getent context base
         */
        if ((rc = _nscd_init_getent_ctx_base(dbi, 1)) != NSCD_SUCCESS) {
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                (me, "unable to initialize a getent context base(%d)\n", dbi);
                goto error_exit;
        }

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "new getent context base(%d) %p created\n", dbi,
            nscd_getent_ctx_base[dbi]);

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "new nsw config created (database = %s, "
        "config = %s)\n", dbn, cfgstr);

        /*
         * Activate the new nscd_nsw_config_t and make it the
         * current nsswitch config. The old one pointed to by
         * nscd_nsw_config[dbi] will either be destroyed
         * immediately or left on the side line (and be
         * destroyed eventually). __nscd_set() will set the
         * associated flags to make it happen.
         */
        nscd_nsw_config[dbi] = (nscd_nsw_config_t **)_nscd_set(
            (nscd_acc_data_t *)nscd_nsw_config[dbi],
            (nscd_acc_data_t *)nsw_cfg_p);

        error_exit:

        if (rc != NSCD_SUCCESS) {

                if (swcfgv1 == NULL && swcfg != NULL)
                        (void) __nsw_freeconfig_v1(swcfg);
                if (src_idx_a != NULL)
                        free(src_idx_a);
                if (nsw_cfg_p)
                        free(nsw_cfg_p);
                if (nsw_cfg != NULL) {
                        if (nsw_cfg->db_name != NULL)
                                free(nsw_cfg->db_name);
                        if (nsw_cfg->nsw_cfg_str != NULL)
                                free(nsw_cfg->nsw_cfg_str);
                        free(nsw_cfg);
                }

                return (rc);
        } else
                return (NSCD_SUCCESS);
}

static nscd_rc_t
create_nsw_config(int dbi)
{

        nscd_nsw_config_t       *nsw_cfg = NULL;
        nscd_nsw_config_t       **nsw_cfg_p = NULL;
        char                    *me = "create_nsw_config";

        /*
         * Allocate a pointer space for saving a pointer to a
         * nscd_nsw_config_t. _nscd_alloc() will also create
         * a nscd_access_t header with a rwlock_t and mutex_t
         * for controlling later access to the data pointed
         * to by the pointer.
         */
        nsw_cfg_p = (nscd_nsw_config_t **)_nscd_alloc(NSCD_DATA_NSW_CONFIG,
            sizeof (nscd_nsw_config_t **), free_nscd_nsw_config,
            NSCD_ALLOC_RWLOCK | NSCD_ALLOC_MUTEX);

        if (nsw_cfg_p == NULL) {
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                (me, "unable to allocate a space for a nsw config pointer\n");
                return (NSCD_NO_MEMORY);
        }
        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
                (me, "addr for saving nsw config pointer = %p\n", nsw_cfg_p);

        /*
         * If pseudo-databases (initf function not defined),
         * no need to create a nscd_nsw_config_t yet,
         * so put a NULL pointer in the pointer space.
         */
        if (nscd_nss_db_initf[dbi] == NULL) {
                *nsw_cfg_p = NULL;
                nscd_nsw_config[dbi] = (nscd_nsw_config_t **)_nscd_set(
                    (nscd_acc_data_t *)nscd_nsw_config[dbi],
                    (nscd_acc_data_t *)nsw_cfg_p);

                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
                (me, "pointer to nsw config has been set to NULL\n");

                return (NSCD_SUCCESS);
        }

        /* allocate the space for a nscd_nsw_config_t */
        nsw_cfg = calloc(1, sizeof (nscd_nsw_config_t));
        if (nsw_cfg == NULL) {
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                (me, "unable to allocate a nsw config structure\n");
                return (NSCD_NO_MEMORY);
        }
        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "nsw config structure %pallocated\n", nsw_cfg);

        nsw_cfg->db_name = strdup(NSCD_NSW_DB_NAME(dbi));
        if (nsw_cfg->db_name == NULL) {
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                (me, "unable to strdup the db name\n");
                return (NSCD_NO_MEMORY);
        }

        /*
         * set default frontend params and then call initf()
         * to initialize or override
         */
        nsw_cfg->fe_params.max_active_per_src = 10;
        nsw_cfg->fe_params.max_dormant_per_src = 1;
        nsw_cfg->fe_params.finders = _nscd_nss_finders;
        (void) (nscd_nss_db_initf[dbi])(&nsw_cfg->fe_params);

        /*
         * activate the new nscd_nsw_config_t
         */
        *nsw_cfg_p = nsw_cfg;
        nscd_nsw_config[dbi] = (nscd_nsw_config_t **)_nscd_set(
            (nscd_acc_data_t *)nscd_nsw_config[dbi],
            (nscd_acc_data_t *)nsw_cfg_p);

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "nsw config %p activated\n", nsw_cfg);

        return (NSCD_SUCCESS);
}

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

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "initializing all nsw config\n");

        for (i = 0; i < NSCD_NUM_DB; i++) {
                if ((rc = create_nsw_config(i)) != NSCD_SUCCESS)
                        return (rc);
        }

        return (NSCD_SUCCESS);
}

static nscd_rc_t
init_nsw_be_info_db(int srci)
{
        nscd_db_t       *ret, **db_p;
        char            *me = "init_nsw_be_info_db";

        ret = _nscd_alloc_db(NSCD_DB_SIZE_SMALL);

        if (ret == NULL) {
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                (me, "unable to allocate a nsw be info database\n");
                return (NSCD_NO_MEMORY);
        }

        /* set up to reference count the backend info db */
        db_p = (nscd_db_t **)_nscd_alloc(NSCD_DATA_BACKEND_INFO_DB,
            sizeof (nscd_db_t **), free_nsw_backend_info_db,
            NSCD_ALLOC_RWLOCK);

        if (db_p == NULL) {
                _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
                (me, "unable to allocate the pointer to the nsw "
                "be info database\n");
                return (NSCD_NO_MEMORY);
        }

        *db_p = ret;
        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "backend database (db_p = %p, db = %p)\n", db_p, *db_p);

        nscd_src_backend_db[srci] = (nscd_db_t **)_nscd_set(
            (nscd_acc_data_t *)nscd_src_backend_db[srci],
            (nscd_acc_data_t *)db_p);

        return (NSCD_SUCCESS);
}

nscd_rc_t
_nscd_init_all_nsw_be_info_db(void)
{

        int             i;
        nscd_rc_t       rc;
        char            *me = "_nscd_init_all_nsw_be_info_db";

        _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
        (me, "initializing all nsw be info databases\n");

        for (i = 0; i < NSCD_NUM_SRC; i++) {
                if ((rc = init_nsw_be_info_db(i)) != NSCD_SUCCESS)
                        return (rc);
        }

        return (NSCD_SUCCESS);
}


nscd_rc_t
_nscd_alloc_nsw_config()
{
        nscd_nsw_config = calloc(NSCD_NUM_DB, sizeof (nscd_nsw_config_t **));
        if (nscd_nsw_config == NULL)
                return (NSCD_NO_MEMORY);

        return (NSCD_SUCCESS);
}

nscd_rc_t
_nscd_alloc_nsw_be_info_db()
{
        int     i;

        _nscd_cfg_num_nsw_src_all = _nscd_cfg_num_nsw_src +
            NSCD_NUM_SRC_FOREIGN;
        nscd_src_backend_db = calloc(NSCD_NUM_SRC, sizeof (nscd_db_t **));
        if (nscd_src_backend_db == NULL)
                return (NSCD_NO_MEMORY);
        nscd_src_backend_db_loaded = calloc(NSCD_NUM_SRC, sizeof (int));
        if (nscd_src_backend_db_loaded == NULL) {
                free(nscd_src_backend_db);
                return (NSCD_NO_MEMORY);
        }

        /* also allocate/init the nsswitch source index/name array */
        _nscd_cfg_nsw_src_all = (nscd_cfg_id_t *)calloc(
            _nscd_cfg_num_nsw_src_all + 1, sizeof (nscd_cfg_id_t));
        for (i = 0; i < _nscd_cfg_num_nsw_src_all + 1; i++)
                (_nscd_cfg_nsw_src_all + i)->index = -1;

        (void) memcpy(_nscd_cfg_nsw_src_all, _nscd_cfg_nsw_src,
            _nscd_cfg_num_nsw_src * sizeof (nscd_cfg_id_t));
        return (NSCD_SUCCESS);
}

nscd_rc_t
_nscd_populate_nsw_backend_info()
{
        int             i;
        nscd_rc_t       rc;

        for (i = 0; i < NSCD_NUM_SRC; i++) {
                if (NSCD_NSW_SRC_NAME(i) == NULL)
                        continue;
                rc = _nscd_populate_nsw_backend_info_db(i);
                if (rc != NSCD_SUCCESS)
                return (rc);
        }

        return (NSCD_SUCCESS);
}

/*
 * The following defines nscd's own lookup and delete functions
 * that are to be stored in nss_backend_finder_t which is used
 * by _nscd_populate_nsw_backend_info_db() to initialize the
 * various nss backend instances
 */

static const int  dlopen_version  = 1;
#ifndef NSS_DLOPEN_FORMAT
#define NSS_DLOPEN_FORMAT "nss_%s.so.%d"
#endif
#ifndef NSS_DLSYM_FORMAT
#define NSS_DLSYM_FORMAT   "_nss_%s_%s_constr"
#define NSS_DLSYM_FORMAT_V "_nss_%s_version"
#endif
static const char dlopen_format[] = NSS_DLOPEN_FORMAT;
static const char dlsym_format [] = NSS_DLSYM_FORMAT;
static const char dlsym_format_v [] = NSS_DLSYM_FORMAT_V;
static const size_t  format_maxlen   = sizeof (dlsym_format);

/*ARGSUSED*/
static nss_backend_constr_t
_nscd_per_src_lookup(void *handle, const char *db_name, const char *src_name,
        void **delete_privp)
{
        char                    *name;
        void                    *dlhandle;
        void                    *sym;
        size_t                  len;
        nss_backend_constr_t    res = NULL;

        len = format_maxlen + strlen(src_name);
        if (db_name != NULL)
                len += strlen(db_name);
        name = alloca(len);
        dlhandle = handle;
        if ((dlhandle = handle) == NULL) {
                (void) sprintf(name, dlopen_format, src_name, dlopen_version);
                dlhandle = dlopen(name, RTLD_LAZY);
        }

        if (dlhandle != NULL) {
                if (db_name != NULL)
                        (void) sprintf(name, dlsym_format, src_name, db_name);
                else
                        (void) sprintf(name, dlsym_format_v, src_name);
                if ((sym = dlsym(dlhandle, name)) == 0) {
                        if (handle == NULL)
                                (void) dlclose(dlhandle);
                } else {
                        *delete_privp = dlhandle;
                        res = (nss_backend_constr_t)sym;
                }
        }
        return (res);
}

/*ARGSUSED*/
static void
_nscd_per_src_delete(void *delete_priv, nss_backend_constr_t dummy)
{
        (void) dlclose(delete_priv);
}