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

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

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

#include <stdio.h>
#include <ctype.h>
#include <setjmp.h>
#include <utmpx.h>
#include <pwd.h>
#include <time.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/errno.h>
#include <rpc/rpc.h>
#include <rpc/pmap_clnt.h>
#include <rpcsvc/mount.h>
#include <rpcsvc/rwall.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <locale.h>
#include <sys/syslog.h>
#include <zone.h>
#include <signal.h>

/*
 *	/usr/etc/shutdown when [messages]
 *
 *	allow super users to tell users and remind users
 *	of iminent shutdown of unix
 *	and shut it down automatically
 *	and even reboot or halt the machine if they desire
 */

#define	EPATH	"PATH=/usr/ucb:/usr/bin:/usr/sbin:"
#define	REBOOT	"/usr/sbin/reboot"
#define	HALT	"/usr/sbin/halt"
#define	MAXINTS 20
#define	HOURS	*3600
#define	MINUTES	*60
#define	SECONDS
#define	NLOG		600		/* no of bytes possible for message */
#define	NOLOGTIME	5 MINUTES
#define	IGNOREUSER	"sleeper"

struct hostlist {
    char *host;
    struct hostlist *nxt;
} *hostlist;

char	hostname[MAXHOSTNAMELEN];
char	mbuf[BUFSIZ];

extern	char *malloc();

extern	char *ctime();
extern	struct tm *localtime();

extern	char *strcpy();
extern	char *strncat();
extern	off_t lseek();

struct	utmpx *utmpx;

int	sint;
int	stogo;
char	tpath[] =	"/dev/";
int	nlflag = 1;		/* nolog yet to be done */
int	killflg = 1;
int	doreboot = 0;
int	halt = 0;
int	fast = 0;
char	*nosync = NULL;
char	nosyncflag[] = "-n";
char	term[sizeof tpath + sizeof (utmpx->ut_line)];
char	tbuf[BUFSIZ];
char    nolog1[] = "\n\nNO LOGINS: System going down at %5.5s\n\n";
char	mesg[NLOG+1];
#ifdef	DEBUG
char	fastboot[] = "fastboot";
#else
char	fastboot[] = "/fastboot";
#endif
char    nologin[] = "/etc/nologin";
time_t	nowtime;
jmp_buf	alarmbuf;

struct interval {
	int stogo;
	int sint;
} interval[] = {
	4 HOURS,	1 HOURS,
	2 HOURS,	30 MINUTES,
	1 HOURS,	15 MINUTES,
	30 MINUTES,	10 MINUTES,
	15 MINUTES,	5 MINUTES,
	10 MINUTES,	5 MINUTES,
	5 MINUTES,	3 MINUTES,
	2 MINUTES,	1 MINUTES,
	1 MINUTES,	30 SECONDS,
	0 SECONDS,	0 SECONDS
};

char	*msg1 = "shutdown: '%c' - unknown flag\n";
char	*msg2 = "Usage: shutdown [ -krhfn ] shutdowntime [ message ]\n";
char	*msg3 = "Usage: shutdown [ -krhfn ] shutdowntime [ message ]";
char	*msg4 = "Usage: shutdown [ -krhfn ] shutdowntime [ message ]\n";
char	*msg5 = "Usage: shutdown [ -krhfn ] shutdowntime [ message ]";
char	*msg6 = "\n\007\007System shutdown time has arrived\007\007\n";
char	*msg7 = "but you'll have to do it yourself\n";
char	*msg8 = "but you'll have to do it yourself";
char	*msg9 = "-l (without fsck's)\n";
char	*msg10 = "-l %s\n";
char	*msg11 = " (without fsck's)\n";
char	*msg12 = "That must be tomorrow\nCan't you wait till then?\n";
char	*msg13 = "That must be tomorrow";
char	*msg14 = "Can't you wait till then?";
char	*msg15 = "\007\007\t*** %sSystem shutdown message from %s@%s ***\r\n\n";
char	*msg16 = "System going down at %5.5s\r\n";
char	*msg17 = "System going down in %d minute%s\r\n";
char	*msg18 = "System going down in %d second%s\r\n";
char	*msg19 = "System going down IMMEDIATELY\r\n";
char	*msg20 = "Can't get PID for init\n";

char *shutter, *getlogin();

static void timeout(void);
static void gethostlist(void);
static void finish(char *, char *, int);
static void nolog(time_t);
static void rprintf(char *, char *);
static void rwarn(char *, time_t, time_t, char *, int);
static void doitfast(void);
static void warn(FILE *, time_t, time_t, char *, int);
static time_t getsdt(char *);

