xref: /illumos-gate/usr/src/lib/libdevinfo/devinfo_devperm.c (revision f00128d8)

/*
 * 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 (c) 2011 Gary Mills
 *
 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#define	_POSIX_PTHREAD_SEMANTICS	/* for getgrnam_r */
#ifdef lint
#define	_REENTRANT			/* for strtok_r */
#endif

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <dirent.h>
#include <errno.h>
#include <grp.h>
#include <pwd.h>
#include <nss_dbdefs.h>
#include <stdarg.h>
#include <syslog.h>
#include <sys/acl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/devinfo_impl.h>
#include <sys/hwconf.h>
#include <sys/modctl.h>
#include <libnvpair.h>
#include <device_info.h>
#include <regex.h>
#include <strings.h>
#include <libdevinfo.h>
#include <zone.h>
#include <fcntl.h>
#include <utmpx.h>

extern int is_minor_node(const char *, const char **);

static int is_login_user(uid_t);
static int logindevperm(const char *, uid_t, gid_t, void (*)());
static int dir_dev_acc(char *, char *, uid_t, gid_t, mode_t, char *line,
	void (*)());
static int setdevaccess(char *, uid_t, gid_t, mode_t, void (*)());
static void logerror(char *);

static int is_blank(char *);

#define	MAX_LINELEN	256
#define	LOGINDEVPERM	"/etc/logindevperm"
#define	DIRWILD		"/*"			/* directory wildcard */
#define	DIRWLDLEN	2			/* strlen(DIRWILD) */

/*
 * Revoke all access to a device node and make sure that there are
 * no interposed streams devices attached.  Must be called before a
 * device is actually opened.
 * When fdetach is called, the underlying device node is revealed; it
 * will have the previous owner and that owner can re-attach; so we
 * retry until we win.
 * Ignore non-existent devices.
 */
static int
setdevaccess(char *dev, uid_t uid, gid_t gid, mode_t mode,
    void (*errmsg)(char *))
{
	int err = 0, local_errno;
	char errstring[MAX_LINELEN];
	struct stat st;

	if (chown(dev, uid, gid) == -1) {
		if (errno == ENOENT)	/* no such file */
			return (0);
		err = -1;
		local_errno = errno;
	}

	/*
	 * don't fdetach block devices, as it will unmount them
	 */
	if (!((stat(dev, &st) == 0) && ((st.st_mode & S_IFMT) == S_IFBLK))) {
		while (fdetach(dev) == 0) {
			if (chown(dev, uid, gid) == -1) {
				err = -1;
				local_errno = errno;
			}
		}
		if (err && errmsg) {
			(void) snprintf(errstring, MAX_LINELEN,
			    "failed to chown device %s: %s\n",
			    dev, strerror(local_errno));
			(*errmsg)(errstring);
		}
	}

	/*
	 * strip_acl sets an acl and changes the files owner/group
	 */
	err = acl_strip(dev, uid, gid, mode);

	if (err != 0) {
		/*
		 * If the file system returned ENOSYS, we know that it
		 * doesn't support ACLs, therefore, we must assume that
		 * there were no ACLs to remove in the first place.
		 */
		err = 0;
		if (errno != ENOSYS) {
			err = -1;

			if (errmsg) {
				(void) snprintf(errstring, MAX_LINELEN,
				    "failed to set acl on device %s: %s\n",
				    dev, strerror(errno));
				(*errmsg)(errstring);
			}
		}
		if (chmod(dev, mode) == -1) {
			err = -1;
			if (errmsg) {
				(void) snprintf(errstring, MAX_LINELEN,
				    "failed to chmod device %s: %s\n",
				    dev, strerror(errno));
				(*errmsg)(errstring);
			}
		}
	}

	return (err);
}

/*
 * logindevperm - change owner/group/permissions of devices
 * list in /etc/logindevperm.
 */
