/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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
 */
/* LINTLIBRARY */

/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * nfs security related library routines.
 *
 * Some of the routines in this file are adopted from
 * lib/libnsl/netselect/netselect.c and are modified to be
 * used for accessing /etc/nfssec.conf.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"
/* SVr4.0 1.18	*/

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <syslog.h>
#include <synch.h>
#include <rpc/rpc.h>
#include <nfs/nfs_sec.h>
#include <rpc/rpcsec_gss.h>
#ifdef WNFS_SEC_NEGO
#include "webnfs.h"
#endif

#define	GETBYNAME	1
#define	GETBYNUM	2

/*
 * mapping for /etc/nfssec.conf
 */
struct sc_data {
	char	*string;
	int	value;
};

static struct sc_data sc_service[] = {
	"default",	rpc_gss_svc_default,
	"-",		rpc_gss_svc_none,
	"none",		rpc_gss_svc_none,
	"integrity",	rpc_gss_svc_integrity,
	"privacy",	rpc_gss_svc_privacy,
	NULL,		SC_FAILURE
};

static char *gettoken(char *, int);
extern	int atoi(const char *str);

extern	bool_t rpc_gss_get_principal_name(rpc_gss_principal_t *, char *,
			char *, char *, char *);

extern	bool_t rpc_gss_mech_to_oid(char *, rpc_gss_OID *);
extern	bool_t rpc_gss_qop_to_num(char *, char *, uint_t *);

/*
 *  blank() returns true if the line is a blank line, 0 otherwise
 */
static int
blank(cp)
char *cp;
{
	while (*cp && isspace(*cp)) {
		cp++;
	}
	return (*cp == '\0');
}

/*
 *  comment() returns true if the line is a comment, 0 otherwise.
 */
static int
comment(cp)
char *cp;
{
	while (*cp && isspace(*cp)) {
		cp++;
	}
	return (*cp == '#');
}


/*
 *	getvalue() searches for the given string in the given array,
 *	and returns the integer value associated with the string.
 */
static unsigned long
getvalue(cp, sc_data)
char *cp;
struct sc_data sc_data[];
{
	int i;	/* used to index through the given struct sc_data array */

	for (i = 0; sc_data[i].string; i++) {
		if (strcmp(sc_data[i].string, cp) == 0) {
			break;
		}
	}
	return (sc_data[i].value);
}

/*
 *	shift1left() moves all characters in the string over 1 to
 *	the left.
 */
static void
shift1left(p)
char *p;
{
	for (; *p; p++)
		*p = *(p + 1);
}


/*
 *	gettoken() behaves much like strtok(), except that
 *	it knows about escaped space characters (i.e., space characters
 *	preceeded by a '\' are taken literally).
 *
 *	XXX We should make this MT-hot by making it more like strtok_r().
 */
static char *
gettoken(cp, skip)
char	*cp;
int skip;
{
	static char	*savep;	/* the place where we left off    */
	register char	*p;	/* the beginning of the new token */
	register char	*retp;	/* the token to be returned	  */


	/* Determine if first or subsequent call  */
	p = (cp == NULL)? savep: cp;

	/* Return if no tokens remain.  */
	if (p == 0) {
		return (NULL);
	}

	while (isspace(*p))
		p++;

	if (*p == '\0') {
		return (NULL);
	}

	/*
	 *	Save the location of the token and then skip past it
	 */

	retp = p;
	while (*p) {
		if (isspace(*p))
			if (skip == TRUE) {
				shift1left(p);
				continue;
			} else
				break;
		/*
		 *	Only process the escape of the space separator;
		 *	since the token may contain other separators,
		 *	let the other routines handle the escape of
		 *	specific characters in the token.
		 */

		if (*p == '\\' && *(p + 1) != '\n' && isspace(*(p + 1))) {
			shift1left(p);
		}
		p++;
	}
	if (*p == '\0') {
		savep = 0;	/* indicate this is last token */
	} else {
		*p = '\0';
		savep = ++p;
	}
	return (retp);
}

