/*
 * 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 "lint.h"
#include <mtlib.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <nss_dbdefs.h>
#include <limits.h>
#include <dlfcn.h>
#include <link.h>
#include <thread.h>
#include <atomic.h>
/* headers for key2str/str2key routines */
#include <sys/ethernet.h>
#include <exec_attr.h>
#include <grp.h>

/*
 * functions in nss_dbdefs.c deal more with the mechanics of
 * the data structures like nss_XbyY_args_t and the interaction
 * with the packed buffers etc.  versus the mechanics of the
 * actual policy component operations such as nss_search sequencing.
 */

/*
 * ALIGN? is there an official definition of this?
 * We use sizeof(long) to cover what we want
 * for both the 32-bit world and 64-bit world.
 */

#define ALIGN(x) ((((long)(x)) + sizeof (long) - 1) & ~(sizeof (long) - 1))

nss_XbyY_buf_t *
_nss_XbyY_buf_alloc(int struct_size, int buffer_size)
{
        nss_XbyY_buf_t  *b;

        /* Use one malloc for dbargs, result struct and buffer */
        b = (nss_XbyY_buf_t *)
            malloc(ALIGN(sizeof (*b)) + struct_size + buffer_size);
        if (b == 0) {
                return (0);
        }
        b->result = (void *)ALIGN(&b[1]);
        b->buffer = (char *)(b->result) + struct_size;
        b->buflen = buffer_size;
        return (b);
}

void
_nss_XbyY_buf_free(nss_XbyY_buf_t *b)
{
        if (b != 0) {
                free(b);
        }
}

/* === Comment:  used by fget{gr,pw,sp}ent */
/* ==== Should do ye olde syslog()ing of suspiciously long lines */

void
_nss_XbyY_fgets(FILE *f, nss_XbyY_args_t *b)
{
        char            buf[LINE_MAX];
        int             len, parsestat;

        if (fgets(buf, LINE_MAX, f) == 0) {
                /* End of file */
                b->returnval = 0;
                b->erange    = 0;
                return;
        }
        len = (int)strlen(buf);
        /* len >= 0 (otherwise we would have got EOF) */
        if (buf[len - 1] != '\n') {
                if ((len + 1) == LINE_MAX) {
                        /* Line too long for buffer; too bad */
                        while (fgets(buf, LINE_MAX, f) != 0 &&
                            buf[strlen(buf) - 1] != '\n') {
                                ;
                        }
                        b->returnval = 0;
                        b->erange    = 1;
                        return;
                }
                /* case where the file is not terminated with a Newline */
                len++;
        }
        parsestat = (*b->str2ent)(buf, (len - 1), b->buf.result, b->buf.buffer,
            b->buf.buflen);
        if (parsestat == NSS_STR_PARSE_ERANGE) {
                b->returnval = 0;
                b->erange    = 1;
        } else if (parsestat == NSS_STR_PARSE_SUCCESS) {
                b->returnval = b->buf.result;
        }
}

/*
 * parse the aliases string into the buffer and if successful return
 * a char ** pointer to the beginning of the aliases.
 *
 * CAUTION: (instr, instr+lenstr) and (buffer, buffer+buflen) are
 * non-intersecting memory areas. Since this is an internal interface,
 * we should be able to live with that.
 *
 * "instr" is the beginning of the aliases string
 * "buffer" has the return val for success
 * "buflen" is the length of the buffer available for aliases
 */
char **
_nss_netdb_aliases(const char *instr, int lenstr, char *buffer, int buflen)
{
        /*
         * Build the alias-list in the start of the buffer, and copy
         * the strings to the end of the buffer.
         */
        const char *instr_limit = instr + lenstr;
        char    *copyptr        = buffer + buflen;
        char    **aliasp        = (char **)ROUND_UP(buffer, sizeof (*aliasp));
        char    **alias_start   = aliasp;
        int     nstrings        = 0;

        for (;;) {
                const char      *str_start;
                size_t          str_len;

                while (instr < instr_limit && isspace(*instr)) {
                        instr++;
                }
                if (instr >= instr_limit || *instr == '#') {
                        break;
                }
                str_start = instr;
                while (instr < instr_limit && !isspace(*instr)) {
                        instr++;
                }

                ++nstrings;

                str_len = instr - str_start;
                copyptr -= str_len + 1;
                if (copyptr <= (char *)(&aliasp[nstrings + 1])) {
                        /* Has to be room for the pointer to */
                        /* the alias we're about to add,   */
                        /* as well as the final NULL ptr.  */
                        return (0);
                }
                *aliasp++ = copyptr;
                (void) memcpy(copyptr, str_start, str_len);
                copyptr[str_len] = '\0';
        }
        *aliasp++ = 0;
        return (alias_start);
}


extern nss_status_t process_cstr(const char *, int, struct nss_groupsbymem *);

/*
 * pack well known getXbyY keys to packed buffer prior to the door_call
 * to nscd.  Some consideration is given to ordering the tests based on
 * usage.  Note: buf is nssuint_t aligned.
 */

typedef struct {
        const char      *name;          /* NSS_DBNAM_* */
        const char      *defconf;       /* NSS_DEFCONF_* */
        const char      *initfn;        /* init function name */
        const char      *strfn;         /* str2X function name */
        const char      *cstrfn;        /* cstr2X function name */
        void            *initfnp;       /* init function pointer */
        void            *strfnp;        /* str2X function pointer */
        uint32_t        dbop;           /* NSS_DBOP_* */
        const char      *tostr;         /* key2str cvt str */
} getXbyY_to_dbop_t;

