sys-utils/rtcwake.c

   1 /*
   2  * rtcwake -- enter a system sleep state until specified wakeup time.
   3  *
   4  * This uses cross-platform Linux interfaces to enter a system sleep state,
   5  * and leave it no later than a specified time.  It uses any RTC framework
   6  * driver that supports standard driver model wakeup flags.
   7  *
   8  * This is normally used like the old "apmsleep" utility, to wake from a
   9  * suspend state like ACPI S1 (standby) or S3 (suspend-to-RAM).  Most
  10  * platforms can implement those without analogues of BIOS, APM, or ACPI.
  11  *
  12  * On some systems, this can also be used like "nvram-wakeup", waking
  13  * from states like ACPI S4 (suspend to disk).  Not all systems have
  14  * persistent media that are appropriate for such suspend modes.
  15  *
  16  * The best way to set the system's RTC is so that it holds the current
  17  * time in UTC.  Use the "-l" flag to tell this program that the system
  18  * RTC uses a local timezone instead (maybe you dual-boot MS-Windows).
  19  * That flag should not be needed on systems with adjtime support.
  20  */
  21
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <getopt.h>
  25 #include <linux/rtc.h>
  26 #include <poll.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <sys/ioctl.h>
  31 #include <sys/stat.h>
  32 #include <sys/time.h>
  33 #include <sys/types.h>
  34 #include <termios.h>
  35 #include <time.h>
  36 #include <unistd.h>
  37
  38 #include "c.h"
  39 #include "closestream.h"
  40 #include "env.h"
  41 #include "nls.h"
  42 #include "optutils.h"
  43 #include "pathnames.h"
  44 #include "strutils.h"
  45 #include "strv.h"
  46 #include "timeutils.h"
  47 #include "xalloc.h"
  48
  49 #ifndef RTC_AF
  50 # define RTC_AF         0x20    /* Alarm interrupt */
  51 #endif
  52
  53 #define ADJTIME_ZONE_BUFSIZ             8
  54 #define SYS_WAKEUP_PATH_TEMPLATE        "/sys/class/rtc/%s/device/power/wakeup"
  55 #define SYS_POWER_STATE_PATH            "/sys/power/state"
  56 #define DEFAULT_RTC_DEVICE              "/dev/rtc0"
  57
  58 enum rtc_modes {        /* manual page --mode option explains these. */
  59         OFF_MODE = 0,
  60         NO_MODE,
  61         ON_MODE,
  62         DISABLE_MODE,
  63         SHOW_MODE,
  64
  65         SYSFS_MODE      /* keep it last */
  66
  67 };
  68
  69 static const char *rtcwake_mode_string[] = {
  70         [OFF_MODE] = "off",
  71         [NO_MODE] = "no",
  72         [ON_MODE] = "on",
  73         [DISABLE_MODE] = "disable",
  74         [SHOW_MODE] = "show"
  75 };
  76
  77 enum clock_modes {
  78         CM_AUTO,
  79         CM_UTC,
  80         CM_LOCAL
  81 };
  82
  83 struct rtcwake_control {
  84         char *mode_str;                 /* name of the requested mode */
  85         char **possible_modes;          /* modes listed in /sys/power/state */
  86         char *adjfile;                  /* adjtime file path */
  87         enum clock_modes clock_mode;    /* hwclock timezone */
  88         time_t sys_time;                /* system time */
  89         time_t rtc_time;                /* hardware time */
  90         unsigned int verbose:1,         /* verbose messaging */
  91                      dryrun:1;          /* do not set alarm, suspend system, etc */
  92 };
  93
  94 static void __attribute__((__noreturn__)) usage(void)
  95 {
  96         FILE *out = stdout;
  97         fputs(USAGE_HEADER, out);
  98         fprintf(out,
  99               _(" %s [options]\n"), program_invocation_short_name);
 100
 101         fputs(USAGE_SEPARATOR, out);
 102         fputs(_("Enter a system sleep state until a specified wakeup time.\n"), out);
 103
 104         fputs(USAGE_OPTIONS, out);
 105         fputs(_(" -a, --auto               reads the clock mode from adjust file (default)\n"), out);
 106         fprintf(out,
 107               _(" -A, --adjfile <file>     specifies the path to the adjust file\n"
 108                 "                            the default is %s\n"), _PATH_ADJTIME);
 109         fputs(_("     --date <timestamp>   date time of timestamp to wake\n"), out);
 110         fputs(_(" -d, --device <device>    select rtc device (rtc0|rtc1|...)\n"), out);
 111         fputs(_(" -n, --dry-run            does everything, but suspend\n"), out);
 112         fputs(_(" -l, --local              RTC uses local timezone\n"), out);
 113         fputs(_("     --list-modes         list available modes\n"), out);
 114         fputs(_(" -m, --mode <mode>        standby|mem|... sleep mode\n"), out);
 115         fputs(_(" -s, --seconds <seconds>  seconds to sleep\n"), out);
 116         fputs(_(" -t, --time <time_t>      time to wake\n"), out);
 117         fputs(_(" -u, --utc                RTC uses UTC\n"), out);
 118         fputs(_(" -v, --verbose            verbose messages\n"), out);
 119
 120         fputs(USAGE_SEPARATOR, out);
 121         fprintf(out, USAGE_HELP_OPTIONS(26));
 122         fprintf(out, USAGE_MAN_TAIL("rtcwake(8)"));
 123         exit(EXIT_SUCCESS);
 124 }
 125
 126 static int is_wakeup_enabled(const char *devname)
 127 {
 128         char    buf[128], *s;
 129         FILE    *f;
 130         size_t  skip = 0;
 131
 132         if (startswith(devname, "/dev/"))
 133                 skip = 5;
 134         snprintf(buf, sizeof buf, SYS_WAKEUP_PATH_TEMPLATE, devname + skip);
 135         f = fopen(buf, "r");
 136         if (!f) {
 137                 warn(_("cannot open %s"), buf);
 138                 return 0;
 139         }
 140
 141         s = fgets(buf, sizeof buf, f);
 142         fclose(f);
 143         if (!s)
 144                 return 0;
 145         s = strchr(buf, '\n');
 146         if (!s)
 147                 return 0;
 148         *s = 0;
 149         /* wakeup events could be disabled or not supported */
 150         return strcmp(buf, "enabled") == 0;
 151 }
 152
 153 static int get_basetimes(struct rtcwake_control *ctl, int fd)
 154 {
 155         struct tm tm = { 0 };
 156         struct rtc_time rtc;
 157
 158         /* This process works in RTC time, except when working
 159          * with the system clock (which always uses UTC).
 160          */
 161         if (ctl->clock_mode == CM_UTC)
 162                 xsetenv("TZ", "UTC", 1);
 163         tzset();
 164         /* Read rtc and system clocks "at the same time", or as
 165          * precisely (+/- a second) as we can read them.
 166          */
 167         if (ioctl(fd, RTC_RD_TIME, &rtc) < 0) {
 168                 warn(_("read rtc time failed"));
 169                 return -1;
 170         }
 171
 172         ctl->sys_time = time(NULL);
 173         if (ctl->sys_time == (time_t)-1) {
 174                 warn(_("read system time failed"));
 175                 return -1;
 176         }
 177         /* Convert rtc_time to normal arithmetic-friendly form,
 178          * updating tm.tm_wday as used by asctime().
 179          */
 180         tm.tm_sec = rtc.tm_sec;
 181         tm.tm_min = rtc.tm_min;
 182         tm.tm_hour = rtc.tm_hour;
 183         tm.tm_mday = rtc.tm_mday;
 184         tm.tm_mon = rtc.tm_mon;
 185         tm.tm_year = rtc.tm_year;
 186         tm.tm_isdst = -1;  /* assume the system knows better than the RTC */
 187
 188         ctl->rtc_time = mktime(&tm);
 189         if (ctl->rtc_time == (time_t)-1) {
 190                 warn(_("convert rtc time failed"));
 191                 return -1;
 192         }
 193
 194         if (ctl->verbose) {
 195                 /* Unless the system uses UTC, either delta or tzone
 196                  * reflects a seconds offset from UTC.  The value can
 197                  * help sort out problems like bugs in your C library. */
 198                 char s[64];
 199                 printf("\tdelta   = %"PRId64"\n", (int64_t) ctl->sys_time - ctl->rtc_time);
 200                 printf("\ttzone   = %ld\n", timezone);
 201                 printf("\ttzname  = %s\n", tzname[daylight]);
 202                 gmtime_r(&ctl->sys_time, &tm);
 203                 printf("\tsystime = %"PRId64", (UTC) %s",
 204                                 (int64_t) ctl->sys_time, asctime_r(&tm, s));
 205                 gmtime_r(&ctl->rtc_time, &tm);
 206                 printf("\trtctime = %"PRId64", (UTC) %s",
 207                                 (int64_t) ctl->rtc_time, asctime_r(&tm, s));
 208         }
 209         return 0;
 210 }
 211
 212 static int setup_alarm(struct rtcwake_control *ctl, int fd, time_t *wakeup)
 213 {
 214         struct tm               tm;
 215         struct rtc_wkalrm       wake = { 0 };
 216
 217         /* The wakeup time is in POSIX time (more or less UTC).  Ideally
 218          * RTCs use that same time; but PCs can't do that if they need to
 219          * boot MS-Windows.  Messy...
 220          *
 221          * When clock_mode == CM_UTC this process's timezone is UTC, so
 222          * we'll pass a UTC date to the RTC.
 223          *
 224          * Else clock_mode == CM_LOCAL so the time given to the RTC will
 225          * instead use the local time zone. */
 226         localtime_r(wakeup, &tm);
 227         wake.time.tm_sec = tm.tm_sec;
 228         wake.time.tm_min = tm.tm_min;
 229         wake.time.tm_hour = tm.tm_hour;
 230         wake.time.tm_mday = tm.tm_mday;
 231         wake.time.tm_mon = tm.tm_mon;
 232         wake.time.tm_year = tm.tm_year;
 233         /* wday, yday, and isdst fields are unused */
 234         wake.time.tm_wday = -1;
 235         wake.time.tm_yday = -1;
 236         wake.time.tm_isdst = -1;
 237         wake.enabled = 1;
 238
 239         if (!ctl->dryrun && ioctl(fd, RTC_WKALM_SET, &wake) < 0) {
 240                 warn(_("set rtc wake alarm failed"));
 241                 return -1;
 242         }
 243         return 0;
 244 }
 245
 246 static char **get_sys_power_states(struct rtcwake_control *ctl)
 247 {
 248         int fd = -1;
 249
 250         if (!ctl->possible_modes) {
 251                 char buf[256] = { 0 };
 252                 ssize_t ss;
 253
 254                 fd = open(SYS_POWER_STATE_PATH, O_RDONLY);
 255                 if (fd < 0)
 256                         goto nothing;
 257                 ss = read(fd, &buf, sizeof(buf) - 1);
 258                 if (ss <= 0)
 259                         goto nothing;
 260                 buf[ss] = '\0';
 261                 ctl->possible_modes = strv_split(buf, " \n");
 262                 close(fd);
 263         }
 264         return ctl->possible_modes;
 265 nothing:
 266         if (fd >= 0)
 267                 close(fd);
 268         return NULL;
 269 }
 270
 271 static void wait_stdin(struct rtcwake_control *ctl)
 272 {
 273         struct pollfd fd[] = {
 274                 {.fd = STDIN_FILENO, .events = POLLIN}
 275         };
 276         int tries = 0;
 277
 278         while (tries < 8 && poll(fd, 1, 10) == 1) {
 279                 if (ctl->verbose)
 280                         warnx(_("discarding stdin"));
 281                 xusleep(250000);
 282                 tcflush(STDIN_FILENO, TCIFLUSH);
 283                 tries++;
 284         }
 285 }
 286
 287 static void suspend_system(struct rtcwake_control *ctl)
 288 {
 289         FILE    *f = fopen(SYS_POWER_STATE_PATH, "w");
 290
 291         if (!f) {
 292                 warn(_("cannot open %s"), SYS_POWER_STATE_PATH);
 293                 return;
 294         }
 295
 296         if (!ctl->dryrun) {
 297                 if (isatty(STDIN_FILENO))
 298                         wait_stdin(ctl);
 299                 fprintf(f, "%s\n", ctl->mode_str);
 300                 fflush(f);
 301         }
 302         /* this executes after wake from suspend */
 303         if (close_stream(f))
 304                 errx(EXIT_FAILURE, _("write error"));
 305 }
 306
 307 static int read_clock_mode(struct rtcwake_control *ctl)
 308 {
 309         FILE *fp;
 310         char linebuf[ADJTIME_ZONE_BUFSIZ];
 311
 312         fp = fopen(ctl->adjfile, "r");
 313         if (!fp)
 314                 return -1;
 315         /* skip two lines */
 316         if (skip_fline(fp) || skip_fline(fp)) {
 317                 fclose(fp);
 318                 return -1;
 319         }
 320         /* read third line */
 321         if (!fgets(linebuf, sizeof linebuf, fp)) {
 322                 fclose(fp);
 323                 return -1;
 324         }
 325
 326         if (strncmp(linebuf, "UTC", 3) == 0)
 327                 ctl->clock_mode = CM_UTC;
 328         else if (strncmp(linebuf, "LOCAL", 5) == 0)
 329                 ctl->clock_mode = CM_LOCAL;
 330         else if (ctl->verbose)
 331                 warnx(_("unexpected third line in: %s: %s"), ctl->adjfile, linebuf);
 332
 333         fclose(fp);
 334         return 0;
 335 }
 336
 337 static int print_alarm(struct rtcwake_control *ctl, int fd)
 338 {
 339         struct rtc_wkalrm wake;
 340         struct tm tm = { 0 };
 341         time_t alarm;
 342         char s[CTIME_BUFSIZ];
 343
 344         if (ioctl(fd, RTC_WKALM_RD, &wake) < 0) {
 345                 warn(_("read rtc alarm failed"));
 346                 return -1;
 347         }
 348
 349         if (wake.enabled != 1 || wake.time.tm_year == -1) {
 350                 printf(_("alarm: off\n"));
 351                 return 0;
 352         }
 353         tm.tm_sec = wake.time.tm_sec;
 354         tm.tm_min = wake.time.tm_min;
 355         tm.tm_hour = wake.time.tm_hour;
 356         tm.tm_mday = wake.time.tm_mday;
 357         tm.tm_mon = wake.time.tm_mon;
 358         tm.tm_year = wake.time.tm_year;
 359         tm.tm_isdst = -1;  /* assume the system knows better than the RTC */
 360
 361         alarm = mktime(&tm);
 362         if (alarm == (time_t)-1) {
 363                 warn(_("convert time failed"));
 364                 return -1;
 365         }
 366         /* 0 if both UTC, or expresses diff if RTC in local time */
 367         alarm += ctl->sys_time - ctl->rtc_time;
 368         ctime_r(&alarm, s);
 369         printf(_("alarm: on  %s"), s);
 370
 371         return 0;
 372 }
 373
 374 static int get_rtc_mode(struct rtcwake_control *ctl, const char *s)
 375 {
 376         size_t i;
 377         char **modes = get_sys_power_states(ctl), **m;
 378
 379         STRV_FOREACH(m, modes) {
 380                 if (strcmp(s, *m) == 0)
 381                         return SYSFS_MODE;
 382         }
 383
 384         for (i = 0; i < ARRAY_SIZE(rtcwake_mode_string); i++)
 385                 if (!strcmp(s, rtcwake_mode_string[i]))
 386                         return i;
 387
 388         return -EINVAL;
 389 }
 390
 391 static int open_dev_rtc(const char *devname)
 392 {
 393         int fd;
 394         char *devpath = NULL;
 395
 396         if (startswith(devname, "/dev"))
 397                 devpath = xstrdup(devname);
 398         else
 399                 xasprintf(&devpath, "/dev/%s", devname);
 400         fd = open(devpath, O_RDONLY | O_CLOEXEC);
 401         if (fd < 0)
 402                 err(EXIT_FAILURE, _("%s: unable to find device"), devpath);
 403         free(devpath);
 404         return fd;
 405 }
 406
 407 static void list_modes(struct rtcwake_control *ctl)
 408 {
 409         size_t i;
 410         char **modes = get_sys_power_states(ctl), **m;
 411
 412         if (!modes)
 413                 errx(EXIT_FAILURE, _("could not read: %s"), SYS_POWER_STATE_PATH);
 414
 415         STRV_FOREACH(m, modes)
 416                 printf("%s ", *m);
 417
 418         for (i = 0; i < ARRAY_SIZE(rtcwake_mode_string); i++)
 419                 printf("%s ", rtcwake_mode_string[i]);
 420         putchar('\n');
 421 }
 422
 423 int main(int argc, char **argv)
 424 {
 425         struct rtcwake_control ctl = {
 426                 .mode_str = "suspend",          /* default mode */
 427                 .adjfile = _PATH_ADJTIME,
 428                 .clock_mode = CM_AUTO
 429         };
 430         char *devname = DEFAULT_RTC_DEVICE;
 431         int suspend = SYSFS_MODE;
 432         int rc = EXIT_SUCCESS;
 433         int t;
 434         int fd;
 435         time_t alarm = 0, seconds = 0;
 436         enum {
 437                 OPT_DATE = CHAR_MAX + 1,
 438                 OPT_LIST
 439         };
 440         static const struct option long_options[] = {
 441                 { "adjfile",    required_argument,      NULL, 'A'      },
 442                 { "auto",       no_argument,            NULL, 'a'      },
 443                 { "dry-run",    no_argument,            NULL, 'n'      },
 444                 { "local",      no_argument,            NULL, 'l'      },
 445                 { "utc",        no_argument,            NULL, 'u'      },
 446                 { "verbose",    no_argument,            NULL, 'v'      },
 447                 { "version",    no_argument,            NULL, 'V'      },
 448                 { "help",       no_argument,            NULL, 'h'      },
 449                 { "mode",       required_argument,      NULL, 'm'      },
 450                 { "device",     required_argument,      NULL, 'd'      },
 451                 { "seconds",    required_argument,      NULL, 's'      },
 452                 { "time",       required_argument,      NULL, 't'      },
 453                 { "date",       required_argument,      NULL, OPT_DATE },
 454                 { "list-modes", no_argument,            NULL, OPT_LIST },
 455                 { NULL, 0, NULL, 0 }
 456         };
 457         static const ul_excl_t excl[] = {
 458                 { 'a', 'l', 'u' },
 459                 { 's', 't', OPT_DATE },
 460                 { 0 },
 461         };
 462         int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
 463
 464         setlocale(LC_ALL, "");
 465         bindtextdomain(PACKAGE, LOCALEDIR);
 466         textdomain(PACKAGE);
 467         close_stdout_atexit();
 468
 469         while ((t = getopt_long(argc, argv, "A:ahd:lm:ns:t:uVv",
 470                                         long_options, NULL)) != EOF) {
 471                 err_exclusive_options(t, long_options, excl, excl_st);
 472                 switch (t) {
 473                 case 'A':
 474                         /* for better compatibility with hwclock */
 475                         ctl.adjfile = optarg;
 476                         break;
 477                 case 'a':
 478                         ctl.clock_mode = CM_AUTO;
 479                         break;
 480                 case 'd':
 481                         devname = optarg;
 482                         break;
 483                 case 'l':
 484                         ctl.clock_mode = CM_LOCAL;
 485                         break;
 486
 487                 case OPT_LIST:
 488                         list_modes(&ctl);
 489                         return EXIT_SUCCESS;
 490
 491                 case 'm':
 492                         if ((suspend = get_rtc_mode(&ctl, optarg)) < 0)
 493                                 errx(EXIT_FAILURE, _("unrecognized suspend state '%s'"), optarg);
 494                         ctl.mode_str = optarg;
 495                         break;
 496                 case 'n':
 497                         ctl.dryrun = 1;
 498                         break;
 499                 case 's':
 500                         /* alarm time, seconds-to-sleep (relative) */
 501                         seconds = strtotime_or_err(optarg, _("invalid seconds argument"));
 502                         break;
 503                 case 't':
 504                         /* alarm time, time_t (absolute, seconds since epoch) */
 505                         alarm = strtotime_or_err(optarg, _("invalid time argument"));
 506                         break;
 507                 case OPT_DATE:
 508                 {       /* alarm time, see timestamp format from manual */
 509                         usec_t p;
 510                         if (parse_timestamp(optarg, &p) < 0)
 511                                 errx(EXIT_FAILURE, _("invalid time value \"%s\""), optarg);
 512                         alarm = (time_t) (p / 1000000);
 513                         break;
 514                 }
 515                 case 'u':
 516                         ctl.clock_mode = CM_UTC;
 517                         break;
 518                 case 'v':
 519                         ctl.verbose = 1;
 520                         break;
 521
 522                 case 'V':
 523                         print_version(EXIT_SUCCESS);
 524                 case 'h':
 525                         usage();
 526                 default:
 527                         errtryhelp(EXIT_FAILURE);
 528                 }
 529         }
 530
 531         if (ctl.clock_mode == CM_AUTO && read_clock_mode(&ctl) < 0) {
 532                 printf(_("%s: assuming RTC uses UTC ...\n"),  program_invocation_short_name);
 533                 ctl.clock_mode = CM_UTC;
 534         }
 535
 536         if (ctl.verbose)
 537                 printf("%s",  ctl.clock_mode == CM_UTC ? _("Using UTC time.\n") :
 538                                 _("Using local time.\n"));
 539
 540         if (!alarm && !seconds && suspend != DISABLE_MODE && suspend != SHOW_MODE)
 541                 errx(EXIT_FAILURE, _("must provide wake time (see --seconds, --time and --date options)"));
 542
 543         /* device must exist and (if we'll sleep) be wakeup-enabled */
 544         fd = open_dev_rtc(devname);
 545
 546         if (suspend != ON_MODE && suspend != NO_MODE && !is_wakeup_enabled(devname))
 547                 errx(EXIT_FAILURE, _("%s not enabled for wakeup events"), devname);
 548
 549         /* relative or absolute alarm time, normalized to time_t */
 550         if (get_basetimes(&ctl, fd) < 0)
 551                 exit(EXIT_FAILURE);
 552
 553         if (ctl.verbose)
 554                 printf(_("alarm %"PRId64", sys_time %"PRId64", "
 555                          "rtc_time %"PRId64", seconds %"PRIu64"\n"),
 556                                 (int64_t) alarm, (int64_t) ctl.sys_time,
 557                                 (int64_t) ctl.rtc_time,
 558                                 (int64_t) seconds);
 559
 560         if (suspend != DISABLE_MODE && suspend != SHOW_MODE) {
 561                 /* perform alarm setup when the show or disable modes are not set */
 562                 if (alarm) {
 563                         if (alarm < ctl.sys_time) {
 564                                 char s[CTIME_BUFSIZ];
 565
 566                                 ctime_r(&alarm, s);
 567                                 errx(EXIT_FAILURE, _("time doesn't go backward to %s"), s);
 568                         }
 569                         alarm -= ctl.sys_time - ctl.rtc_time;
 570                 } else
 571                         alarm = ctl.rtc_time + seconds + 1;
 572
 573                 if (setup_alarm(&ctl, fd, &alarm) < 0)
 574                         exit(EXIT_FAILURE);
 575
 576                 if (suspend == NO_MODE || suspend == ON_MODE) {
 577                         char s[CTIME_BUFSIZ];
 578
 579                         ctime_r(&alarm, s);
 580                         printf(_("%s: wakeup using %s at %s"),
 581                                 program_invocation_short_name, devname, s);
 582                 } else {
 583                         char s[CTIME_BUFSIZ];
 584
 585                         ctime_r(&alarm, s);
 586                         printf(_("%s: wakeup from \"%s\" using %s at %s"),
 587                                 program_invocation_short_name, ctl.mode_str, devname, s);
 588                 }
 589                 fflush(stdout);
 590                 xusleep(10 * 1000);
 591         }
 592
 593         switch (suspend) {
 594         case NO_MODE:
 595                 if (ctl.verbose)
 596                         printf(_("suspend mode: no; leaving\n"));
 597                 ctl.dryrun = 1; /* to skip disabling alarm at the end */
 598                 break;
 599         case OFF_MODE:
 600         {
 601                 char *arg[5];
 602                 int i = 0;
 603
 604                 if (!access(_PATH_SHUTDOWN, X_OK)) {
 605                         arg[i++] = _PATH_SHUTDOWN;
 606                         arg[i++] = "-h";
 607                         arg[i++] = "-P";
 608                         arg[i++] = "now";
 609                         arg[i]   = NULL;
 610                 } else if (!access(_PATH_POWEROFF, X_OK)) {
 611                         arg[i++] = _PATH_POWEROFF;
 612                         arg[i]   = NULL;
 613                 } else {
 614                         arg[i]   = NULL;
 615                 }
 616
 617                 if (arg[0]) {
 618                         if (ctl.verbose)
 619                                 printf(_("suspend mode: off; executing %s\n"),
 620                                                 arg[0]);
 621                         if (!ctl.dryrun) {
 622                                 execv(arg[0], arg);
 623                                 warn(_("failed to execute %s"), arg[0]);
 624                                 rc = EX_EXEC_ENOENT;
 625                         }
 626                 } else {
 627                         /* Failed to find shutdown command */
 628                         warn(_("failed to find shutdown command"));
 629                         rc = EX_EXEC_ENOENT;
 630                 }
 631                 break;
 632         }
 633         case ON_MODE:
 634         {
 635                 unsigned long data;
 636
 637                 if (ctl.verbose)
 638                         printf(_("suspend mode: on; reading rtc\n"));
 639                 if (!ctl.dryrun) {
 640                         do {
 641                                 t = read(fd, &data, sizeof data);
 642                                 if (t < 0) {
 643                                         warn(_("rtc read failed"));
 644                                         break;
 645                                 }
 646                                 if (ctl.verbose)
 647                                         printf("... %s: %03lx\n", devname, data);
 648                         } while (!(data & RTC_AF));
 649                 }
 650                 break;
 651         }
 652         case DISABLE_MODE:
 653                 /* just break, alarm gets disabled in the end */
 654                 if (ctl.verbose)
 655                         printf(_("suspend mode: disable; disabling alarm\n"));
 656                 break;
 657         case SHOW_MODE:
 658                 if (ctl.verbose)
 659                         printf(_("suspend mode: show; printing alarm info\n"));
 660                 if (print_alarm(&ctl, fd))
 661                         rc = EXIT_FAILURE;
 662                 ctl.dryrun = 1; /* don't really disable alarm in the end, just show */
 663                 break;
 664         default:
 665                 if (ctl.verbose)
 666                         printf(_("suspend mode: %s; suspending system\n"), ctl.mode_str);
 667                 sync();
 668                 suspend_system(&ctl);
 669         }
 670
 671         if (!ctl.dryrun) {
 672                 struct rtc_wkalrm wake;
 673
 674                 if (ioctl(fd, RTC_WKALM_RD, &wake) < 0) {
 675                         warn(_("read rtc alarm failed"));
 676                         rc = EXIT_FAILURE;
 677                 } else {
 678                         wake.enabled = 0;
 679                         if (ioctl(fd, RTC_WKALM_SET, &wake) < 0) {
 680                                 warn(_("disable rtc alarm interrupt failed"));
 681                                 rc = EXIT_FAILURE;
 682                         }
 683                 }
 684         }
 685
 686         close(fd);
 687         return rc;
 688 }