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

#include "lint.h"
#include <mtlib.h>
#include <sys/types.h>
#include <errno.h>
#include <pwd.h>
#include <nss_dbdefs.h>
#include <stdio.h>
#include <string.h>
#include <synch.h>
#include <sys/param.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <getxby_door.h>
#include <sys/door.h>
#include <procfs.h>
#include <door.h>
#include <sys/mman.h>
#include "libc.h"
#include "tsd.h"
#include "base_conversion.h"

/* nss<->door hints */
static mutex_t  hints_lock = DEFAULTMUTEX;
static size_t   door_bsize = 0;
static size_t   door_nbsize = 0;
static int      proc_is_cache = -1;

/* library<->nscd door interaction apis */

/*
 *
 * Routine that actually performs the door call.
 * Note that we cache a file descriptor.  We do
 * the following to prevent disasters:
 *
 * 1) Never use 0,1 or 2; if we get this from the open
 *    we dup it upwards.
 *
 * 2) Set the close on exec flags so descriptor remains available
 *    to child processes.
 *
 * 3) Verify that the door is still the same one we had before
 *    by using door_info on the client side.
 *
 *      Note that we never close the file descriptor if it isn't one
 *      we allocated; we check this with door info.  The rather tricky
 *      logic is designed to be fast in the normal case (fd is already
 *      allocated and is ok) while handling the case where the application
 *      closed it underneath us or where the nscd dies or re-execs itself
 *      and we're a multi-threaded application.  Note that we cannot protect
 *      the application if it closes the fd and it is multi-threaded.
 *
 *  int _nsc_trydoorcall(void *dptr, size_t *bufsize, size_t *actualsize);
 *
 *      *dptr           IN: points to arg buffer OUT: points to results buffer
 *      *bufsize        IN: overall size of buffer OUT: overall size of buffer
 *      *actualsize     IN: size of call data OUT: size of return data
 *
 *  Note that *dptr may change if provided space as defined by *bufsize is
 *  inadequate.  In this case the door call mmaps more space and places
 *  the answer there and sets dptr to contain a pointer to the space, which
 *  should be freed with munmap.
 *
 *  Returns 0 if the door call reached the server, -1 if contact was not made.
 *
 */

/*
 * Max size for list of db names supported by the private nscd
 * No implied max here, any size will do, fixed size chosen to
 * reduce yet another malloc
 */

#define BD_BUFSIZE      1024
#define BD_SEP          ','

typedef struct _nsc_door_t {
        int             doorfd;
        mutex_t         door_lock;
        door_info_t     doori;
} nsc_door_t;

static nsc_door_t       nsc_door[2] = {
        { -1, DEFAULTMUTEX, { 0 } },            /* front (fattached) door */
        { -1, DEFAULTMUTEX, { 0 } },            /* back (private) door */
};

/* assumed to be locked by using nsc_door[1] mutex */
static char     *nsc_db_buf = NULL;
static char     **nsc_db_list = NULL;

/*
 * Check for a valid and matching db in the list.
 * assume list is in the locked state.
 */

static int
_nsc_use_backdoor(char *db)
{
        char    **ndb;

        if (db && nsc_db_buf != NULL && nsc_db_list != NULL) {
                for (ndb = nsc_db_list; *ndb; ndb++) {
                        if (strcmp(db, *ndb) == 0)
                                return (1);
                }
        }
        return (0);
}

/*
 * flush private db lists
 */
static void
_nsc_flush_private_db()
{
        if (nsc_db_buf != NULL) {
                libc_free((void *)nsc_db_buf);
                nsc_db_buf = NULL;
        }
        if (nsc_db_list != NULL) {
                libc_free((void *)nsc_db_list);
                nsc_db_list = NULL;
        }
}

/*
 * init/update nsc_db_buf given buff containing list of
 * db's to be processed by a private nscd.
 * This function assumes it has a well formed string from nscd.
 */

static int
_nsc_init_private_db(char *dblist)
{
        char    *cp, **lp;
        int     buflen = 0;
        int     arrlen = 0;

        if (dblist == NULL)
                return (0);

        /* reset db list */
        _nsc_flush_private_db();

        /* rebuild fresh list */
        buflen = strlen(dblist) + 1;
        for (cp = dblist; *cp; cp++)
                if (*cp == BD_SEP)
                        arrlen++;
        if (cp == dblist)
                return (0);
        arrlen += 2;
        nsc_db_buf = (char *)libc_malloc(buflen);
        if (nsc_db_buf == (char *)NULL)
                return (0);
        nsc_db_list = (char **)libc_malloc(arrlen * sizeof (char *));
        if (nsc_db_list == (char **)NULL) {
                libc_free((void *)nsc_db_buf);
                nsc_db_buf = NULL;
                return (0);
        }
        (void) memcpy(nsc_db_buf, dblist, buflen);
        lp = nsc_db_list;
        *lp++ = nsc_db_buf;
        for (cp = nsc_db_buf; *cp; ) {
                if (*cp == BD_SEP) {
                        *cp++ = '\0';
                        *lp++ = cp;
                } else
                        cp++;
        }
        *lp = NULL;
        return (1);
}