/*
 *  matchname() parses a line of the /etc/nfssec.conf file
 *  and match the sc_name with the given name.
 *  If there is a match, it fills the information into the given
 *  pointer of the seconfig_t structure.
 *
 *  Returns TRUE if a match is found.
 */
static bool_t
matchname(char *line, char *name, seconfig_t *secp)
{
	char	*tok1,	*tok2;	/* holds a token from the line */
	char	*secname, *gss_mech, *gss_qop; /* pointer to a secmode name */

	if ((secname = gettoken(line, FALSE)) == NULL) {
		/* bad line */
		return (FALSE);
	}

	if (strcmp(secname, name) != 0) {
		return (FALSE);
	}

	tok1 = tok2 = NULL;
	if (((tok1 = gettoken(NULL, FALSE)) == NULL) ||
		((gss_mech = gettoken(NULL, FALSE)) == NULL) ||
		((gss_qop = gettoken(NULL, FALSE)) == NULL) ||
		((tok2 = gettoken(NULL, FALSE)) == NULL) ||
		((secp->sc_service = getvalue(tok2, sc_service))
			== SC_FAILURE)) {
		return (FALSE);
	}
	secp->sc_nfsnum = atoi(tok1);
	(void) strcpy(secp->sc_name, secname);
	(void) strcpy(secp->sc_gss_mech, gss_mech);
	secp->sc_gss_mech_type = NULL;
	if (secp->sc_gss_mech[0] != '-') {
	    if (!rpc_gss_mech_to_oid(gss_mech, &secp->sc_gss_mech_type) ||
		!rpc_gss_qop_to_num(gss_qop, gss_mech, &secp->sc_qop)) {
		return (FALSE);
	    }
	}

	return (TRUE);
}

/*
 *  matchnum() parses a line of the /etc/nfssec.conf file
 *  and match the sc_nfsnum with the given number.
 *  If it is a match, it fills the information in the given pointer
 *  of the seconfig_t structure.
 *
 *  Returns TRUE if a match is found.
 */
static bool_t
matchnum(char *line, int num, seconfig_t *secp)
{
	char	*tok1,	*tok2;	/* holds a token from the line */
	char	*secname, *gss_mech, *gss_qop;	/* pointer to a secmode name */

	if ((secname = gettoken(line, FALSE)) == NULL) {
		/* bad line */
		return (FALSE);
	}

	tok1 = tok2 = NULL;
	if ((tok1 = gettoken(NULL, FALSE)) == NULL) {
		/* bad line */
		return (FALSE);
	}

	if ((secp->sc_nfsnum = atoi(tok1)) != num) {
		return (FALSE);
	}

	if (((gss_mech = gettoken(NULL, FALSE)) == NULL) ||
		((gss_qop = gettoken(NULL, FALSE)) == NULL) ||
		((tok2 = gettoken(NULL, FALSE)) == NULL) ||
		((secp->sc_service = getvalue(tok2, sc_service))
			== SC_FAILURE)) {
		return (FALSE);
	}

	(void) strcpy(secp->sc_name, secname);
	(void) strcpy(secp->sc_gss_mech, gss_mech);
	if (secp->sc_gss_mech[0] != '-') {
	    if (!rpc_gss_mech_to_oid(gss_mech, &secp->sc_gss_mech_type) ||
		!rpc_gss_qop_to_num(gss_qop, gss_mech, &secp->sc_qop)) {
		return (FALSE);
	    }
	}

	return (TRUE);
}

/*
 *  Fill in the RPC Protocol security flavor number
 *  into the sc_rpcnum of seconfig_t structure.
 *
 *  Mainly to map NFS secmod number to RPCSEC_GSS if
 *  a mechanism name is specified.
 */
static void
get_rpcnum(seconfig_t *secp)
{
	if (secp->sc_gss_mech[0] != '-') {
		secp->sc_rpcnum = RPCSEC_GSS;
	} else {
		secp->sc_rpcnum = secp->sc_nfsnum;
	}
}

