/*

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

/*

 * Devfsadm replaces drvconfig, audlinks, disks, tapes, ports, devlinks

 * as a general purpose device administrative utility.	It creates

 * devices special files in /devices and logical links in /dev, and

 * coordinates updates to /etc/path_to_instance with the kernel.  It

 * operates in both command line mode to handle user or script invoked

 * reconfiguration updates, and operates in daemon mode to handle dynamic

 * reconfiguration for hotplugging support.

 */

#include <string.h>

#include <deflt.h>

#include <tsol/label.h>

#include <bsm/devices.h>

#include <bsm/devalloc.h>

#include <utime.h>

#include <sys/param.h>

#include <bsm/libbsm.h>

#include "devfsadm_impl.h"

/* externs from devalloc.c */

extern void  _reset_devalloc(int);

extern void _update_devalloc_db(devlist_t *, int, int, char *, char *);

extern int _da_check_for_usb(char *, char *);

/* create or remove nodes or links. unset with -n */

static int file_mods = TRUE;

/* cleanup mode.  Set with -C */

static int cleanup = FALSE;

/* devlinks -d compatibility */

static int devlinks_debug = FALSE;

/* flag to check if system is labeled */

int system_labeled = FALSE;

/* flag to enable/disable device allocation with -e/-d */

static int devalloc_flag = 0;

/* flag that indicates if device allocation is on or not */

static int devalloc_is_on = 0;

/* flag to update device allocation database for this device type */

static int update_devdb = 0;

/*

 * devices to be deallocated with -d :

 *	audio, floppy, cd, floppy, tape, rmdisk.

 */

static char *devalloc_list[10] = {DDI_NT_AUDIO, DDI_NT_CD, DDI_NT_CD_CHAN,

				    DDI_NT_FD, DDI_NT_TAPE, DDI_NT_BLOCK_CHAN,

				    DDI_NT_UGEN, DDI_NT_USB_ATTACHMENT_POINT,

				    DDI_NT_SCSI_NEXUS, NULL};

/* list of allocatable devices */

static devlist_t devlist;

/* load a single driver only.  set with -i */

static int single_drv = FALSE;

static char *driver = NULL;

/* attempt to load drivers or defer attach nodes */

static int load_attach_drv = TRUE;

/* set if invoked via /usr/lib/devfsadm/devfsadmd */

static int daemon_mode = FALSE;

/* output directed to syslog during daemon mode if set */

static int logflag = FALSE;

/* build links in /dev.  -x to turn off */

static int build_dev = TRUE;

/* build nodes in /devices.  -y to turn off */

static int build_devices = TRUE;

/* -z to turn off */

static int flush_path_to_inst_enable = TRUE;

/* variables used for path_to_inst flushing */

static int inst_count = 0;

static mutex_t count_lock;

static cond_t cv;

/* variables for minor_fini thread */

static mutex_t minor_fini_mutex;

static int minor_fini_canceled = TRUE;

static int minor_fini_delayed = FALSE;

static cond_t minor_fini_cv;

static int minor_fini_timeout = MINOR_FINI_TIMEOUT_DEFAULT;

/* single-threads /dev modification */

static sema_t dev_sema;

/* the program we were invoked as; ie argv[0] */

static char *prog;

/* pointers to create/remove link lists */

static create_list_t *create_head = NULL;

static remove_list_t *remove_head = NULL;

/*  supports the class -c option */

static char **classes = NULL;

static int num_classes = 0;

/* used with verbose option -v or -V */

static int num_verbose = 0;

static char **verbose = NULL;

static struct mperm *minor_perms = NULL;

static driver_alias_t *driver_aliases = NULL;

/* set if -r alternate root given */

static char *root_dir = "";

/* /devices or <rootdir>/devices */

static char *devices_dir  = DEVICES;

/* /dev or <rootdir>/dev */

static char *dev_dir = DEV;

/* /etc/dev or <rootdir>/etc/dev */

static char *etc_dev_dir = ETCDEV;

/*

 * writable root (for lock files and doors during install).

 * This is also root dir for /dev attr dir during install.

 */

static char *attr_root = NULL;

/* /etc/path_to_inst unless -p used */

static char *inst_file = INSTANCE_FILE;

/* /usr/lib/devfsadm/linkmods unless -l used */

static char *module_dirs = MODULE_DIRS;

/* default uid/gid used if /etc/minor_perm entry not found */

static uid_t root_uid;

static gid_t sys_gid;

/* /etc/devlink.tab unless devlinks -t used */

static char *devlinktab_file = NULL;

/* File and data structure to reserve enumerate IDs */

static char *enumerate_file = ENUMERATE_RESERVED;

static enumerate_file_t *enumerate_reserved = NULL;

/* set if /dev link is new. speeds up rm_stale_links */

static int linknew = TRUE;

/* variables for devlink.tab compat processing */

static devlinktab_list_t *devlinktab_list = NULL;

static unsigned int devlinktab_line = 0;

/* cache head for devfsadm_enumerate*() functions */