/*
 * _nsc_initdoor_fp attempts to validate the given door and
 * confirm that it is still available for use.  The options are:
 *      Front door:
 *              If it's not open, attempt to open or error
 *              If it's open attempt to validate.
 *              If it's not validatable, reset fd and try again.
 *              Other wise it open and validated, return success
 *      Per user (back) door:
 *              This door is passed to the client through th front door
 *              attempt to validate it.  If it can't be validated, it
 *              must be reset. Then send a NSS_ALTRESET error, so nscd can
 *              forward another fd if desired.
 */

static nss_status_t
_nsc_initdoor_fp(nsc_door_t *dp)
{

        door_info_t             my_door;

        if (dp == NULL) {
                errno = ENOTCONN;
                return (NSS_ERROR);
        }

        /*
         * the first time in we try and open and validate the front door.
         * A front door request may return an alternate private back door
         * that the client should use instead.
         *
         * To validate a door the door must have been created with
         * the name service door cookie. The front door is file
         * attached, owned by root and readonly by user, group and
         * other.  If any of these validations fail we refuse to use
         * the door.  A back door is delivered from the front door
         * via a door_desc_t, and have the same cooke notification.
         */

        lmutex_lock(&dp->door_lock);

try_again:

        if (dp->doorfd == -1 && dp == &nsc_door[0]) {   /* open front door */
                int             tbc[3];
                int             i;

                dp->doorfd = open64(NAME_SERVICE_DOOR, O_RDONLY, 0);
                if (dp->doorfd == -1) {
                        lmutex_unlock(&dp->door_lock);
                        return (NSS_ERROR);
                }

                /*
                 * dup up the file descriptor if we have 0 - 2
                 * to avoid problems with shells stdin/out/err
                 */
                i = 0;

                while (dp->doorfd < 3) { /* we have a reserved fd */
                        tbc[i++] = dp->doorfd;
                        if ((dp->doorfd = dup(dp->doorfd)) < 0) {
                                while (i--)
                                        (void) close(tbc[i]);
                                dp->doorfd = -1;
                                lmutex_unlock(&dp->door_lock);
                                return (NSS_ERROR);
                        }
                }

                while (i--)
                        (void) close(tbc[i]);

                /*
                 * mark this door descriptor as close on exec
                 */
                (void) fcntl(dp->doorfd, F_SETFD, FD_CLOEXEC);
                if (__door_info(dp->doorfd, &dp->doori) < 0 ||
                    (dp->doori.di_attributes & DOOR_REVOKED) ||
                    dp->doori.di_data != (uintptr_t)NAME_SERVICE_DOOR_COOKIE) {
                        /*
                         * we should close doorfd because we just opened it
                         */
                        (void) close(dp->doorfd);
                        dp->doorfd = -1;
                        (void) memset((void *)&dp->doori,
                            '\0', sizeof (door_info_t));
                        lmutex_unlock(&dp->door_lock);
                        errno = ECONNREFUSED;
                        return (NSS_ERROR);
                }
        } else {
                if (__door_info(dp->doorfd, &my_door) < 0 ||
                    my_door.di_data != (uintptr_t)NAME_SERVICE_DOOR_COOKIE ||
                    my_door.di_uniquifier != dp->doori.di_uniquifier) {
                        /*
                         * don't close it -
                         * someone else has clobbered fd
                         */
                        dp->doorfd = -1;
                        (void) memset((void *)&dp->doori,
                            '\0', sizeof (door_info_t));
                        if (dp == &nsc_door[1]) {       /* reset back door */
                                /* flush invalid db list */
                                _nsc_flush_private_db();
                                lmutex_unlock(&dp->door_lock);
                                return (NSS_ALTRESET);
                        }
                        goto try_again;
                }

                if (my_door.di_attributes & DOOR_REVOKED) {
                        (void) close(dp->doorfd);       /* nscd exited .... */
                        dp->doorfd = -1;        /* try and restart connection */
                        (void) memset((void *)&dp->doori,
                            '\0', sizeof (door_info_t));
                        if (dp == &nsc_door[1]) {       /* back door reset */
                                /* flush invalid db list */
                                _nsc_flush_private_db();
                                lmutex_unlock(&dp->door_lock);
                                return (NSS_ALTRESET);
                        }
                        goto try_again;
                }
        }

        lmutex_unlock(&dp->door_lock);
        return (NSS_SUCCESS);
}

