xref: /onnv-gate/usr/src/lib/libtsol/common/btos.c (revision 1676:37f4a3e2bd99)

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

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

/*
 *      Binary label to label string translations.
 */

#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <wchar.h>

#include <sys/mman.h>

#include <tsol/label.h>

#include "clnt.h"
#include "labeld.h"
#include <sys/tsol/label_macro.h>

#if	!defined(TEXT_DOMAIN)		/* should be defined by Makefiles */
#define	TEXT_DOMAIN "SYS_TEST"
#endif	/* TEXT_DOMAIN */

static bslabel_t slow;	/* static admin_low high sensitivity label */
static bslabel_t shigh;	/* static admin_high sensitivity label */
static bclear_t clrlow, clrhigh; /* static admin_low and admin_high Clearance */

static char	*sstring;	/* return string for sb*tos */
static size_t	ssize;		/* current size of return string */

static int
return_string(char **string, int str_len, char *val)
{
	char	*cpyptr;
	size_t	val_len = strlen(val) + 1;

	if (*string == NULL) {
		if ((*string = malloc(val_len)) == NULL)
			return (0);
	} else if (val_len > str_len) {
		**string = '\0';
		return (0);
	}

	cpyptr = *string;
	bcopy(val, cpyptr, val_len);

	return (val_len);
}

void
set_label_view(uint_t *callflags, uint_t flags)
{
	if (flags&VIEW_INTERNAL) {
		*callflags |= LABELS_VIEW_INTERNAL;
	} else if (flags&VIEW_EXTERNAL) {
		*callflags |= LABELS_VIEW_EXTERNAL;
	}
}

int
alloc_string(char **string, size_t size, char val)
{
	if (*string == NULL) {
		if ((*string = malloc(ALLOC_CHUNK)) == NULL)
			return (0);
	} else {
		if ((*string = realloc(*string, size + ALLOC_CHUNK)) == NULL) {
			**string = val;
			return (0);
		}
	}
	**string = val;
	return (ALLOC_CHUNK);
}

#define	slcall callp->param.acall.cargs.bsltos_arg
#define	slret callp->param.aret.rvals.bsltos_ret
/*
 *	bsltos - Convert Binary Sensitivity Label to Sensitivity Label string.
 *
 *	Entry	label = Binary Sensitivity Label to be converted.
 *		string = NULL ((char *) 0), if memory to be allocated,
 *			 otherwise, pointer to preallocated memory.
 *		str_len = Length of preallocated memory, else ignored.
 *		flags = Logical sum of:
 *				LONG_CLASSIFICATION or SHORT_CLASSIFICATION,
 *				LONG_WORDS or SHORT_WORDS,
 *				VIEW_INTERNAL or VIEW_EXTERNAL, and
 *				NO_CLASSIFICATION.
 *			LONG_CLASSIFICATION, use long classification names.
 *			SHORT_CLASSIFICATION, use short classification
 *						names (default).
 *			NO_CLASSIFICATION, don't translate classification.
 *			LONG_WORDS, use the long form of words (default).
 *			SHORTWORDS, use the short form of words where available.
 *			VIEW_INTERNAL, don't promote/demote admin low/high.
 *			VIEW_EXTERNAL, promote/demote admin low/high.
 *
 *	Exit	string = Sensitivity Label string, or empty string if
 *			 not enough preallocated memory.
 *
 *	Returns	-1, If unable to access label encodings database.
 *		 0, If unable to allocate string,
 *			or allocated string to short
 *			(and **string = '\0').
 *		length (including null) of Sensitivity Label string,
 *			If successful.
 *
 *	Calls	RPC - LABELS_BSLTOS, BCLHIGH, BCLLOW, BCLTOSL, BLEQUAL,
 *			BLTYPE, SETBSLABEL, UCLNT, memcpy, clnt_call,
 *			clnt_perror, malloc, strcat, strlen.
 *
 *	Uses	ADMIN_HIGH, ADMIN_LOW, shigh, slow.
 */

ssize_t
bsltos(const bslabel_t *label, char **string, size_t str_len,
    int flags)
{
	labeld_data_t	call;
	labeld_data_t	*callp = &call;
	size_t	bufsize = sizeof (labeld_data_t);
	size_t	datasize = CALL_SIZE(bsltos_call_t, 0);
	int	rval;

	if (!BLTYPE(label, SUN_SL_ID)) {
		return (-1);
	}

	call.callop = BSLTOS;
	slcall.label = *label;
	slcall.flags = (flags&NO_CLASSIFICATION) ? LABELS_NO_CLASS : 0;
	slcall.flags |= (flags&SHORT_CLASSIFICATION ||
	    !(flags&LONG_CLASSIFICATION)) ? LABELS_SHORT_CLASS : 0;
	slcall.flags |= (flags&SHORT_WORDS && !(flags&LONG_WORDS)) ?
	    LABELS_SHORT_WORDS : 0;
	set_label_view(&slcall.flags, flags);

	if ((rval = __call_labeld(&callp, &bufsize, &datasize)) == SUCCESS) {

		if (callp->reterr != 0)
			return (-1);

		/* unpack Sensitivity Label */

		rval = return_string(string, str_len, slret.slabel);

		if (callp != &call)
			(void) munmap((void *)callp, bufsize);
		return (rval);
	} else if (rval == NOSERVER) {
		/* server not present */
		/* special case admin_high and admin_low */

		if (!BLTYPE(&slow, SUN_SL_ID)) {
			/* initialize static labels */

			BSLLOW(&slow);
			BSLHIGH(&shigh);
		}

		if (BLEQUAL(label, &slow)) {
			return (return_string(string, str_len, ADMIN_LOW));
		} else if (BLEQUAL(label, &shigh)) {
			return (return_string(string, str_len, ADMIN_HIGH));
		}
	}
	return (-1);
}  /* bsltos */
#undef	slcall
#undef	slret