/*
 *  Parse a given hostname (nodename[.domain@realm]) to
 *  instant name (nodename[.domain]) and realm.
 *
 *  Assuming user has allocated the space for inst and realm.
 */
static int
parsehostname(char *hostname, char *inst, char *realm)
{
	char *h, *r;

	if (!hostname)
		return (0);

	h = (char *)strdup(hostname);
	if (!h) {
		syslog(LOG_ERR, "parsehostname: no memory\n");
		return (0);
	}

	r = (char *)strchr(h, '@');
	if (!r) {
		(void) strcpy(inst, h);
		(void) strcpy(realm, "");
	} else {
		*r++ = '\0';
		(void) strcpy(inst, h);
		(void) strcpy(realm, r);
	}
	free(h);
	return (1);
}

/*
 *  Get the name corresponding to a qop num.
 */
char *
nfs_get_qop_name(seconfig_t *entryp)
{
	char	*tok;	/* holds a token from the line */
	char	*secname, *gss_qop = NULL; /* pointer to a secmode name */
	static	mutex_t matching_lock = DEFAULTMUTEX;
	char	line[BUFSIZ];	/* holds each line of NFSSEC_CONF */
	FILE	*fp;		/* file stream for NFSSEC_CONF */

	if ((fp = fopen(NFSSEC_CONF, "r")) == NULL) {
	    return (NULL);
	}

	(void) mutex_lock(&matching_lock);
	while (fgets(line, BUFSIZ, fp)) {
	    if (!(blank(line) || comment(line))) {
		if ((secname = gettoken(line, FALSE)) == NULL) {
		    /* bad line */
		    continue;
		}
		if (strcmp(secname, entryp->sc_name) == 0) {
		    tok = NULL;
		    if ((tok = gettoken(NULL, FALSE)) == NULL) {
			/* bad line */
			goto err;
		    }

		    if (atoi(tok) != entryp->sc_nfsnum)
			goto err;

		    if ((gettoken(NULL, FALSE) == NULL) ||
			((gss_qop = gettoken(NULL, FALSE)) == NULL)) {
			goto err;
		    }
		    break;
		}
	    }
	}
err:
	(void) mutex_unlock(&matching_lock);
	(void) fclose(fp);
	return (gss_qop);
}

/*
 * This routine creates an auth handle assocaited with the
 * negotiated security flavor contained in nfs_sec.  The auth
 * handle will be used in the next LOOKUP request to fetch
 * the filehandle.
 */
AUTH *
nfs_create_ah(CLIENT *cl, char *hostname, seconfig_t *nfs_sec)
{
	char netname[MAXNETNAMELEN+1];
	char svc_name[MAXNETNAMELEN+1];
	char *gss_qop;
	static int window = 60;

	if (nfs_sec == NULL)
	    goto err;

	switch (nfs_sec->sc_rpcnum) {
	    case AUTH_UNIX:
	    case AUTH_NONE:
		return (NULL);

	    case AUTH_DES:
		if (!host2netname(netname, hostname, NULL))
		    goto err;

		return (authdes_seccreate(netname, window, hostname, NULL));

	    case RPCSEC_GSS:
		if (cl == NULL)
		    goto err;

		if (nfs_sec->sc_gss_mech_type == NULL) {
		    syslog(LOG_ERR,
			"nfs_create_ah: need mechanism information\n");
		    goto err;
		}

		/* RPCSEC_GSS service names are of the form svc@host.dom */
		(void) sprintf(svc_name, "nfs@%s", hostname);

		gss_qop = nfs_get_qop_name(nfs_sec);
		if (gss_qop == NULL)
		    goto err;

		return (rpc_gss_seccreate(cl, svc_name, nfs_sec->sc_gss_mech,
			nfs_sec->sc_service, gss_qop, NULL, NULL));

	    default:
		syslog(LOG_ERR, "nfs_create_ah: unknown flavor\n");
		return (NULL);
	}
err:
	syslog(LOG_ERR, "nfs_create_ah: failed to make auth handle\n");
	return (NULL);
}