/*
 * Try the door request once only, to the specified connection.
 * return the results or error.
 */

static nss_status_t
_nsc_try1door(nsc_door_t *dp, void **dptr, size_t *ndata,
                        size_t *adata, int *pdesc)
{
        door_arg_t              param;
        int                     ret;
        nss_pheader_t           *rp;

        ret = _nsc_initdoor_fp(dp);
        if (ret != NSS_SUCCESS)
                return (ret);

        param.rbuf = (char *)*dptr;
        param.rsize = *ndata;
        param.data_ptr = (char *)*dptr;
        param.data_size = *adata;
        param.desc_ptr = NULL;
        param.desc_num = 0;
        ret = __door_call(dp->doorfd, &param);
        if (ret < 0) {
                return (NSS_ERROR);
        }
        *adata = param.data_size;
        *ndata = param.rsize;
        *dptr = (void *)param.data_ptr;
        rp = (nss_pheader_t *)((void *)param.rbuf);
        if (pdesc != NULL && rp && rp->p_status == NSS_ALTRETRY &&
            param.desc_ptr != NULL && param.desc_num > 0) {
                if ((param.desc_ptr->d_attributes & DOOR_DESCRIPTOR) &&
                    param.desc_ptr->d_data.d_desc.d_descriptor >= 0 &&
                    param.desc_ptr->d_data.d_desc.d_id != 0) {
                        /* have an alt descriptor */
                        *pdesc = param.desc_ptr->d_data.d_desc.d_descriptor;
                        /* got a NSS_ALTRETRY command */
                        return (NSS_ALTRETRY);
                }
                errno = EINVAL;
                return (NSS_ERROR);             /* other error? */
        }
        if (*adata == 0 || *dptr == NULL) {
                errno = ENOTCONN;
                return (NSS_ERROR);
        }

        if (rp->p_status == NSS_ALTRESET ||
            rp->p_status == NSS_ALTRETRY ||
            rp->p_status == NSS_TRYLOCAL)
                return (rp->p_status);

        return (NSS_SUCCESS);
}

/*
 * Backwards compatible API
 */

nss_status_t
_nsc_trydoorcall(void **dptr, size_t *ndata, size_t *adata)
{
        return (_nsc_try1door(&nsc_door[0], dptr, ndata, adata, NULL));
}

/*
 * Send the request to the designated door, based on the supplied db
 * Retry on the alternate door fd if possible.
 */

