/*
 * 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);
}