#ifdef WNFS_SEC_NEGO
/*
 * This routine negotiates sec flavors with server and returns:
 *	SNEGO_SUCCESS:		successful; sec flavors are
 *				returned in snego,
 *	SNEGO_DEF_VALID:	default sec flavor valid; no need
 *				to negotiate flavors,
 *	SNEGO_ARRAY_TOO_SMALL:	array too small,
 *	SNEGO_FAILURE:		failure
 */
/*
 * The following depicts how sec flavors are placed in an
 * overloaded V2 fhandle:
 *
 * Note that the first four octets contain the length octet,
 * the status octet, and two padded octets to make them XDR
 * four-octet aligned.
 *
 *   1   2   3   4                                          32
 * +---+---+---+---+---+---+---+---+   +---+---+---+---+   +---+
 * | l | s |   |   |     sec_1     |...|     sec_n     |...|   |
 * +---+---+---+---+---+---+---+---+   +---+---+---+---+   +---+
 *
 * where
 *
 *   the status octet s indicates whether there are more security
 *   flavors(1 means yes, 0 means no) that require the client to
 *   perform another 0x81 LOOKUP to get them,
 *
 *   the length octet l is the length describing the number of
 *   valid octets that follow.  (l = 4 * n, where n is the number
 *
 * The following depicts how sec flavors are placed in an
 * overloaded V3 fhandle:
 *
 *  1        4
 * +--+--+--+--+
 * |    len    |
 * +--+--+--+--+
 *                                               up to 64
 * +--+--+--+--+--+--+--+--+--+--+--+--+     +--+--+--+--+
 * |s |  |  |  |   sec_1   |   sec_2   | ... |   sec_n   |
 * +--+--+--+--+--+--+--+--+--+--+--+--+     +--+--+--+--+
 *
 * len = 4 * (n+1), where n is the number of security flavors
 * sent in the current overloaded filehandle.
 *
 * the status octet s indicates whether there are more security
 * mechanisms(1 means yes, 0 means no) that require the client
 * to perform another 0x81 LOOKUP to get them.
 *
 * Three octets are padded after the status octet.
 */