#define	clrcall callp->param.acall.cargs.bcleartos_arg
#define	clrret callp->param.aret.rvals.bcleartos_ret
/*
 *	bcleartos - Convert Binary Clearance to Clearance string.
 *
 *	Entry	clearance = Binary Clearance to be converted.
 *		string = NULL ((char *) 0), if memory to be allocated,
 *			 otherwise, pointer to preallocated memory.
 *		str_len = Length of preallocated memory, else ignored.
 *		flags = Logical sum of:
 *				LONG_CLASSIFICATION or SHORT_CLASSIFICATION,
 *				LONG_WORDS or SHORT_WORDS,
 *				VIEW_INTERNAL or VIEW_EXTERNAL.
 *			LONG_CLASSIFICATION, use long classification names.
 *			SHORT_CLASSIFICATION, use short classification
 *						names (default).
 *			LONG_WORDS, use the long form of words (default).
 *			SHORTWORDS, use the short form of words where available.
 *			VIEW_INTERNAL, don't promote/demote admin low/high.
 *			VIEW_EXTERNAL, promote/demote admin low/high.
 *
 *	Exit	string = Clearance string, or empty string if not
 *			enough preallocated memory.
 *
 *	Returns	-1, If unable to access label encodings database.
 *		 0, If unable to allocate string,
 *			or allocated string to short
 *			(and **string = '\0').
 *		length (including null) of Clearance string,
 *			If successful.
 *
 *	Calls	RPC - LABELS_BSLTOS, BCLHIGH, BCLLOW, BCLTOSL, BLEQUAL,
 *			BLTYPE, SETBSLABEL, UCLNT, memcpy, clnt_call,
 *			clnt_perror, malloc, strcat, strlen.
 *
 *	Uses	ADMIN_HIGH, ADMIN_LOW, clrhigh, clrlow.
 */

ssize_t
bcleartos(const bclear_t *clearance, char **string, size_t str_len,
    int flags)
{
	labeld_data_t	call;
	labeld_data_t	*callp = &call;
	size_t	bufsize = sizeof (labeld_data_t);
	size_t	datasize = CALL_SIZE(bcleartos_call_t, 0);
	int	rval;

	if (!BLTYPE(clearance, SUN_CLR_ID)) {
		return (-1);
	}

	call.callop = BCLEARTOS;
	clrcall.clear = *clearance;
	clrcall.flags = (flags&SHORT_CLASSIFICATION ||
	    !(flags&LONG_CLASSIFICATION)) ? LABELS_SHORT_CLASS : 0;
	clrcall.flags |= (flags&SHORT_WORDS && !(flags&LONG_WORDS)) ?
	    LABELS_SHORT_WORDS : 0;
	set_label_view(&clrcall.flags, flags);

	if ((rval = __call_labeld(&callp, &bufsize, &datasize)) == SUCCESS) {

		if (callp->reterr != 0)
			return (-1);

		/* unpack Clearance */

		rval = return_string(string, str_len, clrret.cslabel);

		if (callp != &call)
			/* release return buffer */
			(void) munmap((void *)callp, bufsize);
		return (rval);
	} else if (rval == NOSERVER) {
		/* server not present */
		/* special case admin_high and admin_low */

		if (!BLTYPE(&clrlow, SUN_CLR_ID)) {
			/* initialize static labels */

			BCLEARLOW(&clrlow);
			BCLEARHIGH(&clrhigh);
		}
		if (BLEQUAL(clearance, &clrlow)) {
			return (return_string(string, str_len, ADMIN_LOW));
		} else if (BLEQUAL(clearance, &clrhigh)) {
			return (return_string(string, str_len, ADMIN_HIGH));
		}
	}
	return (-1);
}  /* bcleartos */
#undef	clrcall
#undef	clrret

/*
 *	sbsltos - Convert Sensitivity Label to canonical clipped form.
 *
 *	Entry	label = Sensitivity Label to be converted.
 *		len = Maximum length of translated string, excluding NULL.
 *		      0, full string.
 *		sstring = address of string to translate into.
 *		ssize = size of memory currently allocated to sstring.
 *
 *	Exit	sstring = Newly translated string.
 *		ssize = Updated if more memory pre-allocated.
 *
 *	Returns	NULL, If error, len too small, unable to translate, or get
 *		      memory for string.
 *		Address of string containing converted value.
 *
 *	Calls	alloc_string, bsltos, strcpy.
 *
 *	Uses	ssize, sstring.
 */