static numeral_set_t *head_numeral_set = NULL;

/* list list of devfsadm modules */

static module_t *module_head = NULL;

/* name_to_major list used in utility function */

static n2m_t *n2m_list = NULL;

/* cache of some links used for performance */

static linkhead_t *headlinkhead = NULL;

/* locking variables to prevent multiples writes to /dev */

static int hold_dev_lock = FALSE;

static int hold_daemon_lock = FALSE;

static int dev_lock_fd;

static int daemon_lock_fd;

static char dev_lockfile[PATH_MAX + 1];

static char daemon_lockfile[PATH_MAX + 1];

/* last devinfo node/minor processed. used for performance */

static di_node_t lnode;

static di_minor_t lminor;

static char lphy_path[PATH_MAX + 1] = {""};

/* Globals used by the link database */

static di_devlink_handle_t devlink_cache;

static int update_database = FALSE;

/* Globals used to set logindev perms */

static struct login_dev *login_dev_cache = NULL;

static int login_dev_enable = FALSE;

/* Global to use devinfo snapshot cache */

static int use_snapshot_cache = FALSE;

/* Global for no-further-processing hash */

static item_t **nfp_hash;

static mutex_t  nfp_mutex = DEFAULTMUTEX;

/*

 * Packaged directories - not removed even when empty.

 * The dirs must be listed in canonical form

 * i.e. without leading "/dev/"

 */

static char *packaged_dirs[] =

	{"dsk", "rdsk", "term", NULL};

/* RCM related globals */

static void *librcm_hdl;

static rcm_handle_t *rcm_hdl = NULL;

static thread_t process_rcm_events_tid;

static struct rcm_eventq *volatile rcm_eventq_head = NULL;

static struct rcm_eventq *rcm_eventq_tail = NULL;

static mutex_t rcm_eventq_lock;

static cond_t rcm_eventq_cv;

static volatile int need_to_exit_rcm_event_thread = 0;

/* Devname globals */

static int devname_debug_msg = 1;

static nvlist_t *devname_maps = NULL;

static int devname_first_call = 1;

static int load_devname_nsmaps = FALSE;

static int lookup_door_fd = -1;

static char *lookup_door_path;

static void load_dev_acl(void);

static void update_drvconf(major_t);

static void check_reconfig_state(void);

static void devname_setup_nsmaps(void);

static int s_stat(const char *, struct stat *);

static int is_blank(char *);

/* sysevent queue related globals */

static mutex_t  syseventq_mutex = DEFAULTMUTEX;

static syseventq_t *syseventq_front;

static syseventq_t *syseventq_back;

static void process_syseventq();

int

main(int argc, char *argv[])

{

	struct passwd *pw;

	struct group *gp;

	pid_t pid;

	int cond = 0;

	(void) setlocale(LC_ALL, "");

	(void) textdomain(TEXT_DOMAIN);

	if ((prog = strrchr(argv[0], '/')) == NULL) {

		prog = argv[0];

	} else {

		prog++;

	}

	if (getuid() != 0) {

		err_print(MUST_BE_ROOT);

		devfsadm_exit(1);

	}

	/*

	 * Close all files except stdin/stdout/stderr

	 */

	closefrom(3);

	if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) {

		root_uid = pw->pw_uid;

	} else {

		err_print(CANT_FIND_USER, DEFAULT_DEV_USER);

		root_uid = (uid_t)0;	/* assume 0 is root */

	}

	/* the default group is sys */

	if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) {

		sys_gid = gp->gr_gid;

	} else {

		err_print(CANT_FIND_GROUP, DEFAULT_DEV_GROUP);

		sys_gid = (gid_t)3;	/* assume 3 is sys */

	}

	(void) umask(0);

	system_labeled = is_system_labeled();

	if (system_labeled == FALSE) {

		/*

		 * is_system_labeled() will return false in case we are

		 * starting before the first reboot after Trusted Extensions

		 * is enabled.  Check the setting in /etc/system to see if

		 * TX is enabled (even if not yet booted).

		 */

		if (defopen("/etc/system") == 0) {

			if (defread("set sys_labeling=1") != NULL)

				system_labeled = TRUE;

			/* close defaults file */

			(void) defopen(NULL);

		}

	}

	/*

	 * Check if device allocation is enabled.

	 */

	if (system_labeled) {

		/*

		 * In TX, the first line in /etc/security/device_allocate has

		 * DEVICE_ALLOCATION=ON if the feature is enabled.

		 */

		devalloc_is_on = da_is_on();

	} else if (auditon(A_GETCOND, (caddr_t)&cond, sizeof (cond)) == 0) {

		/*

		 * Device allocation (and auditing) is enabled if BSM is

		 * enabled. auditon returns -1 and sets errno to EINVAL if BSM

		 * is not enabled.

		 */

		devalloc_is_on = 1;

	}

#ifdef DEBUG

	if (system_labeled == FALSE) {

		struct stat tx_stat;

		/* test hook: see also mkdevalloc.c and allocate.c */

		system_labeled = is_system_labeled_debug(&tx_stat);

	}