enum snego_stat
nfs_sec_nego(rpcprog_t vers, CLIENT *clnt, char *fspath, struct snego_t *snego)
{
	enum clnt_stat rpc_stat;
	static int MAX_V2_CNT = (WNL_FHSIZE/sizeof (int)) - 1;
	static int MAX_V3_CNT = (WNL3_FHSIZE/sizeof (int)) - 1;
	static struct timeval TIMEOUT = { 25, 0 };
	int status;

	if (clnt == NULL || fspath == NULL || snego == NULL)
	    return (SNEGO_FAILURE);

	if (vers == WNL_V2) {
	    wnl_diropargs arg;
	    wnl_diropres clnt_res;

	    memset((char *)&arg.dir, 0, sizeof (wnl_fh));
	    arg.name = fspath;
	    memset((char *)&clnt_res, 0, sizeof (clnt_res));
	    rpc_stat = clnt_call(clnt, WNLPROC_LOOKUP,
		    (xdrproc_t)xdr_wnl_diropargs, (caddr_t)&arg,
		    (xdrproc_t)xdr_wnl_diropres, (caddr_t)&clnt_res,
			TIMEOUT);
	    if (rpc_stat == RPC_SUCCESS && clnt_res.status == WNL_OK)
		return (SNEGO_DEF_VALID);
	    if (rpc_stat != RPC_AUTHERROR)
		return (SNEGO_FAILURE);

	    {
		struct rpc_err e;
		wnl_diropres *res;
		char *p;
		int tot = 0;

		CLNT_GETERR(clnt, &e);
		if (e.re_why != AUTH_TOOWEAK)
		    return (SNEGO_FAILURE);

		if ((p = malloc(strlen(fspath)+3)) == NULL) {
		    syslog(LOG_ERR, "no memory\n");
		    return (SNEGO_FAILURE);
		}
		/*
		 * Do an x81 LOOKUP
		 */
		p[0] = (char)WNL_SEC_NEGO;
		strcpy(&p[2], fspath);
		do {
		    p[1] = (char)(1+snego->cnt); /* sec index */
		    arg.name = p;
		    res = wnlproc_lookup_2(&arg, clnt);
		    if (res == NULL || res->status != WNL_OK) {
			free(p);
			return (SNEGO_FAILURE);
		    }

			/*
			 * retrieve flavors from filehandle:
			 *	1st byte: length
			 *	2nd byte: status
			 *	3rd & 4th: pad
			 *	5th and after: sec flavors.
			 */
		    {
			char *c = (char *)&res->wnl_diropres_u.
			    wnl_diropres.file;
			int ii;
			int cnt = ((int)*c)/sizeof (uint_t);
			/* LINTED pointer alignment */
			int *ip = (int *)(c+sizeof (int));

			tot += cnt;
			if (tot >= MAX_FLAVORS) {
			    free(p);
			    return (SNEGO_ARRAY_TOO_SMALL);
			}
			status = (int)*(c+1);
			if (cnt > MAX_V2_CNT || cnt < 0) {
			    free(p);
			    return (SNEGO_FAILURE);
			}
			for (ii = 0; ii < cnt; ii++)
			    snego->array[snego->cnt+ii] =
				ntohl(*(ip+ii));
			snego->cnt += cnt;
		    }
		} while (status);
		free(p);
		return (SNEGO_SUCCESS);
	    }
	} else if (vers == WNL_V3) {
	    WNL_LOOKUP3args arg;
	    WNL_LOOKUP3res clnt_res;

	    memset((char *)&arg.what.dir, 0, sizeof (wnl_fh3));
	    arg.what.name = fspath;
	    arg.what.dir.data.data_len = 0;
	    arg.what.dir.data.data_val = 0;
	    memset((char *)&clnt_res, 0, sizeof (clnt_res));
	    rpc_stat = clnt_call(clnt, WNLPROC3_LOOKUP,
		(xdrproc_t)xdr_WNL_LOOKUP3args, (caddr_t)&arg,
		(xdrproc_t)xdr_WNL_LOOKUP3res, (caddr_t)&clnt_res,
		TIMEOUT);
	    if (rpc_stat == RPC_SUCCESS && clnt_res.status == WNL3_OK)
		return (SNEGO_DEF_VALID);
	    if (rpc_stat != RPC_AUTHERROR)
		return (SNEGO_FAILURE);

	    {
		struct rpc_err e;
		WNL_LOOKUP3res *res;
		char *p;
		int tot = 0;

		CLNT_GETERR(clnt, &e);
		if (e.re_why != AUTH_TOOWEAK)
		    return (SNEGO_FAILURE);

		if ((p = malloc(strlen(fspath)+3)) == NULL) {
		    syslog(LOG_ERR, "no memory\n");
		    return (SNEGO_FAILURE);
		}
		/*
		 * Do an x81 LOOKUP
		 */
		p[0] = (char)WNL_SEC_NEGO;
		strcpy(&p[2], fspath);
		do {
		    p[1] = (char)(1+snego->cnt); /* sec index */
		    arg.what.name = p;
		    res = wnlproc3_lookup_3(&arg, clnt);
		    if (res == NULL || res->status != WNL3_OK) {
			free(p);
			return (SNEGO_FAILURE);
		    }

			/*
			 * retrieve flavors from filehandle:
			 *
			 * 1st byte: status
			 * 2nd thru 4th: pad
			 * 5th and after: sec flavors.
			 */
		    {
			char *c = res->WNL_LOOKUP3res_u.res_ok.
			    object.data.data_val;
			int ii;
			int len = res->WNL_LOOKUP3res_u.res_ok.
			    object.data.data_len;
			int cnt;
			/* LINTED pointer alignment */
			int *ip = (int *)(c+sizeof (int));

			cnt = len/sizeof (uint_t) - 1;
			tot += cnt;
			if (tot >= MAX_FLAVORS) {
			    free(p);
			    return (SNEGO_ARRAY_TOO_SMALL);
			}
			status = (int)(*c);
			if (cnt > MAX_V3_CNT || cnt < 0) {
			    free(p);
			    return (SNEGO_FAILURE);
			}
			for (ii = 0; ii < cnt; ii++)
			    snego->array[snego->cnt+ii] =
				ntohl(*(ip+ii));
			snego->cnt += cnt;

			CLNT_FREERES(clnt, xdr_WNL_LOOKUP3res,
			    (char *)res);
		    }
		} while (status);
		free(p);
		return (SNEGO_SUCCESS);
	    }
	}
	return (SNEGO_FAILURE);
}
#endif

