/*
 * 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
 */
/*
 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Device policy specific subroutines.  We cannot merge them with
 * drvsubr.c because of static linking requirements.
 */

/*
 * Copyright 2020 OmniOS Community Edition (OmniOSce) Association.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <priv.h>
#include <string.h>
#include <libgen.h>
#include <libintl.h>
#include <errno.h>
#include <alloca.h>
#include <sys/modctl.h>
#include <sys/devpolicy.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>

#include "addrem.h"
#include "errmsg.h"
#include "plcysubr.h"

size_t devplcysys_sz;
const priv_impl_info_t *privimplinfo;

/*
 * New token types should be parsed in parse_plcy_entry.
 */
#define	PSET	0

typedef struct token {
	const char	*token;
	int		type;
	ptrdiff_t	off;
} token_t;

static token_t toktab[] = {
	{ DEVPLCY_TKN_RDP, PSET /* offsetof(devplcysys_t, dps_rdp) */ },
	{ DEVPLCY_TKN_WRP, PSET /* offsetof(devplcysys_t, dps_wrp) */ },
};

#define	RDPOL	0
#define	WRPOL	1

#define	NTOK	(sizeof (toktab)/sizeof (token_t))

/*
 * Compute the size of the datastructures needed.
 */
void
devplcy_init(void)
{
	if ((privimplinfo = getprivimplinfo()) == NULL) {
		(void) fprintf(stderr, gettext(ERR_PRIVIMPL));
		exit(1);
	}

	devplcysys_sz = DEVPLCYSYS_SZ(privimplinfo);

	toktab[RDPOL].off =
	    (char *)DEVPLCYSYS_RDP((devplcysys_t *)0, privimplinfo) - (char *)0;
	toktab[WRPOL].off =
	    (char *)DEVPLCYSYS_WRP((devplcysys_t *)0, privimplinfo) - (char *)0;
}

/*
 * Read a configuration file line and return a static buffer pointing to it.
 * It returns a static struct fileentry which has several fields:
 *	- rawbuf, which includes the lines including empty lines and comments
 *	leading up to the file and the entry as found in the file
 *	- orgentry, pointer in rawbuf to the start of the entry proper.
 *	- entry, a pre-parsed entry, escaped newlines removed.
 *	- startline, the line number of the first line in the file
 */
fileentry_t *
fgetline(FILE *fp)
{
	static size_t sz = BUFSIZ;
	static struct fileentry fe;
	static int linecnt = 1;

	char *buf = fe.rawbuf;
	ptrdiff_t off;
	char *p;
	int c, lastc, i;

	if (buf == NULL) {
		fe.rawbuf = buf = malloc(sz);
		if (buf == NULL)
			return (NULL);
	}
	if (fe.entry != NULL) {
		free(fe.entry);
		fe.orgentry = fe.entry = NULL;
	}

	i = 0;
	off = -1;
	c = '\n';

	while (lastc = c, (c = getc(fp)) != EOF) {
		buf[i++] = c;

		if (i == sz) {
			sz *= 2;
			fe.rawbuf = buf = realloc(buf, sz);
			if (buf == NULL)
				return (NULL);
		}

		if (c == '\n') {
			linecnt++;
			/* Newline, escaped or not yet processing an entry */
			if (off == -1 || lastc == '\\')
				continue;
		} else if (lastc == '\n' && off == -1) {
			/* Start of more comments */
			if (c == '#')
				continue;
			/* Found start of entry */
			off = i - 1;
			fe.startline = linecnt;
			continue;
		} else
			continue;

		buf[i] = '\0';
		fe.orgentry = buf + off;
		p = fe.entry = strdup(fe.orgentry);

		if (p == NULL)
			return (NULL);

		/* Remove <backslash><newline> */
		if ((p = strchr(p, '\\')) != NULL) {
			for (off = 0; (p[-off] = p[0]) != '\0'; p++)
				if (p[0] == '\\' && p[1] == '\n') {
					off += 2;
					p++;
				}
		}
		return (&fe);
	}
	if (lastc != '\n' || off != -1)
		return (NULL);
	buf[i] = '\0';
	linecnt = 1;
	return (&fe);
}

/*
 * Parse minor number ranges:
 *	(minor) or (lowminor-highminor)
 * Return 0 for success, -1 for failure.
 */
