xref: /csrg-svn/sbin/shutdown/shutdown.c (revision 35528)

/*
 * Copyright (c) 1988 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1988 Regents of the University of California.\n\
 All rights reserved.\n";
#endif /* not lint */

#ifndef lint
static char sccsid[] = "@(#)shutdown.c	5.8 (Berkeley) 09/18/88";
#endif /* not lint */

#include <sys/param.h>
#include <sys/time.h>
#include <sys/file.h>
#include <sys/resource.h>
#include <sys/syslog.h>
#include <signal.h>
#include <setjmp.h>
#include <tzfile.h>
#include <pwd.h>
#include <stdio.h>
#include <ctype.h>

#define	REBOOT		"/etc/reboot"
#define	HALT		"/etc/halt"

#ifdef DEBUG
#define	NOLOGIN		"./nologin"
#define	FASTBOOT	"./fastboot"
#else
#define	NOLOGIN		"/etc/nologin"
#define	FASTBOOT	"/fastboot"
#endif

#define	H		*60*60
#define	M		*60
#define	S		*1
#define	NOLOG_TIME	5*60
struct interval {
	int timeleft, timetowait;
} tlist[] = {
	10 H,  5 H,	 5 H,  3 H,	 2 H,  1 H,	1 H, 30 M,
	30 M, 10 M,	20 M, 10 M,	10 M,  5 M,	5 M,  3 M,
	 2 M,  1 M,	 1 M, 30 S,	30 S, 30 S,
	 0, 0,
}, *tp = tlist;
#undef H
#undef M
#undef S

static time_t offset, shuttime;
static int dofast, dohalt, doreboot, killflg, mbuflen;
static char *nosync, *whom, mbuf[BUFSIZ];

main(argc, argv)
	int argc;
	char **argv;
{
	extern int optind;
	register char *p;
	int arglen, ch, len;
	struct passwd *pw, *getpwuid();
	char *strcat(), *getlogin();
	uid_t geteuid();

#ifndef DEBUG
	if (geteuid()) {
		fprintf(stderr, "shutdown: NOT super-user\n");
		exit(1);
	}
#endif
	nosync = "";
	while ((ch = getopt(argc, argv, "fhknr")) != EOF)
		switch((char)ch) {
		case 'f':
			dofast = 1;
			break;
		case 'h':
			dohalt = 1;
			break;
		case 'k':
			killflg = 1;
			break;
		case 'n':
			nosync = "-n";
			break;
		case 'r':
			doreboot = 1;
			break;
		case '?':
		default:
			usage();
		}
	argc -= optind;
	argv += optind;

	if (argc < 1)
		usage();

	if (dofast && *nosync) {
		fprintf(stderr,
		    "shutdown: incompatible switches -f and -n.\n");
		usage();
	}
	if (doreboot && dohalt) {
		fprintf(stderr,
		    "shutdown: incompatible switches -h and -r.\n");
		usage();
	}
	getoffset(*argv++);
	if (*argv) {
		do {
			(void)strcat(mbuf, *argv);
			(void)strcat(mbuf, " ");
		} while(*++argv);
		(void)strcat(mbuf, "\n");
	}
	else for (len = sizeof(mbuf), p = mbuf; fgets(p, len, stdin);) {
		arglen = strlen(p);
		if (!(len -= arglen))
			break;
		p += arglen;
	}
	mbuflen = strlen(mbuf);

	if (offset)
		printf("Shutdown at %.24s.", ctime(&shuttime));
	else
		printf("Shutdown NOW!\n");

	if (!(whom = getlogin()))
		whom = (pw = getpwuid(getuid())) ? pw->pw_name : "???";

#ifdef DEBUG
	(void)putc('\n', stdout);
#else
	(void)setpriority(PRIO_PROCESS, 0, PRIO_MIN);
	{
		int forkpid;

		forkpid = fork();
		if (forkpid == -1) {
			perror("shutdown: fork");
			exit(1);
		}
		if (forkpid) {
			printf("shutdown: [pid %d]\n", forkpid);
			exit(0);
		}
	}
#endif
	openlog("shutdown", LOG_CONS, LOG_AUTH);
	loop();
	/*NOTREACHED*/
}