/*
 *  Get seconfig from /etc/nfssec.conf by name or by number or
 *  by descriptior.
 */
/* ARGSUSED */
static int
get_seconfig(int whichway, char *name, int num,
		rpc_gss_service_t service, seconfig_t *entryp)
{
	static	mutex_t matching_lock = DEFAULTMUTEX;
	char	line[BUFSIZ];	/* holds each line of NFSSEC_CONF */
	FILE	*fp;		/* file stream for NFSSEC_CONF */

	if ((whichway == GETBYNAME) && (name == NULL))
		return (SC_NOTFOUND);

	if ((fp = fopen(NFSSEC_CONF, "r")) == NULL) {
		return (SC_OPENFAIL);
	}

	(void) mutex_lock(&matching_lock);
	while (fgets(line, BUFSIZ, fp)) {
	    if (!(blank(line) || comment(line))) {
		switch (whichway) {
		    case GETBYNAME:
			if (matchname(line, name, entryp)) {
				goto found;
			}
			break;

		    case GETBYNUM:
			if (matchnum(line, num, entryp)) {
				goto found;
			}
			break;

		    default:
			break;
		}
	    }
	}
	(void) mutex_unlock(&matching_lock);
	(void) fclose(fp);
	return (SC_NOTFOUND);

found:
	(void) mutex_unlock(&matching_lock);
	(void) fclose(fp);
	(void) get_rpcnum(entryp);
	return (SC_NOERROR);
}


/*
 *  NFS project private API.
 *  Get a seconfig entry from /etc/nfssec.conf by nfs specific sec name,
 *  e.g. des, krb5p, etc.
 */
int
nfs_getseconfig_byname(char *secmode_name, seconfig_t *entryp)
{
	if (!entryp)
		return (SC_NOMEM);

	return (get_seconfig(GETBYNAME, secmode_name, 0, rpc_gss_svc_none,
			entryp));
}

/*
 *  NFS project private API.
 *
 *  Get a seconfig entry from /etc/nfssec.conf by nfs specific sec number,
 *  e.g. AUTH_DES, AUTH_KRB5_P, etc.
 */
int
nfs_getseconfig_bynumber(int nfs_secnum, seconfig_t *entryp)
{
	if (!entryp)
		return (SC_NOMEM);

	return (get_seconfig(GETBYNUM, NULL, nfs_secnum, rpc_gss_svc_none,
				entryp));
}

/*
 *  NFS project private API.
 *
 *  Get a seconfig_t entry used as the default for NFS operations.
 *  The default flavor entry is defined in /etc/nfssec.conf.
 *
 *  Assume user has allocate spaces for secp.
 */
int
nfs_getseconfig_default(seconfig_t *secp)
{
	if (secp == NULL)
		return (SC_NOMEM);

	return (nfs_getseconfig_byname("default", secp));
}


/*
 *  NFS project private API.
 *
 *  Free an sec_data structure.
 *  Free the parts that nfs_clnt_secdata allocates.
 */