int
parse_minor_range(const char *range, minor_t *lo, minor_t *hi, char *type)
{
	unsigned long tmp;
	char *p;

	if (*range++ != '(')
		return (-1);

	errno = 0;
	tmp = strtoul(range, &p, 0);
	if (tmp > L_MAXMIN32 || (tmp == 0 && errno != 0) ||
	    (*p != '-' && *p != ')'))
		return (-1);
	*lo = tmp;
	if (*p == '-') {
		errno = 0;
		tmp = strtoul(p + 1, &p, 0);
		if (tmp > L_MAXMIN32 || (tmp == 0 && errno != 0) || *p != ')')
			return (-1);
	}
	*hi = tmp;
	if (*lo > *hi)
		return (-1);

	switch (p[1]) {
	case '\0':
		*type = '\0';
		break;
	case 'c':
	case 'C':
		*type = 'c';
		break;
	case 'b':
	case 'B':
		*type = 'b';
		break;
	default:
		return (-1);
	}
	return (0);
}

static void
put_minor_range(FILE *fp, fileentry_t *old, const char *devn, const char *tail,
    minor_t lo, minor_t hi, char type)
{
	/* Preserve preceeding comments */
	if (old != NULL && old->rawbuf != old->orgentry)
		(void) fwrite(old->rawbuf, 1, old->orgentry - old->rawbuf, fp);

	if (type == '\0') {
		put_minor_range(fp, NULL, devn, tail, lo, hi, 'b');
		put_minor_range(fp, NULL, devn, tail, lo, hi, 'c');
	} else if (lo == hi) {
		(void) fprintf(fp, "%s:(%d)%c%s", devn, (int)lo, type, tail);
	} else {
		(void) fprintf(fp, "%s:(%d-%d)%c%s", devn, (int)lo, (int)hi,
		    type, tail);
	}
}

static int
delete_one_entry(const char *filename, const char *entry)
{
	char tfile[MAXPATHLEN];
	char ofile[MAXPATHLEN];
	char *nfile;
	FILE *old, *new;
	fileentry_t *fep;
	struct stat buf;
	int newfd;
	char *mpart;
	boolean_t delall;
	boolean_t delrange;
	minor_t rlo, rhi;
	char rtype;

	mpart = strchr(entry, ':');
	if (mpart == NULL) {
		delall = B_TRUE;
		delrange = B_FALSE;
	} else {
		delall = B_FALSE;
		mpart++;
		if (*mpart == '(') {
			if (parse_minor_range(mpart, &rlo, &rhi, &rtype) != 0)
				return (-1);
			delrange = B_TRUE;
		} else {
			delrange = B_FALSE;
		}
	}

	if (strlen(filename) + sizeof (XEND)  > sizeof (tfile))
		return (-1);

	old = fopen(filename, "r");

	if (old == NULL)
		return (-1);

	(void) snprintf(tfile, sizeof (tfile), "%s%s", filename, XEND);
	(void) snprintf(ofile, sizeof (ofile), "%s%s", filename, ".old");

	nfile = mktemp(tfile);

	new = fopen(nfile, "w");
	if (new == NULL) {
		(void) fclose(old);
		return (ERROR);
	}

	newfd = fileno(new);

	/* Copy permissions, ownership */
	if (fstat(fileno(old), &buf) == 0) {
		(void) fchown(newfd, buf.st_uid, buf.st_gid);
		(void) fchmod(newfd, buf.st_mode);
	} else {
		(void) fchown(newfd, 0, 3);	/* root:sys */
		(void) fchmod(newfd, 0644);
	}

	while ((fep = fgetline(old))) {
		char *tok;
		char *min;
		char *tail;
		char tc;
		int len;

		/* Trailing comments */
		if (fep->entry == NULL) {
			(void) fputs(fep->rawbuf, new);
			break;
		}

		tok = fep->entry;
		while (*tok && isspace(*tok))
			tok++;

		if (*tok == '\0') {
			(void) fputs(fep->rawbuf, new);
			break;
		}

		/* Make sure we can recover the remainder incl. whitespace */
		tail = strpbrk(tok, "\t\n ");
		if (tail == NULL)
			tail = tok + strlen(tok);
		tc = *tail;
		*tail = '\0';

		if (delall || delrange) {
			min = strchr(tok, ':');
			if (min)
				*min++ = '\0';
		}

		len = strlen(tok);
		if (delrange) {
			minor_t lo, hi;
			char type;

			/*
			 * Delete or shrink overlapping ranges.
			 */
			if (strncmp(entry, tok, len) == 0 &&
			    entry[len] == ':' &&
			    min != NULL &&
			    parse_minor_range(min, &lo, &hi, &type) == 0 &&
			    (type == rtype || rtype == '\0') &&
			    lo <= rhi && hi >= rlo) {
				minor_t newlo, newhi;

				/* Complete overlap, then drop it. */
				if (lo >= rlo && hi <= rhi)
					continue;

				/* Partial overlap, shrink range */
				if (lo < rlo)
					newhi = rlo - 1;
				else
					newhi = hi;
				if (hi > rhi)
					newlo = rhi + 1;
				else
					newlo = lo;

				/* restore NULed character */
				*tail = tc;

				/* Split range? */
				if (newlo > newhi) {
					/*
					 * We have two ranges:
					 * lo ... newhi (== rlo - 1)
					 * newlo (== rhi + 1) .. hi
					 */
					put_minor_range(new, fep, tok, tail,
					    lo, newhi, type);
					put_minor_range(new, NULL, tok, tail,
					    newlo, hi, type);
				} else {
					put_minor_range(new, fep, tok, tail,
					    newlo, newhi, type);
				}
				continue;
			}
		} else if (strcmp(entry, tok) == 0 ||
		    (strncmp(entry, tok, len) == 0 &&
		    entry[len] == ':' &&
		    entry[len+1] == '*' &&
		    entry[len+2] == '\0')) {
			/*
			 * Delete exact match.
			 */
			continue;
		}

		/* Copy unaffected entry. */
		(void) fputs(fep->rawbuf, new);
	}
	(void) fclose(old);
	(void) fflush(new);
	(void) fsync(newfd);
	if (ferror(new) == 0 && fclose(new) == 0 && fep != NULL) {
		if (rename(filename, ofile) != 0) {
			perror(NULL);
			(void) fprintf(stderr, gettext(ERR_UPDATE), ofile);
			(void) unlink(ofile);
			(void) unlink(nfile);
			return (ERROR);
		} else if (rename(nfile, filename) != 0) {
			perror(NULL);
			(void) fprintf(stderr, gettext(ERR_UPDATE), ofile);
			(void) rename(ofile, filename);
			(void) unlink(nfile);
			return (ERROR);
		}
		(void) unlink(ofile);
	} else
		(void) unlink(nfile);
	return (0);
}