static int
logindevperm(const char *ttyn, uid_t uid, gid_t gid, void (*errmsg)(char *))
{
	int err = 0, lineno = 0;
	const char *field_delims = " \t\n";
	char line[MAX_LINELEN], errstring[MAX_LINELEN];
	char saveline[MAX_LINELEN];
	char *console;
	char *mode_str;
	char *dev_list;
	char *device;
	char *ptr;
	int mode;
	FILE *fp;
	char ttyn_path[PATH_MAX + 1];
	int n;

	if ((fp = fopen(LOGINDEVPERM, "r")) == NULL) {
		if (errmsg) {
			(void) snprintf(errstring, MAX_LINELEN,
			    LOGINDEVPERM ": open failed: %s\n",
			    strerror(errno));
			(*errmsg)(errstring);
		}
		return (-1);
	}

	if ((n = resolvepath(ttyn, ttyn_path, PATH_MAX)) == -1)
		return (-1);
	ttyn_path[n] = '\0';

	while (fgets(line, MAX_LINELEN, fp) != NULL) {
		char *last;
		char tmp[PATH_MAX + 1];

		lineno++;

		if ((ptr = strchr(line, '#')) != NULL)
			*ptr = '\0';	/* handle comments */

		(void) strcpy(saveline, line);

		console = strtok_r(line, field_delims, &last);
		if (console == NULL)
			continue;	/* ignore blank lines */

		if ((n = resolvepath(console, tmp, PATH_MAX)) == -1)
			continue;
		tmp[n] = '\0';

		if (strcmp(ttyn_path, tmp) != 0)
			continue;

		mode_str = strtok_r(last, field_delims, &last);
		if (mode_str == NULL) {
			err = -1;	/* invalid entry, skip */
			if (errmsg) {
				(void) snprintf(errstring, MAX_LINELEN,
				    LOGINDEVPERM
				    ": line %d, invalid entry -- %s\n",
				    lineno, line);
				(*errmsg)(errstring);
			}
			continue;
		}

		/* convert string to octal value */
		mode = strtol(mode_str, &ptr, 8);
		if (mode < 0 || mode > 0777 || *ptr != '\0') {
			err = -1;	/* invalid mode, skip */
			if (errmsg) {
				(void) snprintf(errstring, MAX_LINELEN,
				    LOGINDEVPERM
				    ": line %d, invalid mode -- %s\n",
				    lineno, mode_str);
				(*errmsg)(errstring);
			}
			continue;
		}

		dev_list = strtok_r(last, field_delims, &last);
		if (dev_list == NULL) {
			err = -1;	/* empty device list, skip */
			if (errmsg) {
				(void) snprintf(errstring, MAX_LINELEN,
				    LOGINDEVPERM
				    ": line %d, empty device list -- %s\n",
				    lineno, line);
				(*errmsg)(errstring);
			}
			continue;
		}

		device = strtok_r(dev_list, ":", &last);
		while (device != NULL) {
			if ((device[0] != '/') || (strlen(device) <= 1))  {
				err = -1;
			} else if (dir_dev_acc("/", &device[1], uid, gid, mode,
			    saveline, errmsg)) {
				err = -1;
			}
			device = strtok_r(last, ":", &last);
		}
	}
	(void) fclose(fp);
	return (err);
}

/*
 * returns 0 if resolved, -1 otherwise.
 * devpath: Absolute path to /dev link
 * devfs_path: Returns malloced string: /devices path w/out "/devices"
 */
