/*

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

/*

 *	priv_str_xlate.c - Privilege translation routines.

 */

#pragma weak _priv_str_to_set = priv_str_to_set

#pragma weak _priv_set_to_str = priv_set_to_str

#pragma weak _priv_gettext = priv_gettext

#include "lint.h"

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <strings.h>

#include <errno.h>

#include <string.h>

#include <locale.h>

#include <sys/param.h>

#include <priv.h>

#include <alloca.h>

#include <locale.h>

#include "libc.h"

#include "../i18n/_loc_path.h"

#include "priv_private.h"

priv_set_t *

priv_basic(void)

{

	priv_data_t *d;

	LOADPRIVDATA(d);

	return (d->pd_basicset);

}

/*

 *	Name:	priv_str_to_set()

 *

 *	Description:	Given a buffer with privilege strings, the

 *	equivalent privilege set is returned.

 *

 *	Special tokens recognized: all, none, basic and "".

 *

 *	On failure, this function returns NULL.

 *	*endptr == NULL and errno set: resource error.

 *	*endptr != NULL: parse error.

 */

priv_set_t *

priv_str_to_set(const char *priv_names,

		const char *separators,

		const char **endptr)

{

	char *base;

	char *offset;

	char *last;

	priv_set_t *pset = NULL;

	priv_set_t *zone;

	priv_set_t *basic;

	if (endptr != NULL)

		*endptr = NULL;

	if ((base = libc_strdup(priv_names)) == NULL ||

	    (pset = priv_allocset()) == NULL) {

		/* Whether base is NULL or allocated, this works */

		libc_free(base);

		return (NULL);

	}

	priv_emptyset(pset);

	basic = priv_basic();

	zone = privdata->pd_zoneset;

	/* This is how to use strtok_r nicely in a while loop ... */

	last = base;

	while ((offset = strtok_r(NULL, separators, &last)) != NULL) {

		/*

		 * Search for these special case strings.

		 */

		if (basic != NULL && strcasecmp(offset, "basic") == 0) {

			priv_union(basic, pset);

		} else if (strcasecmp(offset, "none") == 0) {

			priv_emptyset(pset);

		} else if (strcasecmp(offset, "all") == 0) {

			priv_fillset(pset);

		} else if (strcasecmp(offset, "zone") == 0) {

			priv_union(zone, pset);

		} else {

			boolean_t neg = (*offset == '-' || *offset == '!');

			int privid;

			int slen;

			privid = priv_getbyname(offset +

			    ((neg || *offset == '+') ? 1 : 0));

			if (privid < 0) {

				slen = offset - base;

				libc_free(base);

				priv_freeset(pset);

				if (endptr != NULL)

					*endptr = priv_names + slen;

				errno = EINVAL;

				return (NULL);

			} else {

				if (neg)

					PRIV_DELSET(pset, privid);

				else

					PRIV_ADDSET(pset, privid);

			}

		}

	}

	libc_free(base);

	return (pset);

}

/*

 *	Name:	priv_set_to_str()

 *

 *	Description:	Given a set of privileges, list of privileges are

 *	returned in privilege numeric order (which can be an ASCII sorted

 *	list as our implementation allows renumbering.

 *

 *	String "none" identifies an empty privilege set, and string "all"

 *	identifies a full set.

 *

 *	A pointer to a buffer is returned which needs to be freed by

 *	the caller.

 *

 *	Several types of output are supported:

 *		PRIV_STR_PORT		- portable output: basic,!basic

 *		PRIV_STR_LIT		- literal output

 *		PRIV_STR_SHORT		- shortest output

 *

 * NOTE: this function is called both from inside the library for the

 * current environment and from outside the library using an externally

 * generated priv_data_t * in order to analyze core files.  It should

 * return strings which can be free()ed by applications and it should

 * not use any data from the current environment except in the special

 * case that it is called from within libc, with a NULL priv_data_t *

 * argument.

 */

char *

__priv_set_to_str(

	priv_data_t *d,

	const priv_set_t *pset,

	char separator,

	int flag)

