remind-rb 6.2.10.1

data/remind-v06.02.10/src/init.c

@@ -0,0 +1,1494 @@
+/***************************************************************/
+/*                                                             */
+/*  INIT.C                                                     */
+/*                                                             */
+/*  Initialize remind; perform certain tasks between           */
+/*  iterations in calendar mode; do certain checks after end   */
+/*  in normal mode.                                            */
+/*                                                             */
+/*  This file is part of REMIND.                               */
+/*  Copyright (C) 1992-2026 by Dianne Skoll                    */
+/*  SPDX-License-Identifier: GPL-2.0-only                      */
+/*                                                             */
+/***************************************************************/
+
+#include "version.h"
+#include "config.h"
+
+#define L_IN_INIT 1
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <poll.h>
+#include <pwd.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <termios.h>
+
+#ifdef HAVE_INITGROUPS
+#include <grp.h>
+#endif
+
+#ifdef HAVE_SYS_TERMIOS_H
+#ifdef __sun
+#include <sys/termios.h>
+#endif
+#endif
+
+
+#include "types.h"
+#include "globals.h"
+#include "protos.h"
+#include "err.h"
+
+static int should_guess_terminal_background = 1;
+
+static void guess_terminal_background(int *r, int *g, int *b);
+static int tty_init(int fd);
+static void tty_raw(int fd);
+static void tty_reset(int fd);
+
+static int GetInitDateFromTrigger(char const *s, int *y, int *m, int *d, int *systime);
+static void SetTodayFromCmdlineArgs(int dse, int y, int m, int d);
+
+static void ProcessLongOption(char const *arg);
+/***************************************************************
+ *
+ *  Command line options recognized:
+ *
+ *  -n       = Output next trigger date of each reminder in
+ *             simple calendar format.
+ *  -r       = Disallow RUN mode
+ *  -c[n]    = Produce a calendar for n months (default = 1)
+ *  -@[n,m,b]= Colorize n=0 VT100 n=1 85 n=2 True m=0 dark terminal m=1 light
+ *             b=0 ignore SHADE b=1 respect SHADE
+ *  -w[n,n,n] = Specify output device width, padding and spacing
+ *  -s[n]    = Produce calendar in "simple calendar" format
+ *  -p[n]    = Produce calendar in format compatible with rem2ps
+ *  -l       = Prefix simple calendar lines with a comment containing
+ *             their trigger line numbers and filenames
+ *  -v       = Verbose mode
+ *  -o       = Ignore ONCE directives
+ *  -a       = Don't issue timed reminders which will be queued
+ *  -q       = Don't queue timed reminders
+ *  -t       = Trigger all reminders (infinite delta)
+ *  -h       = Hush mode
+ *  -f       = Do not fork
+ *  -dchars  = Debugging mode:  Chars are:
+ *             f = Trace file openings
+ *             e = Echo input lines
+ *             x = Display expression evaluation
+ *             t = Display trigger dates
+ *             v = Dump variables at end
+ *             l = Display entire line in error messages
+ *             s = Display expression-parsing stack usage before exit
+ *  -e       = Send messages normally sent to stderr to stdout instead
+ *  -z[n]    = Daemon mode waking up every n (def 1) minutes.
+ *  -bn      = Time format for cal (0, 1, or 2)
+ *  -xn      = Max. number of iterations for SATISFY
+ *  -uname   = Run as user 'name' - only valid when run by root.  If run
+ *             by non-root, changes environment but not effective uid.
+ *  -kcmd    = Run 'cmd' for MSG-type reminders instead of printing to stdout
+ *  -iVAR=EXPR = Initialize and preserve VAR.
+ *  -m       = Start calendar with Monday instead of Sunday.
+ *  -j[n]    = Purge all junk from reminder files (n = INCLUDE depth)
+ *  A minus sign alone indicates to take input from stdin
+ *
+ **************************************************************/
+
+/* For parsing an integer */
+#define PARSENUM(var, s)   \
+do {                       \
+  var = 0;                 \
+  while (isdigit(*(s))) {  \
+      var *= 10;           \
+      var += *(s) - '0';   \
+      s++;                 \
+  }} while(0)
+
+static void ChgUser(char const *u);
+static void InitializeVar(char const *str);
+
+static char const *BadDate = "Illegal date on command line\n";
+static void AddTrustedUser(char const *username);
+
+static DynamicBuffer default_filename_buf;
+
+static void
+InitCalWidthAndFormWidth(int fd)
+{
+    struct winsize w;
+
+    if (!isatty(fd)) {
+        return;
+    }
+    if (ioctl(fd, TIOCGWINSZ, &w) == 0) {
+        CalWidth = w.ws_col;
+        if (CalWidth < 71) {
+            CalWidth = 71;
+        }
+        FormWidth = w.ws_col - 8;
+        if (FormWidth < 20) FormWidth = 20;
+        if (FormWidth > 500) FormWidth = 500;
+    }
+}
+
+/***************************************************************/
+/*                                                             */
+/*  DefaultFilename                                            */
+/*                                                             */
+/*  If we're invoked as "rem" rather than "remind", use a      */
+/*  default filename.  Use $DOTREMINDERS or $HOME/.reminders   */
+/*                                                             */
+/***************************************************************/
+static char const *DefaultFilename(void)
+{
+    char const *s;
+
+    DBufInit(&default_filename_buf);
+
+    s = getenv("DOTREMINDERS");
+    if (s) {
+        return s;
+    }
+
+    s = getenv("HOME");
+    if (!s) {
+        fprintf(ErrFp, "HOME environment variable not set.  Unable to determine reminder file.\n");
+        exit(EXIT_FAILURE);
+    }
+    DBufPuts(&default_filename_buf, s);
+    DBufPuts(&default_filename_buf, "/.reminders");
+    return DBufValue(&default_filename_buf);
+}
+
+/***************************************************************/
+/*                                                             */
+/*  InitRemind                                                 */
+/*                                                             */
+/*  Initialize the system - called only once at beginning!     */
+/*                                                             */
+/***************************************************************/
+void InitRemind(int argc, char const *argv[])
+{
+    char const *arg;
+    int i;
+    int y, m, d, rep;
+    Token tok;
+    int InvokedAsRem = 0;
+    char const *s;
+    int weeks;
+    int x;
+    int dse;
+    int ttyfd;
+    int r;
+
+    /* Make sure remind is not installed set-uid or set-gid */
+    if (getgid() != getegid() ||
+        getuid() != geteuid()) {
+        fprintf(ErrFp, "\nRemind should not be installed set-uid or set-gid.\nCHECK YOUR SYSTEM SECURITY.\n");
+        exit(EXIT_FAILURE);
+    }
+
+    dse = NO_DATE;
+
+    /* Initialize local time zone */
+    LocalTimeZone = getenv("TZ");
+    if (LocalTimeZone) {
+        LocalTimeZone = strdup(LocalTimeZone);
+        if (!LocalTimeZone) {
+            fprintf(stderr, "Out of memory!\n");
+            exit(1);
+        }
+    }
+
+    /* Initialize variable hash table */
+    InitVars();
+
+    /* Initialize user-defined functions hash table */
+    InitUserFunctions();
+
+    InitTranslationTable();
+    InitFiles();
+
+    /* If stdout is a terminal, initialize $FormWidth to terminal width-8,
+       but clamp to [20, 500] */
+    InitCalWidthAndFormWidth(STDOUT_FILENO);
+
+    /* Initialize global dynamic buffers */
+    DBufInit(&Banner);
+    DBufInit(&LineBuffer);
+    DBufInit(&ExprBuf);
+
+    DBufPuts(&Banner, "Reminders for %w, %d%s %m, %y%o:");
+
+    PurgeFP = NULL;
+
+    InitDedupeTable();
+
+    y = NO_YR;
+    m = NO_MON;
+    d = NO_DAY;
+    rep = NO_REP;
+
+    RealToday = SystemDate(&CurYear, &CurMon, &CurDay);
+    if (RealToday < 0) {
+        fprintf(ErrFp, GetErr(M_BAD_SYS_DATE), BASE);
+        fprintf(ErrFp, "\n");
+        exit(EXIT_FAILURE);
+    }
+    LocalSysTime = SystemTime(0);
+    DSEToday = RealToday;
+    LocalDSEToday = DSEToday;
+    FromDSE(DSEToday, &CurYear, &CurMon, &CurDay);
+
+    /* Initialize Latitude and Longitude */
+    set_components_from_lat_and_long();
+
+    /* See if we were invoked as "rem" rather than "remind" */
+    if (argv[0]) {
+        s = strrchr(argv[0], '/');
+        if (!s) {
+            s = argv[0];
+        } else {
+            s++;
+        }
+        if (!strcmp(s, "rem")) {
+            InvokedAsRem = 1;
+        }
+    } else {
+        fprintf(ErrFp, "Invoked with a NULL argv[0]; bailing because that's just plain bizarre.\n");
+        exit(EXIT_FAILURE);
+    }
+
+    /* Parse the command-line options */
+    i = 1;
+
+    while (i < argc) {
+        arg = argv[i];
+        if (*arg != '-') break; /* Exit the loop if it's not an option */
+        i++;
+        arg++;
+        if (!*arg) {
+            UseStdin = 1;
+            i--;
+            break;
+        }
+        while (*arg) {
+            switch(*arg++) {
+            case '+':
+                AddTrustedUser(arg);
+                while(*arg) arg++;
+                break;
+
+            case '-':
+                ProcessLongOption(arg);
+                while(*arg) arg++;
+                break;
+
+            case '@':
+                UseVTColors = 1;
+                if (*arg) {
+                    PARSENUM(x, arg);
+                    if (x == 1) {
+                        Use256Colors = 1;
+                    } else if (x == 2) {
+                        UseTrueColors = 1;
+                    } else if (x != 0) {
+                        fprintf(ErrFp, "%s: -@n,m,b: n must be 0, 1 or 2 (assuming 0)\n",
+                                argv[0]);
+                    }
+                }
+                if (*arg == ',') {
+                    arg++;
+                    if (*arg != ',') {
+                        if (*arg == 't') {
+                            arg++;
+                            should_guess_terminal_background = 2;
+                        } else {
+                            PARSENUM(x, arg);
+                            if (x == 0) {
+                                should_guess_terminal_background = 0;
+                                TerminalBackground = TERMINAL_BACKGROUND_DARK;
+                            } else if (x == 1) {
+                                should_guess_terminal_background = 0;
+                                TerminalBackground = TERMINAL_BACKGROUND_LIGHT;
+                            } else if (x == 2) {
+                                should_guess_terminal_background = 0;
+                                TerminalBackground = TERMINAL_BACKGROUND_UNKNOWN;
+                            } else {
+                                fprintf(ErrFp, "%s: -@n,m,b: m must be t, 0, 1 or 2 (assuming 2)\n",
+                                        argv[0]);
+                            }
+                        }
+                    }
+                }
+                if (*arg == ',') {
+                    arg++;
+                    PARSENUM(x, arg);
+                    if (x != 0 && x != 1) {
+                        fprintf(ErrFp, "%s: -@n,m,b: b must be 0 or 1 (assuming 0)\n",
+                                argv[0]);
+                        x = 0;
+                    }
+                    UseBGVTColors = x;
+                }
+                break;
+
+            case 'j':
+            case 'J':
+                PurgeMode = 1;
+                if (*arg) {
+                    PARSENUM(PurgeIncludeDepth, arg);
+                }
+                break;
+            case 'i':
+            case 'I':
+                InitializeVar(arg);
+                while(*arg) arg++;
+                break;
+
+            case 'n':
+            case 'N':
+                NextMode = 1;
+                DontQueue = 1;
+                Daemon = 0;
+                IgnoreOnce = 1;
+                break;
+
+            case 'r':
+            case 'R':
+                RunDisabled = RUN_CMDLINE;
+                break;
+
+            case 'm':
+            case 'M':
+                MondayFirst = 1;
+                break;
+
+            case 'o':
+            case 'O':
+                IgnoreOnce = 1;
+                break;
+
+            case 'y':
+            case 'Y':
+                SynthesizeTags = 1;
+                break;
+
+            case 't':
+            case 'T':
+                if (*arg == 'T' || *arg == 't') {
+                    arg++;
+                    if (!*arg) {
+                        DefaultTDelta = 5;
+                    } else {
+                        PARSENUM(DefaultTDelta, arg);
+                        if (DefaultTDelta < 0) {
+                            DefaultTDelta = 0;
+                        } else if (DefaultTDelta > MINUTES_PER_DAY) {
+                            DefaultTDelta = MINUTES_PER_DAY;
+                        }
+                    }
+                } else if (!*arg) {
+                    InfiniteDelta = 1;
+                } else {
+                    if (*arg == 'z') {
+                        DeltaOverride = -1;
+                        arg++;
+                    } else {
+                        PARSENUM(DeltaOverride, arg);
+                        if (DeltaOverride < 0) {
+                            DeltaOverride = 0;
+                        }
+                    }
+                }
+                break;
+            case 'e':
+            case 'E':
+                ErrFp = stdout;
+                break;
+
+            case 'h':
+            case 'H':
+                Hush = 1;
+                break;
+
+            case 'g':
+            case 'G':
+                SortByDate = SORT_ASCEND;
+                SortByTime = SORT_ASCEND;
+                SortByPrio = SORT_ASCEND;
+                UntimedBeforeTimed = 0;
+                if (*arg) {
+                    if (*arg == 'D' || *arg == 'd')
+                        SortByDate = SORT_DESCEND;
+                    arg++;
+                }
+                if (*arg) {
+                    if (*arg == 'D' || *arg == 'd')
+                        SortByTime = SORT_DESCEND;
+                    arg++;
+                }
+                if (*arg) {
+                    if (*arg == 'D' || *arg == 'd')
+                        SortByPrio = SORT_DESCEND;
+                    arg++;
+                }
+                if (*arg) {
+                    if (*arg == 'D' || *arg == 'd')
+                        UntimedBeforeTimed = 1;
+                    arg++;
+                }
+                break;
+
+            case 'u':
+            case 'U':
+                if (*arg == '+') {
+                    ChgUser(arg+1);
+                } else {
+                    RunDisabled = RUN_CMDLINE;
+                    ChgUser(arg);
+                }
+                while (*arg) arg++;
+                break;
+            case 'z':
+            case 'Z':
+                DontFork = 1;
+                if (*arg == 'j' || *arg == 'J') {
+                    while (*arg) arg++;
+                    Daemon = -1;
+                    DaemonJSON = 1;
+                } else if (*arg == '0') {
+                    PARSENUM(Daemon, arg);
+                    if (Daemon == 0) Daemon = -1;
+                    else if (Daemon < 1) Daemon = 1;
+                    else if (Daemon > 60) Daemon = 60;
+                } else {
+                    PARSENUM(Daemon, arg);
+                    if (Daemon<1) Daemon=1;
+                    else if (Daemon>60) Daemon=60;
+                }
+                break;
+
+            case 'a':
+            case 'A':
+                DontIssueAts++;
+                break;
+
+            case 'q':
+            case 'Q':
+                DontQueue = 1;
+                break;
+
+            case 'f':
+            case 'F':
+                DontFork = 1;
+                break;
+            case 'c':
+            case 'C':
+                IgnoreOnce = 1;
+                DoCalendar = 1;
+                weeks = 0;
+                /* Parse the flags */
+                while(*arg) {
+                    if (*arg == 'a' ||
+                        *arg == 'A') {
+                        DoSimpleCalDelta = 1;
+                        arg++;
+                        continue;
+                    }
+                    if (*arg == '+') {
+                        weeks = 1;
+                        arg++;
+                        continue;
+                    }
+                    if (*arg == 'l' || *arg == 'L') {
+                        UseVTChars = 1;
+                        arg++;
+                        continue;
+                    }
+                    if (*arg == 'u' || *arg == 'U') {
+                        UseUTF8Chars = 1;
+                        arg++;
+                        continue;
+                    }
+                    if (*arg == 'z' || *arg == 'Z') {
+                        TerminalHyperlinks = 1;
+                        arg++;
+                        continue;
+                    }
+                    if (*arg == 'c' || *arg == 'C') {
+                        UseVTColors = 1;
+                        arg++;
+                        continue;
+                    }
+                    break;
+                }
+                if (weeks) {
+                    CalType = "weekly";
+                    PARSENUM(CalWeeks, arg);
+                    if (!CalWeeks) CalWeeks = 1;
+                } else {
+                    CalType = "monthly";
+                    PARSENUM(CalMonths, arg);
+                    if (!CalMonths) CalMonths = 1;
+                }
+                break;
+
+            case 's':
+            case 'S':
+                DoSimpleCalendar = 1;
+                IgnoreOnce = 1;
+                weeks = 0;
+                while(*arg) {
+                    if (*arg == 'a' || *arg == 'A') {
+                        DoSimpleCalDelta = 1;
+                        arg++;
+                        continue;
+                    }
+                    if (*arg == '+') {
+                        arg++;
+                        weeks = 1;
+                        continue;
+                    }
+                    break;
+                }
+                if (weeks) {
+                    CalType = "weekly";
+                    PARSENUM(CalWeeks, arg);
+                    if (!CalWeeks) CalWeeks = 1;
+                } else {
+                    CalType = "monthly";
+                    PARSENUM(CalMonths, arg);
+                    if (!CalMonths) CalMonths = 1;
+                }
+                break;
+
+            case 'p':
+            case 'P':
+                DoSimpleCalendar = 1;
+                IgnoreOnce = 1;
+                PsCal = PSCAL_LEVEL1;
+                weeks = 0;
+                while (*arg == 'a' || *arg == 'A' ||
+                       *arg == 'q' || *arg == 'Q' ||
+                       *arg == '+' ||
+                       *arg == 'p' || *arg == 'P') {
+                    if (*arg == '+') {
+                        weeks = 1;
+                    } else if (*arg == 'a' || *arg == 'A') {
+                        DoSimpleCalDelta = 1;
+                    } else if (*arg == 'p' || *arg == 'P') {
+                        /* JSON interchange formats always include
+                           file and line number info */
+                        DoPrefixLineNo = 1;
+                        if (PsCal == PSCAL_LEVEL1) {
+                            PsCal = PSCAL_LEVEL2;
+                        } else {
+                            PsCal = PSCAL_LEVEL3;
+                        }
+                    } else if (*arg == 'q' || *arg == 'Q') {
+                        DontSuppressQuoteMarkers = 1;
+                    }
+                    arg++;
+                }
+                if (weeks) {
+                    CalType = "weekly";
+                    PARSENUM(CalWeeks, arg);
+                    if (!CalWeeks) CalWeeks = 1;
+                    PsCal = PSCAL_LEVEL3;
+                } else {
+                    CalType = "monthly";
+                    PARSENUM(CalMonths, arg);
+                    if (!CalMonths) CalMonths = 1;
+                }
+                break;
+
+            case 'l':
+            case 'L':
+                DoPrefixLineNo = 1;
+                break;
+
+            case 'w':
+            case 'W':
+                if (*arg != ',') {
+                    if (*arg == 't') {
+                        arg++;
+                        /* -wt means get width from /dev/tty */
+                        ttyfd = open("/dev/tty", O_RDONLY);
+                        if (ttyfd < 0) {
+                            fprintf(ErrFp, "%s: `-wt': Cannot open /dev/tty: %s\n",
+                                    argv[0], strerror(errno));
+                        } else {
+                            InitCalWidthAndFormWidth(ttyfd);
+                            close(ttyfd);
+                        }
+                    } else {
+                        PARSENUM(CalWidth, arg);
+                        if (CalWidth != 0 && CalWidth < 71) CalWidth = 71;
+                        if (CalWidth == 0) {
+                            /* Cal width of 0 means obtain from stdout */
+                            if (isatty(STDOUT_FILENO)) {
+                                InitCalWidthAndFormWidth(STDOUT_FILENO);
+                            } else {
+                                CalWidth = 80;
+                            }
+                        }
+                        FormWidth = CalWidth - 8;
+                        if (FormWidth < 20) FormWidth = 20;
+                        if (FormWidth > 500) FormWidth = 500;
+                    }
+                }
+                if (*arg == ',') {
+                    arg++;
+                    if (*arg != ',') {
+                        PARSENUM(CalLines, arg);
+                        if (CalLines > 20) CalLines = 20;
+                    }
+                    if (*arg == ',') {
+                        arg++;
+                        if (*arg != ',') {
+                            PARSENUM(CalPad, arg);
+                            if (CalPad > 20) CalPad = 20;
+                        }
+                        if (*arg == ',') {
+                            arg++;
+                            PARSENUM(CalSepLine, arg);
+                            if (CalSepLine) {
+                                CalSepLine = 1;
+                            }
+                        }
+                    }
+                }
+                break;
+
+            case 'd':
+            case 'D':
+                while (*arg) {
+                    switch(*arg++) {
+                    case 'p': case 'P': DebugFlag |= DB_PUSHPOP;     break;
+                    case 's': case 'S': DebugFlag |= DB_PARSE_EXPR;  break;
+                    case 'h': case 'H': DebugFlag |= DB_HASHSTATS;   break;
+                    case 'e': case 'E': DebugFlag |= DB_ECHO_LINE;   break;
+                    case 'x': case 'X': DebugFlag |= DB_PRTEXPR;     break;
+                    case 't': case 'T': DebugFlag |= DB_PRTTRIG;     break;
+                    case 'v': case 'V': DebugFlag |= DB_DUMP_VARS;   break;
+                    case 'l': case 'L': DebugFlag |= DB_PRTLINE;     break;
+                    case 'f': case 'F': DebugFlag |= DB_TRACE_FILES; break;
+                    case 'q': case 'Q': DebugFlag |= DB_TRANSLATE;   break;
+                    case 'n': case 'N': DebugFlag |= DB_NONCONST;    break;
+                    case 'u': case 'U': DebugFlag |= DB_UNUSED_VARS; break;
+                    case 'z': case 'Z': DebugFlag |= DB_SWITCH_ZONE; break;
+                    default:
+                        fprintf(ErrFp, GetErr(M_BAD_DB_FLAG), *(arg-1));
+                        fprintf(ErrFp, "\n");
+                    }
+                }
+                break;
+
+            case 'v':
+            case 'V':
+                DebugFlag |= DB_PRTLINE;
+                ShowAllErrors = 1;
+                break;
+
+            case 'b':
+            case 'B':
+                PARSENUM(ScFormat, arg);
+                if (ScFormat<0 || ScFormat>2) ScFormat=SC_AMPM;
+                break;
+
+            case 'x':
+            case 'X':
+                PARSENUM(MaxSatIter, arg);
+                if (MaxSatIter < 10) MaxSatIter=10;
+                break;
+
+            case 'k':
+            case 'K':
+                if (*arg == ':') {
+                    arg++;
+                    QueuedMsgCommand = arg;
+                } else {
+                    MsgCommand = arg;
+                }
+                while (*arg) arg++;  /* Chew up remaining chars in this arg */
+                break;
+
+            default:
+                fprintf(ErrFp, GetErr(M_BAD_OPTION), *(arg-1));
+                fprintf(ErrFp, "\n");
+            }
+
+        }
+    }
+
+    /* Get the filename. */
+    if (!InvokedAsRem) {
+        if (i >= argc) {
+            Usage();
+            exit(EXIT_FAILURE);
+        }
+        InitialFile = argv[i++];
+    } else {
+        InitialFile = DefaultFilename();
+    }
+
+    /* Get the date, if any */
+    if (i < argc) {
+        while (i < argc) {
+            arg = argv[i++];
+            /* If it begins with '@' then it's a trigger spec */
+            if (*arg == '@') {
+                SetTodayFromCmdlineArgs(dse, y, m, d);
+                r = GetInitDateFromTrigger(arg+1, &y, &m, &d, &SysTime);
+                if (r == OK) {
+                    dse = NO_DATE; /* Date is in y/m/d */
+                    if (SysTime != -1) {
+                        DontQueue = 1;
+                        Daemon = 0;
+                        LocalSysTime = SysTime;
+                    }
+                } else {
+                    fprintf(stderr, "Could not evaluate command-line trigger: %s\n", GetErr(r));
+                    exit(1);
+                }
+                continue;
+            }
+            FindToken(arg, &tok);
+            switch (tok.type) {
+            case T_Time:
+                if (SysTime != -1) Usage();
+                else {
+                    SysTime = (long) tok.val * 60L;
+                    LocalSysTime = SysTime;
+                    DontQueue = 1;
+                    Daemon = 0;
+                }
+                break;
+
+            case T_DateTime:
+                if (SysTime != -1) Usage();
+                if (m != NO_MON || d != NO_DAY || y != NO_YR || dse != NO_DATE) Usage();
+                SysTime = (tok.val % MINUTES_PER_DAY) * 60;
+                LocalSysTime = SysTime;
+                DontQueue = 1;
+                Daemon = 0;
+                dse = tok.val / MINUTES_PER_DAY;
+                break;
+
+            case T_Date:
+                if (m != NO_MON || d != NO_DAY || y != NO_YR || dse != NO_DATE) Usage();
+                dse = tok.val;
+                break;
+
+            case T_Month:
+                if (m != NO_MON || dse != NO_DATE) Usage();
+                else m = tok.val;
+                break;
+
+            case T_Day:
+                if (d != NO_DAY || dse != NO_DATE) Usage();
+                else d = tok.val;
+                break;
+
+            case T_Year:
+                if (y != NO_YR || dse != NO_DATE) Usage();
+                else y = tok.val;
+                break;
+
+            case T_Rep:
+                if (rep != NO_REP) Usage();
+                else rep = tok.val;
+                break;
+
+            default:
+                if (tok.type == T_Illegal && tok.val < 0) {
+                    fprintf(ErrFp, "%s: `%s'\n", GetErr(-tok.val), arg);
+                    Usage();
+                }
+                Usage();
+            }
+        }
+
+        if (rep > 0) {
+            Iterations = rep;
+            OrigIterations = rep;
+            IgnoreOnce = 1;
+            DontQueue = 1;
+            Daemon = 0;
+        }
+
+        SetTodayFromCmdlineArgs(dse, y, m, d);
+    }
+
+    /* JSON mode turns off sorting */
+    if (JSONMode) {
+        SortByTime = SORT_NONE;
+        SortByDate = SORT_NONE;
+        SortByPrio = SORT_NONE;
+        /* Make sure we don't blat errors to stdout! */
+        ErrFp = stderr;
+    }
+
+    /* Figure out the offset from UTC */
+    if (CalculateUTC) {
+        (void) CalcMinsFromUTC(DSEToday, MinutesPastMidnight(0),
+                               &MinsFromUTC, NULL);
+    }
+
+    /* If stdout is a tty, enable terminal hyperlinks by default */
+    if (TerminalHyperlinks == -1) {
+        if (isatty(STDOUT_FILENO)) {
+            TerminalHyperlinks = 1;
+        } else {
+            TerminalHyperlinks = 0;
+        }
+    }
+}
+
+/***************************************************************/
+/*                                                             */
+/*  Usage                                                      */
+/*                                                             */
+/*  Print the usage info.                                      */
+/*                                                             */
+/***************************************************************/
+#ifndef L_USAGE_OVERRIDE
+void Usage(void)
+{
+    fprintf(ErrFp, "\nREMIND %s Copyright (C) 1992-2026 Dianne Skoll\n", VERSION);
+#ifdef BETA
+    fprintf(ErrFp, ">>>> BETA VERSION <<<<\n");
+#endif
+    fprintf(ErrFp, "Usage: remind [options] filename [date] [time] [*rep]\n");
+    fprintf(ErrFp, "Options:\n");
+    fprintf(ErrFp, " -n     Output next occurrence of reminders in simple format\n");
+    fprintf(ErrFp, " -r     Disable RUN directives\n");
+    fprintf(ErrFp, " -@[n,m,b] Colorize COLOR/SHADE reminders\n");
+    fprintf(ErrFp, " -c[a][n] Produce a calendar for n (default 1) months\n");
+    fprintf(ErrFp, " -c[a]+[n] Produce a calendar for n (default 1) weeks\n");
+    fprintf(ErrFp, " -w[n[,p[,s]]]  Specify width, padding and spacing of calendar\n");
+    fprintf(ErrFp, " -s[a][+][n] Produce `simple calendar' for n (1) months (weeks)\n");
+    fprintf(ErrFp, " -p[a][n] Same as -s, but input compatible with rem2ps\n");
+    fprintf(ErrFp, " -l     Prefix each simple calendar line with line number and filename comment\n");
+    fprintf(ErrFp, " -v     Verbose mode\n");
+    fprintf(ErrFp, " -o     Ignore ONCE directives\n");
+    fprintf(ErrFp, " -t[n]  Trigger all future (or those within `n' days)\n");
+    fprintf(ErrFp, " -h     `Hush' mode - be very quiet\n");
+    fprintf(ErrFp, " -a     Don't trigger timed reminders immediately - just queue them\n");
+    fprintf(ErrFp, " -q     Don't queue timed reminders\n");
+    fprintf(ErrFp, " -f     Trigger timed reminders by staying in foreground\n");
+    fprintf(ErrFp, " -z[n]  Enter daemon mode, waking every n (1) minutes.\n");
+    fprintf(ErrFp, " -d...  Debug: See man page for details\n");
+    fprintf(ErrFp, " -e     Divert messages normally sent to stderr to stdout\n");
+    fprintf(ErrFp, " -b[n]  Time format for cal: 0=am/pm, 1=24hr, 2=none\n");
+    fprintf(ErrFp, " -x[n]  Iteration limit for SATISFY clause (def=1000)\n");
+    fprintf(ErrFp, " -kcmd  Run `cmd' for MSG-type reminders\n");
+    fprintf(ErrFp, " -g[dddd] Sort reminders by date, time, priority, and 'timedness'\n");
+    fprintf(ErrFp, " -ivar=val Initialize var to val and preserve var\n");
+    fprintf(ErrFp, " -m     Start calendar with Monday rather than Sunday\n");
+    fprintf(ErrFp, " -y     Synthesize tags for tagless reminders\n");
+    fprintf(ErrFp, " -j[n]  Run in 'purge' mode.  [n = INCLUDE depth]\n");
+    fprintf(ErrFp, "\nLong Options:\n");
+    fprintf(ErrFp, " --version                Print Remind version\n");
+    fprintf(ErrFp, " --hide-completed-todos   Don't show completed todos on calendar\n");
+    fprintf(ErrFp, " --only-todos             Only issue TODO reminders\n");
+    fprintf(ErrFp, " --only-events            Do not issue TODO reminders\n");
+    fprintf(ErrFp, " --json                   Use JSON output instead of plain-text\n");
+    fprintf(ErrFp, " --max-execution-time=n   Limit execution time to n seconds\n");
+    fprintf(ErrFp, " --max-expr-complexity=n  Limit expression evaluation to n nodes per line\n");
+    fprintf(ErrFp, " --print-config-cmd       Print ./configure cmd used to build Remind\n");
+    fprintf(ErrFp, " --print-errs             Print all possible error messages\n");
+    fprintf(ErrFp, " --print-tokens           Print all possible Remind tokens\n");
+    fprintf(ErrFp, "\nRemind home page: %s\n", PACKAGE_URL);
+    exit(EXIT_FAILURE);
+}
+#endif /* L_USAGE_OVERRIDE */
+/***************************************************************/
+/*                                                             */
+/*  ChgUser                                                    */
+/*                                                             */
+/*  Run as a specified user.  Can only be used if Remind is    */
+/*  started by root.  This changes the real and effective uid, */
+/*  the real and effective gid, and sets the HOME, SHELL and   */
+/*  USER environment variables.                                */
+/*                                                             */
+/***************************************************************/
+static void ChgUser(char const *user)
+{
+    uid_t myeuid;
+
+    struct passwd *pwent;
+    static char *home;
+    static char *shell;
+    static char *username;
+    static char *logname;
+
+    myeuid = geteuid();
+
+    pwent = getpwnam(user);
+
+    if (!pwent) {
+        fprintf(ErrFp, GetErr(M_BAD_USER), user);
+        fprintf(ErrFp, "\n");
+        exit(EXIT_FAILURE);
+    }
+
+    if (!myeuid) {
+        /* Started as root, so drop privileges */
+#ifdef HAVE_INITGROUPS
+        if (initgroups(pwent->pw_name, pwent->pw_gid) < 0) {
+            fprintf(ErrFp, GetErr(M_NO_CHG_GID), pwent->pw_gid);
+            fprintf(ErrFp, "\n");
+            exit(EXIT_FAILURE);
+        };
+#endif
+        if (setgid(pwent->pw_gid) < 0) {
+            fprintf(ErrFp, GetErr(M_NO_CHG_GID), pwent->pw_gid);
+            fprintf(ErrFp, "\n");
+            exit(EXIT_FAILURE);
+        }
+
+        if (setuid(pwent->pw_uid) < 0) {
+            fprintf(ErrFp, GetErr(M_NO_CHG_UID), pwent->pw_uid);
+            fprintf(ErrFp, "\n");
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    home = malloc(strlen(pwent->pw_dir) + 6);
+    if (!home) {
+        fprintf(ErrFp, "%s", GetErr(M_NOMEM_ENV));
+        fprintf(ErrFp, "\n");
+        exit(EXIT_FAILURE);
+    }
+    sprintf(home, "HOME=%s", pwent->pw_dir);
+    putenv(home);
+
+    shell = malloc(strlen(pwent->pw_shell) + 7);
+    if (!shell) {
+        fprintf(ErrFp, "%s", GetErr(M_NOMEM_ENV));
+        fprintf(ErrFp, "\n");
+        exit(EXIT_FAILURE);
+    }
+    sprintf(shell, "SHELL=%s", pwent->pw_shell);
+    putenv(shell);
+
+    if (pwent->pw_uid) {
+        username = malloc(strlen(pwent->pw_name) + 6);
+        if (!username) {
+            fprintf(ErrFp, "%s", GetErr(M_NOMEM_ENV));
+            fprintf(ErrFp, "\n");
+            exit(EXIT_FAILURE);
+        }
+        sprintf(username, "USER=%s", pwent->pw_name);
+        putenv(username);
+        logname= malloc(strlen(pwent->pw_name) + 9);
+        if (!logname) {
+            fprintf(ErrFp, "%s", GetErr(M_NOMEM_ENV));
+            fprintf(ErrFp, "\n");
+            exit(EXIT_FAILURE);
+        }
+        sprintf(logname, "LOGNAME=%s", pwent->pw_name);
+        putenv(logname);
+    }
+}
+
+static void
+DefineFunction(char const *str)
+{
+    Parser p;
+    int r;
+
+    CreateParser(str, &p);
+    r = DoFset(&p);
+    DestroyParser(&p);
+    if (r != OK) {
+        fprintf(ErrFp, "-i option: %s: %s\n", str, GetErr(r));
+    }
+}
+/***************************************************************/
+/*                                                             */
+/*  InitializeVar                                              */
+/*                                                             */
+/*  Initialize and preserve a variable                         */
+/*                                                             */
+/***************************************************************/
+static void InitializeVar(char const *str)
+{
+    char const *expr;
+    char const *ostr = str;
+    char varname[VAR_NAME_LEN+1];
+
+    Value val;
+
+    int r;
+
+    /* Scan for an '=' sign */
+    r = 0;
+    while (*str && *str != '=') {
+        if (r < VAR_NAME_LEN) {
+            if (isalpha(*str) || *str == '_' || (r > 0 && *str == '(') || (r == 0 && *str == '$') || (r > 0 && isdigit(*str))) {
+                varname[r++] = *str;
+            } else {
+                fprintf(ErrFp, GetErr(M_I_OPTION), GetErr(E_ILLEGAL_CHAR));
+                fprintf(ErrFp, "\n");
+                return;
+            }
+        }
+        if (*str == '(') {
+            /* Do a function definition if we see a paren */
+            DefineFunction(ostr);
+            return;
+        }
+        str++;
+    }
+    varname[r] = 0;
+    if (!*varname) {
+        fprintf(ErrFp, GetErr(M_I_OPTION), GetErr(E_MISS_VAR));
+        fprintf(ErrFp, "\n");
+        return;
+    }
+    if (!*str) {
+        val.type = INT_TYPE;
+        val.v.val = 0;
+        if (*varname == '$') {
+            r = SetSysVar(varname+1, &val);
+        } else {
+            r = SetVar(varname, &val, 1);
+            if (!r) {
+                r = PreserveVar(varname);
+            }
+        }
+        if (r) {
+            fprintf(ErrFp, GetErr(M_I_OPTION), GetErr(r));
+            fprintf(ErrFp, "\n");
+        }
+        return;
+    }
+
+    expr = str+1;
+    if (!*expr) {
+        fprintf(ErrFp, GetErr(M_I_OPTION), GetErr(E_MISS_EXPR));
+        fprintf(ErrFp, "\n");
+        return;
+    }
+
+    r=EvalExpr(&expr, &val, NULL);
+    if (r) {
+        fprintf(ErrFp, GetErr(M_I_OPTION), GetErr(r));
+        fprintf(ErrFp, "\n");
+        return;
+    }
+
+    if (*varname == '$') {
+        r=SetSysVar(varname+1, &val);
+        DestroyValue(val);
+        if (r) {
+            fprintf(ErrFp, GetErr(M_I_OPTION), GetErr(r));
+            fprintf(ErrFp, "\n");
+        }
+        return;
+    }
+
+    r=SetVar(varname, &val, 1);
+    if (r) {
+        fprintf(ErrFp, GetErr(M_I_OPTION), GetErr(r));
+        fprintf(ErrFp, "\n");
+        return;
+    }
+    r=PreserveVar(varname);
+    if (r) {
+        fprintf(ErrFp, GetErr(M_I_OPTION), GetErr(r));
+        fprintf(ErrFp, "\n");
+    }
+    return;
+}
+
+static void
+AddTrustedUser(char const *username)
+{
+    struct passwd const *pwent;
+    if (NumTrustedUsers >= MAX_TRUSTED_USERS) {
+        fprintf(ErrFp, "Too many trusted users (%d max)\n",
+                MAX_TRUSTED_USERS);
+        exit(EXIT_FAILURE);
+    }
+
+    pwent = getpwnam(username);
+    if (!pwent) {
+        fprintf(ErrFp, GetErr(M_BAD_USER), username);
+        fprintf(ErrFp, "\n");
+        exit(EXIT_FAILURE);
+    }
+    TrustedUsers[NumTrustedUsers] = pwent->pw_uid;
+    NumTrustedUsers++;
+}
+
+static pid_t LimiterPid = (pid_t) -1;
+
+void unlimit_execution_time(void)
+{
+    if (LimiterPid != (pid_t) -1) {
+        kill(LimiterPid, SIGTERM);
+        LimiterPid = (pid_t) -1;
+    }
+}
+
+static void limit_execution_time(int t)
+{
+    pid_t parent = getpid();
+
+    pid_t pid = fork();
+    if (pid < 0) {
+        perror("fork");
+        exit(1);
+    }
+
+    if (pid > 0) {
+        LimiterPid = pid;
+        /* In the parent */
+        return;
+    }
+
+    /* In the child */
+    time_t start = time(NULL);
+    while(1) {
+        sleep(1);
+        if (kill(parent, 0) < 0) {
+            /* Parent has probably exited */
+            exit(0);
+        }
+        if (time(NULL) - start > t) {
+            kill(parent, SIGXCPU);
+            exit(0);
+        }
+    }
+}
+
+static void
+ProcessLongOption(char const *arg)
+{
+    int t;
+    unsigned long tt;
+
+    if (!strcmp(arg, "test")) {
+        fprintf(stderr, "Enabling test mode: This is meant for the acceptance test.\nDo not use --test in production.\nIn test mode, the system time is fixed at 2025-01-06@19:00\n");
+        TestMode = 1;
+
+        /* Update RealToday because of TestMode */
+        RealToday = SystemDate(&CurYear, &CurMon, &CurDay);
+        DSEToday = RealToday;
+        LocalDSEToday = DSEToday;
+        FromDSE(DSEToday, &CurYear, &CurMon, &CurDay);
+
+        return;
+    }
+    if (!strcmp(arg, "only-todos")) {
+        if (TodoFilter == ONLY_EVENTS) {
+            fprintf(ErrFp, "remind: Cannot combine --only-todos and --only-events\n");
+            exit(1);
+        }
+        TodoFilter = ONLY_TODOS;
+        return;
+    }
+    if (!strcmp(arg, "only-events")) {
+        if (TodoFilter == ONLY_TODOS) {
+            fprintf(ErrFp, "remind: Cannot combine --only-todos and --only-events\n");
+            exit(1);
+        }
+        TodoFilter = ONLY_EVENTS;
+        return;
+    }
+    if (!strcmp(arg, "flush")) {
+        setvbuf(stdout, NULL, _IONBF, 0);
+        setvbuf(stderr, NULL, _IONBF, 0);
+        return;
+    }
+    if (!strcmp(arg, "json")) {
+        JSONMode = 1;
+        DontQueue = 1;
+        return;
+    }
+
+    if (!strcmp(arg, "version")) {
+        printf("%s\n", VERSION);
+        exit(EXIT_SUCCESS);
+    }
+    if (!strcmp(arg, "print-config-cmd")) {
+        printf("%s\n", CONFIG_CMD);
+        exit(EXIT_SUCCESS);
+    }
+    if (!strcmp(arg, "print-errs")) {
+        for (t=0; t<NumErrs; t++) {
+            if (*ErrMsg[t]) {
+                print_escaped_string(stdout, ErrMsg[t]);
+                printf("\n");
+            }
+        }
+        exit(EXIT_SUCCESS);
+    }
+
+    if (!strcmp(arg, "hide-completed-todos")) {
+        HideCompletedTodos = 1;
+        return;
+    }
+
+    if (!strcmp(arg, "print-tokens")) {
+        print_remind_tokens();
+        print_builtinfunc_tokens();
+        print_sysvar_tokens();
+        exit(0);
+    }
+    if (sscanf(arg, "max-expr-complexity=%lu", &tt) == 1) {
+        ExpressionNodeLimitPerLine = tt;
+        return;
+    }
+    if (sscanf(arg, "max-execution-time=%d", &t) == 1) {
+        if (t < 0) {
+            fprintf(ErrFp, "%s: --max-execution-time must be non-negative\n", ArgV[0]);
+            return;
+        }
+        if (t > 0) {
+            limit_execution_time(t);
+        }
+        return;
+    }
+    fprintf(ErrFp, "%s: Unknown long option --%s\n", ArgV[0], arg);
+}
+
+static void
+guess_terminal_background(int *r, int *g, int *b)
+{
+    int ttyfd;
+    struct pollfd p;
+    unsigned int rr, gg, bb;
+    char buf[128];
+    int n;
+
+    *r = -1;
+    *g = -1;
+    *b = -1;
+
+    /* Don't guess if stdout not a terminal unless asked to by @,t */
+    if (should_guess_terminal_background != 2) {
+        if (!isatty(STDOUT_FILENO)) {
+            return;
+        }
+    }
+
+    ttyfd = open("/dev/tty", O_RDWR);
+    if (ttyfd < 0) {
+        return;
+    }
+
+    if (!isatty(ttyfd)) {
+        /* Not a TTY: Can't guess the color */
+        close(ttyfd);
+        return;
+    }
+
+    if (!tty_init(ttyfd)) {
+        return;
+    }
+    tty_raw(ttyfd);
+    n = write(ttyfd, "\033]11;?\033\\", 8);
+
+    if (n != 8) {
+        /* write failed... WTF?  Not much we can do */
+        tty_reset(ttyfd);
+        close(ttyfd);
+        return;
+    }
+
+    /* Wait up to 0.1s for terminal to respond */
+    p.fd = ttyfd;
+    p.events = POLLIN;
+    if (poll(&p, 1, 100) < 0) {
+        tty_reset(ttyfd);
+        close(ttyfd);
+        return;
+    }
+    if (!(p.revents & POLLIN)) {
+        tty_reset(ttyfd);
+        close(ttyfd);
+        return;
+    }
+    n = read(ttyfd, buf, 127);
+    if (n <= 0) {
+        tty_reset(ttyfd);
+        close(ttyfd);
+        return;
+    }
+    tty_reset(ttyfd);
+    close(ttyfd);
+    buf[n+1] = 0;
+    if (n < 25) {
+        /* Too short */
+        return;
+    }
+    if (sscanf(buf+5, "rgb:%x/%x/%x", &rr, &gg, &bb) != 3) {
+        /* Couldn't scan color codes */
+        return;
+    }
+    *r = (int) ((rr >> 8) & 255);
+    *g = (int) ((gg >> 8) & 255);
+    *b = (int) ((bb >> 8) & 255);
+}
+
+static struct termios orig_termios;
+
+static int
+tty_init(int fd)
+{
+    if (tcgetattr(fd, &orig_termios) < 0) {
+        return 0;
+    }
+    return 1;
+}
+
+static void
+tty_raw(int fd)
+{
+    struct termios raw;
+
+    raw = orig_termios;
+
+    raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
+    raw.c_oflag &= ~(OPOST);
+    raw.c_cflag |= (CS8);
+    raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
+
+    /* put terminal in raw mode after flushing */
+    tcsetattr(fd,TCSAFLUSH,&raw);
+}
+
+static void
+tty_reset(int fd)
+{
+    tcsetattr(fd, TCSAFLUSH, &orig_termios);
+}
+
+int
+GetTerminalBackground(void)
+{
+    int r, g, b;
+    if (should_guess_terminal_background) {
+        guess_terminal_background(&r, &g, &b);
+        if (r >= 0 && g >= 0 && b >= 0) {
+            if (r+g+b <= 85*3 && r <= 128 && g <= 128 && b <= 128) {
+                TerminalBackground = TERMINAL_BACKGROUND_DARK;
+            } else {
+                TerminalBackground = TERMINAL_BACKGROUND_LIGHT;
+            }
+        }
+        should_guess_terminal_background = 0;
+    }
+    return TerminalBackground;
+}
+
+static int
+GetInitDateFromTrigger(char const *s, int *y, int *m, int *d, int *systime)
+{
+    Parser p;
+    Trigger trig;
+    TimeTrig tim;
+    int dse;
+    int r;
+
+    CreateParser(s, &p);
+    r = ParseRem(&p, &trig, &tim);
+    if (r) {
+        DestroyParser(&p);
+        return r;
+    }
+    if (trig.tz != NULL && tim.ttime == NO_TIME) {
+        DestroyParser(&p);
+        FreeTrig(&trig);
+        return E_TZ_NO_AT;
+    }
+    if (trig.typ == SAT_TYPE) {
+        EnterTimezone(trig.tz);
+        r=DoSatRemind(&trig, &tim, &p);
+        ExitTimezone(trig.tz);
+        if (r) {
+            DestroyParser(&p);
+            FreeTrig(&trig);
+            return r;
+        }
+        dse = LastTriggerDate;
+    } else if (trig.typ == NO_TYPE) {
+        EnterTimezone(trig.tz);
+        dse = ComputeTrigger(get_scanfrom(&trig), &trig, &tim, &r, 0);
+        ExitTimezone(trig.tz);
+    } else {
+        DestroyParser(&p);
+        FreeTrig(&trig);
+        return E_PARSE_ERR;
+    }
+
+    DestroyParser(&p);
+    if (r) {
+        FreeTrig(&trig);
+        return r;
+    }
+    if (dse < 0) {
+        FreeTrig(&trig);
+        return E_CANT_TRIG;
+    }
+    if (dse >= 0) {
+        if (tim.ttime != NO_TIME) {
+            if (*systime != -1) {
+                Usage();
+            }
+            dse=AdjustTriggerForTimeZone(&trig, dse, &tim, 1);
+            *systime = tim.ttime * 60;
+        }
+        FromDSE(dse, y, m, d);
+        if (dse != RealToday) {
+            IgnoreOnce = 1;
+        }
+    }
+    FreeTrig(&trig);
+    return OK;
+}
+
+static void
+SetTodayFromCmdlineArgs(int dse, int y, int m, int d)
+{
+    if (dse != NO_DATE) {
+        FromDSE(dse, &y, &m, &d);
+    }
+    /* Must supply date in the form:  day, mon, yr OR mon, yr */
+    if (m != NO_MON || y != NO_YR || d != NO_DAY) {
+        if (y == NO_YR) {
+            y = CurYear;
+        }
+        if (m == NO_MON) {
+            Usage();
+        }
+        if (d == NO_DAY) d=1;
+        if (d > DaysInMonth(m, y)) {
+            fprintf(ErrFp, "%s", BadDate);
+            Usage();
+        }
+        DSEToday = DSE(y, m, d);
+        if (DSEToday == -1) {
+            fprintf(ErrFp, "%s", BadDate);
+            Usage();
+        }
+        LocalDSEToday = DSEToday;
+        CurYear = y;
+        CurMon = m;
+        CurDay = d;
+        if (DSEToday != RealToday) IgnoreOnce = 1;
+    }
+}