int
devfs_resolve_link(char *devpath, char **devfs_path)
{
	char contents[PATH_MAX + 1];
	char stage_link[PATH_MAX + 1];
	char *ptr;
	int linksize;
	char *slashdev = "/dev/";

	if (devfs_path) {
		*devfs_path = NULL;
	}

	linksize = readlink(devpath, contents, PATH_MAX);

	if (linksize <= 0) {
		return (-1);
	} else {
		contents[linksize] = '\0';
	}

	/*
	 * if the link contents is not a minor node assume
	 * that link contents is really a pointer to another
	 * link, and if so recurse and read its link contents.
	 */
	if (is_minor_node((const char *)contents, (const char **)&ptr) !=
	    1) {
		if (strncmp(contents, slashdev, strlen(slashdev)) == 0)  {
			/* absolute path, starting with /dev */
			(void) strcpy(stage_link, contents);
		} else {
			/* relative path, prefix devpath */
			if ((ptr = strrchr(devpath, '/')) == NULL) {
				/* invalid link */
				return (-1);
			}
			*ptr = '\0';
			(void) strcpy(stage_link, devpath);
			*ptr = '/';
			(void) strcat(stage_link, "/");
			(void) strcat(stage_link, contents);

		}
		return (devfs_resolve_link(stage_link, devfs_path));
	}

	if (devfs_path) {
		*devfs_path = strdup(ptr);
		if (*devfs_path == NULL) {
			return (-1);
		}
	}

	return (0);
}

/*
 * check a logindevperm line for a driver list and match this against
 * the driver of the minor node
 * returns 0 if no drivers were specified or a driver match
 */
static int
check_driver_match(char *path, char *line)
{
	char *drv, *driver, *lasts;
	char *devfs_path = NULL;
	char saveline[MAX_LINELEN];
	char *p;

	if (devfs_resolve_link(path, &devfs_path) == 0) {
		char *p;
		char pwd_buf[PATH_MAX];
		di_node_t node;

		/* truncate on : so we can take a snapshot */
		(void) strcpy(pwd_buf, devfs_path);
		p = strrchr(pwd_buf, ':');
		*p = '\0';

		node = di_init(pwd_buf, DINFOMINOR);
		free(devfs_path);

		if (node) {
			drv = di_driver_name(node);
			di_fini(node);
		} else {
			return (0);
		}
	} else {
		return (0);
	}

	(void) strcpy(saveline, line);

	p = strstr(saveline, "driver");
	if (p == NULL) {
		return (0);
	}

	driver = strtok_r(p, "=", &lasts);
	if (driver) {
		if (strcmp(driver, "driver") == 0) {
			driver = strtok_r(NULL, ", \t\n", &lasts);
			while (driver) {
				if (strcmp(driver, drv) == 0) {
					return (0);
				}
				driver = strtok_r(NULL, ", \t\n", &lasts);
			}
		}
	}

	return (-1);
}

/*
 * Check whether the user has logged onto "/dev/console" or "/dev/vt/#".
 */
static int
is_login_user(uid_t uid)
{
	int changed = 0;
	struct passwd pwd, *ppwd;
	char pwd_buf[NSS_BUFLEN_PASSWD];
	struct utmpx *utx;

	if ((getpwuid_r(uid, &pwd, pwd_buf, NSS_BUFLEN_PASSWD, &ppwd) != 0) ||
	    (ppwd == NULL)) {
		return (0);
	}

	setutxent();
	while ((utx = getutxent()) != NULL) {
		if (utx->ut_type == USER_PROCESS &&
		    strncmp(utx->ut_user, ppwd->pw_name,
		    strlen(ppwd->pw_name)) == 0 && (strncmp(utx->ut_line,
		    "console", strlen("console")) == 0 || strncmp(utx->ut_line,
		    "vt", strlen("vt")) == 0)) {

			changed = 1;
			break;
		}
	}
	endutxent();

	return (changed);
}

/*
 * Apply owner/group/perms to all files (except "." and "..")
 * in a directory.
 * This function is recursive. We start with "/" and the rest of the pathname
 * in left_to_do argument, and we walk the entire pathname which may contain
 * regular expressions or '*' for each directory name or basename.
 */