void
nfs_free_secdata(sec_data_t *secdata)
{
	dh_k4_clntdata_t *dkdata;
	gss_clntdata_t *gdata;

	if (!secdata)
		return;

	switch (secdata->rpcflavor) {
	    case AUTH_UNIX:
	    case AUTH_NONE:
		break;

	    case AUTH_DES:
		/* LINTED pointer alignment */
		dkdata = (dh_k4_clntdata_t *)secdata->data;
		if (dkdata) {
			if (dkdata->netname)
				free(dkdata->netname);
			if (dkdata->syncaddr.buf)
				free(dkdata->syncaddr.buf);
			free(dkdata);
		}
		break;

	    case RPCSEC_GSS:
		/* LINTED pointer alignment */
		gdata = (gss_clntdata_t *)secdata->data;
		if (gdata) {
			if (gdata->mechanism.elements)
				free(gdata->mechanism.elements);
			free(gdata);
		}
		break;

	    default:
		break;
	}

	free(secdata);
}

/*
 *  Make an client side sec_data structure and fill in appropriate value
 *  based on its rpc security flavor.
 *
 *  It is caller's responsibility to allocate space for seconfig_t,
 *  and this routine will allocate space for the sec_data structure
 *  and related data field.
 *
 *  Return the sec_data_t on success.
 *  If fail, return NULL pointer.
 */
sec_data_t *
nfs_clnt_secdata(seconfig_t *secp, char *hostname, struct knetconfig *knconf,
		struct netbuf *syncaddr, int flags)
{
	char netname[MAXNETNAMELEN+1];
	sec_data_t *secdata;
	dh_k4_clntdata_t *dkdata;
	gss_clntdata_t *gdata;

	secdata = malloc(sizeof (sec_data_t));
	if (!secdata) {
		syslog(LOG_ERR, "nfs_clnt_secdata: no memory\n");
		return (NULL);
	}
	(void) memset(secdata, 0, sizeof (sec_data_t));

	secdata->secmod = secp->sc_nfsnum;
	secdata->rpcflavor = secp->sc_rpcnum;
	secdata->uid = secp->sc_uid;
	secdata->flags = flags;

	/*
	 *  Now, fill in the information for client side secdata :
	 *
	 *  For AUTH_UNIX, AUTH_DES
	 *  hostname can be in the form of
	 *    nodename or
	 *    nodename.domain
	 *
	 *  For RPCSEC_GSS security flavor
	 *  hostname can be in the form of
	 *    nodename or
	 *    nodename.domain  or
	 *    nodename@realm (realm can be the same as the domain) or
	 *    nodename.domain@realm
	 */
	switch (secp->sc_rpcnum) {
	    case AUTH_UNIX:
	    case AUTH_NONE:
		secdata->data = NULL;
		break;

	    case AUTH_DES:
		/*
		 *  If hostname is in the format of host.nisdomain
		 *  the netname will be constructed with
		 *  this nisdomain name rather than the default
		 *  domain of the machine.
		 */
		    if (!host2netname(netname, hostname, NULL)) {
			syslog(LOG_ERR, "host2netname: %s: unknown\n",
				hostname);
			goto err_out;
		    }
		dkdata = malloc(sizeof (dh_k4_clntdata_t));
		if (!dkdata) {
		    syslog(LOG_ERR, "nfs_clnt_secdata: no memory\n");
		    goto err_out;
		}
		(void) memset((char *)dkdata, 0, sizeof (dh_k4_clntdata_t));
		if ((dkdata->netname = strdup(netname)) == NULL) {
		    syslog(LOG_ERR, "nfs_clnt_secdata: no memory\n");
		    goto err_out;
		}
		dkdata->netnamelen = strlen(netname);
		dkdata->knconf = knconf;
		dkdata->syncaddr = *syncaddr;
		dkdata->syncaddr.buf = malloc(syncaddr->len);
		if (dkdata->syncaddr.buf == NULL) {
		    syslog(LOG_ERR, "nfs_clnt_secdata: no memory\n");
		    goto err_out;
		}
		(void) memcpy(dkdata->syncaddr.buf, syncaddr->buf,
						syncaddr->len);
		secdata->data = (caddr_t)dkdata;
		break;

	    case RPCSEC_GSS: {

		if (secp->sc_gss_mech_type == NULL) {
		    syslog(LOG_ERR,
			"nfs_clnt_secdata: need mechanism information\n");
		    goto err_out;
		}

		gdata = malloc(sizeof (gss_clntdata_t));
		if (!gdata) {
		    syslog(LOG_ERR, "nfs_clnt_secdata: no memory\n");
		    goto err_out;
		}

		(void) strcpy(gdata->uname, "nfs");
		if (!parsehostname(hostname, gdata->inst, gdata->realm)) {
		    syslog(LOG_ERR, "nfs_clnt_secdata: bad host name\n");
		    goto err_out;
		}

		gdata->mechanism.length = secp->sc_gss_mech_type->length;
		if (!(gdata->mechanism.elements =
			malloc(secp->sc_gss_mech_type->length))) {
			syslog(LOG_ERR, "nfs_clnt_secdata: no memory\n");
			goto err_out;
		}
		(void) memcpy(gdata->mechanism.elements,
			secp->sc_gss_mech_type->elements,
			secp->sc_gss_mech_type->length);

		gdata->qop = secp->sc_qop;
		gdata->service = secp->sc_service;
		secdata->data = (caddr_t)gdata;
	    }
	    break;

	    default:
		syslog(LOG_ERR, "nfs_clnt_secdata: unknown flavor\n");
		goto err_out;
	}