int
delete_plcy_entry(const char *filename, const char *entry)
{
	char *p, *single;
	char *copy;
	int ret = 0;

	copy = strdup(entry);
	if (copy == NULL)
		return (ERROR);

	for (single = strtok_r(copy, " \t\n", &p);
	    single != NULL;
	    single = strtok_r(NULL, " \t\n", &p)) {
		if ((ret = delete_one_entry(filename, single)) != 0) {
			free(copy);
			return (ret);
		}
	}
	free(copy);
	return (0);
}

/*
 * Analyze the device policy token; new tokens should be added to
 * toktab; new token types should be coded here.
 */
int
parse_plcy_token(char *token, devplcysys_t *dp)
{
	char *val = strchr(token, '=');
	const char *perr;
	int i;
	priv_set_t *pset;

	if (val == NULL) {
		(void) fprintf(stderr, gettext(ERR_NO_EQUALS), token);
		return (1);
	}
	*val++ = '\0';

	for (i = 0; i < NTOK; i++) {
		if (strcmp(token, toktab[i].token) == 0) {
			/* standard pointer computation for tokens */
			void *item = (char *)dp + toktab[i].off;

			switch (toktab[i].type) {
			case PSET:
				pset = priv_str_to_set(val, ",", &perr);
				if (pset == NULL) {
					if (perr == NULL) {
						(void) fprintf(stderr,
						    gettext(ERR_NO_MEM));
					} else {
						(void) fprintf(stderr,
						    gettext(ERR_BAD_PRIVS),
						    perr - val, val, perr);
					}
					return (1);
				}
				priv_copyset(pset, item);
				priv_freeset(pset);
				break;
			default:
				(void) fprintf(stderr,
				    "Internal Error: bad token type: %d\n",
				    toktab[i].type);
				return (1);
			}
			/* Standard cleanup & return for good tokens */
			val[-1] = '=';
			return (0);
		}
	}
	(void) fprintf(stderr, gettext(ERR_BAD_TOKEN), token);
	return (1);
}

static int
add2str(char **dstp, const char *str, size_t *sz)
{
	char *p = *dstp;
	size_t len = strlen(p) + strlen(str) + 1;

	if (len > *sz) {
		*sz *= 2;
		if (*sz < len)
			*sz = len;
		*dstp = p = realloc(p, *sz);
		if (p == NULL) {
			(void) fprintf(stderr, gettext(ERR_NO_MEM));
			return (-1);
		}
	}
	(void) strcat(p, str);
	return (0);
}