static int
dir_dev_acc(char *path, char *left_to_do, uid_t uid, gid_t gid, mode_t mode,
    char *line, void (*errmsg)(char *))
{
	struct stat stat_buf;
	int err = 0;
	char errstring[MAX_LINELEN];
	char *p;
	regex_t regex;
	int alwaysmatch = 0;
	char *match;
	char *name, *newpath, *remainder_path;
	finddevhdl_t handle;

	/*
	 * Determine if the search needs to be performed via finddev,
	 * which returns only persisted names in the global /dev, or
	 * readdir, for paths other than /dev and non-global zones.
	 * This use of finddev avoids triggering potential implicit
	 * reconfig for names managed by logindevperm but not present
	 * on the system.
	 */
	if (!device_exists(path)) {
		return (-1);
	}
	if (stat(path, &stat_buf) == -1) {
		/*
		 * ENOENT errors are expected errors when there are
		 * dangling /dev device links. Ignore them silently
		 */
		if (errno == ENOENT) {
			return (0);
		}
		if (errmsg) {
			(void) snprintf(errstring, MAX_LINELEN,
			    "failed to stat %s: %s\n", path,
			    strerror(errno));
			(*errmsg)(errstring);
		}
		return (-1);
	} else {
		if (!S_ISDIR(stat_buf.st_mode)) {
			if (strlen(left_to_do) == 0) {
				/* finally check the driver matches */
				if (check_driver_match(path, line) == 0) {
					/*
					 * if the owner of device has been
					 * login, the ownership and mode
					 * should be set already. in
					 * this case, do not set the
					 * permissions.
					 */
					if (is_login_user(stat_buf.st_uid)) {

						return (0);
					}
					/* we are done, set the permissions */
					if (setdevaccess(path,
					    uid, gid, mode, errmsg)) {

						return (-1);
					}
				}
			}
			return (0);
		}
	}

	if (finddev_readdir(path, &handle) != 0)
		return (0);

	p = strchr(left_to_do, '/');
	alwaysmatch = 0;

	newpath = (char *)malloc(MAXPATHLEN);
	if (newpath == NULL) {
		finddev_close(handle);
		return (-1);
	}
	match = (char *)calloc(MAXPATHLEN + 2, 1);
	if (match == NULL) {
		finddev_close(handle);
		free(newpath);
		return (-1);
	}

	/* transform pattern into ^pattern$ for exact match */
	if (snprintf(match, MAXPATHLEN + 2, "^%.*s$",
	    p ? (p - left_to_do) : strlen(left_to_do), left_to_do) >=
	    MAXPATHLEN + 2) {
		finddev_close(handle);
		free(newpath);
		free(match);
		return (-1);
	}

	if (strcmp(match, "^*$") == 0) {
		alwaysmatch = 1;
	} else {
		if (regcomp(&regex, match, REG_EXTENDED) != 0) {
			free(newpath);
			free(match);
			finddev_close(handle);
			return (-1);
		}
	}

	while ((name = (char *)finddev_next(handle)) != NULL) {
		if (alwaysmatch ||
		    regexec(&regex, name, 0, NULL, 0) == 0) {
			if (strcmp(path, "/") == 0) {
				(void) snprintf(newpath,
				    MAXPATHLEN, "%s%s", path, name);
			} else {
				(void) snprintf(newpath,
				    MAXPATHLEN, "%s/%s", path, name);
			}

			/*
			 * recurse but adjust what is still left to do
			 */
			remainder_path = (p ?
			    left_to_do + (p - left_to_do) + 1 :
			    &left_to_do[strlen(left_to_do)]);
			if (dir_dev_acc(newpath, remainder_path,
			    uid, gid, mode, line, errmsg)) {
				err = -1;
			}
		}
	}

	finddev_close(handle);
	free(newpath);
	free(match);
	if (!alwaysmatch) {
		regfree(&regex);
	}

	return (err);
}

/*
 * di_devperm_login - modify access of devices in /etc/logindevperm
 * by changing owner/group/permissions to that of ttyn.
 */