pid_t
get_initpid(void)
{
	pid_t init_pid;

	if (zone_getattr(getzoneid(), ZONE_ATTR_INITPID, &init_pid,
	    sizeof (init_pid)) != sizeof (init_pid)) {
		(void) fprintf(stderr, gettext(msg20));
		exit(1);
	}
	return (init_pid);
}

int
main(int argc, char **argv)
{
	int i;
	char *f;
	char *ts;
	time_t sdt;
	int h, m;
	int first;
	void finish_sig();
	FILE *termf;
	struct passwd *pw, *getpwuid();
	extern char *strcat();
	extern uid_t geteuid();
	struct hostlist *hl;
	char *shutdown_program;
	char *shutdown_action;
	int fd;

	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	audit_shutdown_setup(argc, argv);

	shutter = getlogin();
	if (shutter == 0 && (pw = getpwuid(getuid())))
		shutter = pw->pw_name;
	if (shutter == 0)
		shutter = "???";
	(void) gethostname(hostname, sizeof (hostname));
	openlog("shutdown", 0, LOG_AUTH);
	argc--, argv++;
	while (argc > 0 && (f = argv[0], *f++ == '-')) {
		while (i = *f++) {
			switch (i) {
				case 'k':
					killflg = 0;
					continue;
				case 'n':
					nosync = nosyncflag;
					continue;
				case 'f':
					fast = 1;
					continue;
				case 'r':
					doreboot = 1;
					continue;
				case 'h':
					halt = 1;
					continue;
				default:
					(void) fprintf(stderr, gettext(msg1),
									i);
					(void) fprintf(stderr, gettext(msg2));
					finish(gettext(msg3), "", 1);
			}
		}
		argc--, argv++;
	}
	if (argc < 1) {
		(void) fprintf(stderr, gettext(msg4));
		finish(gettext(msg5), "", 1);
	}
	if (doreboot && halt) {
		(void) fprintf(stderr,
		    gettext("shutdown: Incompatible switches '-r' & '-h'\n"));
		finish(gettext("shutdown: Incompatible switches '-r' & '-h'"),
		    "", 1);
	}
	if (fast && (nosync == nosyncflag)) {
		(void) fprintf(stderr,
		    gettext("shutdown: Incompatible switches '-f' & '-n'\n"));
		finish(gettext("shutdown: Incompatible switches '-f' & '-n'"),
		    "", 1);
	}
	if (geteuid()) {
		(void) fprintf(stderr, gettext("shutdown: NOT super-user\n"));
		finish(gettext("shutdown: NOT super-user"), "", 1);
	}
	gethostlist();
	nowtime = time((time_t *)NULL);
	sdt = getsdt(argv[0]);
	argc--, argv++;
	mesg[0] = '\0';
	i = 0;
	while (argc-- > 0) {
		if (i + strlen(*argv) > NLOG)
			break;	/* no more room for the message */
		i += strlen(*argv) + 1;
		(void) strcat(mesg, *argv++);
		(void) strcat(mesg, " ");
	}
	if (i != 0)
		mesg[i - 1] = '\0';	/* remove trailing blank */
	m = ((stogo = sdt - nowtime) + 30)/60;
	h = m/60;
	m %= 60;
	ts = ctime(&sdt);
	(void) printf(gettext("Shutdown at %5.5s (in "), ts+11);
	if (h > 0)
		(void) printf("%d hour%s ", h, h != 1 ? "s" : "");
	(void) printf("%d minute%s) ", m, m != 1 ? "s" : "");
#ifndef DEBUG
	(void) signal(SIGHUP, SIG_IGN);
	(void) signal(SIGQUIT, SIG_IGN);
	(void) signal(SIGINT, SIG_IGN);
#endif
	(void) signal(SIGTTOU, SIG_IGN);
	(void) signal(SIGINT, finish_sig);
	(void) signal(SIGALRM, (void(*)())timeout);
	(void) setpriority(PRIO_PROCESS, 0, PRIO_MIN);
	(void) fflush(stdout);
#ifndef DEBUG
	if (i = fork()) {
		(void) printf(gettext("[pid %d]\n"), i);
		exit(0);
	}
#else
	(void) putc('\n', stdout);
#endif
	sint = 1 HOURS;
	f = "";
	first = 1;
	if (doreboot) {
		shutdown_program = REBOOT;
		shutdown_action = "reboot";
	} else if (halt) {
		shutdown_program = HALT;
		shutdown_action = "halt";
	} else {
		shutdown_program = NULL;
		shutdown_action = "shutdown";
	}
	for (;;) {
		for (i = 0; stogo <= interval[i].stogo && interval[i].sint; i++)
			sint = interval[i].sint;
		if (stogo > 0 && (stogo-sint) < interval[i].stogo)
			sint = stogo - interval[i].stogo;
		if (stogo <= NOLOGTIME && nlflag) {
			nlflag = 0;
			nolog(sdt);
		}
		if (sint >= stogo || sint == 0)
			f = "FINAL ";
		nowtime = time((time_t *)NULL);

		setutxent();

		while ((utmpx = getutxent()) != NULL) {
		    if (utmpx->ut_name[0] &&
			strncmp(utmpx->ut_name, IGNOREUSER,
			    sizeof (utmpx->ut_name))) {
			/*
			 * don't write to pty's unless they're rlogin sessions
			 */
			if (utmpx->ut_type != USER_PROCESS &&
			    utmpx->ut_user[0] != '\0')
				continue;

			if (setjmp(alarmbuf))
				continue;
			(void) strcpy(term, tpath);
			(void) strncat(term, utmpx->ut_line,
			    sizeof (utmpx->ut_line));
			(void) alarm(5);

			/* check if device is really a tty */
			if ((fd = open(term, O_WRONLY|O_NOCTTY)) == -1) {
				fprintf(stderr, gettext("Cannot open %s.\n"),
				    term);
				(void) alarm(0);
				continue;
			} else {
			    if (!isatty(fd)) {
				fprintf(stderr,
				    gettext("%.*s in utmpx is not a tty\n"),
				    sizeof (utmpx->ut_line), utmpx->ut_line);
				syslog(LOG_CRIT, "%.*s in utmpx is not "
				    "a tty\n", sizeof (utmpx->ut_line),
				    utmpx->ut_line);
				close(fd);
				(void) alarm(0);
				continue;
			    }
			}
			close(fd);
#ifdef DEBUG
			if ((termf = stdout) != NULL)
#else
			if ((termf = fopen(term, "w")) != NULL)
#endif
			{
				(void) alarm(0);
				setbuf(termf, tbuf);
				(void) fprintf(termf, "\n\r\n");
				warn(termf, sdt, nowtime, f, first);
				(void) alarm(5);
#ifdef DEBUG
				(void) fflush(termf);
#else
				(void) fclose(termf);
#endif
				(void) alarm(0);
			}
		    }
		}  /* while */

		endutxent();

		for (hl = hostlist; hl != NULL; hl = hl->nxt)
			rwarn(hl->host, sdt, nowtime, f, first);
		if (stogo <= 0) {
			(void) printf(gettext(msg6));
			if (*mesg)
				syslog(LOG_CRIT, "%s by %s: %s",
				    shutdown_action, shutter, mesg);
			else
				syslog(LOG_CRIT, "%s by %s",
				    shutdown_action, shutter);
			sleep(2);
			(void) unlink(nologin);
			if (!killflg) {
				(void) printf(gettext(msg7));
				finish(gettext(msg8), "", 0);
			}
			if (fast)
				doitfast();
#ifndef DEBUG
			(void) putenv(EPATH);
			if (shutdown_program != NULL) {
				audit_shutdown_success();
				execlp(shutdown_program, shutdown_program,
				    "-l", nosync, (char *)0);
			} else {
				if (geteuid() == 0) {
					audit_shutdown_success();
					sleep(5);
				}
				if (getzoneid() == GLOBAL_ZONEID) {
					(void) system(
					    "/sbin/bootadm -a update_all");
				}

				(void) kill(get_initpid(), SIGINT); /* sync */
				(void) kill(get_initpid(), SIGINT); /* sync */
				sleep(20);
			}
#else
			if (shutdown_program) {
				(void) printf("%s ", shutdown_program);
				if (fast)
					(void) printf(gettext(msg9));
				else if (nosync != NULL)
					(void) printf(gettext(msg10), nosync);
				else
					(void) printf(gettext("-l\n"));
			} else {
				(void) printf("/sbin/bootadm -a update_all");
				(void) printf("kill -INT 1");
				if (fast)
					(void) printf(gettext(msg11));
				else
					(void) printf("\n");
			}
#endif
			finish("", "", 0);
		}
		stogo = sdt - time((time_t *)NULL);
		if (stogo > 0 && sint > 0)
			sleep((unsigned)(sint < stogo ? sint : stogo));
		stogo -= sint;
		first = 0;
	}
	/* NOTREACHED */
}

