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

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdarg.h>
#include <strings.h>
#include <syslog.h>
#include <priv.h>
#include <wait.h>
#include <getopt.h>
#include <synch.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <libhotplug.h>
#include <libhotplug_impl.h>
#include "hotplugd_impl.h"

/*
 * Define long options for command line.
 */
static const struct option lopts[] = {
	{ "help",	no_argument,	0, '?' },
	{ "version",	no_argument,	0, 'V' },
	{ "debug",	no_argument,	0, 'd' },
	{ 0, 0, 0, 0 }
};

/*
 * Local functions.
 */
static void		usage(void);
static boolean_t	check_privileges(void);
static int		daemonize(void);
static void		init_signals(void);
static void		signal_handler(int signum);
static void		shutdown_daemon(void);

/*
 * Global variables.
 */
static char		*prog;
static char		version[] = "1.0";
static boolean_t	log_flag = B_FALSE;
static boolean_t	debug_flag = B_FALSE;
static boolean_t	exit_flag = B_FALSE;
static sema_t		signal_sem;

/*
 * main()
 *
 *	The hotplug daemon is designed to be a background daemon
 *	controlled by SMF.  So by default it will daemonize and
 *	do some coordination with its parent process in order to
 *	indicate proper success or failure back to SMF.  And all
 *	output will be sent to syslog.
 *
 *	But if given the '-d' command line option, it will instead
 *	run in the foreground in a standalone, debug mode.  Errors
 *	and additional debug messages will be printed to the controlling
 *	terminal instead of to syslog.
 */
int
main(int argc, char *argv[])
{
	int	opt;
	int	pfd;
	int	status;

	if ((prog = strrchr(argv[0], '/')) == NULL)
		prog = argv[0];
	else
		prog++;

	/* Check privileges */
	if (!check_privileges()) {
		(void) fprintf(stderr, "Insufficient privileges.  "
		    "(All privileges are required.)\n");
		return (-1);
	}

	/* Process options  */
	while ((opt = getopt_clip(argc, argv, "dV?", lopts, NULL)) != -1) {
		switch (opt) {
		case 'd':
			debug_flag = B_TRUE;
			break;
		case 'V':
			(void) printf("%s: Version %s\n", prog, version);
			return (0);
		default:
			if (optopt == '?') {
				usage();
				return (0);
			}
			(void) fprintf(stderr, "Unrecognized option '%c'.\n",
			    optopt);
			usage();
			return (-1);
		}
	}

	/* Initialize semaphore for daemon shutdown */
	if (sema_init(&signal_sem, 1, USYNC_THREAD, NULL) != 0)
		exit(EXIT_FAILURE);

	/* Initialize signal handling */
	init_signals();

	/* Daemonize, if not in DEBUG mode */
	if (!debug_flag)
		pfd = daemonize();

	/* Initialize door service */
	if (!door_server_init()) {
		if (!debug_flag) {
			status = EXIT_FAILURE;
			(void) write(pfd, &status, sizeof (status));
			(void) close(pfd);
		}
		exit(EXIT_FAILURE);
	}

	/* Daemon initialized */
	if (!debug_flag) {
		status = 0;
		(void) write(pfd, &status, sizeof (status));
		(void) close(pfd);
	}

	/* Note that daemon is running */
	log_info("hotplug daemon started.\n");

	/* Wait for shutdown signal */
	while (!exit_flag)
		(void) sema_wait(&signal_sem);

	shutdown_daemon();
	return (0);
}

/*
 * usage()
 *
 *	Print a brief usage synopsis for the command line options.
 */
static void
usage(void)
{
	(void) printf("Usage: %s [-d]\n", prog);
}

/*
 * check_privileges()
 *
 *	Check if the current process has enough privileges
 *	to run the daemon.  Note that all privileges are
 *	required in order for RCM interactions to work.
 */
static boolean_t
check_privileges(void)
{
	priv_set_t	*privset;
	boolean_t	rv = B_FALSE;

	if ((privset = priv_allocset()) != NULL) {
		if (getppriv(PRIV_EFFECTIVE, privset) == 0) {
			rv = priv_isfullset(privset);
		}
		priv_freeset(privset);
	}

	return (rv);
}

/*
 * daemonize()
 *
 *	Fork the daemon process into the background, and detach from
 *	the controlling terminal.  Setup a shared pipe that will later
 *	be used to report startup status to the parent process.
 */