int
di_devperm_login(const char *ttyn, uid_t uid, gid_t gid,
    void (*errmsg)(char *))
{
	int err;
	struct group grp, *grpp;
	gid_t tty_gid;
	char grbuf[NSS_BUFLEN_GROUP];

	if (errmsg == NULL)
		errmsg = logerror;

	if (ttyn == NULL) {
		(*errmsg)("di_devperm_login: NULL tty device\n");
		return (-1);
	}

	if (getgrnam_r("tty", &grp, grbuf, NSS_BUFLEN_GROUP, &grpp) != 0) {
		tty_gid = grpp->gr_gid;
	} else {
		/*
		 * this should never happen, but if it does set
		 * group to tty's traditional value.
		 */
		tty_gid = 7;
	}

	/* set the login console device permission */
	err = setdevaccess((char *)ttyn, uid, tty_gid,
	    S_IRUSR|S_IWUSR|S_IWGRP, errmsg);
	if (err) {
		return (err);
	}

	/* set the device permissions */
	return (logindevperm(ttyn, uid, gid, errmsg));
}

/*
 * di_devperm_logout - clean up access of devices in /etc/logindevperm
 * by resetting owner/group/permissions.
 */
int
di_devperm_logout(const char *ttyn)
{
	struct passwd *pwd;
	uid_t root_uid;
	gid_t root_gid;

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

	pwd = getpwnam("root");
	if (pwd != NULL) {
		root_uid = pwd->pw_uid;
		root_gid = pwd->pw_gid;
	} else {
		/*
		 * this should never happen, but if it does set user
		 * and group to root's traditional values.
		 */
		root_uid = 0;
		root_gid = 0;
	}

	return (logindevperm(ttyn, root_uid, root_gid, NULL));
}

static void
logerror(char *errstring)
{
	syslog(LOG_AUTH | LOG_CRIT, "%s", errstring);
}


/*
 * Tokens are separated by ' ', '\t', ':', '=', '&', '|', ';', '\n', or '\0'
 */
static int
getnexttoken(char *next, char **nextp, char **tokenpp, char *tchar)
{
	char *cp;
	char *cp1;
	char *tokenp;

	cp = next;
	while (*cp == ' ' || *cp == '\t') {
		cp++;			/* skip leading spaces */
	}
	tokenp = cp;			/* start of token */
	while (*cp != '\0' && *cp != '\n' && *cp != ' ' && *cp != '\t' &&
	    *cp != ':' && *cp != '=' && *cp != '&' &&
	    *cp != '|' && *cp != ';') {
		cp++;			/* point to next character */
	}
	/*
	 * If terminating character is a space or tab, look ahead to see if
	 * there's another terminator that's not a space or a tab.
	 * (This code handles trailing spaces.)
	 */
	if (*cp == ' ' || *cp == '\t') {
		cp1 = cp;
		while (*++cp1 == ' ' || *cp1 == '\t')
			;
		if (*cp1 == '=' || *cp1 == ':' || *cp1 == '&' || *cp1 == '|' ||
		    *cp1 == ';' || *cp1 == '\n' || *cp1 == '\0') {
			*cp = '\0';	/* terminate token */
			cp = cp1;
		}
	}
	if (tchar != NULL) {
		*tchar = *cp;		/* save terminating character */
		if (*tchar == '\0') {
			*tchar = '\n';
		}
	}
	*cp++ = '\0';			/* terminate token, point to next */
	*nextp = cp;			/* set pointer to next character */
	if (cp - tokenp - 1 == 0) {
		return (0);
	}
	*tokenpp = tokenp;
	return (1);
}

/*
 * get a decimal octal or hex number. Handle '~' for one's complement.
 */
