time/getdate.c

   1 /* Convert a string representation of time to a time value.
   2    Copyright (C) 1997-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <limits.h>
  20 #include <stdio.h>
  21 #include <stdio_ext.h>
  22 #include <stdlib.h>
  23 #include <stdbool.h>
  24 #include <string.h>
  25 #include <time.h>
  26 #include <unistd.h>
  27 #include <sys/stat.h>
  28 #include <ctype.h>
  29
  30 #define TM_YEAR_BASE 1900
  31
  32
  33 /* Prototypes for local functions.  */
  34 static int first_wday (int year, int mon, int wday);
  35 static int check_mday (int year, int mon, int mday);
  36
  37
  38 /* Set to one of the following values to indicate an error.
  39      1  the DATEMSK environment variable is null or undefined,
  40      2  the template file cannot be opened for reading,
  41      3  failed to get file status information,
  42      4  the template file is not a regular file,
  43      5  an error is encountered while reading the template file,
  44      6  memory allication failed (not enough memory available),
  45      7  there is no line in the template that matches the input,
  46      8  invalid input specification Example: February 31 or a time is
  47         specified that can not be represented in a time_t (representing
  48         the time in seconds since 00:00:00 UTC, January 1, 1970) */
  49 int getdate_err;
  50
  51
  52 /* Returns the first weekday WDAY of month MON in the year YEAR.  */
  53 static int
  54 first_wday (int year, int mon, int wday)
  55 {
  56   struct tm tm;
  57
  58   if (wday == INT_MIN)
  59     return 1;
  60
  61   memset (&tm, 0, sizeof (struct tm));
  62   tm.tm_year = year;
  63   tm.tm_mon = mon;
  64   tm.tm_mday = 1;
  65   mktime (&tm);
  66
  67   return (1 + (wday - tm.tm_wday + 7) % 7);
  68 }
  69
  70
  71 /* Returns 1 if MDAY is a valid day of the month in month MON of year
  72    YEAR, and 0 if it is not.  */
  73 static int
  74 check_mday (int year, int mon, int mday)
  75 {
  76   switch (mon)
  77     {
  78     case 0:
  79     case 2:
  80     case 4:
  81     case 6:
  82     case 7:
  83     case 9:
  84     case 11:
  85       if (mday >= 1 && mday <= 31)
  86         return 1;
  87       break;
  88     case 3:
  89     case 5:
  90     case 8:
  91     case 10:
  92       if (mday >= 1 && mday <= 30)
  93         return 1;
  94       break;
  95     case 1:
  96       if (mday >= 1 && mday <= (__isleap (year) ? 29 : 28))
  97         return 1;
  98       break;
  99     }
 100
 101   return 0;
 102 }
 103
 104
 105 int
 106 __getdate_r (const char *string, struct tm *tp)
 107 {
 108   FILE *fp;
 109   char *line;
 110   size_t len;
 111   char *datemsk;
 112   char *result = NULL;
 113   __time64_t timer;
 114   struct tm tm;
 115   struct __stat64_t64 st;
 116   bool mday_ok = false;
 117
 118   datemsk = getenv ("DATEMSK");
 119   if (datemsk == NULL || *datemsk == '\0')
 120     return 1;
 121
 122   if (__stat64_time64 (datemsk, &st) < 0)
 123     return 3;
 124
 125   if (!S_ISREG (st.st_mode))
 126     return 4;
 127
 128   if (__access (datemsk, R_OK) < 0)
 129     return 2;
 130
 131   /* Open the template file.  */
 132   fp = fopen (datemsk, "rce");
 133   if (fp == NULL)
 134     return 2;
 135
 136   /* No threads reading this stream.  */
 137   __fsetlocking (fp, FSETLOCKING_BYCALLER);
 138
 139   /* Skip leading whitespace.  */
 140   while (isspace (*string))
 141     string++;
 142
 143   size_t inlen, oldlen;
 144
 145   oldlen = inlen = strlen (string);
 146
 147   /* Skip trailing whitespace.  */
 148   while (inlen > 0 && isspace (string[inlen - 1]))
 149     inlen--;
 150
 151   char *instr = NULL;
 152
 153   if (inlen < oldlen)
 154     {
 155       instr = __strndup(string, inlen);
 156       if (instr == NULL)
 157         {
 158           fclose(fp);
 159           return 6;
 160         }
 161
 162       string = instr;
 163     }
 164
 165   line = NULL;
 166   len = 0;
 167   do
 168     {
 169       ssize_t n;
 170
 171       n = __getline (&line, &len, fp);
 172       if (n < 0)
 173         break;
 174       if (line[n - 1] == '\n')
 175         line[n - 1] = '\0';
 176
 177       /* Do the conversion.  */
 178       tp->tm_year = tp->tm_mon = tp->tm_mday = tp->tm_wday = INT_MIN;
 179       tp->tm_hour = tp->tm_sec = tp->tm_min = INT_MIN;
 180       tp->tm_isdst = -1;
 181       tp->tm_gmtoff = 0;
 182       tp->tm_zone = NULL;
 183       result = strptime (string, line, tp);
 184       if (result && *result == '\0')
 185         break;
 186     }
 187   while (!__feof_unlocked (fp));
 188
 189   free (instr);
 190
 191   /* Free the buffer.  */
 192   free (line);
 193
 194   /* Check for errors. */
 195   if (__ferror_unlocked (fp))
 196     {
 197       fclose (fp);
 198       return 5;
 199     }
 200
 201   /* Close template file.  */
 202   fclose (fp);
 203
 204   if (result == NULL || *result != '\0')
 205     return 7;
 206
 207   /* Get current time.  */
 208   timer = time64_now ();
 209   __localtime64_r (&timer, &tm);
 210
 211   /* If only the weekday is given, today is assumed if the given day
 212      is equal to the current day and next week if it is less.  */
 213   if (tp->tm_wday >= 0 && tp->tm_wday <= 6 && tp->tm_year == INT_MIN
 214       && tp->tm_mon == INT_MIN && tp->tm_mday == INT_MIN)
 215     {
 216       tp->tm_year = tm.tm_year;
 217       tp->tm_mon = tm.tm_mon;
 218       tp->tm_mday = tm.tm_mday + (tp->tm_wday - tm.tm_wday + 7) % 7;
 219       mday_ok = true;
 220     }
 221
 222   /* If only the month is given, the current month is assumed if the
 223      given month is equal to the current month and next year if it is
 224      less and no year is given (the first day of month is assumed if
 225      no day is given.  */
 226   if (tp->tm_mon >= 0 && tp->tm_mon <= 11 && tp->tm_mday == INT_MIN)
 227     {
 228       if (tp->tm_year == INT_MIN)
 229         tp->tm_year = tm.tm_year + (((tp->tm_mon - tm.tm_mon) < 0) ? 1 : 0);
 230       tp->tm_mday = first_wday (tp->tm_year, tp->tm_mon, tp->tm_wday);
 231       mday_ok = true;
 232     }
 233
 234   /* If no hour, minute and second are given the current hour, minute
 235      and second are assumed.  */
 236   if (tp->tm_hour == INT_MIN && tp->tm_min == INT_MIN && tp->tm_sec == INT_MIN)
 237     {
 238       tp->tm_hour = tm.tm_hour;
 239       tp->tm_min = tm.tm_min;
 240       tp->tm_sec = tm.tm_sec;
 241     }
 242
 243   /* Fill in the gaps.  */
 244   if (tp->tm_hour == INT_MIN)
 245     tp->tm_hour = 0;
 246   if (tp->tm_min == INT_MIN)
 247     tp->tm_min = 0;
 248   if (tp->tm_sec == INT_MIN)
 249     tp->tm_sec = 0;
 250
 251   /* If no date is given, today is assumed if the given hour is
 252      greater than the current hour and tomorrow is assumed if
 253      it is less.  */
 254   if (tp->tm_hour >= 0 && tp->tm_hour <= 23
 255       && tp->tm_mon == INT_MIN
 256       && tp->tm_mday == INT_MIN && tp->tm_wday == INT_MIN)
 257     {
 258       tp->tm_mon = tm.tm_mon;
 259       tp->tm_mday = tm.tm_mday + ((tp->tm_hour - tm.tm_hour) < 0 ? 1 : 0);
 260       mday_ok = 1;
 261     }
 262
 263   /* More fillers.  */
 264   if (tp->tm_year == INT_MIN)
 265     tp->tm_year = tm.tm_year;
 266   if (tp->tm_mon == INT_MIN)
 267     tp->tm_mon = tm.tm_mon;
 268
 269   /* Check if the day of month is within range, and if the time can be
 270      represented in a time_t.  We make use of the fact that the mktime
 271      call normalizes the struct tm.  */
 272   if ((!mday_ok && !check_mday (TM_YEAR_BASE + tp->tm_year, tp->tm_mon,
 273                                 tp->tm_mday))
 274       || __mktime64 (tp) == (time_t) -1)
 275     return 8;
 276
 277   return 0;
 278 }
 279 weak_alias (__getdate_r, getdate_r)
 280 libc_hidden_def (__getdate_r)
 281
 282 struct tm *
 283 getdate (const char *string)
 284 {
 285   /* Buffer returned by getdate.  */
 286   static struct tm tmbuf;
 287   int errval = __getdate_r (string, &tmbuf);
 288
 289   if (errval != 0)
 290     {
 291       getdate_err = errval;
 292       return NULL;
 293     }
 294
 295   return &tmbuf;
 296 }