From 20c422af69f3257d35c841af218dc956e654bbd2 Mon Sep 17 00:00:00 2001 From: Joachim Wiberg Date: Tue, 17 Nov 2026 10:09:42 +0100 Subject: [PATCH] shutdown: add time argument, wall message, and cancel shutdown ignored everything after its options, so a delayed shutdown went down right away: shutdown -r +10 "Upgrading, back in five" Take a time, now, +MIN, or the next HH:MM, and an optional message. Finit keeps the countdown, so it survives logging out: - warns logged-in users at 60, 30, 15 and 10 minutes left, then every minute from five, and on the console - writes the message to /etc/nologin from five minutes before, leaving one already in place alone - shutdown -c cancels, and a new shutdown TIME replaces it Without a time, or with now and no message, shutdown acts right away as before. An immediate reboot, halt, or power-off, also over D-Bus, cancels a scheduled one. The warnings are written by a child, reading utmp and closing a serial tty can block. Fixes #149 Signed-off-by: Joachim Wiberg --- doc/ChangeLog.md | 3 + doc/commands.md | 22 ++++ src/Makefile.am | 1 + src/api.c | 52 +++----- src/dbus.c | 13 +- src/finit.h | 2 + src/initctl.c | 30 +++++ src/reboot.c | 116 ++++++++++++++++-- src/shutdown.c | 264 +++++++++++++++++++++++++++++++++++++++++ src/shutdown.h | 31 +++++ test/Makefile.am | 2 + test/shutdown-sched.sh | 59 +++++++++ 12 files changed, 542 insertions(+), 53 deletions(-) create mode 100644 src/shutdown.c create mode 100644 src/shutdown.h create mode 100755 test/shutdown-sched.sh diff --git a/doc/ChangeLog.md b/doc/ChangeLog.md index a029faab..d5e36e8a 100644 --- a/doc/ChangeLog.md +++ b/doc/ChangeLog.md @@ -8,6 +8,9 @@ All relevant changes are documented in this file. ### Changes +- `shutdown` now takes a time, `now`, `+MIN`, or `HH:MM`, and a message. + Finit warns logged-in users as the time approaches, refuses new logins + from five minutes before, and `shutdown -c` cancels. Issue #149 - Add `stop-scope`, which processes a stop applies to: `pgroup`, the process group of the main process (default), `process`, only the main process, `cgroup`, the cgroup of the service, or `mixed` like systemd. Issue #413 diff --git a/doc/commands.md b/doc/commands.md index 95782a06..3077ddcb 100644 --- a/doc/commands.md +++ b/doc/commands.md @@ -11,3 +11,25 @@ For compatibility reasons Finit listens to the same set of signals as BusyBox init. This is not 100% compatible with SysV init, but clearly the more common combination for Finit. For more details, see the [Signal](signals.md) section. + +Scheduled Shutdown +------------------ + +The `shutdown` command takes a time, and an optional message to warn +logged-in users with: + + shutdown -r +10 "Upgrading to v5.0, back in five" + shutdown -h 23:30 + shutdown -c + +The time is `now`, `+MIN` minutes from now, at most a year, or the next +`HH:MM`. Finit keeps track of it, so it survives logging out. It counts +down the time left, changing the system clock does not move it. At 60, 30, 15 and 10 +minutes left, and then every minute from five, Finit writes the warning +to the terminal of every logged-in user. From five minutes before, it +also creates `/etc/nologin`, with the message, to refuse new logins. A +`/etc/nologin` already in place is left alone. + +A new `shutdown TIME` replaces the scheduled one, and `shutdown -c` +cancels it. Without a time, or with `now` and no message, `shutdown` +acts right away, as before. diff --git a/src/Makefile.am b/src/Makefile.am index 3d5ede65..5418c4e2 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -54,6 +54,7 @@ finit_SOURCES = api.c cgroup.c cgroup.h \ legacy.c legacy.h \ devmon.c devmon.h \ exec.c finit.c finit.h \ + shutdown.c shutdown.h \ stty.c \ helpers.c helpers.h \ initramfs.c \ diff --git a/src/api.c b/src/api.c index 38fa0e4c..dd50a756 100644 --- a/src/api.c +++ b/src/api.c @@ -48,6 +48,7 @@ #include "schedule.h" #include "service.h" #include "sm.h" +#include "shutdown.h" #include "sig.h" #include "util.h" @@ -241,43 +242,9 @@ static int do_reboot(int cmd, int timeout, char *buf, size_t len) switch (cmd) { case INIT_CMD_REBOOT: - halt = SHUT_REBOOT; - break; - case INIT_CMD_HALT: - halt = SHUT_HALT; - break; - case INIT_CMD_POWEROFF: - halt = SHUT_OFF; - break; - - case INIT_CMD_SUSPEND: - break; - - default: - return 255; - } - - shutdown_bypass(timeout); - - switch (cmd) { - case INIT_CMD_REBOOT: - dbg("reboot"); - halt = SHUT_REBOOT; - sm_runlevel(6); - break; - - case INIT_CMD_HALT: - dbg("halt"); - halt = SHUT_HALT; - sm_runlevel(0); - break; - - case INIT_CMD_POWEROFF: - dbg("poweroff"); - halt = SHUT_OFF; - sm_runlevel(0); + shutdown_now(cmd, timeout); break; case INIT_CMD_SUSPEND: @@ -293,8 +260,7 @@ static int do_reboot(int cmd, int timeout, char *buf, size_t len) break; default: - /* Handled previously */ - break; + return 255; } return rc; @@ -384,6 +350,7 @@ static void api_cb(uev_t *w, void *arg, int events) case INIT_CMD_HALT: case INIT_CMD_POWEROFF: case INIT_CMD_SUSPEND: + case INIT_CMD_SHUTDOWN: if (IS_RESERVED_RUNLEVEL(runlevel)) { strterm(rq.data, sizeof(rq.data)); warnx("Unsupported command (cmd: %d, data: %s) in runlevel S and 6/0.", @@ -484,6 +451,17 @@ static void api_cb(uev_t *w, void *arg, int events) result = do_reboot(rq.cmd, rq.sleeptime, rq.data, sizeof(rq.data)); break; + case INIT_CMD_SHUTDOWN: + strterm(rq.data, sizeof(rq.data)); + result = shutdown_schedule(rq.runlevel, rq.sleeptime, rq.data); + break; + + case INIT_CMD_SHUTDOWN_CANCEL: + result = shutdown_cancel(); + if (result) + strlcpy(rq.data, "No scheduled shutdown to cancel.", sizeof(rq.data)); + break; + case INIT_CMD_SWITCH_ROOT: result = do_switch_root_api(sd, &rq); if (result) diff --git a/src/dbus.c b/src/dbus.c index 3e32a253..ae8c3566 100644 --- a/src/dbus.c +++ b/src/dbus.c @@ -50,6 +50,7 @@ #include "schedule.h" #include "service.h" #include "sig.h" +#include "shutdown.h" #include "sm.h" #include "svc.h" #include "util.h" @@ -438,7 +439,7 @@ static int manager_set_runlevel(link_call_t *call, void *userdata) return 0; } -static int dbus_shutdown(link_call_t *call, shutop_t target, int level) +static int dbus_shutdown(link_call_t *call, int cmd) { uint32_t timeout; @@ -450,16 +451,14 @@ static int dbus_shutdown(link_call_t *call, shutop_t target, int level) return link_call_reply_error(call, "org.finit.Error.WrongRunlevel", "Already in shutdown"); - halt = target; - shutdown_bypass((int)timeout); - sm_runlevel(level); + shutdown_now(cmd, (int)timeout); (void)link_call_reply(call); return 0; } -static int manager_reboot (link_call_t *c, void *u) { (void)u; return dbus_shutdown(c, SHUT_REBOOT, 6); } -static int manager_poweroff(link_call_t *c, void *u) { (void)u; return dbus_shutdown(c, SHUT_OFF, 0); } -static int manager_halt (link_call_t *c, void *u) { (void)u; return dbus_shutdown(c, SHUT_HALT, 0); } +static int manager_reboot (link_call_t *c, void *u) { (void)u; return dbus_shutdown(c, INIT_CMD_REBOOT); } +static int manager_poweroff(link_call_t *c, void *u) { (void)u; return dbus_shutdown(c, INIT_CMD_POWEROFF); } +static int manager_halt (link_call_t *c, void *u) { (void)u; return dbus_shutdown(c, INIT_CMD_HALT); } static int manager_set_debug(link_call_t *call, void *u) { diff --git a/src/finit.h b/src/finit.h index 30657537..ad14989a 100644 --- a/src/finit.h +++ b/src/finit.h @@ -100,6 +100,8 @@ #define INIT_CMD_POWEROFF 22 #define INIT_CMD_SUSPEND 23 #define INIT_CMD_SWITCH_ROOT 24 /* Switch to new root filesystem */ +#define INIT_CMD_SHUTDOWN 25 /* runlevel: REBOOT/HALT/POWEROFF, sleeptime: sec, data: msg */ +#define INIT_CMD_SHUTDOWN_CANCEL 26 #define INIT_CMD_WDOG_HELLO 128 /* Watchdog register and hello */ #define INIT_CMD_SVC_ITER 129 #define INIT_CMD_SVC_QUERY 130 diff --git a/src/initctl.c b/src/initctl.c index 4edad582..7b746666 100644 --- a/src/initctl.c +++ b/src/initctl.c @@ -1090,6 +1090,36 @@ static int do_reboot_dbus(const char *method) } #endif +/* Scheduled shutdown, see issue #149, @cmd is INIT_CMD_REBOOT, _HALT or _POWEROFF */ +int do_shutdown_at(int cmd, int sec, const char *msg) +{ + struct init_request rq = { + .magic = INIT_MAGIC, + .cmd = INIT_CMD_SHUTDOWN, + .runlevel = cmd, + .sleeptime = sec, + }; + + strlcpy(rq.data, msg ? msg : "", sizeof(rq.data)); + return client_send(&rq, sizeof(rq)); +} + +int do_shutdown_cancel(void) +{ + struct init_request rq = { + .magic = INIT_MAGIC, + .cmd = INIT_CMD_SHUTDOWN_CANCEL, + }; + + if (client_send(&rq, sizeof(rq))) { + if (rq.cmd == INIT_CMD_NACK) + warnx("%s", rq.data); + return 1; + } + + return 0; +} + int do_reboot (char *arg) { #ifdef HAVE_DBUS diff --git a/src/reboot.c b/src/reboot.c index 3d5079e2..defe10a3 100644 --- a/src/reboot.c +++ b/src/reboot.c @@ -28,15 +28,17 @@ #include #include #include +#include #include +#include "finit.h" #include "util.h" typedef enum { - CMD_UNKNOWN = -1, - CMD_REBOOT = 0, - CMD_HALT, - CMD_POWEROFF, - CMD_SUSPEND, + CMD_UNKNOWN = -1, + CMD_REBOOT = INIT_CMD_REBOOT, + CMD_HALT = INIT_CMD_HALT, + CMD_POWEROFF = INIT_CMD_POWEROFF, + CMD_SUSPEND = INIT_CMD_SUSPEND, } cmd_t; static cmd_t cmd = CMD_UNKNOWN; @@ -49,6 +51,8 @@ extern int do_reboot (char *arg); extern int do_halt (char *arg); extern int do_poweroff(char *arg); extern int do_suspend (char *arg); +extern int do_shutdown_at(int cmd, int sec, const char *msg); +extern int do_shutdown_cancel(void); static void transform(char *nm) @@ -101,18 +105,83 @@ static void do_kill(int signo, char *msg) do_sleep(5); } +#define MAX_MIN (365 * 24 * 60) /* Finit takes no more than a year */ + +/* now, +MIN, or HH:MM, as seconds from now, or -1 */ +static int parse_time(const char *arg) +{ + struct tm tm; + time_t t, at; + int hh, mm; + char *end; + long min; + char c; + + if (!strcmp(arg, "now")) + return 0; + + if (arg[0] == '+') { + min = strtol(&arg[1], &end, 10); + if (end == &arg[1] || *end || min < 0 || min > MAX_MIN) + return -1; + return (int)min * 60; + } + + if (sscanf(arg, "%d:%d%c", &hh, &mm, &c) != 2 || hh < 0 || hh > 23 || mm < 0 || mm > 59) + return -1; + + /* Next time the clock shows HH:MM, today or tomorrow */ + t = time(NULL); + localtime_r(&t, &tm); + tm.tm_hour = hh; + tm.tm_min = mm; + tm.tm_sec = 0; + tm.tm_isdst = -1; + at = mktime(&tm); + if (at <= t) { + tm.tm_mday++; + tm.tm_isdst = -1; + at = mktime(&tm); + } + + return (int)(at - t); +} + +static int schedule(int sec, const char *text) +{ + char tm[32]; + time_t at; + + if (do_shutdown_at(cmd, sec, text)) + errx(1, "Failed scheduling %s.", msg); + + if (sec > 0) { + at = time(NULL) + sec; + strftime(tm, sizeof(tm), "%a %Y-%m-%d %H:%M", localtime(&at)); + printf("Scheduled %s at %s, use 'shutdown -c' to cancel.\n", msg, tm); + } + + return 0; +} + static int usage(int rc) { - fprintf(stderr, "Usage: %s [OPTIONS]\n\n" + int sd = !strcmp(prognm, "shutdown"); + + fprintf(stderr, "Usage: %s [OPTIONS]%s\n\n" "Options:\n" " -?, --help This help text\n" + " -c Cancel a scheduled shutdown\n" " -f, --force Force unsafe %s now, do not contact the init system.\n" " --halt Halt system, regardless of how the command is called.\n" " -h Halt or power off after shutdown.\n" " -P, --poweroff Power-off system, regardless of how the command is called.\n" " -r, --reboot Reboot system, regardless of how the command is called.\n" " -t, --timeout=SEC Force reboot/shutdown after a given timeout\n" - "\n", prognm, msg); + "\n", prognm, sd ? " [TIME [MESSAGE]]" : "", msg); + if (sd) + fprintf(stderr, "TIME is now, +MIN, or HH:MM. Logged-in users are sent MESSAGE as a\n" + "warning, and from five minutes before, new logins are refused.\n\n"); return rc; } @@ -128,17 +197,21 @@ int reboot_main(int argc, char *argv[]) {"timeout", 1, NULL, 't'}, {NULL, 0, NULL, 0} }; - int c, force = 0; + int c, force = 0, cancel = 0; int tmp; /* Initial command taken from program name */ transform(prognm); - while ((c = getopt_long(argc, argv, "h?fHPprt:", long_options, NULL)) != EOF) { + while ((c = getopt_long(argc, argv, "h?cfHPprt:", long_options, NULL)) != EOF) { switch(c) { case '?': return usage(0); + case 'c': + cancel = 1; + break; + case 'f': force = 1; break; @@ -176,6 +249,31 @@ int reboot_main(int argc, char *argv[]) if (getenv("SULOGIN")) force = 1; + if (cancel) + return do_shutdown_cancel(); + + /* shutdown [opts] [TIME [MESSAGE]], see issue #149 */ + if (!strcmp(prognm, "shutdown") && optind < argc) { + char text[256] = ""; + int sec, i; + + sec = parse_time(argv[optind]); + if (sec < 0) + errx(1, "Invalid time '%s', use now, +MIN, or HH:MM.", argv[optind]); + + for (i = optind + 1; i < argc; i++) { + if (text[0]) + strlcat(text, " ", sizeof(text)); + strlcat(text, argv[i], sizeof(text)); + } + + if (sec > 0 || text[0]) { + if (force) + errx(1, "Cannot schedule a forced %s.", msg); + return schedule(sec, text); + } + } + if (force) { sync(); diff --git a/src/shutdown.c b/src/shutdown.c new file mode 100644 index 00000000..92b8dd54 --- /dev/null +++ b/src/shutdown.c @@ -0,0 +1,264 @@ +/* Scheduled shutdown with wall messages and nologin, see issue #149 + * + * Copyright (c) 2026 Joachim Wiberg + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include + +#include "conf.h" +#include "finit.h" +#include "log.h" +#include "private.h" +#include "schedule.h" +#include "shutdown.h" +#include "sig.h" +#include "sm.h" +#include "util.h" +#include "utmp-api.h" + +/* Minutes left at each warning, 0 is the deadline */ +static const int warn_at[] = { 60, 30, 15, 10, 5, 4, 3, 2, 1, 0 }; +#define NOLOGIN_MIN 5 +#define MAX_WAIT 3600 /* sec, keeps the msec timer delay an int */ +#define MAX_DELAY (365 * 24 * 3600) + +static struct { + int cmd; /* INIT_CMD_REBOOT, _HALT, _POWEROFF, 0: none */ + long when; /* Deadline, jiffies() */ + int next; /* Minutes left at next warning */ + int nologin; /* We created FINIT_NOLOGIN_PATH */ + char msg[256]; + struct wq work; +} sched; + +static const char *action(int cmd) +{ + switch (cmd) { + case INIT_CMD_REBOOT: + return "reboot"; + case INIT_CMD_HALT: + return "halt"; + default: + return "power-off"; + } +} + +/* + * Write @text to the terminal of every logged-in user. Done in a + * child, reading utmp may wait for its lock and closing a serial + * tty for its output to drain. + */ +static void wall(const char *text) +{ + char host[64] = "", tm[32], hdr[160]; + struct utmp *ut; + time_t t; + + if (!has_utmp() || fork()) + return; + + t = time(NULL); + gethostname(host, sizeof(host) - 1); + strftime(tm, sizeof(tm), "%a %b %e %H:%M:%S %Y", localtime(&t)); + snprintf(hdr, sizeof(hdr), "\r\nBroadcast message from root@%s (%s):\r\n\r\n", host, tm); + + setutent(); + while ((ut = getutent())) { + char tty[sizeof(ut->ut_line) + 6]; + int fd; + + if (ut->ut_type != USER_PROCESS || !ut->ut_line[0]) + continue; + + snprintf(tty, sizeof(tty), "/dev/%.*s", (int)sizeof(ut->ut_line), ut->ut_line); + if (strstr(tty, "..")) + continue; + + /* utmp is not ours alone to write, make sure it is a tty */ + fd = open(tty, O_WRONLY | O_NOCTTY | O_NONBLOCK | O_NOFOLLOW | O_CLOEXEC); + if (fd < 0) + continue; + if (isatty(fd) && write(fd, hdr, strlen(hdr)) > 0) + (void)!write(fd, text, strlen(text)); + close(fd); + } + endutent(); + + _exit(0); +} + +static void announce(int min) +{ + char line[80], text[sizeof(sched.msg) + sizeof(line) + 8]; + + if (min > 0) + snprintf(line, sizeof(line), "The system is going DOWN for %s in %d minute%s!", + action(sched.cmd), min, min > 1 ? "s" : ""); + else + snprintf(line, sizeof(line), "The system is going DOWN for %s NOW!", action(sched.cmd)); + + logit(LOG_CONSOLE | LOG_NOTICE, "%s", line); + snprintf(text, sizeof(text), "%s%s%s\r\n", sched.msg, sched.msg[0] ? "\r\n" : "", line); + wall(text); +} + +/* Never touch an admin's nologin, only create and remove our own */ +static void nologin(void) +{ + FILE *fp; + + if (fexist(FINIT_NOLOGIN_PATH)) + return; + + fp = fopen(FINIT_NOLOGIN_PATH, "w"); + if (!fp) { + dbg("Failed creating %s: %s", FINIT_NOLOGIN_PATH, strerror(errno)); + return; + } + fprintf(fp, "%s%sThe system is going down for %s.\n", sched.msg, + sched.msg[0] ? "\n" : "", action(sched.cmd)); + fclose(fp); + sched.nologin = 1; +} + +static void tick(void *arg) +{ + long left, wait; + size_t i; + int min; + + if (!sched.cmd || IS_RESERVED_RUNLEVEL(runlevel)) + return; + + left = sched.when - jiffies(); + if (left <= 0) { + announce(0); + shutdown_now(sched.cmd, 0); + return; + } + + min = (left + 59) / 60; + if (min <= NOLOGIN_MIN) + nologin(); + if (min == sched.next) + announce(min); + + for (i = 0; warn_at[i] >= min; i++) + ; + sched.next = warn_at[i]; + + wait = left - sched.next * 60; + if (wait > MAX_WAIT) + wait = MAX_WAIT; + sched.work.delay = wait * 1000; + schedule_work(&sched.work); +} + +/* + * Reboot, halt, or power off now, replacing any scheduled shutdown. + * A @timeout in seconds arms the emergency shutdown bypass, 0: none. + */ +int shutdown_now(int cmd, int timeout) +{ + switch (cmd) { + case INIT_CMD_REBOOT: + halt = SHUT_REBOOT; + break; + case INIT_CMD_HALT: + halt = SHUT_HALT; + break; + case INIT_CMD_POWEROFF: + halt = SHUT_OFF; + break; + default: + return 1; + } + + if (sched.cmd) { + sched.cmd = 0; + uev_timer_stop(&sched.work.watcher); + } + + shutdown_bypass(timeout); + dbg("%s", action(cmd)); + sm_runlevel(cmd == INIT_CMD_REBOOT ? 6 : 0); + + return 0; +} + +/* Replaces any already scheduled shutdown */ +int shutdown_schedule(int cmd, int sec, const char *msg) +{ + if (cmd != INIT_CMD_REBOOT && cmd != INIT_CMD_HALT && cmd != INIT_CMD_POWEROFF) + return 1; + if (sec < 0 || sec > MAX_DELAY) + return 1; + + /* Our nologin belongs to the shutdown being replaced */ + if (sched.nologin) { + erase(FINIT_NOLOGIN_PATH); + sched.nologin = 0; + } + + sched.cmd = cmd; + sched.when = jiffies() + sec; + sched.next = (sec + 59) / 60; /* First tick warns */ + strlcpy(sched.msg, msg ? msg : "", sizeof(sched.msg)); + + /* First tick right away, a zero delay would disarm the timer */ + sched.work.cb = tick; + sched.work.delay = 1; + + return schedule_work(&sched.work); +} + +int shutdown_cancel(void) +{ + if (!sched.cmd) + return 1; + + sched.cmd = 0; + uev_timer_stop(&sched.work.watcher); + + if (sched.nologin) { + erase(FINIT_NOLOGIN_PATH); + sched.nologin = 0; + } + + logit(LOG_CONSOLE | LOG_NOTICE, "The system shutdown has been cancelled."); + wall("The system shutdown has been cancelled.\r\n"); + + return 0; +} + +/** + * Local Variables: + * indent-tabs-mode: t + * c-file-style: "linux" + * End: + */ diff --git a/src/shutdown.h b/src/shutdown.h new file mode 100644 index 00000000..dcf97c4d --- /dev/null +++ b/src/shutdown.h @@ -0,0 +1,31 @@ +/* Scheduled shutdown, see issue #149 + * + * Copyright (c) 2026 Joachim Wiberg + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef FINIT_SHUTDOWN_H_ +#define FINIT_SHUTDOWN_H_ + +int shutdown_now (int cmd, int timeout); +int shutdown_schedule(int cmd, int sec, const char *msg); +int shutdown_cancel (void); + +#endif /* FINIT_SHUTDOWN_H_ */ diff --git a/test/Makefile.am b/test/Makefile.am index 20a393cf..e28f4c56 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -58,6 +58,7 @@ EXTRA_DIST += pidfile.sh EXTRA_DIST += pidfile-stopped.sh EXTRA_DIST += stale-pidfile.sh EXTRA_DIST += stop-scope.sh +EXTRA_DIST += shutdown-sched.sh EXTRA_DIST += pre-post-serv.sh EXTRA_DIST += pre-fail.sh EXTRA_DIST += process-depends.sh @@ -131,6 +132,7 @@ TESTS += pidfile.sh TESTS += pidfile-stopped.sh TESTS += stale-pidfile.sh TESTS += stop-scope.sh +TESTS += shutdown-sched.sh TESTS += pre-post-serv.sh TESTS += pre-fail.sh TESTS += process-depends.sh diff --git a/test/shutdown-sched.sh b/test/shutdown-sched.sh new file mode 100755 index 00000000..12c432cc --- /dev/null +++ b/test/shutdown-sched.sh @@ -0,0 +1,59 @@ +#!/bin/sh +# Verify scheduled shutdown, see issue #149: shutdown TIME [MESSAGE] +# blocks new logins from five minutes before, and shutdown -c cancels +# it. The countdown never runs out here, it is always cancelled. +set -eu + +TEST_DIR=$(dirname "$0") + +NOLOGIN=/etc/nologin + +# Assert that the command, run in the test namespace, fails +fails() +{ + assert "$1 fails" "$(texec sh -c "$1 >/dev/null 2>&1 || echo fail")" = fail +} + +test_teardown() +{ + say "Running test teardown." + run "shutdown -c 2>/dev/null || true" + run "rm -f $NOLOGIN" +} + +# shellcheck source=/dev/null +. "$TEST_DIR/lib/setup.sh" + +sep +say 'Schedule a reboot in two minutes, within the nologin window' +run "shutdown -r +2 Testing scheduled reboot" +retry "assert_file_contains $NOLOGIN 'Testing scheduled reboot'" + +say 'Cancel it, nologin is removed and the system stays up' +run "shutdown -c" +retry "texec sh -c '! test -e $NOLOGIN'" +assert "Still in runlevel 2" "$(texec initctl runlevel | awk '{print $2}')" = 2 + +sep +say 'Nothing to cancel' +fails "shutdown -c" + +say 'An invalid time is refused' +fails "shutdown -r 25:00" +fails "shutdown -r +999999999" + +sep +say 'A later shutdown replaces it, and its nologin' +run "shutdown -r +2 First" +retry "assert_file_contains $NOLOGIN First" +run "shutdown -r +120 Second" +retry "texec sh -c '! test -e $NOLOGIN'" +run "shutdown -c" + +sep +say 'A nologin file of the admin is left alone' +run "echo 'Down for maintenance' > $NOLOGIN" +run "shutdown -h +2" +sleep 1 # first tick, where nologin would be written +run "shutdown -c" +assert_file_contains $NOLOGIN 'Down for maintenance'