static int
getvalue(char *token, int *valuep)
{
	int radix;
	int retval = 0;
	int onescompl = 0;
	int negate = 0;
	char c;

	if (*token == '~') {
		onescompl++; /* perform one's complement on result */
		token++;
	} else if (*token == '-') {
		negate++;
		token++;
	}
	if (*token == '0') {
		token++;
		c = *token;

		if (c == '\0') {
			*valuep = 0;	/* value is 0 */
			return (0);
		}

		if (c == 'x' || c == 'X') {
			radix = 16;
			token++;
		} else {
			radix = 8;
		}
	} else
		radix = 10;

	while ((c = *token++)) {
		switch (radix) {
		case 8:
			if (c >= '0' && c <= '7') {
				c -= '0';
			} else {
				/* invalid number */
				return (0);
			}
			retval = (retval << 3) + c;
			break;
		case 10:
			if (c >= '0' && c <= '9') {
				c -= '0';
			} else {
				/* invalid number */
				return (0);
			}
			retval = (retval * 10) + c;
			break;
		case 16:
			if (c >= 'a' && c <= 'f') {
				c = c - 'a' + 10;
			} else if (c >= 'A' && c <= 'F') {
				c = c - 'A' + 10;
			} else if (c >= '0' && c <= '9') {
				c -= '0';
			} else {
				/* invalid number */
				return (0);
			}
			retval = (retval << 4) + c;
			break;
		}
	}
	if (onescompl) {
		retval = ~retval;
	}
	if (negate) {
		retval = -retval;
	}
	*valuep = retval;
	return (1);
}

/*
 * Read /etc/minor_perm, return mperm list of entries
 */
