/*

 * 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.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#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;