Extend PR_ParseTimeString() to accept some ISO 8601 formats to fix timezone parsing in SyslogParser.

base/third_party/nspr/prtime.cc

 /* Portions are Copyright (C) 2011 Google Inc */
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
@@ skipping 43 matching lines @@
  * PR_GMTParameters
  * PR_ImplodeTime
  *   This was modified to use the Win32 SYSTEMTIME/FILETIME structures
  *   and the timezone offsets are applied to the FILETIME structure.
  * All types and macros are defined in the base/third_party/prtime.h file.
  * These have been copied from the following nspr files. We have only copied
  * over the types we need.
  * 1. prtime.h
  * 2. prtypes.h
  * 3. prlong.h
+ *
+ * Unit tests are in base/time/pr_time_unittest.cc.

[wtc, 2014/05/08 21:04:19]

Maybe this entire comment block should be moved to
base/third_party/nspr/README.chromium?

[Thiemo Nagel, 2014/05/09 16:19:00]

I don't have an opinion about that...

  */
 
 #include "base/logging.h"
 #include "base/third_party/nspr/prtime.h"
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #elif defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
@@ skipping 424 matching lines @@
  *   Mon Jan 16 16:12 +0130 1989
  *   6 May 1992 16:41-JST (Wednesday)
  *   22-AUG-1993 10:59:12.82
  *   22-AUG-1993 10:59pm
  *   22-AUG-1993 12:59am
  *   22-AUG-1993 12:59 PM
  *   Friday, August 04, 1995 3:54 PM
  *   06/21/95 04:24:34 PM
  *   20/06/95 21:07
  *   95-06-08 19:32:48 EDT