nss_status_t
_nsc_trydoorcall_ext(void **dptr, size_t *ndata, size_t *adata)
{
        int             ret = NSS_ALTRETRY;
        nsc_door_t      *frontd = &nsc_door[0];
        nsc_door_t      *backd = &nsc_door[1];
        int             fd;

        nss_pheader_t   *ph, ph_save;
        char            *dbl;
        char            *db = NULL;
        nss_dbd_t       *dbd;
        int             fb2frontd = 0;
        int             reset_frontd = 0;
        size_t          ndata_save = *ndata, adata_save = *adata;
        void            *dptr_save = *dptr;

        ph = (nss_pheader_t *)*dptr;
        dbd = (nss_dbd_t *)((void *)((char *)ph + ph->dbd_off));
        if (dbd->o_name != 0)
                db = (char *)dbd + dbd->o_name;

        /*
         * save away a copy of the header, in case the request needs
         * to be sent to nscd more than once. In that case, this
         * original header can be copied back to the door buffer
         * to replace the possibly changed header
         */
        ph_save = *ph;

        while (ret == NSS_ALTRETRY || ret == NSS_ALTRESET) {
                /* try private (back) door first if it exists and applies */
                if (db != NULL && backd->doorfd > 0 && fb2frontd == 0 &&
                    _nsc_use_backdoor(db)) {
                        ret = _nsc_try1door(backd, dptr, ndata, adata, NULL);
                        if (ret == NSS_ALTRESET) {
                                /*
                                 * received NSS_ALTRESET command,
                                 * retry on front door
                                 */
                                lmutex_lock(&backd->door_lock);
                                backd->doorfd = -1;
                                (void) memset((void *)&backd->doori,
                                    '\0', sizeof (door_info_t));
                                /* flush now invalid db list */
                                _nsc_flush_private_db();
                                lmutex_unlock(&backd->door_lock);
                                continue;
                        } else if (ret == NSS_ALTRETRY) {
                                /*
                                 * received NSS_ALTRETRY command,
                                 * fall back and retry on front door
                                 */
                                fb2frontd = 1;
                                if (*dptr != dptr_save)
                                        (void) munmap((void *)*dptr, *ndata);

                                /*
                                 * restore the buffer size and header
                                 * data so that the front door will
                                 * see the original request
                                 */
                                *ndata = ndata_save;
                                *adata = adata_save;
                                *dptr = dptr_save;
                                ph =  (nss_pheader_t *)*dptr;
                                *ph = ph_save;
                                /*
                                 * tell the front door server, this is
                                 * a fallback call
                                 */
                                ph->p_status = NSS_ALTRETRY;
                                continue;
                        }

                        /* return the result or error */
                        break;
                }

                /* try the front door */
                fd = -1;
                ret = _nsc_try1door(frontd, dptr, ndata, adata, &fd);

                if (ret != NSS_ALTRETRY) {
                        /*
                         * got a success or failure result.
                         * but front door should never send NSS_ALTRESET
                         */
                        if (ret == NSS_ALTRESET)
                                /* reset the front door */
                                reset_frontd = 1;
                        else
                                /*
                                 * not NSS_ALTRETRY and not NSS_ALTRESET
                                 * return the result or error
                                 */
                                break;
                } else if (fb2frontd == 1) {
                        /*
                         * front door should never send NSS_ALTRETRY
                         * in a fallback call. Reset the front door.
                         */
                        reset_frontd = 1;
                }

                if (reset_frontd == 1) {
                        lmutex_lock(&frontd->door_lock);
                        frontd->doorfd = -1;
                        (void) memset((void *)&frontd->doori,
                            '\0', sizeof (door_info_t));
                        lmutex_unlock(&frontd->door_lock);
                        /* error out */
                        ret = NSS_ERROR;
                        break;
                }

                /* process NSS_ALTRETRY request from front door */
                if (fd < 0)
                        continue;       /* no new door given, try again */

                /* update and try alternate door */
                lmutex_lock(&backd->door_lock);
                if (backd->doorfd >= 0) {
                        /* unexpected open alt door - clean up, continue */
                        _nsc_flush_private_db();
                        (void) close(backd->doorfd);
                }

                /* set up back door fd */
                backd->doorfd = fd;

                /* set up back door db list */
                ph =  (nss_pheader_t *)*dptr;
                dbl = ((char *)ph) + ph->data_off;

                if (_nsc_init_private_db(dbl) == 0) {
                        /* could not init db list, try again */
                        (void) close(backd->doorfd);
                        backd->doorfd = -1;
                        lmutex_unlock(&backd->door_lock);
                        continue;
                }
                if (door_info(backd->doorfd, &backd->doori) < 0 ||
                    (backd->doori.di_attributes & DOOR_REVOKED) ||
                    backd->doori.di_data !=
                    (uintptr_t)NAME_SERVICE_DOOR_COOKIE) {
                        /* doorfd bad, or must not really be open */
                        (void) close(backd->doorfd);
                        backd->doorfd = -1;
                        (void) memset((void *)&backd->doori,
                            '\0', sizeof (door_info_t));
                }
                (void) fcntl(backd->doorfd, F_SETFD, FD_CLOEXEC);
                lmutex_unlock(&backd->door_lock);
                /* NSS_ALTRETRY new back door */
                if (*dptr != dptr_save)
                        (void) munmap((void *)*dptr, *ndata);

                /*
                 * restore the buffer size and header
                 * data so that the back door will
                 * see the original request
                 */
                *ndata = ndata_save;
                *adata = adata_save;
                *dptr = dptr_save;
                ph =  (nss_pheader_t *)*dptr;
                *ph = ph_save;
        }
        return (ret);
}

/*
 * Get the current (but growable) buffer size for a NSS2 packet.
 * Heuristic algorithm used:
 *      1) Make sure it's at least NSS_BUFLEN_DOOR in length (16k default)
 *      2) if an incoming user buffer is > larger than the current size
 *         Make the buffer at least NSS_BUFLEN_DOOR/2+user buffer size
 *         This should account for any reasonable nss_pheader, keys
 *         extended area etc.
 *      3) keep the prototype/debugging (private)NSS_BUFLEN option
 *         to change any preconfigured value if needed(?)
 */