struct mperm *
i_devfs_read_minor_perm(char *drvname, void (*errcb)(minorperm_err_t, int))
{
	FILE *pfd;
	struct mperm *mp;
	char line[MAX_MINOR_PERM_LINE];
	char *cp, *p, t;
	struct mperm *minor_perms = NULL;
	struct mperm *mptail = NULL;
	struct passwd *pw;
	struct group *gp;
	uid_t root_uid;
	gid_t sys_gid;
	int ln = 0;

	/*
	 * Get root/sys ids, these being the most common
	 */
	if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) {
		root_uid = pw->pw_uid;
	} else {
		(*errcb)(MP_CANT_FIND_USER_ERR, 0);
		root_uid = (uid_t)0;	/* assume 0 is root */
	}
	if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) {
		sys_gid = gp->gr_gid;
	} else {
		(*errcb)(MP_CANT_FIND_GROUP_ERR, 0);
		sys_gid = (gid_t)3;	/* assume 3 is sys */
	}

	if ((pfd = fopen(MINOR_PERM_FILE, "r")) == NULL) {
		(*errcb)(MP_FOPEN_ERR, errno);
		return (NULL);
	}
	while (fgets(line, MAX_MINOR_PERM_LINE, pfd) != NULL) {
		ln++;
		/* cut off comments starting with '#' */
		if ((cp = strchr(line, '#')) != NULL)
			*cp = '\0';
		/* ignore comment or blank lines */
		if (is_blank(line))
			continue;
		mp = (struct mperm *)calloc(1, sizeof (struct mperm));
		if (mp == NULL) {
			(*errcb)(MP_ALLOC_ERR, sizeof (struct mperm));
			continue;
		}
		cp = line;
		/* sanity-check */
		if (getnexttoken(cp, &cp, &p, &t) == 0) {
			(*errcb)(MP_IGNORING_LINE_ERR, ln);
			devfs_free_minor_perm(mp);
			continue;
		}
		mp->mp_drvname = strdup(p);
		if (mp->mp_drvname == NULL) {
			(*errcb)(MP_ALLOC_ERR, strlen(p)+1);
			devfs_free_minor_perm(mp);
			continue;
		} else if (t == '\n' || t == '\0') {
			(*errcb)(MP_IGNORING_LINE_ERR, ln);
			devfs_free_minor_perm(mp);
			continue;
		}
		if (t == ':') {
			if (getnexttoken(cp, &cp, &p, &t) == 0) {
				(*errcb)(MP_IGNORING_LINE_ERR, ln);
				devfs_free_minor_perm(mp);
			}
			mp->mp_minorname = strdup(p);
			if (mp->mp_minorname == NULL) {
				(*errcb)(MP_ALLOC_ERR, strlen(p)+1);
				devfs_free_minor_perm(mp);
				continue;
			}
		} else {
			mp->mp_minorname = NULL;
		}

		if (t == '\n' || t == '\0') {
			devfs_free_minor_perm(mp);
			(*errcb)(MP_IGNORING_LINE_ERR, ln);
			continue;
		}
		if (getnexttoken(cp, &cp, &p, &t) == 0) {
			goto link;
		}
		if (getvalue(p, (int *)&mp->mp_mode) == 0) {
			goto link;
		}
		if (t == '\n' || t == '\0') {	/* no owner or group */
			goto link;
		}
		if (getnexttoken(cp, &cp, &p, &t) == 0) {
			goto link;
		}
		mp->mp_owner = strdup(p);
		if (mp->mp_owner == NULL) {
			(*errcb)(MP_ALLOC_ERR, strlen(p)+1);
			devfs_free_minor_perm(mp);
			continue;
		} else if (t == '\n' || t == '\0') {	/* no group */
			goto link;
		}
		if (getnexttoken(cp, &cp, &p, 0) == 0) {
			goto link;
		}
		mp->mp_group = strdup(p);
		if (mp->mp_group == NULL) {
			(*errcb)(MP_ALLOC_ERR, strlen(p)+1);
			devfs_free_minor_perm(mp);
			continue;
		}
link:
		if (drvname != NULL) {
			/*
			 * We only want the minor perm entry for a
			 * the named driver.  The driver name is the
			 * minor in the clone case.
			 */
			if (strcmp(mp->mp_drvname, "clone") == 0) {
				if (mp->mp_minorname == NULL ||
				    strcmp(drvname, mp->mp_minorname) != 0) {
					devfs_free_minor_perm(mp);
					continue;
				}
			} else {
				if (strcmp(drvname, mp->mp_drvname) != 0) {
					devfs_free_minor_perm(mp);
					continue;
				}
			}
		}
		if (minor_perms == NULL) {
			minor_perms = mp;
		} else {
			mptail->mp_next = mp;
		}
		mptail = mp;

		/*
		 * Compute the uid's and gid's here - there are
		 * fewer lines in the /etc/minor_perm file than there
		 * are devices to be stat(2)ed.  And almost every
		 * device is 'root sys'.  See 1135520.
		 */
		if (mp->mp_owner == NULL ||
		    strcmp(mp->mp_owner, DEFAULT_DEV_USER) == 0 ||
		    (pw = getpwnam(mp->mp_owner)) == NULL) {
			mp->mp_uid = root_uid;
		} else {
			mp->mp_uid = pw->pw_uid;
		}

		if (mp->mp_group == NULL ||
		    strcmp(mp->mp_group, DEFAULT_DEV_GROUP) == 0 ||
		    (gp = getgrnam(mp->mp_group)) == NULL) {
			mp->mp_gid = sys_gid;
		} else {
			mp->mp_gid = gp->gr_gid;
		}
	}

	if (fclose(pfd) == EOF) {
		(*errcb)(MP_FCLOSE_ERR, errno);
	}

	return (minor_perms);
}

struct mperm *
devfs_read_minor_perm(void (*errcb)(minorperm_err_t, int))
{
	return (i_devfs_read_minor_perm(NULL, errcb));
}

static struct mperm *
i_devfs_read_minor_perm_by_driver(char *drvname,
    void (*errcb)(minorperm_err_t mp_err, int key))
{
	return (i_devfs_read_minor_perm(drvname, errcb));
}

/*
 * Free mperm list of entries
 */
void
devfs_free_minor_perm(struct mperm *mplist)
{
	struct mperm *mp, *next;

	for (mp = mplist; mp != NULL; mp = next) {
		next = mp->mp_next;

		if (mp->mp_drvname)
			free(mp->mp_drvname);
		if (mp->mp_minorname)
			free(mp->mp_minorname);
		if (mp->mp_owner)
			free(mp->mp_owner);
		if (mp->mp_group)
			free(mp->mp_group);
		free(mp);
	}
}