{

	const char *pstr;

	char *res, *resp;

	int i;

	char neg = separator == '!' ? '-' : '!';

	priv_set_t *zone;

	boolean_t all;

	boolean_t use_libc_data = (d == NULL);

	if (use_libc_data)

		LOADPRIVDATA(d);

	if (flag != PRIV_STR_PORT && __priv_isemptyset(d, pset))

		return (strdup("none"));

	if (flag != PRIV_STR_LIT && __priv_isfullset(d, pset))

		return (strdup("all"));

	/* Safe upper bound: global info contains all NULL separated privs */

	res = resp = alloca(d->pd_pinfo->priv_globalinfosize);

	/*

	 * Compute the shortest form; i.e., the form with the fewest privilege

	 * tokens.

	 * The following forms are possible:

	 *	literal: priv1,priv2,priv3

	 *		tokcount = present

	 *	port: basic,!missing_basic,other

	 *		tokcount = 1 + present - presentbasic + missingbasic

	 *	zone: zone,!missing_zone

	 *		tokcount = 1 + missingzone

	 *	all: all,!missing1,!missing2

	 *		tokcount = 1 + d->pd_nprivs - present;

	 *

	 * Note that zone and all forms are identical in the global zone;

	 * in that case (or any other where the token count is the same),

	 * all is preferred.  Also, the zone form is only used when the

	 * indicated privileges are a subset of the zone set.

	 */

	if (use_libc_data)

		LOCKPRIVDATA();

	if (flag == PRIV_STR_SHORT) {

		int presentbasic, missingbasic, present, missing;

		int presentzone, missingzone;

		int count;

		presentbasic = missingbasic = present = 0;

		presentzone = missingzone = 0;

		zone = d->pd_zoneset;

		for (i = 0; i < d->pd_nprivs; i++) {

			int mem = PRIV_ISMEMBER(pset, i);

			if (d->pd_basicset != NULL &&

			    PRIV_ISMEMBER(d->pd_basicset, i)) {

				if (mem)

					presentbasic++;

				else

					missingbasic++;

			}

			if (zone != NULL && PRIV_ISMEMBER(zone, i)) {

				if (mem)

					presentzone++;

				else

					missingzone++;

			}

			if (mem)

				present++;

		}

		missing = d->pd_nprivs - present;

		if (1 - presentbasic + missingbasic < 0) {

			flag = PRIV_STR_PORT;

			count = present + 1 - presentbasic + missingbasic;

		} else {

			flag = PRIV_STR_LIT;

			count = present;

		}

		if (count >= 1 + missing) {

			flag = PRIV_STR_SHORT;

			count = 1 + missing;

			all = B_TRUE;

		}

		if (present == presentzone && 1 + missingzone < count) {

			flag = PRIV_STR_SHORT;

			all = B_FALSE;

		}

	}

	switch (flag) {

	case PRIV_STR_LIT:

		*res = '\0';

		break;

	case PRIV_STR_PORT:

		(void) strcpy(res, "basic");

		if (d->pd_basicset == NULL)

			flag = PRIV_STR_LIT;

		break;

	case PRIV_STR_SHORT:

		if (all)

			(void) strcpy(res, "all");

		else

			(void) strcpy(res, "zone");

		break;

	default:

		if (use_libc_data)

			UNLOCKPRIVDATA();

		return (NULL);

	}

	res += strlen(res);

	for (i = 0; i < d->pd_nprivs; i++) {

		/* Map the privilege to the next one sorted by name */

		int priv = d->pd_setsort[i];

		if (PRIV_ISMEMBER(pset, priv)) {

			switch (flag) {

			case PRIV_STR_SHORT:

				if (all || PRIV_ISMEMBER(zone, priv))

					continue;

				break;

			case PRIV_STR_PORT:

				if (PRIV_ISMEMBER(d->pd_basicset, priv))

					continue;

				break;

			case PRIV_STR_LIT:

				break;

			}

			if (res != resp)

				*res++ = separator;

		} else {

			switch (flag) {

			case PRIV_STR_LIT:

				continue;

			case PRIV_STR_PORT:

				if (!PRIV_ISMEMBER(d->pd_basicset, priv))

					continue;

				break;

			case PRIV_STR_SHORT:

				if (!all && !PRIV_ISMEMBER(zone, priv))

					continue;

				break;

			}

			if (res != resp)

				*res++ = separator;

			*res++ = neg;

		}

		pstr = __priv_getbynum(d, priv);

		(void) strcpy(res, pstr);

		res += strlen(pstr);

	}

	if (use_libc_data)

		UNLOCKPRIVDATA();

	/* Special case the set with some high bits set */

	return (strdup(*resp == '\0' ? "none" : resp));

}