	return (secdata);

err_out:
	free(secdata);
	return (NULL);
}

/*
 *  nfs_get_root_principal() maps a host name to its principal name
 *  based on the given security information.
 *
 *  input :  seconfig - security configuration information
 *		host - the host name which could be in the following forms:
 *		node
 *		node.namedomain
 *		node@secdomain (e.g. kerberos realm is a secdomain)
 *		node.namedomain@secdomain
 *  output : rootname_p - address of the principal name for the host
 *
 *  Currently, this routine is only used by share program.
 *
 */
bool_t
nfs_get_root_principal(seconfig_t *seconfig, char *host, caddr_t *rootname_p)
{
	char netname[MAXNETNAMELEN+1], node[MAX_NAME_LEN];
	char secdomain[MAX_NAME_LEN];
	rpc_gss_principal_t gssname;

	switch (seconfig->sc_rpcnum) {
		case AUTH_DES:
		    if (!host2netname(netname, host, NULL)) {
			syslog(LOG_ERR,
			    "nfs_get_root_principal: unknown host: %s\n", host);
			return (FALSE);
		    }
		    *rootname_p = strdup(netname);
		    if (!*rootname_p) {
			syslog(LOG_ERR, "nfs_get_root_principal: no memory\n");
			return (FALSE);
		    }
		    break;

		case RPCSEC_GSS:
		    if (!parsehostname(host, node, secdomain)) {
			syslog(LOG_ERR,
			    "nfs_get_root_principal: bad host name\n");
			return (FALSE);
		    }
		    if (!rpc_gss_get_principal_name(&gssname,
				seconfig->sc_gss_mech, "root",
				node, secdomain)) {
			syslog(LOG_ERR,
	"nfs_get_root_principal: can not get principal name : %s\n", host);
			return (FALSE);
		    }

		    *rootname_p = (caddr_t)gssname;
		    break;

		default:
		    return (FALSE);
	}
	return (TRUE);
}


/*
 *  SYSLOG SC_* errors.
 */
int
nfs_syslog_scerr(int scerror, char msg[])
{
	switch (scerror) {
		case SC_NOMEM :
			sprintf(msg, "%s : no memory", NFSSEC_CONF);
			return (0);
		case SC_OPENFAIL :
			sprintf(msg, "can not open %s", NFSSEC_CONF);
			return (0);
		case SC_NOTFOUND :
			sprintf(msg, "has no entry in %s", NFSSEC_CONF);
			return (0);
		case SC_BADENTRIES :
			sprintf(msg, "bad entry in %s", NFSSEC_CONF);
			return (0);
		default:
			msg[0] = '\0';
			return (-1);
	}
}