#endif

	parse_args(argc, argv);

	(void) sema_init(&dev_sema, 1, USYNC_THREAD, NULL);

	/* Initialize device allocation list */

	devlist.audio = devlist.cd = devlist.floppy = devlist.tape =

	devlist.rmdisk = NULL;

	if (daemon_mode == TRUE) {

		/*

		 * Build /dev and /devices before daemonizing if

		 * reconfig booting and daemon invoked with alternate

		 * root. This is to support install.

		 */

		if (getenv(RECONFIG_BOOT) != NULL && root_dir[0] != '\0') {

			vprint(INFO_MID, CONFIGURING);

			load_dev_acl();

			update_drvconf((major_t)-1);

			process_devinfo_tree();

			(void) modctl(MODSETMINIROOT);

		}

		/*

		 * fork before detaching from tty in order to print error

		 * message if unable to acquire file lock.  locks not preserved

		 * across forks.  Even under debug we want to fork so that

		 * when executed at boot we don't hang.

		 */

		if (fork() != 0) {

			devfsadm_exit(0);

		}

		/* set directory to / so it coredumps there */

		if (chdir("/") == -1) {

			err_print(CHROOT_FAILED, strerror(errno));

		}

		/* only one daemon can run at a time */

		if ((pid = enter_daemon_lock()) == getpid()) {

			detachfromtty();

			(void) cond_init(&cv, USYNC_THREAD, 0);

			(void) mutex_init(&count_lock, USYNC_THREAD, 0);

			if (thr_create(NULL, NULL,

			    (void *(*)(void *))instance_flush_thread,

			    NULL, THR_DETACHED, NULL) != 0) {

				err_print(CANT_CREATE_THREAD, "daemon",

					strerror(errno));

				devfsadm_exit(1);

			}

			/* start the minor_fini_thread */

			(void) mutex_init(&minor_fini_mutex, USYNC_THREAD, 0);

			(void) cond_init(&minor_fini_cv, USYNC_THREAD, 0);

			if (thr_create(NULL, NULL,

			    (void *(*)(void *))minor_fini_thread,

			    NULL, THR_DETACHED, NULL)) {

				err_print(CANT_CREATE_THREAD, "minor_fini",

				    strerror(errno));

				devfsadm_exit(1);

			}

			/*

			 * No need for rcm notifications when running

			 * with an alternate root. So initialize rcm only

			 * when devfsadm is running with root dir "/".

			 * Similarly, logindevperms need only be set

			 * in daemon mode and when root dir is "/".

			 */

			if (root_dir[0] == '\0') {

				(void) rcm_init();

				login_dev_enable = TRUE;

			}

			daemon_update();

		} else {

			err_print(DAEMON_RUNNING, pid);

			devfsadm_exit(1);

		}

		exit_daemon_lock();

	} else {

		/* not a daemon, so just build /dev and /devices */

		process_devinfo_tree();

		if (devalloc_flag != 0)

			/* Enable/disable device allocation */

			_reset_devalloc(devalloc_flag);

	}

	return (0);

}

static void

update_drvconf(major_t major)

{

	if (modctl(MODLOADDRVCONF, major) != 0)

		err_print(gettext("update_drvconf failed for major %d\n"),

		    major);

}

static void

load_dev_acl()

{

	if (load_devpolicy() != 0)

		err_print(gettext("device policy load failed\n"));

	load_minor_perm_file();

}

/*

 * As devfsadm is run early in boot to provide the kernel with

 * minor_perm info, we might as well check for reconfig at the

 * same time to avoid running devfsadm twice.  This gets invoked

 * earlier than the env variable RECONFIG_BOOT is set up.

 */

static void

check_reconfig_state()

{

	struct stat sb;

	if (s_stat("/reconfigure", &sb) == 0) {

		(void) modctl(MODDEVNAME, MODDEVNAME_RECONFIG, 0);

	}

}

static void

modctl_sysavail()

{

	/*

	 * Inform /dev that system is available, that

	 * implicit reconfig can now be performed.

	 */

	(void) modctl(MODDEVNAME, MODDEVNAME_SYSAVAIL, 0);

}

static void

set_lock_root(void)

{

	struct stat sb;

	char *lock_root;

	size_t len;

	lock_root = attr_root ? attr_root : root_dir;

	len = strlen(lock_root) + strlen(ETCDEV) + 1;

	etc_dev_dir = s_malloc(len);

	(void) snprintf(etc_dev_dir, len, "%s%s", lock_root, ETCDEV);

	if (s_stat(etc_dev_dir, &sb) != 0) {

		s_mkdirp(etc_dev_dir, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);

	} else if (!S_ISDIR(sb.st_mode)) {

		err_print(NOT_DIR, etc_dev_dir);

		devfsadm_exit(1);

	}

}

/*

 * Parse arguments for all 6 programs handled from devfsadm.

 */

static void

parse_args(int argc, char *argv[])

{