static time_t
getsdt(char *s)
{
	time_t t, t1, tim;
	char c;
	struct tm *lt;
	int c_count;

	if (strcmp(s, "now") == 0)
		return (nowtime);
	if (*s == '+') {
		++s;
		t = 0;
		for (c_count = 1; ; c_count++) {
			c = *s++;
			if (!isdigit(c)) {
					if (c_count == 1) {
							goto badform;
					} else {
							break;
					}
			}
			t = t * 10 + c - '0';
		}
		if (t <= 0)
			t = 5;
		t *= 60;
		tim = time((time_t *)NULL) + t;
		return (tim);
	}
	t = 0;
	while (strlen(s) > 2 && isdigit(*s))
		t = t * 10 + *s++ - '0';
	if (*s == ':')
		s++;
	if (t > 23)
		goto badform;
	tim = t*60;
	t = 0;
	while (isdigit(*s))
		t = t * 10 + *s++ - '0';
	if (t > 59)
		goto badform;
	tim += t;
	tim *= 60;
	t1 = time((time_t *)NULL);
	lt = localtime(&t1);
	t = lt->tm_sec + lt->tm_min*60 + lt->tm_hour*3600;
	if (tim < t || tim >= (24*3600)) {
		/* before now or after midnight */
		(void) printf(gettext(msg12));
		finish(gettext(msg13), gettext(msg14), 0);
	}
	return (t1 + tim - t);
badform:
	(void) printf(gettext("Bad time format\n"));
	finish(gettext("Bad time format"), "", 0);
	return (0);
	/* NOTREACHED */
}