static size_t
_nsc_getdoorbsize(size_t min_size)
{
        if (!door_bsize) {
                lmutex_lock(&hints_lock);
                if (!door_bsize) {
                        /* future work - get nscd hint & use hint size */
                        door_bsize = ROUND_UP(door_bsize, NSS_BUFSIZ);
                        if (door_bsize < NSS_BUFLEN_DOOR) {
                                door_bsize = NSS_BUFLEN_DOOR;
                        }
                }
                lmutex_unlock(&hints_lock);
        }
        if (min_size && door_bsize < (min_size + NSS_BUFLEN_DOOR/2)) {
                lmutex_lock(&hints_lock);
                if (door_bsize < (min_size + NSS_BUFLEN_DOOR/2)) {
                        min_size += NSS_BUFLEN_DOOR;
                        door_bsize = ROUND_UP(min_size, NSS_BUFSIZ);
                }
                lmutex_unlock(&hints_lock);
        }
        return (door_bsize);
}

static void
_nsc_freedbuf(void *arg)
{
        nss_XbyY_buf_t *tsdbuf = arg;

        if (tsdbuf != NULL && tsdbuf->buffer != NULL) {
                lfree(tsdbuf->buffer, (size_t)tsdbuf->buflen);
                tsdbuf->result = NULL;
                tsdbuf->buffer = NULL;
                tsdbuf->buflen = 0;
        }
}

/*
 * _nsc_getdoorbuf - return the client side per thread door buffer
 * Elsewhere, it is assumed that the header is 0'd upon return from here.
 */

int
_nsc_getdoorbuf(void **doorptr, size_t *bufsize)
{
        nss_XbyY_buf_t *tsdbuf;
        char *bp;
        size_t dsize;

        if (doorptr == NULL || bufsize == NULL)
                return (-1);

        /* Get thread specific pointer to door buffer */
        tsdbuf = tsdalloc(_T_DOORBUF, sizeof (nss_XbyY_buf_t), _nsc_freedbuf);
        if (tsdbuf == NULL)
                return (-1);

        /* if door buffer does not exist create it */
        if (tsdbuf->buffer == NULL) {
                dsize = _nsc_getdoorbsize(*bufsize);

                /* setup a door buffer with a total length of dsize */
                bp = lmalloc(dsize);
                if (bp == NULL)
                        return (-1);
                tsdbuf->buffer = bp;
                tsdbuf->buflen = dsize;
        } else {
                /* check old buffer size and resize if needed */
                if (*bufsize) {
                        dsize = _nsc_getdoorbsize(*bufsize);
                        if (tsdbuf->buflen < dsize) {
                                lfree(tsdbuf->buffer, (size_t)tsdbuf->buflen);
                                bp = lmalloc(dsize);
                                if (bp == NULL)
                                        return (-1);
                                tsdbuf->buffer = bp;
                                tsdbuf->buflen = dsize;
                        }
                }
                /* freshly malloc'd door bufs are 0'd */
                /* 0 header for now.  Zero entire buf(?) TDB */
                (void) memset((void *)tsdbuf->buffer, 0,
                    (size_t)sizeof (nss_pheader_t));

        }
        *doorptr = (void *)tsdbuf->buffer;
        *bufsize = tsdbuf->buflen;
        return (0);
}

void
_nsc_resizedoorbuf(size_t bsize)
{
        /* signal to update if new door size is desired */
        lmutex_lock(&hints_lock);
        if (bsize > door_bsize && door_nbsize < bsize)
                door_nbsize = bsize;
        lmutex_unlock(&hints_lock);
}

/*
 * Check uid and /proc/PID/psinfo to see if this process is nscd
 * If it is set the appropriate flags and allow policy reconfiguration.
 */
int
_nsc_proc_is_cache()
{
        psinfo_t        pinfo;
        char            fname[128];
        int             ret;
        int             fd;

        if (proc_is_cache >= 0)
                return (proc_is_cache);
        lmutex_lock(&hints_lock);
        if (proc_is_cache >= 0) {
                lmutex_unlock(&hints_lock);
                return (proc_is_cache);
        }
        proc_is_cache = 0;
        /* It can't be nscd if it's not running as root... */
        if (getuid() != 0) {
                lmutex_unlock(&hints_lock);
                return (0);
        }
        ret = snprintf(fname, 128, "/proc/%d/psinfo", getpid());
        if (ret > 0 && ret < 128) {
                if ((fd = open(fname,  O_RDONLY)) >= 0) {
                        ret = read(fd, &pinfo, sizeof (psinfo_t));
                        (void) close(fd);
                        if (ret == sizeof (psinfo_t) &&
                            (strcmp(pinfo.pr_fname, "nscd") == 0)) {
                                /* process runs as root and is named nscd */
                                /* that's good enough for now */
                                proc_is_cache = 1;
                        }
                }
        }
        lmutex_unlock(&hints_lock);
        return (proc_is_cache);
}