xref: /haiku/src/bin/shutdown.cpp (revision e18440dc8359d3bbd771df435b393901807a61fd)

/*
 * Copyright 2002-2010, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Francois Revol (mmu_man@users.sf.net)
 */


/*!	Shuts down the system, either halting or rebooting. */


#include <syscalls.h>

#include <OS.h>
#include <Roster.h>
#include <RosterPrivate.h>

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>


uint32 gTimeToSleep = 0;
bool gReboot = false;


/*!	We get here when shutdown is cancelled.
	Then sleep() returns.
*/
void
handle_usr1(int sig)
{
	while (0);
}


bool
parseTime(char *arg, char *argv, int32 *_i)
{
	char *unit;

	if (isdigit(arg[0])) {
		gTimeToSleep = strtoul(arg, &unit, 10);
	} else if (argv && isdigit(argv[0])) {
		(*_i)++;
		gTimeToSleep = strtoul(argv, &unit, 10);
	} else
		return false;

	if (unit[0] == '\0' || strcmp(unit, "s") == 0)
		return true;
	if (strcmp(unit, "m") == 0) {
		gTimeToSleep *= 60;
		return true;
	}

	return false;
}


void
usage(const char *program)
{
	fprintf(stderr, "usage: %s [-rqca] [-d time]\n"
		"\t-r reboot,\n"
		"\t-q quick shutdown (don't broadcast apps),\n"
		"\t-a ask user to confirm the shutdown (ignored when -q is given),\n"
		"\t-c cancel a running shutdown,\n"
		"\t-s run shutdown synchronously (only returns if shutdown is cancelled)\n"
		"\t-d delay shutdown by <time> seconds.\n", program);
	exit(1);
}


int
main(int argc, char **argv)
{
	bool askUser = false;
	bool quick = false;
	bool async = true;

	const char *program = strrchr(argv[0], '/');
	if (program == NULL)
		program = argv[0];
	else
		program++;

	// handle 'halt' and 'reboot' symlinks
	if (strcmp(program, "reboot") == 0)
		gReboot = true;
	if (strcmp(program, "shutdown") != 0)
		askUser = true;

	for (int32 i = 1; i < argc; i++) {
		char *arg = argv[i];
		if (arg[0] == '-') {
			if (!isalpha(arg[1]))
				usage(program);

			while (arg && isalpha((++arg)[0])) {
				switch (arg[0]) {
					case 'a':
						askUser = true;
						break;
					case 'q':
						quick = true;
						break;
					case 'r':
						gReboot = true;
						break;
					case 's':
						async = false;
						break;
					case 'c':
					{
						// find all running shutdown commands and signal their
						// shutdown threads

						thread_info threadInfo;
						get_thread_info(find_thread(NULL), &threadInfo);

						team_id thisTeam = threadInfo.team;

						int32 team_cookie = 0;
						team_info teamInfo;
						while (get_next_team_info(&team_cookie, &teamInfo)
								== B_OK) {
							if (strstr(teamInfo.args, "shutdown") != NULL
								&& teamInfo.team != thisTeam) {
								int32 thread_cookie = 0;
								while (get_next_thread_info(teamInfo.team,
										&thread_cookie, &threadInfo) == B_OK) {
									if (strcmp(threadInfo.name, "shutdown") == 0)
										kill(threadInfo.thread, SIGUSR1);
								}
							}
						}
						exit(0);
						break;
					}
					case 'd':
						if (parseTime(arg + 1, argv[i + 1], &i)) {
							arg = NULL;
							break;
						}
						// supposed to fall through

					default:
						usage(program);
				}
			}
		} else
			usage(program);
	}

	if (gTimeToSleep > 0) {
		int32 left;

		signal(SIGUSR1, handle_usr1);

		printf("Delaying %s by %" B_PRIu32 " seconds...\n",
			gReboot ? "reboot" : "shutdown", gTimeToSleep);

		left = sleep(gTimeToSleep);

		if (left > 0) {
			fprintf(stderr, "Shutdown cancelled.\n");
			exit(0);
		}
	}

	if (quick) {
		#ifdef __HAIKU__
		_kern_shutdown(gReboot);
		#endif // __HAIKU__
		fprintf(stderr, "Shutdown failed! (Do you have ACPI enabled?)\n");
		return 2;
	} else {
		BRoster roster;
		BRoster::Private rosterPrivate(roster);
		status_t error = rosterPrivate.ShutDown(gReboot, askUser, !async);
		if (error != B_OK) {
			fprintf(stderr, "Shutdown failed: %s\n", strerror(error));
			return 2;
		}
	}

	return 0;
}