static void
warn(FILE *termf, time_t sdt, time_t now, char *type, int first)
{
	char *ts;
	time_t delay = sdt - now;

	if (delay > 8)
		while (delay % 5)
			delay++;

	(void) fprintf(termf, gettext(msg15), type, shutter, hostname);

	ts = ctime(&sdt);
	if (delay > 10 MINUTES)
		(void) fprintf(termf, gettext(msg16), ts+11);
	else if (delay > 95 SECONDS) {
		(void) fprintf(termf, gettext(msg17), (delay+30)/60,
						(delay+30)/60 != 1 ? "s" : "");
	} else if (delay > 0) {
		(void) fprintf(termf, gettext(msg18), delay,
							delay != 1 ? "s" : "");
	} else
		(void) fprintf(termf, gettext(msg19));

	if (first || sdt - now > 1 MINUTES) {
		if (*mesg)
			(void) fprintf(termf, "\t...%s\r\n", mesg);
	}
}

static void
doitfast(void)
{
	FILE *fastd;

	if ((fastd = fopen(fastboot, "w")) != NULL) {
		(void) putc('\n', fastd);
		(void) fclose(fastd);
	}
}

static void
rwarn(char *host, time_t sdt, time_t now, char *type, int first)
{
	char *ts;
	time_t delay = sdt - now;
	char *bufp;

	if (delay > 8)
		while (delay % 5)
			delay++;

	(void) sprintf(mbuf,
	    "\007\007\t*** %sShutdown message for %s from %s@%s ***\r\n\n",
		type, hostname, shutter, hostname);
	ts = ctime(&sdt);
	bufp = mbuf + strlen(mbuf);
	if (delay > 10 MINUTES) {
		(void) sprintf(bufp, "%s going down at %5.5s\r\n", hostname,
		    ts+11);
	} else if (delay > 95 SECONDS) {
		(void) sprintf(bufp, "%s going down in %d minute%s\r\n",
		    hostname, (delay+30)/60, (delay+30)/60 != 1 ? "s" : "");
	} else if (delay > 0) {
		(void) sprintf(bufp, "%s going down in %d second%s\r\n",
		    hostname, delay, delay != 1 ? "s" : "");
	} else {
		(void) sprintf(bufp, "%s going down IMMEDIATELY\r\n",
		    hostname);
	}
	bufp = mbuf + strlen(mbuf);
	if (first || sdt - now > 1 MINUTES) {
		if (*mesg)
			(void) sprintf(bufp, "\t...%s\r\n", mesg);
	}
	rprintf(host, mbuf);
}