/*
 * Verify that the policy entry is valid and return the canonical entry.
 */
char *
check_plcy_entry(char *entry, const char *driver, boolean_t todel)
{
	char *res;
	devplcysys_t *ds;
	char *tok;
	size_t sz = strlen(entry) * 2 + strlen(driver) + 3;
	boolean_t tokseen = B_FALSE;

	devplcy_init();

	res = malloc(sz);
	ds = alloca(devplcysys_sz);

	if (res == NULL || ds == NULL) {
		(void) fprintf(stderr, gettext(ERR_NO_MEM));
		free(res);
		return (NULL);
	}

	*res = '\0';

	while ((tok = strtok(entry, " \t\n")) != NULL) {
		entry = NULL;

		/* It's not a token */
		if (strchr(tok, '=') == NULL) {
			if (strchr(tok, ':') != NULL) {
				(void) fprintf(stderr, gettext(ERR_BAD_MINOR));
				free(res);
				return (NULL);
			}
			if (*res != '\0' && add2str(&res, "\n", &sz) != 0)
				return (NULL);

			if (*tok == '(') {
				char type;
				if (parse_minor_range(tok, &ds->dps_lomin,
				    &ds->dps_himin, &type) != 0 ||
				    (!todel && type == '\0')) {
					(void) fprintf(stderr,
					    gettext(ERR_BAD_MINOR));
					free(res);
					return (NULL);
				}
			} else {
				char *tmp = strchr(tok, '*');

				if (tmp != NULL &&
				    strchr(tmp + 1, '*') != NULL) {
					(void) fprintf(stderr,
					    gettext(ERR_BAD_MINOR));
					free(res);
				}
			}

			if (add2str(&res, driver, &sz) != 0)
				return (NULL);
			if (add2str(&res, ":", &sz) != 0)
				return (NULL);
			if (add2str(&res, tok, &sz) != 0)
				return (NULL);
			tokseen = B_FALSE;
		} else {
			if (*res == '\0') {
				if (add2str(&res, driver, &sz) != 0)
					return (NULL);
				if (add2str(&res, ":*", &sz) != 0)
					return (NULL);
			}
			if (parse_plcy_token(tok, ds) != 0) {
				free(res);
				return (NULL);
			}

			if (add2str(&res, "\t", &sz) != 0)
				return (NULL);
			if (add2str(&res, tok, &sz) != 0)
				return (NULL);
			tokseen = B_TRUE;
		}
	}
	if ((todel && tokseen) || *res == '\0' || (!todel && !tokseen)) {
		(void) fprintf(stderr, gettext(ERR_INVALID_PLCY));
		free(res);
		return (NULL);
	}
	if (!todel)
		if (add2str(&res, "\n", &sz) != 0)
			return (NULL);
	return (res);
}

int
update_device_policy(const char *filename, const char *entry, boolean_t repl)
{
	FILE *fp;

	if (repl) {
		char *dup, *tok, *s1;

		dup = strdup(entry);
		if (dup == NULL) {
			(void) fprintf(stderr, gettext(ERR_NO_MEM));
			return (ERROR);
		}

		/*
		 * Split the entry in lines; then get the first token
		 * of each line.
		 */
		for (tok = strtok_r(dup, "\n", &s1); tok != NULL;
		    tok = strtok_r(NULL, "\n", &s1)) {

			tok = strtok(tok, " \n\t");

			if (delete_one_entry(filename, tok) != 0) {
				free(dup);
				return (ERROR);
			}
		}

		free(dup);
	}

	fp = fopen(filename, "a");
	if (fp == NULL)
		return (ERROR);

	(void) fputs(entry, fp);

	if (fflush(fp) != 0 || fsync(fileno(fp)) != 0 || fclose(fp) != 0)
		return (ERROR);

	return (NOERR);
}


/*
 * We need to allocate the privileges now or the privilege set
 * parsing code will not allow them.
 */
int
check_priv_entry(const char *privlist, boolean_t add)
{
	char *l = strdup(privlist);
	char *pr;

	if (l == NULL) {
		(void) fprintf(stderr, gettext(ERR_NO_MEM));
		return (ERROR);
	}

	while ((pr = strtok_r(l, ",", &l)) != NULL) {
		/* Privilege already exists */
		if (priv_getbyname(pr) != -1)
			continue;

		if (add && modctl(MODALLOCPRIV, pr) != 0) {
			(void) fprintf(stderr, gettext(ERR_BAD_PRIV), pr,
			    strerror(errno));
			return (ERROR);
		}
	}
	return (NOERR);
}