#define	WALL_CMD	"/bin/wall"

loop()
{
	u_int sltime;
	int logged;

	if (offset <= NOLOG_TIME) {
		logged = 1;
		nolog();
	}
	else
		logged = 0;
	tp = tlist;
	if (tp->timeleft < offset)
		(void)sleep((u_int)(offset - tp->timeleft));
	else {
		while (offset < tp->timeleft)
			++tp;
		/*
		 * warn now, if going to sleep more than a fifth of
		 * the next wait time.
		 */
		if (sltime = offset - tp->timeleft) {
			if (sltime > tp->timetowait / 5)
				warn();
			(void)sleep(sltime);
		}
	}
	for (;; ++tp) {
		warn();
		if (!logged && tp->timeleft <= NOLOG_TIME) {
			logged = 1;
			nolog();
		}
		(void)sleep((u_int)tp->timetowait);
		if (!tp->timeleft)
			break;
	}
	die_you_gravy_sucking_pig_dog();
}

static jmp_buf alarmbuf;

warn()
{
	static int first;
	static char hostname[MAXHOSTNAMELEN];
	FILE *pf;
	char *ctime();
	int timeout();

	if (!first++) {
		(void)signal(SIGALRM, timeout);
		(void)gethostname(hostname, sizeof(hostname));
	}

	if (!(pf = popen(WALL_CMD, "w"))) {
		syslog(LOG_ERR, "shutdown: can't find %s: %m", WALL_CMD);
		return;
	}

	fprintf(pf, "*** %sSystem shutdown message ***\n",
	    tp->timeleft ? "": "FINAL ");

	if (tp->timeleft > 10*60)
		fprintf(pf, "System going down at %5.5s\n\n",
		    ctime(&shuttime) + 11);
	else if (tp->timeleft > 59)
		fprintf(pf, "System going down in %d minute%s\n\n",
		    tp->timeleft / 60, (tp->timeleft > 60) ? "s" : "");
	else if (tp->timeleft)
		fprintf(pf, "System going down in 30 seconds\n\n");
	else
		fprintf(pf, "System going down IMMEDIATELY\n\n");

	(void)fwrite(mbuf, sizeof(*mbuf), mbuflen, pf);

	/*
	 * play some games, just in case wall doesn't come back
	 * probably unecessary, given that wall is careful.
	 */
	if (!setjmp(alarmbuf)) {
		(void)alarm((u_int)30);
		(void)pclose(pf);
		(void)alarm((u_int)0);
	}
}

timeout()
{
	longjmp(alarmbuf, 1);
}

die_you_gravy_sucking_pig_dog()
{
	syslog(LOG_NOTICE, "%s by %s: %s",
	    doreboot ? "reboot" : dohalt ? "halt" : "shutdown", whom, mbuf);
	(void)sleep(2);

	printf("\r\nSystem shutdown time has arrived\007\007\r\n");
	if (killflg) {
		printf("\rbut you'll have to do it yourself\r\n");
		finish();
	}
	if (dofast)
		doitfast();
#ifdef DEBUG
	if (doreboot)
		printf("REBOOT");
	if (dohalt)
		printf(" HALT");
	if (dofast)
		printf(" -l %s (without fsck's)\n", nosync);
	else
		printf(" -l %s\n", nosync);
	printf("kill -HUP 1\n");
#else
	if (doreboot) {
		execle(REBOOT, "reboot", "-l", nosync, 0, 0);
		syslog(LOG_ERR, "shutdown: can't exec %s: %m.", REBOOT);
		perror("shutdown");
	}
	else if (dohalt) {
		execle(HALT, "halt", "-l", nosync, 0, 0);
		syslog(LOG_ERR, "shutdown: can't exec %s: %m.", HALT);
		perror("shutdown");
	}
	(void)kill(1, SIGTERM);		/* to single user */
#endif
	finish();
}