static void
rprintf(char *host, char *bufp)
{
	int err;

#ifdef DEBUG
	(void) fprintf(stderr, gettext("about to call %s\n"), host);
#endif
	if (err = callrpcfast(host, (rpcprog_t)WALLPROG, (rpcvers_t)WALLVERS,
	    (rpcproc_t)WALLPROC_WALL, xdr_dirpath, (char *)&bufp, xdr_void,
	    (char *)NULL)) {
#ifdef DEBUG
		(void) fprintf(stderr, gettext("couldn't make rpc call: "));
		clnt_perrno(err);
		(void) fprintf(stderr, "\n");
#endif
	    }
}

static void
nolog(time_t sdt)
{
	FILE *nologf;

	(void) unlink(nologin);			/* in case linked to std file */
	if ((nologf = fopen(nologin, "w")) != NULL) {
		(void) fprintf(nologf, nolog1, (ctime(&sdt)) + 11);
		if (*mesg)
			(void) fprintf(nologf, "\t%s\n", mesg);
		(void) fclose(nologf);
	}
}

void
finish_sig(void)
{
	finish("SIGINT", "", 1);
}

static void
finish(char *s1, char *s2, int exitcode)
{
	(void) signal(SIGINT, SIG_IGN);
	exit(exitcode);
}

static void
timeout(void)
{
	(void) signal(SIGALRM, (void(*)())timeout);
	longjmp(alarmbuf, 1);
}

static void
gethostlist(void)
{
	int s;
	struct mountbody *ml;
	struct hostlist *hl;
	struct sockaddr_in addr;
	CLIENT *cl;
	static struct timeval TIMEOUT = { 25, 0 };

	/*
	 * check for portmapper
	 */
	get_myaddress(&addr);
	s = socket(AF_INET, SOCK_STREAM, 0);
	if (s < 0)
		return;
	if (connect(s, (struct sockaddr *)&addr, sizeof (addr)) < 0)
		return;
	(void) close(s);

	/*
	 * First try tcp, then drop back to udp if
	 * tcp is unavailable (an old version of mountd perhaps)
	 * Using tcp is preferred because it can handle
	 * arbitrarily long export lists.
	 */
	cl = clnt_create(hostname, (ulong_t)MOUNTPROG, (ulong_t)MOUNTVERS,
	    "tcp");
	if (cl == NULL) {
		cl = clnt_create(hostname, (ulong_t)MOUNTPROG,
		    (ulong_t)MOUNTVERS, "udp");
		if (cl == NULL) {
			if (rpc_createerr.cf_stat != RPC_PROGNOTREGISTERED) {
				clnt_pcreateerror("shutdown warning");
			}
			return;
		}
	}

	ml = NULL;
	if (clnt_call(cl, MOUNTPROC_DUMP,
	    xdr_void, 0, xdr_mountlist, (char *)&ml, TIMEOUT) != RPC_SUCCESS) {
		clnt_perror(cl, "shutdown warning");
		return;
	}
	for (; ml != NULL; ml = ml->ml_next) {
		for (hl = hostlist; hl != NULL; hl = hl->nxt)
			if (strcmp(ml->ml_hostname, hl->host) == 0)
				goto again;
		hl = (struct hostlist *)malloc(sizeof (struct hostlist));
		hl->host = ml->ml_hostname;
		hl->nxt = hostlist;
		hostlist = hl;
	    again:;
	}
}

/*
 * Don't want to wait for usual portmapper timeout you get with
 * callrpc or clnt_call, so use rmtcall instead.  Use timeout
 * of 8 secs, based on the per try timeout of 3 secs for rmtcall
 */
int
callrpcfast(char *host, rpcprog_t prognum, rpcprog_t versnum,
    rpcprog_t procnum, xdrproc_t inproc, xdrproc_t outproc,
    char *in, char *out)
{
	struct sockaddr_in server_addr;
	struct hostent *hp;
	struct timeval rpctimeout;
	rpcport_t port;

	if ((hp = gethostbyname(host)) == NULL)
		return ((int)RPC_UNKNOWNHOST);
	bcopy(hp->h_addr, (char *)&server_addr.sin_addr, hp->h_length);
	server_addr.sin_family = AF_INET;
	server_addr.sin_port =  0;
	rpctimeout.tv_sec = 8;
	rpctimeout.tv_usec = 0;
	return ((int)pmap_rmtcall(&server_addr, prognum, versnum, procnum,
	    inproc, in, outproc, out, rpctimeout, &port));
}