/*

 * priv_set_to_str() is defined to return a string that

 * the caller must deallocate with free(3C).  Grr...

 */

char *

priv_set_to_str(const priv_set_t *pset, char separator, int flag)

{

	return (__priv_set_to_str(NULL, pset, separator, flag));

}

static char *

do_priv_gettext(const char *priv, const char *file)

{

	char buf[8*1024];

	boolean_t inentry = B_FALSE;

	FILE	*namefp;

	namefp = fopen(file, "rF");

	if (namefp == NULL)

		return (NULL);

	/*

	 * parse the file; it must have the following format

	 * Lines starting with comments "#"

	 * Lines starting with non white space with one single token:

	 * the privileges; white space indented lines which are the

	 * description; no empty lines are allowed in the description.

	 */

	while (fgets(buf, sizeof (buf), namefp) != NULL) {

		char *lp;		/* pointer to the current line */

		if (buf[0] == '#')

			continue;

		if (buf[0] == '\n') {

			inentry = B_FALSE;

			continue;

		}

		if (inentry)

			continue;

		/* error; not skipping; yet line starts with white space */

		if (isspace((unsigned char)buf[0]))

			goto out;

		/* Trim trailing newline */

		buf[strlen(buf) - 1] = '\0';

		if (strcasecmp(buf, priv) != 0) {

			inentry = B_TRUE;

			continue;

		}

		lp = buf;

		while (fgets(lp, sizeof (buf) - (lp - buf), namefp) != NULL) {

			char *tstart;	/* start of text */

			int len;

			/* Empty line or start of next entry terminates */

			if (*lp == '\n' || !isspace((unsigned char)*lp)) {

				*lp = '\0';

				(void) fclose(namefp);

				return (strdup(buf));

			}

			/* Remove leading white space */

			tstart = lp;

			while (*tstart != '\0' &&

			    isspace((unsigned char)*tstart)) {

				tstart++;

			}

			len = strlen(tstart);

			(void) memmove(lp, tstart, len + 1);

			lp += len;

			/* Entry to big; prevent fgets() loop */

			if (lp == &buf[sizeof (buf) - 1])

				goto out;

		}

		if (lp != buf) {

			*lp = '\0';

			(void) fclose(namefp);

			return (strdup(buf));

		}

	}

out:

	(void) fclose(namefp);

	return (NULL);

}

/*

 * priv_gettext() is defined to return a string that

 * the caller must deallocate with free(3C).  Grr...

 */

char *

priv_gettext(const char *priv)

{

	char file[MAXPATHLEN];

	const char *loc;

	char	*ret;

	/* Not a valid privilege */

	if (priv_getbyname(priv) < 0)

		return (NULL);

	if ((loc = setlocale(LC_MESSAGES, NULL)) == NULL)

		loc = "C";

	if (snprintf(file, sizeof (file),

	    _DFLT_LOC_PATH "%s/LC_MESSAGES/priv_names", loc) < sizeof (file)) {

		ret = do_priv_gettext(priv, (const char *)file);

		if (ret != NULL)

			return (ret);

	}

	/* If the path is too long or can't be opened, punt to default */

	ret = do_priv_gettext(priv, "/etc/security/priv_names");

	return (ret);

}