static int
daemonize(void)
{
	int		status;
	int		pfds[2];
	pid_t		pid;
	sigset_t	set;
	sigset_t	oset;

	/*
	 * Temporarily block all signals.  They will remain blocked in
	 * the parent, but will be unblocked in the child once it has
	 * notified the parent of its startup status.
	 */
	(void) sigfillset(&set);
	(void) sigdelset(&set, SIGABRT);
	(void) sigprocmask(SIG_BLOCK, &set, &oset);

	/* Create the shared pipe */
	if (pipe(pfds) == -1) {
		log_err("Cannot create pipe (%s)\n", strerror(errno));
		exit(EXIT_FAILURE);
	}

	/* Fork the daemon process */
	if ((pid = fork()) == -1) {
		log_err("Cannot fork daemon process (%s)\n", strerror(errno));
		exit(EXIT_FAILURE);
	}

	/* Parent:  waits for exit status from child. */
	if (pid > 0) {
		(void) close(pfds[1]);
		if (read(pfds[0], &status, sizeof (status)) == sizeof (status))
			_exit(status);
		if ((waitpid(pid, &status, 0) == pid) && WIFEXITED(status))
			_exit(WEXITSTATUS(status));
		log_err("Failed to spawn daemon process.\n");
		_exit(EXIT_FAILURE);
	}

	/* Child continues... */

	(void) setsid();
	(void) chdir("/");
	(void) umask(CMASK);
	(void) sigprocmask(SIG_SETMASK, &oset, NULL);
	(void) close(pfds[0]);

	/* Detach from controlling terminal */
	(void) close(0);
	(void) close(1);
	(void) close(2);
	(void) open("/dev/null", O_RDONLY);
	(void) open("/dev/null", O_WRONLY);
	(void) open("/dev/null", O_WRONLY);

	/* Use syslog for future messages */
	log_flag = B_TRUE;
	openlog(prog, LOG_PID, LOG_DAEMON);

	return (pfds[1]);
}

/*
 * init_signals()
 *
 *	Initialize signal handling.
 */
static void
init_signals(void)
{
	struct sigaction	act;
	sigset_t		set;

	(void) sigfillset(&set);
	(void) sigdelset(&set, SIGABRT);

	(void) sigfillset(&act.sa_mask);
	act.sa_handler = signal_handler;
	act.sa_flags = 0;

	(void) sigaction(SIGTERM, &act, NULL);
	(void) sigaction(SIGHUP, &act, NULL);
	(void) sigaction(SIGINT, &act, NULL);
	(void) sigaction(SIGPIPE, &act, NULL);

	(void) sigdelset(&set, SIGTERM);
	(void) sigdelset(&set, SIGHUP);
	(void) sigdelset(&set, SIGINT);
	(void) sigdelset(&set, SIGPIPE);
}

/*
 * signal_handler()
 *
 *	Most signals cause the hotplug daemon to shut down.
 *	Shutdown is triggered using a semaphore to wake up
 *	the main thread for a clean exit.
 *
 *	Except SIGPIPE is used to coordinate between the parent
 *	and child processes when the daemon first starts.
 */
static void
signal_handler(int signum)
{
	log_info("Received signal %d.\n", signum);

	switch (signum) {
	case 0:
	case SIGPIPE:
		break;
	default:
		exit_flag = B_TRUE;
		(void) sema_post(&signal_sem);
		break;
	}
}

/*
 * shutdown_daemon()
 *
 *	Perform a clean shutdown of the daemon.
 */
static void
shutdown_daemon(void)
{
	log_info("Hotplug daemon shutting down.\n");

	door_server_fini();

	if (log_flag)
		closelog();

	(void) sema_destroy(&signal_sem);
}

/*
 * log_err()
 *
 *	Display an error message.  Use syslog if in daemon
 *	mode, otherwise print to stderr when in debug mode.
 */
/*PRINTFLIKE1*/
void
log_err(char *fmt, ...)
{
	va_list	ap;

	va_start(ap, fmt);
	if (debug_flag || !log_flag)
		(void) vfprintf(stderr, fmt, ap);
	else
		vsyslog(LOG_ERR, fmt, ap);
	va_end(ap);
}

/*
 * log_info()
 *
 *	Display an information message.  Use syslog if in daemon
 *	mode, otherwise print to stdout when in debug mode.
 */
/*PRINTFLIKE1*/
void
log_info(char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	if (debug_flag || !log_flag)
		(void) vfprintf(stdout, fmt, ap);
	else
		vsyslog(LOG_INFO, fmt, ap);
	va_end(ap);
}

/*
 * dprintf()
 *
 *	Print a debug tracing statement.  Only works in debug
 *	mode, and always prints to stdout.
 */
/*PRINTFLIKE1*/
void
dprintf(char *fmt, ...)
{
	va_list	ap;

	if (debug_flag) {
		va_start(ap, fmt);
		(void) vprintf(fmt, ap);
		va_end(ap);
	}
}