static int
i_devfs_add_perm_entry(nvlist_t *nvl, struct mperm *mp)
{
	int err;

	err = nvlist_add_string(nvl, mp->mp_drvname, mp->mp_minorname);
	if (err != 0)
		return (err);

	err = nvlist_add_int32(nvl, "mode", (int32_t)mp->mp_mode);
	if (err != 0)
		return (err);

	err = nvlist_add_uint32(nvl, "uid", mp->mp_uid);
	if (err != 0)
		return (err);

	err = nvlist_add_uint32(nvl, "gid", mp->mp_gid);
	return (err);
}

static nvlist_t *
i_devfs_minor_perm_nvlist(struct mperm *mplist,
    void (*errcb)(minorperm_err_t, int))
{
	int err;
	struct mperm *mp;
	nvlist_t *nvl = NULL;

	if ((err = nvlist_alloc(&nvl, 0, 0)) != 0) {
		(*errcb)(MP_NVLIST_ERR, err);
		return (NULL);
	}

	for (mp = mplist; mp != NULL; mp = mp->mp_next) {
		if ((err = i_devfs_add_perm_entry(nvl, mp)) != 0) {
			(*errcb)(MP_NVLIST_ERR, err);
			nvlist_free(nvl);
			return (NULL);
		}
	}

	return (nvl);
}

/*
 * Load all minor perm entries into the kernel
 * Done at boot time via devfsadm
 */
int
devfs_load_minor_perm(struct mperm *mplist, void (*errcb)(minorperm_err_t, int))
{
	int err;
	char *buf = NULL;
	size_t buflen;
	nvlist_t *nvl;

	nvl = i_devfs_minor_perm_nvlist(mplist, errcb);
	if (nvl == NULL)
		return (-1);

	if (nvlist_pack(nvl, &buf, &buflen, NV_ENCODE_NATIVE, 0) != 0) {
		nvlist_free(nvl);
		return (-1);
	}

	err = modctl(MODLOADMINORPERM, buf, buflen);
	nvlist_free(nvl);
	free(buf);

	return (err);
}

/*
 * Add/remove minor perm entry for a driver
 */
static int
i_devfs_update_minor_perm(char *drv, int ctl,
    void (*errcb)(minorperm_err_t, int))
{
	int err;
	char *buf;
	size_t buflen;
	nvlist_t *nvl;
	struct mperm *mplist;

	mplist = i_devfs_read_minor_perm_by_driver(drv, errcb);

	nvl = i_devfs_minor_perm_nvlist(mplist, errcb);
	if (nvl == NULL)
		return (-1);

	buf = NULL;
	if (nvlist_pack(nvl, &buf, &buflen, NV_ENCODE_NATIVE, 0) != 0) {
		nvlist_free(nvl);
		return (-1);
	}

	err = modctl(ctl, buf, buflen);
	nvlist_free(nvl);
	devfs_free_minor_perm(mplist);
	free(buf);

	return (err);
}

int
devfs_add_minor_perm(char *drv, void (*errcb)(minorperm_err_t, int))
{
	return (i_devfs_update_minor_perm(drv, MODADDMINORPERM, errcb));
}

int
devfs_rm_minor_perm(char *drv, void (*errcb)(minorperm_err_t, int))
{
	return (i_devfs_update_minor_perm(drv, MODREMMINORPERM, errcb));
}

/*
 * is_blank() returns 1 (true) if a line specified is composed of
 * whitespace characters only. otherwise, it returns 0 (false).
 *
 * Note. the argument (line) must be null-terminated.
 */
static int
is_blank(char *line)
{
	for (/* nothing */; *line != '\0'; line++)
		if (!isspace(*line))
			return (0);
	return (1);
}