int
main (int argc,
char *argv[])
{
char **args;
int runlevel;
int ret;
nih_main_init (argv[0]);
nih_option_set_usage ("RUNLEVEL");
nih_option_set_synopsis (_("Change runlevel."));
nih_option_set_help (
_("RUNLEVEL should be one of 0123456sS, where s and S are "
"considered identical.\n"
"\n"
"RUNLEVEL may also be Q or q to instruct the init daemon "
"to reload its configuration, this is rarely necessary "
"since the daemon watches its configuration for changes.\n"
"\n"
"RUNLEVEL may be U or u to instruct the init daemon to "
"re-execute itself, this is not recommended since Upstart "
"does not currently preserve its state.\n"));
args = nih_option_parser (NULL, argc, argv, options, FALSE);
if (! args)
exit (1);
/* First argument must be a single character we know */
if (! args[0]) {
fprintf (stderr, _("%s: missing runlevel\n"), program_name);
nih_main_suggest_help ();
exit (1);
}
if ((! strchr ("0123456SsQqUu", args[0][0])) || args[0][1]) {
fprintf (stderr, _("%s: illegal runlevel: %s\n"),
program_name, args[0]);
nih_main_suggest_help ();
exit (1);
}
/* Check we're root */
setuid (geteuid ());
if (getuid ()) {
nih_fatal (_("Need to be root"));
exit (1);
}
/* Send the appropriate message */
runlevel = args[0][0];
switch (runlevel) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
ret = sysv_change_runlevel (runlevel, extra_env, NULL, NULL);
break;
case 'S':
case 's':
ret = sysv_change_runlevel ('S', extra_env, NULL, NULL);
break;
case 'Q':
case 'q':
ret = kill (1, SIGHUP);
if (ret < 0)
nih_error_raise_system ();
break;
case 'U':
case 'u':
ret = kill (1, SIGTERM);
if (ret < 0)
nih_error_raise_system ();
break;
default:
nih_assert_not_reached ();
}
if (ret < 0) {
NihError *err;
err = nih_error_get ();
nih_error ("%s", err->message);
nih_free (err);
exit (1);
}
return 0;
}
int
main (int argc,
char *argv[])
{
char ** args;
nih_local char *message = NULL;
size_t messagelen;
nih_local char *msg = NULL;
int arg;
pid_t pid = 0;
nih_main_init (argv[0]);
nih_option_set_usage (_("TIME [MESSAGE]"));
nih_option_set_synopsis (_("Bring the system down."));
nih_option_set_help (
_("TIME may have different formats, the most common is simply "
"the word 'now' which will bring the system down "
"immediately. Other valid formats are +m, where m is the "
"number of minutes to wait until shutting down and hh:mm "
"which specifies the time on the 24hr clock.\n"
"\n"
"Logged in users are warned by a message sent to their "
"terminal, you may include an optional MESSAGE included "
"with this. Messages can be sent without actually "
"bringing the system down by using the -k option.\n"
"\n"
"If TIME is given, the command will remain in the "
"foreground until the shutdown occurs. It can be cancelled "
"by Control-C, or by another user using the -c option.\n"
"\n"
"The system is brought down into maintenance (single-user) "
"mode by default, you can change this with either the -r or "
"-h option which specify a reboot or system halt "
"respectively. The -h option can be further modified with "
"-H or -P to specify whether to halt the system, or to "
"power it off afterwards. The default is left up to the "
"shutdown scripts."));
args = nih_option_parser (NULL, argc, argv, options, FALSE);
if (! args)
exit (1);
/* If the runlevel wasn't given explicitly, set it to 1 so we go
* down into single-user mode.
*/
if (! runlevel) {
runlevel = '1';
init_halt = NULL;
}
/* When may be specified with -g, or must be first argument */
if (! (cancel || when || args[0])) {
fprintf (stderr, _("%s: time expected\n"), program_name);
nih_main_suggest_help ();
exit (1);
} else if (! (cancel || when)) {
when = NIH_MUST (nih_strdup (NULL, args[0]));
arg = 1;
} else {
arg = 0;
}
/* Parse the time argument */
if (when) {
if (! strcmp (when, "now")) {
/* "now" means, err, now */
delay = 0;
} else if (strchr (when, ':')) {
/* Clock time */
long hours, mins;
char *endptr;
struct tm *tm;
time_t now;
hours = strtoul (when, &endptr, 10);
if ((*endptr != ':') || (hours < 0) || (hours > 23)) {
fprintf (stderr, _("%s: illegal hour value\n"),
program_name);
nih_main_suggest_help ();
exit (1);
}
mins = strtoul (endptr + 1, &endptr, 10);
if (*endptr || (mins < 0) || (mins > 59)) {
fprintf (stderr,
_("%s: illegal minute value\n"),
program_name);
nih_main_suggest_help ();
exit (1);
}
/* Subtract the current time to get the delay.
* Add a whole day if we go negative */
now = time (NULL);
tm = localtime (&now);
delay = (((hours * 60) + mins)
- ((tm->tm_hour * 60) + tm->tm_min));
if (delay < 0)
delay += 1440;
} else {
/* Delay in minutes */
char *endptr;
delay = strtoul (when, &endptr, 10);
if (*endptr || (delay < 0)) {
fprintf (stderr, _("%s: illegal time value\n"),
program_name);
nih_main_suggest_help ();
exit (1);
}
}
nih_free (when);
}
/* The rest of the arguments are a message.
* Really this should be just the next argument, but that's not
* how this has been traditionally done *sigh*
*/
message = NIH_MUST (nih_strdup (NULL, ""));
messagelen = 0;
for (; args[arg]; arg++) {
message = NIH_MUST (nih_realloc (
message, NULL,
messagelen + strlen(args[arg]) + 4));
strcat (message, args[arg]);
strcat (message, " ");
messagelen += strlen (args[arg]) + 1;
}
/* Terminate with \r\n */
if (messagelen)
strcat (message, "\r\n");
/* Check we're root, or setuid root */
setuid (geteuid ());
if (getuid ()) {
nih_fatal (_("Need to be root"));
exit (1);
}
/* Look for an existing pid file and deal with the existing
* process if there is one.
*/
pid = nih_main_read_pidfile ();
if (pid > 0) {
if (cancel) {
if (kill (pid, SIGINT) < 0) {
nih_error (_("Shutdown is not running"));
exit (1);
}
if (messagelen)
wall (message);
exit (0);
} else if (kill (pid, 0) == 0) {
nih_error (_("Another shutdown is already running"));
exit (1);
}
} else if (cancel) {
nih_error (_("Cannot find pid of running shutdown"));
exit (1);
}
/* Send an initial message */
msg = NIH_MUST (warning_message (message));
wall (msg);
if (warn_only)
exit (0);
/* Give us a sane environment */
if (chdir ("/") < 0)
nih_warn ("%s: %s", _("Unable to change directory"),
strerror (errno));
umask (022);
/* Shutdown now? */
if (! delay)
shutdown_now ();
/* Save our pid so we can be interrupted later */
if (nih_main_write_pidfile (getpid ()) < 0) {
NihError *err;
err = nih_error_get ();
nih_warn ("%s: %s: %s", nih_main_get_pidfile(),
_("Unable to write pid file"), err->message);
nih_free (err);
}
/* Ignore a whole bunch of signals */
nih_signal_set_ignore (SIGCHLD);
nih_signal_set_ignore (SIGHUP);
nih_signal_set_ignore (SIGTSTP);
nih_signal_set_ignore (SIGTTIN);
nih_signal_set_ignore (SIGTTOU);
/* Catch the usual quit signals */
nih_signal_set_handler (SIGINT, nih_signal_handler);
NIH_MUST (nih_signal_add_handler (NULL, SIGINT,
cancel_callback, NULL));
nih_signal_set_handler (SIGQUIT, nih_signal_handler);
NIH_MUST (nih_signal_add_handler (NULL, SIGQUIT,
cancel_callback, NULL));
nih_signal_set_handler (SIGTERM, nih_signal_handler);
NIH_MUST (nih_signal_add_handler (NULL, SIGTERM,
cancel_callback, NULL));
/* Call a timer every minute until we shutdown */
NIH_MUST (nih_timer_add_periodic (NULL, 60,
(NihTimerCb)timer_callback,
message));
/* Hang around */
nih_main_loop ();
return 0;
}