lib/posixtm.c

   1 /* Parse dates for touch and date.
   2
   3    Copyright (C) 1989-1991, 1998, 2000-2014 Free Software Foundation, Inc.
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program 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
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 /* Yacc-based version written by Jim Kingdon and David MacKenzie.
  19    Rewritten by Jim Meyering.  */
  20
  21 #include <config.h>
  22
  23 #include "posixtm.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <sys/types.h>
  28 #include <string.h>
  29
  30 #if USE_UNLOCKED_IO
  31 # include "unlocked-io.h"
  32 #endif
  33
  34 /* ISDIGIT differs from isdigit, as follows:
  35    - Its arg may be any int or unsigned int; it need not be an unsigned char
  36      or EOF.
  37    - It's typically faster.
  38    POSIX says that only '0' through '9' are digits.  Prefer ISDIGIT to
  39    isdigit unless it's important to use the locale's definition
  40    of "digit" even when the host does not conform to POSIX.  */
  41 #define ISDIGIT(c) ((unsigned int) (c) - '0' <= 9)
  42
  43 /*
  44   POSIX requires:
  45
  46   touch -t [[CC]YY]mmddhhmm[.ss] FILE...
  47     8, 10, or 12 digits, followed by optional .ss
  48     (PDS_LEADING_YEAR | PDS_CENTURY | PDS_SECONDS)
  49
  50   touch mmddhhmm[YY] FILE... (obsoleted by POSIX 1003.1-2001)
  51     8 or 10 digits, YY (if present) must be in the range 69-99
  52     (PDS_TRAILING_YEAR | PDS_PRE_2000)
  53
  54   date mmddhhmm[[CC]YY]
  55     8, 10, or 12 digits
  56     (PDS_TRAILING_YEAR | PDS_CENTURY)
  57
  58 */
  59
  60 static int
  61 year (struct tm *tm, const int *digit_pair, size_t n, unsigned int syntax_bits)
  62 {
  63   switch (n)
  64     {
  65     case 1:
  66       tm->tm_year = *digit_pair;
  67       /* Deduce the century based on the year.
  68          POSIX requires that 00-68 be interpreted as 2000-2068,
  69          and that 69-99 be interpreted as 1969-1999.  */
  70       if (digit_pair[0] <= 68)
  71         {
  72           if (syntax_bits & PDS_PRE_2000)
  73             return 1;
  74           tm->tm_year += 100;
  75         }
  76       break;
  77
  78     case 2:
  79       if (! (syntax_bits & PDS_CENTURY))
  80         return 1;
  81       tm->tm_year = digit_pair[0] * 100 + digit_pair[1] - 1900;
  82       break;
  83
  84     case 0:
  85       {
  86         time_t now;
  87         struct tm *tmp;
  88
  89         /* Use current year.  */
  90         time (&now);
  91         tmp = localtime (&now);
  92         if (! tmp)
  93           return 1;
  94         tm->tm_year = tmp->tm_year;
  95       }
  96       break;
  97
  98     default:
  99       abort ();
 100     }
 101
 102   return 0;
 103 }
 104
 105 static int
 106 posix_time_parse (struct tm *tm, const char *s, unsigned int syntax_bits)
 107 {
 108   const char *dot = NULL;
 109   int pair[6];
 110   int *p;
 111   size_t i;
 112
 113   size_t s_len = strlen (s);
 114   size_t len = (((syntax_bits & PDS_SECONDS) && (dot = strchr (s, '.')))
 115                 ? (size_t) (dot - s)
 116                 : s_len);
 117
 118   if (len != 8 && len != 10 && len != 12)
 119     return 1;
 120
 121   if (dot)
 122     {
 123       if (!(syntax_bits & PDS_SECONDS))
 124         return 1;
 125
 126       if (s_len - len != 3)
 127         return 1;
 128     }
 129
 130   for (i = 0; i < len; i++)
 131     if (!ISDIGIT (s[i]))
 132       return 1;
 133
 134   len /= 2;
 135   for (i = 0; i < len; i++)
 136     pair[i] = 10 * (s[2*i] - '0') + s[2*i + 1] - '0';
 137
 138   p = pair;
 139   if (syntax_bits & PDS_LEADING_YEAR)
 140     {
 141       if (year (tm, p, len - 4, syntax_bits))
 142         return 1;
 143       p += len - 4;
 144       len = 4;
 145     }
 146
 147   /* Handle 8 digits worth of 'MMDDhhmm'.  */
 148   tm->tm_mon = *p++ - 1;
 149   tm->tm_mday = *p++;
 150   tm->tm_hour = *p++;
 151   tm->tm_min = *p++;
 152   len -= 4;
 153
 154   /* Handle any trailing year.  */
 155   if (syntax_bits & PDS_TRAILING_YEAR)
 156     {
 157       if (year (tm, p, len, syntax_bits))
 158         return 1;
 159     }
 160
 161   /* Handle seconds.  */
 162   if (!dot)
 163     {
 164       tm->tm_sec = 0;
 165     }
 166   else
 167     {
 168       int seconds;
 169
 170       ++dot;
 171       if (!ISDIGIT (dot[0]) || !ISDIGIT (dot[1]))
 172         return 1;
 173       seconds = 10 * (dot[0] - '0') + dot[1] - '0';
 174
 175       tm->tm_sec = seconds;
 176     }
 177
 178   return 0;
 179 }
 180
 181 /* Parse a POSIX-style date, returning true if successful.  */
 182
 183 bool
 184 posixtime (time_t *p, const char *s, unsigned int syntax_bits)
 185 {
 186   struct tm tm0;
 187   struct tm tm1;
 188   struct tm const *tm;
 189   time_t t;
 190
 191   if (posix_time_parse (&tm0, s, syntax_bits))
 192     return false;
 193
 194   tm1 = tm0;
 195   tm1.tm_isdst = -1;
 196   t = mktime (&tm1);
 197
 198   if (t != (time_t) -1)
 199     tm = &tm1;
 200   else
 201     {
 202       /* mktime returns -1 for errors, but -1 is also a valid time_t
 203          value.  Check whether an error really occurred.  */
 204       tm = localtime (&t);
 205       if (! tm)
 206         return false;
 207     }
 208
 209   /* Reject dates like "September 31" and times like "25:61".
 210      Do not reject times that specify "60" as the number of seconds.  */
 211   if ((tm0.tm_year ^ tm->tm_year)
 212       | (tm0.tm_mon ^ tm->tm_mon)
 213       | (tm0.tm_mday ^ tm->tm_mday)
 214       | (tm0.tm_hour ^ tm->tm_hour)
 215       | (tm0.tm_min ^ tm->tm_min)
 216       | (tm0.tm_sec ^ tm->tm_sec))
 217     {
 218       /* Any mismatch without 60 in the tm_sec field is invalid.  */
 219       if (tm0.tm_sec != 60)
 220         return false;
 221
 222       {
 223         /* Allow times like 01:35:60 or 23:59:60.  */
 224         time_t dummy;
 225         char buf[16];
 226         char *b = stpcpy (buf, s);
 227         strcpy (b - 2, "59");
 228         if (!posixtime (&dummy, buf, syntax_bits))
 229           return false;
 230       }
 231     }
 232
 233   *p = t;
 234   return true;
 235 }