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