+ *   1995-06-17T23:11:25.342156Z
  *
  * If the input string doesn't contain a description of the timezone,
  * we consult the `default_to_gmt' to decide whether the string should
  * be interpreted relative to the local time zone (PR_FALSE) or GMT (PR_TRUE).
  * The correct value for this argument depends on what standard specified
  * the time string which you are parsing.
  */
 
 PRStatus
 PR_ParseTimeString(
         const char *string,
         PRBool default_to_gmt,
         PRTime *result_imploded)
 {
   PRExplodedTime tm;
   PRExplodedTime *result = &tm;
   TIME_TOKEN dotw = TT_UNKNOWN;
   TIME_TOKEN month = TT_UNKNOWN;
   TIME_TOKEN zone = TT_UNKNOWN;
   int zone_offset = -1;
   int dst_offset = 0;
   int date = -1;
   PRInt32 year = -1;
   int hour = -1;
   int min = -1;
   int sec = -1;
+  int usec = -1;
 
   const char *rest = string;
 
   int iterations = 0;
 
   PR_ASSERT(string && result);
   if (!string || !result) return PR_FAILURE;
 
   while (*rest)
         {
@@ skipping 223 matching lines @@
                         zone = TT_GMT;
                         break;
                   }
 
                 case '0': case '1': case '2': case '3': case '4':
                 case '5': case '6': case '7': case '8': case '9':
                   {
                         int tmp_hour = -1;
                         int tmp_min = -1;
                         int tmp_sec = -1;
+                        int tmp_usec = -1;
                         const char *end = rest + 1;
                         while (*end >= '0' && *end <= '9')
                           end++;
 
                         /* end is now the first character after a range of digits. */
 
                         if (*end == ':')
                           {
                                 if (hour >= 0 && min >= 0) /* already got it */
                                   break;
@@ skipping 39 matching lines @@
                                   ;
                                 else if ((end - rest) > 2)
                                   /* it is [0-9][0-9][0-9]+: */
                                   break;
                                 else if ((end - rest) == 2)
                                   tmp_sec = ((rest[0]-'0')*10 +
                                                          (rest[1]-'0'));
                                 else
                                   tmp_sec = (rest[0]-'0');
 
+                                /* fractional second */
+                                rest = end;
+                                if (*rest == '.') {
+                                  rest++;
+                                  end++;
+                                  tmp_usec = 0;
+                                  /* use up to 6 digits, skip over the rest */
+                                  while (*end >= '0' && *end <= '9') {
+                                    if (end - rest < 6) {
+                                      tmp_usec = tmp_usec * 10 + *end - '0';
+                                    } else if (end - rest == 6) {
+                                      if ('5' <= *end && *end <= '9') tmp_usec++;  /* round to nearest */

[wtc, 2014/05/08 21:04:19]

I suggest we always truncate. The reason is that rounding up may produce
surprising results. For example:

  2014-05-08T23:59:59.9999995Z

would be rounded up to

  2014-05-09T00:00:00.000000Z

[Thiemo Nagel, 2014/05/09 16:19:00]

I wouldn't consider that surprising...  ;-)

Anyways, I'm truncating now.

+                                    }
+                                    end++;
+                                  }
+                                  int ndigits = end - rest;
+                                  while (ndigits++ < 6) tmp_usec *= 10;

[wtc, 2014/05/08 21:04:19]

Nit: put
    tmp_usec *= 10;
on a separate line.

[Thiemo Nagel, 2014/05/09 16:19:00]

Done.

+                                }
+
+                                rest = end;
+                                if (*rest == 'Z') {

[wtc, 2014/05/08 21:04:19]

Should we only allow 'Z' if 'T' was used as a delimiter?

[Thiemo Nagel, 2014/05/09 16:19:00]

I wouldn't do that since according to Wikipedia "it is permitted to omit the 'T'
character by mutual agreement."

+                                  zone = TT_GMT;
+                                  end++;

[wtc, 2014/05/08 21:04:19]

It seems that we should skip the AM/PM processing code if we have seen 'Z'.

[Thiemo Nagel, 2014/05/09 16:19:00]

Done.

+                                }
+
                                 /* If we made it here, we've parsed hour and min,
                                    and possibly sec, so it worked as a unit. */
 
                                 /* skip over whitespace and see if there's an AM or PM
                                    directly following the time.
                                  */
                                 if (tmp_hour <= 12)
                                   {
                                         const char *s = end;
                                         while (*s && (*s == ' ' || *s == '\t'))
                                           s++;
                                         if ((s[0] == 'p' || s[0] == 'P') &&
                                                 (s[1] == 'm' || s[1] == 'M'))
                                           /* 10:05pm == 22:05, and 12:05pm == 12:05 */
                                           tmp_hour = (tmp_hour == 12 ? 12 : tmp_hour + 12);
                                         else if (tmp_hour == 12 &&
                                                          (s[0] == 'a' || s[0] == 'A') &&
                                                          (s[1] == 'm' || s[1] == 'M'))
                                           /* 12:05am == 00:05 */
                                           tmp_hour = 0;
                                   }
 
                                 hour = tmp_hour;
                                 min = tmp_min;
                                 sec = tmp_sec;
+                                usec = tmp_usec;
                                 rest = end;
                                 break;
                           }
                         else if ((*end == '/' || *end == '-') &&
                                          end[1] >= '0' && end[1] <= '9')
                           {
                                 /* Perhaps this is 6/16/95, 16/6/95, 6-16-95, or 16-6-95
-                                   or even 95-06-05...
-                                   #### But it doesn't handle 1995-06-22.
+                                   or even 95-06-05 or 1995-06-22.
                                  */
                                 int n1, n2, n3;
                                 const char *s;
 
                                 if (month != TT_UNKNOWN)
                                   /* if we saw a month name, this can't be. */
                                   break;
 
                                 s = rest;
 
-                                n1 = (*s++ - '0');                                /* first 1 or 2 digits */
+                                n1 = (*s++ - '0');                                /* first 1, 2 or 4 digits */
                                 if (*s >= '0' && *s <= '9')
                                   n1 = n1*10 + (*s++ - '0');
 
+                                if (*s >= '0' && *s <= '9')            /* optional digits 3 and 4 */
+                                  {
+                                        n1 = n1*10 + (*s++ - '0');
+                                        if (*s < '0' || *s > '9')
+                                          break;
+                                        n1 = n1*10 + (*s++ - '0');
+                                  }
+
                                 if (*s != '/' && *s != '-')                /* slash */
                                   break;
                                 s++;
 
                                 if (*s < '0' || *s > '9')                /* second 1 or 2 digits */
                                   break;
                                 n2 = (*s++ - '0');
                                 if (*s >= '0' && *s <= '9')
                                   n2 = n2*10 + (*s++ - '0');
 
@@ skipping 10 matching lines @@
                                 if (*s >= '0' && *s <= '9')            /* optional digits 3, 4, and 5 */
                                   {
                                         n3 = n3*10 + (*s++ - '0');
                                         if (*s < '0' || *s > '9')
                                           break;
                                         n3 = n3*10 + (*s++ - '0');
                                         if (*s >= '0' && *s <= '9')
                                           n3 = n3*10 + (*s++ - '0');
                                   }
 
-                                if ((*s >= '0' && *s <= '9') ||        /* followed by non-alphanum */
-                                        (*s >= 'A' && *s <= 'Z') ||
-                                        (*s >= 'a' && *s <= 'z'))
+                                if (((*s >= '0' && *s <= '9') ||        /* followed by non-alphanum */
+                                     (*s >= 'A' && *s <= 'Z') ||
+                                     (*s >= 'a' && *s <= 'z')) &&
+                                    !(*s == 'T' && '0' <= s[1] && s[1] <= '9'))  /* allow ISO 8601 T delimiter */

[wtc, 2014/05/08 21:04:19]

I think we should skip over 'T' right here, so that we don't need to check for
'T' in the while loops on lines 1069 and 1078 below.

[Thiemo Nagel, 2014/05/09 16:19:00]

We could skip over the 'T' here, but we cannot eliminate the logic from the
"skip to the end of this token" while() loop (line 1069) as it is required to
prevent the loop from eating the rest of the token.

I've updated the CL, trying to make it more legible.  If you still think
skipping over 'T' here is better, I can do that, but I can't think of an easy
way of removing the logic from line 1069 (except by introducing a new variable
like dont_skip_this_token which I don't consider particularly elegant, either).

                                   break;
 
                                 /* Ok, we parsed three 1-2 digit numbers, with / or -

[wtc, 2014/05/08 21:04:19]

This comment needs to be updated because "three 1-2 digit numbers" is no longer
true.

[Thiemo Nagel, 2014/05/09 16:19:00]

Done.

                                    between them.  Now decide what the hell they are
                                    (DD/MM/YY or MM/DD/YY or YY/MM/DD.)

[wtc, 2014/05/08 21:04:19]

The last item should be YY[YY]/MM/DD or [YY]YY/MM/DD. See the next comment.

[Thiemo Nagel, 2014/05/09 16:19:00]

Done.

                                  */
 
-                                if (n1 > 31 || n1 == 0)  /* must be YY/MM/DD */
+                                if (n1 > 31 || n1 == 0)  /* must be YY[YY]/MM/DD */

[wtc, 2014/05/08 21:04:19]

Nit: [YY]YY/MM/DD seems more accurate. Not very sure about this though :-)

[Thiemo Nagel, 2014/05/09 16:19:00]

Absolutely!

                                   {
                                         if (n2 > 12) break;
                                         if (n3 > 31) break;
                                         year = n1;
                                         if (year < 70)
                                             year += 2000;
                                         else if (year < 100)
                                             year += 1900;
                                         month = (TIME_TOKEN)(n2 + ((int)TT_JAN) - 1);
                                         date = n3;
@@ skipping 84 matching lines @@
 
           /* Skip to the end of this token, whether we parsed it or not.
                  Tokens are delimited by whitespace, or ,;-/
                  But explicitly not :+-.
            */
           while (*rest &&
                          *rest != ' ' && *rest != '\t' &&
                          *rest != ',' && *rest != ';' &&
                          *rest != '-' && *rest != '+' &&
                          *rest != '/' &&
-                         *rest != '(' && *rest != ')' && *rest != '[' && *rest != ']')
+                         *rest != '(' && *rest != ')' && *rest != '[' && *rest != ']' &&
+                         !(*rest == 'T' && '0' <= rest[1] && rest[1] <= '9')  /* T precedes time in ISO 8601 */
+                )
                 rest++;
           /* skip over uninteresting chars. */
         SKIP_MORE:
           while (*rest &&
                          (*rest == ' ' || *rest == '\t' ||
                           *rest == ',' || *rest == ';' || *rest == '/' ||
-                          *rest == '(' || *rest == ')' || *rest == '[' || *rest == ']'))
+                          *rest == '(' || *rest == ')' || *rest == '[' || *rest == ']' ||
+                          (*rest == 'T' && '0' <= rest[1] && rest[1] <= '9')  /* T precedes time in ISO 8601 */
+                         )
+                )
                 rest++;
 
           /* "-" is ignored at the beginning of a token if we have not yet
                  parsed a year (e.g., the second "-" in "30-AUG-1966"), or if
                  the character after the dash is not a digit. */         
           if (*rest == '-' && ((rest > string &&
               isalpha((unsigned char)rest[-1]) && year < 0) ||
               rest[1] < '0' || rest[1] > '9'))
                 {
                   rest++;
                   goto SKIP_MORE;
                 }
 
-        }
+        }  /* while */
 
   if (zone != TT_UNKNOWN && zone_offset == -1)
         {
           switch (zone)
                 {
                 case TT_PST: zone_offset = -8 * 60; break;
                 case TT_PDT: zone_offset = -8 * 60; dst_offset = 1 * 60; break;
                 case TT_MST: zone_offset = -7 * 60; break;
                 case TT_MDT: zone_offset = -7 * 60; dst_offset = 1 * 60; break;
                 case TT_CST: zone_offset = -6 * 60; break;
@@ skipping 14 matching lines @@
         }
 
   /* If we didn't find a year, month, or day-of-the-month, we can't
          possibly parse this, and in fact, mktime() will do something random
          (I'm seeing it return "Tue Feb  5 06:28:16 2036", which is no doubt
          a numerologically significant date... */
   if (month == TT_UNKNOWN || date == -1 || year == -1 || year > PR_INT16_MAX)
       return PR_FAILURE;
 
   memset(result, 0, sizeof(*result));
+  if (usec != -1)
+        result->tm_usec = usec; 
   if (sec != -1)
         result->tm_sec = sec;
   if (min != -1)
         result->tm_min = min;
   if (hour != -1)
         result->tm_hour = hour;
   if (date != -1)
         result->tm_mday = date;
   if (month != TT_UNKNOWN)
         result->tm_month = (((int)month) - ((int)TT_JAN));
@@ skipping 102 matching lines @@
                               + 60 * localTime.tm_hour
                               + 1440 * (localTime.tm_mday - 2);
         }
 
   result->tm_params.tp_gmt_offset = zone_offset * 60;
   result->tm_params.tp_dst_offset = dst_offset * 60;
 
   *result_imploded = PR_ImplodeTime(result);
   return PR_SUCCESS;
 }