char *
sbsltos(const bslabel_t *label, size_t len)
{
	ssize_t	slen;		/* length including NULL */
	wchar_t *wstring;
	int	wccount;

	if (ssize == 0) {
		/* Allocate string memory. */
		if ((ssize = alloc_string(&sstring, ssize, 's')) == 0)
			/* can't get initial memory for string */
			return (NULL);
	}

again:
	if ((slen = bsltos(label, &sstring, ssize,
	    (SHORT_CLASSIFICATION | LONG_WORDS))) <= 0) {
		/* error in translation */
		if (slen == 0) {
			if (*sstring == '\0') {
				int newsize;
				/* sstring not long enough */
				if ((newsize = alloc_string(&sstring, ssize,
				    's')) == 0) {
					/* Can't get more memory */
					return (NULL);
				}
				ssize += newsize;
				goto again;
			}
		}
		return (NULL);
	}
	if (len == 0) {
		return (sstring);
	} else if (len < MIN_SL_LEN) {
		return (NULL);
	}
	if ((wstring = malloc(slen * sizeof (wchar_t))) == NULL)
		return (NULL);
	if ((wccount = mbstowcs(wstring, sstring, slen - 1)) == -1) {
		free(wstring);
		return (NULL);
	}
	if (wccount > len) {
		wchar_t *clipp = wstring + (len - 2);

		/* Adjust string size to desired length */

		clipp[0] = L'<';
		clipp[1] = L'-';
		clipp[2] = L'\0';

		while (wcstombs(NULL, wstring, 0) >= ssize) {
			int newsize;

			/* sstring not long enough */
			if ((newsize = alloc_string(&sstring, ssize, 's')) ==
			    0) {
				/* Can't get more memory */
				return (NULL);
			}
			ssize += newsize;
		}

		if ((wccount = wcstombs(sstring, wstring, ssize)) == -1) {
			free(wstring);
			return (NULL);
		}
	}
	free(wstring);

	return (sstring);
}  /* sbsltos */

/*
 *	sbcleartos - Convert Clearance to canonical clipped form.
 *
 *	Entry	clearance = Clearance to be converted.
 *		len = Maximum length of translated string, excluding NULL.
 *		      0, full string.
 *		sstring = address of string to translate into.
 *		ssize = size of memory currently allocated to sstring.
 *
 *	Exit	sstring = Newly translated string.
 *		ssize = Updated if more memory pre-allocated.
 *
 *	Returns	NULL, If error, len too small, unable to translate, or get
 *		      memory for string.
 *		Address of string containing converted value.
 *
 *	Calls	alloc_string, bcleartos, strcpy.
 *
 *	Uses	ssize, sstring.
 */

char *
sbcleartos(const bclear_t *clearance, size_t len)
{
	ssize_t	slen;		/* length including NULL */
	wchar_t *wstring;
	int	wccount;

	if (ssize == 0) {
		/* Allocate string memory. */
		if ((ssize = alloc_string(&sstring, ssize, 'c')) == 0)
			/* can't get initial memory for string */
			return (NULL);
	}

again:
	if ((slen = bcleartos(clearance, &sstring, ssize,
	    (SHORT_CLASSIFICATION | LONG_WORDS))) <= 0) {
		/* error in translation */
		if (slen == 0) {
			if (*sstring == '\0') {
				int newsize;
				/* sstring not long enough */
				if ((newsize = alloc_string(&sstring, ssize,
				    'c')) == 0) {
					/* Can't get more memory */
					return (NULL);
				}
				ssize += newsize;
				goto again;
			}
		}
		return (NULL);
	}
	if (len == 0) {
		return (sstring);
	} else if (len < MIN_CLR_LEN) {
		return (NULL);
	}
	if ((wstring = malloc(slen * sizeof (wchar_t))) == NULL)
		return (NULL);
	if ((wccount = mbstowcs(wstring, sstring, slen - 1)) == -1) {
		free(wstring);
		return (NULL);
	}
	if (wccount > len) {
		wchar_t *clipp = wstring + (len - 2);

		/* Adjust string size to desired length */

		clipp[0] = L'<';
		clipp[1] = L'-';
		clipp[2] = L'\0';

		while (wcstombs(NULL, wstring, 0) >= ssize) {
			int newsize;

			/* sstring not long enough */
			if ((newsize = alloc_string(&sstring, ssize, 'c')) ==
			    0) {
				/* Can't get more memory */
				free(wstring);
				return (NULL);
			}
			ssize += newsize;
		}
		if ((wccount = wcstombs(sstring, wstring, ssize)) == -1) {
			free(wstring);
			return (NULL);
		}
	}
	free(wstring);

	return (sstring);
}  /* sbcleartos */