#define	ATOI2(p)	(p[0] - '0') * 10 + (p[1] - '0'); p += 2;
static int dmsize[] =
	{ -1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

getoffset(timearg)
	register char *timearg;
{
	register struct tm *lt;
	register char *p;
	time_t now, time();
	int year, month, day, hour, min;

	if (!strcasecmp(timearg, "now")) {		/* now */
		offset = 0;
		return;
	}

	(void)time(&now);
	if (*timearg == '+') {				/* +minutes */
		if (!isdigit(*++timearg))
			goto badtime;
		min = atoi(timearg);
		offset = min * 60;
		shuttime = now + offset;
		return;
	}

	/* handle hh:mm by getting rid of the colon */
	for (p = timearg; *p; ++p)
		if (!isascii(*p) || !isdigit(*p))
			if (*p == ':' && strlen(p) == 3) {
				p[0] = p[1];
				p[1] = p[2];
				p[2] = '\0';
			}
			else
				goto badtime;

	unsetenv("TZ");					/* OUR timezone */
	lt = localtime(&now);				/* [yymmdd]hhmm */
	year = lt->tm_year;
	month = lt->tm_mon + 1;
	day = lt->tm_mday;

	switch(strlen(timearg)) {
	case 10:
		year = ATOI2(timearg);
		/* FALLTHROUGH */
	case 8:
		month = ATOI2(timearg);
		/* FALLTHROUGH */
	case 6:
		day = ATOI2(timearg);
		/* FALLTHROUGH */
	case 4:
		hour = ATOI2(timearg);
		min = ATOI2(timearg);
		if (month < 1 || month > 12 || day < 1 || day > 31 ||
		    hour < 0 || hour > 23 || min < 0 || min > 59)
			goto badtime;
		shuttime = 0;
		year += TM_YEAR_BASE;
		if (isleap(year) && month > 2)
			++shuttime;
		for (--year; year >= EPOCH_YEAR; --year)
			shuttime += isleap(year) ?
			    DAYS_PER_LYEAR : DAYS_PER_NYEAR;
		while (--month)
			shuttime += dmsize[month];
		shuttime += day - 1;
		shuttime = HOURS_PER_DAY * shuttime + hour;
		shuttime = MINS_PER_HOUR * shuttime + min;
		shuttime *= SECS_PER_MIN;
		shuttime -= lt->tm_gmtoff;
		if ((offset = shuttime - now) >= 0)
			break;
		/* FALLTHROUGH */
	default:
badtime:	fprintf(stderr,
		    "shutdown: bad time format, or already past.\n");
		exit(1);
	}
}

#define	FSMSG	"fastboot file for fsck\n"
doitfast()
{
	int fastfd;

	if ((fastfd = open(FASTBOOT, O_WRONLY|O_CREAT|O_TRUNC, 0664)) >= 0) {
		(void)write(fastfd, FSMSG, sizeof(FSMSG) - 1);
		(void)close(fastfd);
	}
}

#define	NOMSG	"\n\nNO LOGINS: System going down at "
nolog()
{
	int logfd, finish();
	char *ct, *ctime();

	(void)unlink(NOLOGIN);		/* in case linked to another file */
	(void)signal(SIGINT, finish);
	(void)signal(SIGHUP, finish);
	(void)signal(SIGQUIT, finish);
	(void)signal(SIGTERM, finish);
	if ((logfd = open(NOLOGIN, O_WRONLY|O_CREAT|O_TRUNC, 0664)) >= 0) {
		(void)write(logfd, NOMSG, sizeof(NOMSG) - 1);
		ct = ctime(&shuttime);
		(void)write(logfd, ct + 11, 5);
		(void)write(logfd, "\n\n", 2);
		(void)write(logfd, mbuf, strlen(mbuf));
		(void)close(logfd);
	}
}

finish()
{
	(void)unlink(NOLOGIN);
	exit(0);
}

usage()
{
	fprintf(stderr, "usage: shutdown [-fhknr] shutdowntime [ message ]\n");
	exit(1);
}