#define NSS_MK_GETXYDBOP(x, y, f, e)    \
        { NSS_DBNAM_##x, NSS_DEFCONF_##x, "_nss_initf_" f, "str2" f, \
                NULL, NULL, NULL, NSS_DBOP_##x##_##y, (e) }

#define NSS_MK_GETXYDBOPA(x, a, f, e)   \
        { NSS_DBNAM_##x, NSS_DEFCONF_##x, "_nss_initf_" f, "str2" f, \
                NULL, NULL, NULL, NSS_DBOP_##a, (e) }

#define NSS_MK_GETXYDBOPB(x, b, a, f, s, e)     \
        { NSS_DBNAM_##x, NSS_DEFCONF_##b, "_nss_initf_" f, s,  \
                NULL, NULL, NULL, NSS_DBOP_##a, (e) }

#define NSS_MK_GETXYDBOPC(x, a, f, s, e)        \
        { NSS_DBNAM_##x, NSS_DEFCONF_##x, "_nss_initf_" f, s, \
                NULL, NULL, NULL, NSS_DBOP_##x##_##a, (e) }

#define NSS_MK_GETXYDBOPD(x, y, i, f, e)        \
        { NSS_DBNAM_##x, NSS_DEFCONF_##x, "_nss_initf_" i, "str2" f, \
                NULL, NULL, NULL, NSS_DBOP_##x##_##y, (e) }

#define NSS_MK_GETXYDBOPCSTR(x, a, f, s, e)     \
        { NSS_DBNAM_##x, NSS_DEFCONF_##x, "_nss_initf_" f, s, \
                "process_cstr", NULL, NULL, NSS_DBOP_##x##_##a, (e) }

/*
 * The getXbyY_to_dbop structure is hashed on first call in order to
 * reduce the search time for the well known getXbyY operations.
 * A binary search was not fast enough.  There were on average
 * 3-4 tests (strcmps) per getXbyY call.
 *
 * DBOP_PRIME_HASH must be a prime number (reasonably small) but that
 * is sufficient to uniquely map the entries in the following table
 * without collision.
 *
 * The DBOP_PRIME_HASH was selected as the smallest hash value
 * for this table without collisions. Changing this table WILL
 * necessitate re-testing for possible collisions.
 */

#define DBOP_PRIME_HASH         227
#define DBOP_HASH_TAG           0xf0000000
static int getXbyYdbopHASH[DBOP_PRIME_HASH] = { 0 };
static mutex_t getXbydbop_hash_lock = DEFAULTMUTEX;
static int getXbyYdbop_hashed = 0;

/*
 * If the size of getXbyY_to_dbop[] is changed then hash function must be
 * corrected to be without collisions in nss_dbop_search().
 */
static getXbyY_to_dbop_t getXbyY_to_dbop[] = {
        /* NSS_MK_GETXYDBOP(ALIASES, ?, ?), */
        NSS_MK_GETXYDBOPD(AUDITUSER, BYNAME, "auuser", "audituser", "n"),
        NSS_MK_GETXYDBOP(AUTHATTR, BYNAME, "authattr", "n"),
        /* NSS_MK_GETXYDBOP(AUTOMOUNT, ?, ?), */
        NSS_MK_GETXYDBOP(BOOTPARAMS, BYNAME, "bootparams", "n"),
        NSS_MK_GETXYDBOPC(ETHERS, HOSTTON, "ethers", "str2ether", "n"),
        NSS_MK_GETXYDBOPC(ETHERS, NTOHOST, "ethers", "str2ether", "e"),
        NSS_MK_GETXYDBOP(EXECATTR, BYNAME, "execattr", "A"),
        NSS_MK_GETXYDBOP(EXECATTR, BYID, "execattr", "A"),
        NSS_MK_GETXYDBOP(EXECATTR, BYNAMEID, "execattr", "A"),
        NSS_MK_GETXYDBOP(GROUP, BYNAME, "group", "n"),
        NSS_MK_GETXYDBOP(GROUP, BYGID, "group", "g"),
        NSS_MK_GETXYDBOPCSTR(GROUP, BYMEMBER, "group", "str2group", "I"),
        NSS_MK_GETXYDBOPC(HOSTS, BYNAME, "hosts", "str2hostent", "n"),
        NSS_MK_GETXYDBOPC(HOSTS, BYADDR, "hosts", "str2hostent", "h"),
        NSS_MK_GETXYDBOPC(IPNODES, BYNAME, "ipnodes", "str2hostent", "i"),
        NSS_MK_GETXYDBOPC(IPNODES, BYADDR, "ipnodes", "str2hostent", "h"),
        NSS_MK_GETXYDBOP(NETGROUP, IN, "netgroup", "t"),
        NSS_MK_GETXYDBOP(NETGROUP, SET, "netgroup", "T"),
        NSS_MK_GETXYDBOPC(NETMASKS, BYNET, "netmasks", "str2addr", "n"),
        NSS_MK_GETXYDBOPC(NETWORKS, BYNAME, "net", "str2netent", "n"),
        NSS_MK_GETXYDBOPC(NETWORKS, BYADDR, "net", "str2netent", "a"),
        NSS_MK_GETXYDBOP(PASSWD, BYNAME, "passwd", "n"),
        NSS_MK_GETXYDBOP(PASSWD, BYUID, "passwd", "u"),
        NSS_MK_GETXYDBOP(PRINTERS, BYNAME, "printers", "n"),
        NSS_MK_GETXYDBOP(PROFATTR, BYNAME, "profattr", "n"),
        NSS_MK_GETXYDBOP(PROJECT, BYNAME, "project", "n"),
        NSS_MK_GETXYDBOP(PROJECT, BYID, "project", "p"),
        NSS_MK_GETXYDBOPC(PROTOCOLS, BYNAME, "proto", "str2protoent", "n"),
        NSS_MK_GETXYDBOPC(PROTOCOLS, BYNUMBER, "proto", "str2protoent", "N"),
        NSS_MK_GETXYDBOPA(PUBLICKEY, KEYS_BYNAME, "publickey", "k"),
        NSS_MK_GETXYDBOPC(RPC, BYNAME, "rpc", "str2rpcent", "n"),
        NSS_MK_GETXYDBOPC(RPC, BYNUMBER, "rpc", "str2rpcent", "N"),
        NSS_MK_GETXYDBOPC(SERVICES, BYNAME, "services", "str2servent", "s"),
        NSS_MK_GETXYDBOPC(SERVICES, BYPORT, "services", "str2servent", "S"),
        NSS_MK_GETXYDBOPB(SHADOW, PASSWD, PASSWD_BYNAME, "shadow",
            "str2spwd", "n"),
        NSS_MK_GETXYDBOPC(TSOL_RH, BYADDR, "tsol_rh", "str_to_rhstr", "h"),
        NSS_MK_GETXYDBOPC(TSOL_TP, BYNAME, "tsol_tp", "str_to_tpstr", "n"),
        NSS_MK_GETXYDBOPC(TSOL_ZC, BYNAME, "tsol_zc", "str_to_zcstr", "n"),
        NSS_MK_GETXYDBOP(USERATTR, BYNAME, "userattr", "n"),
};

static int
nss_dbop_search(const char *name, uint32_t dbop)
{
        getXbyY_to_dbop_t *hptr;
        int count = (sizeof (getXbyY_to_dbop) / sizeof (getXbyY_to_dbop_t));
        uint32_t hval, g;
        const char *cp;
        int i, idx;
        static const uint32_t hbits_tst = 0xf0000000;

        /* Uses a table size is known to have no collisions */
        if (getXbyYdbop_hashed == 0) {
                lmutex_lock(&getXbydbop_hash_lock);
                if (getXbyYdbop_hashed == 0) {
                        for (i = 0; i < count; i++) {
                                cp = getXbyY_to_dbop[i].name;
                                hval = 0;
                                while (*cp) {
                                        hval = (hval << 4) + *cp++;
                                        if ((g = (hval & hbits_tst)) != 0)
                                                hval ^= g >> 24;
                                        hval &= ~g;
                                }
                                hval += getXbyY_to_dbop[i].dbop;
                                hval %= DBOP_PRIME_HASH;
                                if (getXbyYdbopHASH[hval] != 0) {
                                        /* hash table collision-see above */
                                        lmutex_unlock(&getXbydbop_hash_lock);
                                        return (-1);
                                }
                                getXbyYdbopHASH[hval] = i | DBOP_HASH_TAG;
                        }
                        membar_producer();
                        getXbyYdbop_hashed = 1;
                }
                lmutex_unlock(&getXbydbop_hash_lock);
        }
        membar_consumer();
        cp = name;
        hval = 0;
        while (*cp) {
                hval = (hval << 4) + *cp++;
                if ((g = (hval & hbits_tst)) != 0)
                        hval ^= g >> 24;
                hval &= ~g;
        }
        hval += dbop;
        hval %= DBOP_PRIME_HASH;
        idx = getXbyYdbopHASH[hval];
        if ((idx & DBOP_HASH_TAG) != DBOP_HASH_TAG)
                return (-1);
        idx &= ~DBOP_HASH_TAG;
        if (idx >= count)
                return (-1);
        hptr = &getXbyY_to_dbop[idx];
        if (hptr->dbop != dbop || strcmp(name, hptr->name) != 0)
                return (-1);
        return (idx);
}

/*
 * nss_pack_key2str
 * Private key to string packing function for getXbyY routines
 * This routine performs a printf like parse over the argument
 * key, given a string of items to pack and assembles the key in
 * the packed structure.  This routine is called (currently) by
 * nss_default_key2str, but will be used by other external
 * APIs in the future.
 *
 * buffer - Start of the key buffer location [in packed buffer]
 * length - Length of key buffer component
 * Key offsets are relative to start of key buffer location.
 *
 * Pack fields                  Key
 *   key.name                   n
 *   key.number                 N
 *   key.uid                    u
 *   key.gid                    g
 *   key.hostaddr               h
 *   key.ipnode                 i
 *   key.projid                 p
 *   key.serv(name)             s
 *   key.serv(port)             S
 *   key.ether                  e
 *   key.pkey                   k
 *   key.netaddr                a
 *   key.attrp                  A
 *   groupsbymember             I
 *   innetgr_args               t
 *   setnetgr_args              T
 */

static nss_status_t
nss_pack_key2str(void *buffer, size_t length, nss_XbyY_args_t *arg,
    const char *dbname, int dbop __unused, size_t *rlen, const char *typestr)
{
        int                             i, j;
        size_t                          len, len2, len3, len4, len5, slop;
        nssuint_t                       *uptr, offv, offc;
        struct nss_setnetgrent_args     *sng;
        struct nss_innetgr_args         *ing;
        struct nss_groupsbymem          *gbm;
        char                            **cv, *dptr;
        nss_pnetgr_t                    *pptr;
        _priv_execattr                  *pe;

        if (buffer == NULL || length == 0 || arg == NULL ||
            dbname == NULL || rlen == NULL || typestr == NULL)
                return (NSS_ERROR);

        while (typestr && *typestr) {
                switch (*typestr++) {
                case 'n':
                        if (arg->key.name == NULL)
                                return (NSS_NOTFOUND);
                        len = strlen(arg->key.name) + 1;
                        if (len >= length)
                                return (NSS_ERROR);
                        (void) strlcpy(buffer, arg->key.name, len);
                        *rlen = len;
                        break;
                case 'N':
                        len = sizeof (nssuint_t);
                        if (len >= length)
                                return (NSS_ERROR);
                        *(nssuint_t *)buffer = (nssuint_t)arg->key.number;
                        *rlen = len;
                        break;
                case 'u':
                        len = sizeof (nssuint_t);
                        if (len >= length)
                                return (NSS_ERROR);
                        *(nssuint_t *)buffer = (nssuint_t)arg->key.uid;
                        *rlen = len;
                        break;
                case 'g':
                        len = sizeof (nssuint_t);
                        if (len >= length)
                                return (NSS_ERROR);
                        *(nssuint_t *)buffer = (nssuint_t)arg->key.gid;
                        *rlen = len;
                        break;
                case 'h':
                        if (arg->key.hostaddr.addr == NULL)
                                return (-1);
                        len = arg->key.hostaddr.len;
                        len = ROUND_UP(len, sizeof (nssuint_t));
                        len2 = (sizeof (nssuint_t) * 2) + len;
                        if (len2 >= length)
                                return (NSS_ERROR);
                        *(nssuint_t *)buffer =
                            (nssuint_t)arg->key.hostaddr.len;
                        buffer = (void *)((char *)buffer + sizeof (nssuint_t));
                        *(nssuint_t *)buffer =
                            (nssuint_t)arg->key.hostaddr.type;
                        buffer = (void *)((char *)buffer + sizeof (nssuint_t));
                        (void) memcpy(buffer, arg->key.hostaddr.addr,
                            arg->key.hostaddr.len);
                        *rlen = len2;
                        break;
                case 'i':
                        if (arg->key.ipnode.name == NULL)
                                return (NSS_NOTFOUND);
                        len = strlen(arg->key.ipnode.name) + 1;
                        len = ROUND_UP(len, sizeof (nssuint_t));
                        len2 = (sizeof (nssuint_t) * 2) + len;
                        if (len2 >= length)
                                return (NSS_ERROR);
                        *(nssuint_t *)buffer =
                            (nssuint_t)arg->key.ipnode.af_family;
                        buffer = (void *)((char *)buffer + sizeof (nssuint_t));
                        *(nssuint_t *)buffer =
                            (nssuint_t)arg->key.ipnode.flags;
                        buffer = (void *)((char *)buffer + sizeof (nssuint_t));
                        (void) strlcpy(buffer, arg->key.ipnode.name, len);
                        *rlen = len2;
                        break;
                case 'p':
                        len = sizeof (nssuint_t);
                        if (len >= length)
                                return (NSS_ERROR);
                        *(nssuint_t *)buffer = (nssuint_t)arg->key.projid;
                        *rlen = len;
                        break;
                case 's':
                        if (arg->key.serv.serv.name == NULL)
                                return (NSS_NOTFOUND);
                        len = strlen(arg->key.serv.serv.name) + 1;
                        len2 = 1;
                        if (arg->key.serv.proto != NULL)
                                len2 += strlen(arg->key.serv.proto);
                        len3 = len + len2;
                        len3 = ROUND_UP(len3, sizeof (nssuint_t));
                        if (len3 >= length)
                                return (NSS_ERROR);
                        (void) strlcpy(buffer, arg->key.serv.serv.name, len);
                        buffer = (void *)((char *)buffer + len);
                        if (len2 > 1)
                                (void) strlcpy(buffer, arg->key.serv.proto,
                                    len2);
                        else
                                *(char *)buffer = '\0';
                        *rlen = len3;
                        break;
                case 'S':
                        len2 = 0;
                        if (arg->key.serv.proto != NULL)
                                len2 = strlen(arg->key.serv.proto) + 1;
                        len = sizeof (nssuint_t) + len2;
                        if (len >= length)
                                return (NSS_ERROR);
                        uptr = (nssuint_t *)buffer;
                        *uptr++ = (nssuint_t)arg->key.serv.serv.port;
                        if (len2) {
                                (void) strlcpy((char *)uptr,
                                    arg->key.serv.proto, len2);
                        }
                        *rlen = len;
                        break;
                case 'e':
                        if (arg->key.ether == NULL)
                                return (NSS_NOTFOUND);
                        len = sizeof (struct ether_addr);
                        len = ROUND_UP(len, sizeof (nssuint_t));
                        if (len >= length)
                                return (NSS_ERROR);
                        *(struct ether_addr *)buffer =
                            *(struct ether_addr *)arg->key.ether;
                        *rlen = len;
                        break;
                case 'k':
                        if (arg->key.pkey.name == NULL ||
                            arg->key.pkey.keytype == NULL)
                                return (NSS_NOTFOUND);
                        len = strlen(arg->key.pkey.name) + 1;
                        len2 = strlen(arg->key.pkey.keytype) + 1;
                        len3 = len + len2;
                        len3 = ROUND_UP(len3, sizeof (nssuint_t));
                        if (len3 >= length)
                                return (NSS_ERROR);
                        (void) strlcpy(buffer, arg->key.pkey.name, len);
                        buffer = (void *)((char *)buffer + len);
                        (void) strlcpy(buffer, arg->key.pkey.keytype, len2);
                        *rlen = len3;
                        break;
                case 'a':
                        uptr = (nssuint_t *)buffer;
                        len = sizeof (nssuint_t) * 2;
                        if (len >= length)
                                return (NSS_ERROR);
                        *uptr++ = (nssuint_t)arg->key.netaddr.net;
                        *uptr++ = (nssuint_t)arg->key.netaddr.type;
                        *rlen = len;
                        break;
                case 'A':
                        pe = (_priv_execattr *)(arg->key.attrp);
                        if (pe == NULL)
                                return (NSS_NOTFOUND);
                        /* for search flag */
                        len = sizeof (nssuint_t);
                        /* for sizeof (_priv_execattr) static buffer */
                        /* Plus lots of slop just in case... */
                        slop = sizeof (nssuint_t) * 16;
                        len += slop;

                        len2 = len3 = len4 = len5 = 1;
                        if (pe->name != NULL)
                                len2 = strlen(pe->name) + 1;
                        if (pe->type != NULL)
                                len3 = strlen(pe->type) + 1;
                        if (pe->id != NULL)
                                len4 = strlen(pe->id) + 1;
                        if (pe->policy != NULL)
                                len5 = strlen(pe->policy) + 1;
                        /* head_exec, prev_exec - are client side only... */
                        len += len2 + len3 + len4 + len5;
                        len = ROUND_UP(len, sizeof (nssuint_t));
                        if (len >= length)
                                return (NSS_ERROR);
                        (void) memset((void *)buffer, 0, slop);
                        uptr = (nssuint_t *)((void *)((char *)buffer + slop));
                        *uptr++ = (nssuint_t)pe->search_flag;
                        dptr = (char *)uptr;
                        if (len2 == 1)
                                *dptr++ = '\0';
                        else {
                                (void) strlcpy(dptr, pe->name, len2);
                                dptr += len2;
                        }
                        if (len3 == 1)
                                *dptr++ = '\0';
                        else {
                                (void) strlcpy(dptr, pe->type, len3);
                                dptr += len3;
                        }
                        if (len4 == 1)
                                *dptr++ = '\0';
                        else {
                                (void) strlcpy(dptr, pe->id, len4);
                                dptr += len4;
                        }
                        if (len5 == 1)
                                *dptr++ = '\0';
                        else
                                (void) strlcpy(dptr, pe->policy, len5);
                        *rlen = len;
                        break;
                case 'I':
                        gbm = (struct nss_groupsbymem *)arg;
                        if (gbm->username == NULL)
                                return (NSS_NOTFOUND);
                        len = strlen(gbm->username) + 1;
                        len2 = sizeof (nssuint_t) * 4;
                        len2 += ROUND_UP(len, sizeof (nssuint_t));
                        if (len2 >= length)
                                return (NSS_ERROR);
                        uptr = (nssuint_t *)buffer;
                        *uptr++ = (nssuint_t)gbm->force_slow_way;
                        *uptr++ = (nssuint_t)gbm->maxgids;
                        *uptr++ = (nssuint_t)gbm->numgids;
                        if (gbm->numgids == 1) {
                                *uptr++ = (nssuint_t)gbm->gid_array[0];
                        } else {
                                *uptr++ = (nssuint_t)0;
                        }
                        (void) strlcpy((void *)uptr, gbm->username, len);
                        *rlen = len2;
                        break;
                case 't':
                        pptr = (nss_pnetgr_t *)buffer;
                        ing = (struct nss_innetgr_args *)arg;
                        len = sizeof (nss_pnetgr_t);
                        len2 = ing->arg[NSS_NETGR_MACHINE].argc +
                            ing->arg[NSS_NETGR_USER].argc +
                            ing->arg[NSS_NETGR_DOMAIN].argc +
                            ing->groups.argc;
                        len2 *= sizeof (nssuint_t);
                        len3 = 0;
                        for (j = 0; j < NSS_NETGR_N; j++) {
                                cv = ing->arg[j].argv;
                                for (i = ing->arg[j].argc; --i >= 0; ) {
                                        if (*cv)
                                                len3 += strlen(*cv++) + 1;
                                }
                        }
                        cv = ing->groups.argv;
                        for (i = ing->groups.argc; --i >= 0; ) {
                                if (*cv)
                                        len3 += strlen(*cv++) + 1;
                        }
                        len3 = ROUND_UP(len3, sizeof (nssuint_t));
                        /*
                         * Double argv space. Reason:
                         *    First 1/2 offsets
                         *    Second 1/2 for client side pointer arrays
                         *    resolves malloc/free issues with unpacked argvs
                         */
                        if ((len + (len2 << 1) + len3) >= length)
                                return (NSS_ERROR);
                        *rlen = len + (len2 << 1) + len3;

                        pptr->machine_argc = ing->arg[NSS_NETGR_MACHINE].argc;
                        pptr->user_argc = ing->arg[NSS_NETGR_USER].argc;
                        pptr->domain_argc = ing->arg[NSS_NETGR_DOMAIN].argc;
                        pptr->groups_argc = ing->groups.argc;
                        offv = len;
                        uptr = (nssuint_t *)((void *)((char *)buffer + offv));
                        offc = len + (len2 << 1);
                        dptr = (char *)buffer + offc;
                        if (pptr->machine_argc == 0) {
                                pptr->machine_offv = (nssuint_t)0;
                        } else {
                                pptr->machine_offv = offv;
                                cv = ing->arg[NSS_NETGR_MACHINE].argv;
                                i = pptr->machine_argc;
                                offv += sizeof (nssuint_t) * i;
                                for (; --i >= 0; ) {
                                        *uptr++ = offc;
                                        len3 = strlen(*cv) + 1;
                                        (void) strlcpy(dptr, *cv++, len3);
                                        offc += len3;
                                        dptr += len3;
                                }
                        }
                        if (pptr->user_argc == 0) {
                                pptr->user_offv = (nssuint_t)0;
                        } else {
                                pptr->user_offv = offv;
                                cv = ing->arg[NSS_NETGR_USER].argv;
                                i = pptr->user_argc;
                                offv += sizeof (nssuint_t) * i;
                                for (; --i >= 0; ) {
                                        *uptr++ = offc;
                                        len3 = strlen(*cv) + 1;
                                        (void) strlcpy(dptr, *cv++, len3);
                                        offc += len3;
                                        dptr += len3;
                                }
                        }
                        if (pptr->domain_argc == 0) {
                                pptr->domain_offv = (nssuint_t)0;
                        } else {
                                pptr->domain_offv = offv;
                                cv = ing->arg[NSS_NETGR_DOMAIN].argv;
                                i = pptr->domain_argc;
                                offv += sizeof (nssuint_t) * i;
                                for (; --i >= 0; ) {
                                        *uptr++ = offc;
                                        len3 = strlen(*cv) + 1;
                                        (void) strlcpy(dptr, *cv++, len3);
                                        offc += len3;
                                        dptr += len3;
                                }
                        }
                        if (pptr->groups_argc == 0) {
                                pptr->groups_offv = (nssuint_t)0;
                        } else {
                                pptr->groups_offv = offv;
                                cv = ing->groups.argv;
                                i = pptr->groups_argc;
                                offv += sizeof (nssuint_t) * i;
                                for (; --i >= 0; ) {
                                        *uptr++ = offc;
                                        len3 = strlen(*cv) + 1;
                                        (void) strlcpy(dptr, *cv++, len3);
                                        offc += len3;
                                        dptr += len3;
                                }
                        }
                        break;
                case 'T':
                        sng = (struct nss_setnetgrent_args *)arg;
                        if (sng->netgroup == NULL)
                                return (NSS_NOTFOUND);
                        len = strlen(sng->netgroup) + 1;
                        if (len >= length)
                                return (NSS_ERROR);
                        (void) strlcpy(buffer, sng->netgroup, len);
                        *rlen = len;
                        break;
                default:
                        return (NSS_ERROR);
                }
        }
        return (NSS_SUCCESS);
}

nss_status_t
nss_default_key2str(void *buffer, size_t length, nss_XbyY_args_t *arg,
    const char *dbname, int dbop, size_t *rlen)
{
        int             index;

        if (buffer == NULL || length == 0 || arg == NULL ||
            dbname == NULL || rlen == NULL)
                return (NSS_ERROR);

        /*
         * If this is not one of the well known getXbyYs
         * (IE _printers special processing etc.) use a
         * local (non-nscd) getXbyY lookup.
         */
        if ((index = nss_dbop_search(dbname, (uint32_t)dbop)) < 0)
                return (NSS_TRYLOCAL);

        return (nss_pack_key2str(buffer, length, arg, dbname,
            dbop, rlen, getXbyY_to_dbop[index].tostr));
}

void
nss_packed_set_status(void *buffer, size_t length __unused, nss_status_t status,
    nss_XbyY_args_t *arg)
{
        nss_pheader_t   *pbuf = (nss_pheader_t *)buffer;
        nss_dbd_t       *pdbd;
        char            *dbn;

        /* sidestep odd cases */
        pdbd = (nss_dbd_t *)((void *)((char *)buffer + pbuf->dbd_off));
        dbn = (char *)pdbd + pdbd->o_name;
        if (pbuf->nss_dbop == NSS_DBOP_GROUP_BYMEMBER) {
                if (strcmp(dbn, NSS_DBNAM_GROUP) == 0) {
                        struct nss_groupsbymem *in =
                            (struct nss_groupsbymem *)arg;

                        if (in->numgids >= 0) {
                                pbuf->p_status = NSS_SUCCESS;
                                pbuf->data_len = in->numgids *
                                    sizeof (gid_t);
                                pbuf->p_herrno = 0;
                        } else {
                                pbuf->p_status = status;
                                pbuf->p_errno = errno;
                                pbuf->data_len = 0;
                                pbuf->p_herrno = (uint32_t)arg->h_errno;
                        }
                        return;
                }
        }
        if (pbuf->nss_dbop == NSS_DBOP_NETGROUP_IN) {
                if (strcmp(dbn, NSS_DBNAM_NETGROUP) == 0) {
                        struct nss_innetgr_args *in =
                            (struct nss_innetgr_args *)arg;

                        /* tell nss_unpack() operation is successful */
                        pbuf->data_len = 1;

                        if (status != NSS_SUCCESS && status != NSS_NOTFOUND) {
                                pbuf->p_status = status;
                                pbuf->p_errno = errno;
                                return;
                        }

                        if (in->status == NSS_NETGR_FOUND) {
                                pbuf->p_status = NSS_SUCCESS;
                        } else {
                                pbuf->p_status = NSS_NOTFOUND;
                                pbuf->p_errno = errno;
                        }
                        return;
                }
        }

        /* process normal cases */
        if ((pbuf->p_status = status) != NSS_SUCCESS) {
                if (arg->erange == 1)
                        pbuf->p_errno = ERANGE;
                else
                        pbuf->p_errno = errno;
        } else
                pbuf->p_errno = 0;
        if (arg != NULL) {
                pbuf->p_herrno = (uint32_t)arg->h_errno;
                pbuf->data_len = (nssuint_t)arg->returnlen;
        } else {
                pbuf->p_herrno = 0;
                pbuf->data_len = 0;
        }
}

/*
 * nss_upack_key2arg
 * Private string to key unpacking function for getXbyY routines
 * This routine performs a scanf/printf like parse over the packed
 * string, to uppack and re-assemble the key in the args structure.
 *
 * buffer - Start of the key buffer location [in packed buffer]
 * length - Length of key buffer component
 * Key offsets are relative to start of key buffer location.
 *
 * Unpack fields                Key
 *   key.name                   n
 *   key.number                 N
 *   key.uid                    u
 *   key.gid                    g
 *   key.hostaddr               h
 *   key.ipnode                 i
 *   key.projid                 p
 *   key.serv(name)             s
 *   key.serv(port)             S
 *   key.ether                  e
 *   key.pkey                   k
 *   key.netaddr                a
 *   key.attrp                  A
 *   groupsbymember             I
 *   innetgr_args               t
 *   setnetgr_args              T
 * Assumes arguments are all valid
 */

static nss_status_t
nss_upack_key2arg(void *buffer, size_t length __unused, char **dbname __unused,
    int *dbop __unused, nss_XbyY_args_t *arg, int index)
{
        nss_pheader_t                   *pbuf = (nss_pheader_t *)buffer;
        const char                      *strtype = NULL;
        nssuint_t                       off, *uptr, keysize;
        size_t                          len, slop;
        int                             i, j;
        char                            **cv, *bptr;
        struct nss_setnetgrent_args     *sng;
        struct nss_innetgr_args         *ing;
        struct nss_groupsbymem          *gbm;
        nss_pnetgr_t                    *pptr;
        _priv_execattr                  *pe;

        /* keysize is length of the key area */
        keysize = pbuf->data_off - pbuf->key_off;

        off = pbuf->key_off;
        bptr = (char *)buffer + off;
        uptr = (nssuint_t *)((void *)bptr);
        strtype = getXbyY_to_dbop[index].tostr;
        if (strtype == NULL)
                return (NSS_ERROR);
        while (*strtype) {
                switch (*strtype++) {
                case 'n':
                        arg->key.name = (const char *)bptr;
                        break;
                case 'N':
                        arg->key.number = (int)(*uptr);
                        break;
                case 'u':
                        arg->key.uid = (uid_t)(*uptr);
                        break;
                case 'g':
                        arg->key.gid = (gid_t)(*uptr);
                        break;
                case 'h':
                        arg->key.hostaddr.len = (int)(*uptr++);
                        arg->key.hostaddr.type = (int)(*uptr++);
                        arg->key.hostaddr.addr = (const char *)uptr;
                        break;
                case 'i':
                        arg->key.ipnode.af_family = (int)(*uptr++);
                        arg->key.ipnode.flags = (int)(*uptr++);
                        arg->key.ipnode.name = (const char *)uptr;
                        break;
                case 'p':
                        arg->key.projid = (projid_t)(*uptr);
                        break;
                case 's':
                        arg->key.serv.serv.name = (const char *)bptr;
                        len = strlen(arg->key.serv.serv.name) + 1;
                        bptr += len;
                        if (*(const char *)bptr == '\0')
                                arg->key.serv.proto = NULL;
                        else
                                arg->key.serv.proto = (const char *)bptr;
                        break;
                case 'S':
                        arg->key.serv.serv.port = (int)(*uptr++);
                        if (pbuf->key_len == sizeof (nssuint_t)) {
                                arg->key.serv.proto = NULL;
                        } else {
                                bptr += sizeof (nssuint_t);
                                arg->key.serv.proto = (const char *)bptr;
                        }
                        break;
                case 'e':
                        arg->key.ether = bptr;
                        break;
                case 'k':
                        arg->key.pkey.name = (const char *)bptr;
                        len = strlen(arg->key.pkey.name) + 1;
                        bptr += len;
                        arg->key.pkey.keytype = (const char *)bptr;
                        break;
                case 'a':
                        arg->key.netaddr.net = (uint32_t)(*uptr++);
                        arg->key.netaddr.type = (int)(*uptr++);
                        break;
                case 'A':
                        pe = (_priv_execattr *)((void *)bptr);
                        /* use slop space as priv_execattr structure */
                        arg->key.attrp = (void *)pe;
                        /* skip over slop ... */
                        slop = sizeof (nssuint_t) * 16;
                        uptr = (nssuint_t *)((void *)((char *)bptr + slop));
                        pe->search_flag = (int)*uptr++;
                        bptr = (char *)uptr;
                        if (*bptr == '\0') {
                                pe->name = NULL;
                                bptr++;
                        } else {
                                pe->name = (char *)bptr;
                                bptr += strlen(pe->name) + 1;
                        }
                        if (*bptr == '\0') {
                                pe->type = NULL;
                                bptr++;
                        } else {
                                pe->type = (char *)bptr;
                                bptr += strlen(pe->type) + 1;
                        }
                        if (*bptr == '\0') {
                                pe->id = NULL;
                                bptr++;
                        } else {
                                pe->id = (char *)bptr;
                                bptr += strlen(pe->id) + 1;
                        }
                        if (*bptr == '\0') {
                                pe->policy = NULL;
                        } else {
                                pe->policy = (char *)bptr;
                        }
                        pe->head_exec = NULL;
                        pe->prev_exec = NULL;
                        break;
                case 'I':
                        gbm = (struct nss_groupsbymem *)arg;
                        gbm->gid_array = (gid_t *)
                            ((void *)((char *)pbuf + pbuf->data_off));
                        gbm->force_slow_way = (int)(*uptr++);
                        gbm->maxgids = (int)(*uptr++);
                        gbm->numgids = (int)(*uptr++);
                        if (gbm->numgids == 1) {
                                /* insert initial group into data area */
                                gbm->gid_array[0] = (gid_t)(*uptr++);
                        } else
                                uptr++;
                        gbm->username = (const char *)uptr;
                        break;
                case 't':
                        pptr = (nss_pnetgr_t *)((void *)bptr);
                        ing = (struct nss_innetgr_args *)arg;
                        ing->arg[NSS_NETGR_MACHINE].argc = pptr->machine_argc;
                        ing->arg[NSS_NETGR_USER].argc = pptr->user_argc;
                        ing->arg[NSS_NETGR_DOMAIN].argc = pptr->domain_argc;
                        ing->groups.argc = pptr->groups_argc;

                        /*
                         * Start of argv pointer storage
                         */
                        off = ing->arg[NSS_NETGR_MACHINE].argc +
                            ing->arg[NSS_NETGR_USER].argc +
                            ing->arg[NSS_NETGR_DOMAIN].argc +
                            ing->groups.argc;
                        off *= sizeof (nssuint_t);
                        off += sizeof (nss_pnetgr_t);

                        cv = (char **)((void *)(bptr + off));
                        uptr = (nssuint_t *)
                            ((void *)(bptr + sizeof (nss_pnetgr_t)));
                        for (j = 0; j < NSS_NETGR_N; j++) {
                                ing->arg[j].argv = cv;
                                for (i = 0; i < ing->arg[j].argc; i++) {
                                        if (*uptr >= keysize)
                                                return (NSS_ERROR);
                                        *cv++ = (bptr + *uptr++);
                                }
                        }
                        ing->groups.argv = cv;
                        for (i = 0; i < ing->groups.argc; i++) {
                                if (*uptr >= keysize)
                                        return (NSS_ERROR);
                                *cv++ = (bptr + *uptr++);
                        }
                        break;
                case 'T':
                        sng = (struct nss_setnetgrent_args *)arg;
                        sng->netgroup = (const char *)bptr;
                        sng->iterator = 0;
                        break;

                default:
                        return (NSS_ERROR);
                }
        }
        return (NSS_SUCCESS);
}

static nss_status_t
nss_pinit_funcs(int index, nss_db_initf_t *initf, nss_str2ent_t *s2e)
{
        const char      *name;
        void            *htmp = NULL;
        void            *sym;
        static void     *handle = NULL;
        static mutex_t  handle_lock = DEFAULTMUTEX;
        static mutex_t  initf_lock = DEFAULTMUTEX;
        static mutex_t  s2e_lock = DEFAULTMUTEX;

        if (handle == NULL) {
                htmp = dlopen((const char *)0, RTLD_LAZY);

                lmutex_lock(&handle_lock);
                if (handle == NULL) {
                        if (htmp == NULL) {
                                lmutex_unlock(&handle_lock);
                                return (NSS_ERROR);
                        } else {
                                membar_producer();
                                handle = htmp;
                                htmp = NULL;
                        }
                }
                lmutex_unlock(&handle_lock);
                if (htmp)
                        (void) dlclose(htmp);
        }
        membar_consumer();

        if (initf) {
                if (getXbyY_to_dbop[index].initfnp == NULL) {
                        name = getXbyY_to_dbop[index].initfn;
                        if ((sym = dlsym(handle, name)) == NULL)
                                return (NSS_ERROR);
                        lmutex_lock(&initf_lock);
                        if (getXbyY_to_dbop[index].initfnp == NULL)
                                getXbyY_to_dbop[index].initfnp = sym;
                        membar_producer();
                        lmutex_unlock(&initf_lock);
                }
                membar_consumer();
                *initf = (nss_db_initf_t)getXbyY_to_dbop[index].initfnp;
        }
        if (s2e) {
                if (getXbyY_to_dbop[index].strfnp == NULL) {
                        name = getXbyY_to_dbop[index].strfn;
                        if ((sym = dlsym(handle, name)) == NULL)
                                return (NSS_ERROR);
                        lmutex_lock(&s2e_lock);
                        if (getXbyY_to_dbop[index].strfnp == NULL)
                                getXbyY_to_dbop[index].strfnp = sym;
                        membar_producer();
                        lmutex_unlock(&s2e_lock);
                }
                membar_consumer();
                *s2e = (nss_str2ent_t)getXbyY_to_dbop[index].strfnp;
        }

        return (NSS_SUCCESS);
}

nss_status_t
nss_packed_getkey(void *buffer, size_t length, char **dbname,
    int *dbop, nss_XbyY_args_t *arg)
{
        nss_pheader_t   *pbuf = (nss_pheader_t *)buffer;
        nss_dbd_t       *pdbd;
        nssuint_t       off, dbdsize;
        int             index;

        if (buffer == NULL || length == 0 || dbop == NULL ||
            arg == NULL || dbname == NULL)
                return (NSS_ERROR);

        *dbop = pbuf->nss_dbop;
        off = pbuf->dbd_off;
        pdbd = (nss_dbd_t *)((void *)((char *)buffer + off));
        dbdsize = pbuf->key_off - pbuf->dbd_off;
        if (pdbd->o_name >= dbdsize || pdbd->o_config_name >= dbdsize ||
            pdbd->o_default_config >= dbdsize)
                return (NSS_ERROR);
        *dbname = (char *)buffer + off + pdbd->o_name;
        if ((index = nss_dbop_search(*dbname, (uint32_t)*dbop)) < 0)
                return (NSS_ERROR);
        return (nss_upack_key2arg(buffer, length, dbname, dbop, arg, index));
}


/*
 * str2packent: Standard format interposed str2X function for normal APIs
 *
 * Return values: 0 = success, 1 = parse error, 2 = erange ...
 *
 * The structure pointer is ignored since this is a nscd side packed request.
 * The client side routine does all the real parsing; we just check limits and
 * store the entry in the buffer we were passed by the caller.
 */

static int
str2packent(
    const char *instr,
    int lenstr,
    void *ent __unused,         /* really (char *) */
    char *buffer,
    int buflen)
{
        if (buflen <= lenstr) {         /* not enough buffer */
                return (NSS_STR_PARSE_ERANGE);
        }
        (void) memmove(buffer, instr, lenstr);
        buffer[lenstr] = '\0';

        return (NSS_STR_PARSE_SUCCESS);
}

/*
 * Initialize db_root, initf, dbop and arg from a packed buffer
 */

nss_status_t
nss_packed_arg_init(void *buffer, size_t length,
    nss_db_root_t *db_root __unused,
    nss_db_initf_t *initf, int *dbop, nss_XbyY_args_t *arg)
{
        nss_pheader_t           *pbuf = (nss_pheader_t *)buffer;
        nss_str2ent_t           s2e = str2packent;
        nss_str2ent_t           real_s2e = NULL;
        nss_dbd_t               *pdbd;
        nssuint_t               off, dbdsize;
        char                    *dbname, *bptr;
        size_t                  len;
        int                     index;

        if (buffer == NULL || length == 0 ||
            dbop == NULL || arg == NULL)
                return (NSS_ERROR);

        /* init dbop */
        *dbop = pbuf->nss_dbop;
        off = pbuf->dbd_off;
        pdbd = (nss_dbd_t *)((void *)((char *)buffer + off));
        dbdsize = pbuf->key_off - pbuf->dbd_off;
        if (pdbd->o_name >= dbdsize || pdbd->o_config_name >= dbdsize ||
            pdbd->o_default_config >= dbdsize)
                return (NSS_ERROR);
        dbname = (char *)buffer + off + pdbd->o_name;
        if ((index = nss_dbop_search(dbname, (uint32_t)*dbop)) < 0)
                return (NSS_ERROR);

        /* db_root is initialized by nscd's based on door info */
        /* do nothing here */

        /* init key information - (and get dbname dbop etc...) */
        if (nss_upack_key2arg(buffer, length, &dbname,
            dbop, arg, index) != NSS_SUCCESS)
                return (NSS_ERROR);

        /* possible audituser init */
        if (strcmp(dbname, NSS_DBNAM_AUTHATTR) == 0)
                arg->h_errno = (int)pbuf->p_herrno;

        bptr = (char *)buffer + pbuf->data_off;
        len = (size_t)pbuf->data_len;

        /* sidestep odd arg cases */
        if (*dbop == NSS_DBOP_GROUP_BYMEMBER &&
            strcmp(dbname, NSS_DBNAM_GROUP) == 0) {
                /* get initf  and str2ent functions */
                if (nss_pinit_funcs(index, initf, &real_s2e) != NSS_SUCCESS)
                        return (NSS_ERROR);
                ((struct nss_groupsbymem *)arg)->str2ent = real_s2e;
                ((struct nss_groupsbymem *)arg)->process_cstr = process_cstr;
                return (NSS_SUCCESS);
        }
        if (pbuf->nss_dbop == NSS_DBOP_NETGROUP_IN &&
            strcmp(dbname, NSS_DBNAM_NETGROUP) == 0) {
                return (NSS_SUCCESS);
        }

        /* get initf  and str2ent functions */
        if (nss_pinit_funcs(index, initf, NULL) != NSS_SUCCESS)
                return (NSS_ERROR);

        /* init normal arg cases */
        NSS_XbyY_INIT(arg, NULL, bptr, len, s2e);
        arg->h_errno = 0;

        return (NSS_SUCCESS);
}

/*
 * Initialize db_root, initf, dbop, contextp and arg from a packed buffer
 */

nss_status_t
nss_packed_context_init(void *buffer, size_t length __unused,
    nss_db_root_t *db_root __unused,
    nss_db_initf_t *initf __unused, nss_getent_t **contextp __unused,
    nss_XbyY_args_t *arg)
{
        nss_pheader_t   *pbuf = (nss_pheader_t *)buffer;
        nss_str2ent_t   s2e = str2packent;
        char            *bptr;
        size_t          len;

        /* init arg */
        if (arg != NULL) {
                bptr = (char *)buffer + pbuf->data_off;
                len = (size_t)pbuf->data_len;
                NSS_XbyY_INIT(arg, NULL, bptr, len, s2e);
        }

        return (NSS_SUCCESS);
}