usr/src/lib/libc/port/locale/strptime.c

   1 /*
   2  * Copyright (c) 2014 Gary Mills
   3  * Copyright 2014 Garrett D'Amore <garrett@damore.org>
   4  * Copyright 2011, Nexenta Systems, Inc.  All rights reserved.
   5  * Copyright (c) 1994 Powerdog Industries.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer
  16  *    in the documentation and/or other materials provided with the
  17  *    distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY POWERDOG INDUSTRIES ``AS IS'' AND ANY
  20  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE POWERDOG INDUSTRIES BE
  23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  26  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  27  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  28  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  29  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  * The views and conclusions contained in the software and documentation
  32  * are those of the authors and should not be interpreted as representing
  33  * official policies, either expressed or implied, of Powerdog Industries.
  34  */
  35
  36 #include "lint.h"
  37 #include <time.h>
  38 #include <ctype.h>
  39 #include <errno.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <pthread.h>
  43 #include <alloca.h>
  44 #include <locale.h>
  45 #include "timelocal.h"
  46 #include "localeimpl.h"
  47
  48 #define asizeof(a)      (sizeof (a) / sizeof ((a)[0]))
  49
  50 #define F_GMT           (1 << 0)
  51 #define F_RECURSE       (1 << 2)
  52
  53 static char *
  54 __strptime(const char *_RESTRICT_KYWD buf, const char *_RESTRICT_KYWD fmt,
  55     struct tm *_RESTRICT_KYWD tm, int *_RESTRICT_KYWD flagsp,
  56     locale_t _RESTRICT_KYWD loc)
  57 {
  58         char    c;
  59         const char *ptr;
  60         int     i, len, recurse = 0;
  61         int Ealternative, Oalternative;
  62         const struct lc_time *tptr = loc->time;
  63
  64         if (*flagsp & F_RECURSE)
  65                 recurse = 1;
  66         *flagsp |= F_RECURSE;
  67
  68         ptr = fmt;
  69         while (*ptr != 0) {
  70                 if (*buf == 0)
  71                         break;
  72
  73                 c = *ptr++;
  74
  75                 if (c != '%') {
  76                         if (isspace(c))
  77                                 while (isspace(*buf))
  78                                         buf++;
  79                         else if (c != *buf++)
  80                                 return (NULL);
  81                         continue;
  82                 }
  83
  84                 Ealternative = 0;
  85                 Oalternative = 0;
  86 label:
  87                 c = *ptr++;
  88                 switch (c) {
  89                 case 0:
  90                 case '%':
  91                         if (*buf++ != '%')
  92                                 return (NULL);
  93                         break;
  94
  95                 case '+':
  96                         buf = __strptime(buf, tptr->date_fmt, tm, flagsp, loc);
  97                         if (buf == NULL)
  98                                 return (NULL);
  99                         break;
 100
 101                 case 'C':
 102                         if (!isdigit(*buf))
 103                                 return (NULL);
 104
 105                         /* XXX This will break for 3-digit centuries. */
 106                         len = 2;
 107                         for (i = 0; len && isdigit(*buf); buf++) {
 108                                 i *= 10;
 109                                 i += *buf - '0';
 110                                 len--;
 111                         }
 112                         if (i < 19)
 113                                 return (NULL);
 114
 115                         tm->tm_year = i * 100 - 1900;
 116                         break;
 117
 118                 case 'c':
 119                         buf = __strptime(buf, tptr->c_fmt, tm, flagsp, loc);
 120                         if (buf == NULL)
 121                                 return (NULL);
 122                         break;
 123
 124                 case 'D':
 125                         buf = __strptime(buf, "%m/%d/%y", tm, flagsp, loc);
 126                         if (buf == NULL)
 127                                 return (NULL);
 128                         break;
 129
 130                 case 'E':
 131                         if (Ealternative || Oalternative)
 132                                 break;
 133                         Ealternative++;
 134                         goto label;
 135
 136                 case 'O':
 137                         if (Ealternative || Oalternative)
 138                                 break;
 139                         Oalternative++;
 140                         goto label;
 141
 142                 case 'F':
 143                         buf = __strptime(buf, "%Y-%m-%d", tm, flagsp, loc);
 144                         if (buf == NULL)
 145                                 return (NULL);
 146                         break;
 147
 148                 case 'R':
 149                         buf = __strptime(buf, "%H:%M", tm, flagsp, loc);
 150                         if (buf == NULL)
 151                                 return (NULL);
 152                         break;
 153
 154                 case 'r':
 155                         buf = __strptime(buf, tptr->ampm_fmt, tm, flagsp, loc);
 156                         if (buf == NULL)
 157                                 return (NULL);
 158                         break;
 159
 160                 case 'T':
 161                         buf = __strptime(buf, "%H:%M:%S", tm, flagsp, loc);
 162                         if (buf == NULL)
 163                                 return (NULL);
 164                         break;
 165
 166                 case 'X':
 167                         buf = __strptime(buf, tptr->X_fmt, tm, flagsp, loc);
 168                         if (buf == NULL)
 169                                 return (NULL);
 170                         break;
 171
 172                 case 'x':
 173                         buf = __strptime(buf, tptr->x_fmt, tm, flagsp, loc);
 174                         if (buf == NULL)
 175                                 return (NULL);
 176                         break;
 177
 178                 case 'j':
 179                         if (!isdigit(*buf))
 180                                 return (NULL);
 181
 182                         len = 3;
 183                         for (i = 0; len && isdigit(*buf); buf++) {
 184                                 i *= 10;
 185                                 i += *buf - '0';
 186                                 len--;
 187                         }
 188                         if (i < 1 || i > 366)
 189                                 return (NULL);
 190
 191                         tm->tm_yday = i - 1;
 192                         break;
 193
 194                 case 'M':
 195                 case 'S':
 196                         if (*buf == 0 || isspace(*buf))
 197                                 break;
 198
 199                         if (!isdigit(*buf))
 200                                 return (NULL);
 201
 202                         len = 2;
 203                         for (i = 0; len && isdigit(*buf); buf++) {
 204                                 i *= 10;
 205                                 i += *buf - '0';
 206                                 len--;
 207                         }
 208
 209                         if (c == 'M') {
 210                                 if (i > 59)
 211                                         return (NULL);
 212                                 tm->tm_min = i;
 213                         } else {
 214                                 if (i > 60)
 215                                         return (NULL);
 216                                 tm->tm_sec = i;
 217                         }
 218
 219                         break;
 220
 221                 case 'H':
 222                 case 'I':
 223                 case 'k':
 224                 case 'l':
 225                         /*
 226                          * Of these, %l is the only specifier explicitly
 227                          * documented as not being zero-padded.  However,
 228                          * there is no harm in allowing zero-padding.
 229                          *
 230                          * XXX The %l specifier may gobble one too many
 231                          * digits if used incorrectly.
 232                          */
 233                         if (!isdigit(*buf))
 234                                 return (NULL);
 235
 236                         len = 2;
 237                         for (i = 0; len && isdigit(*buf); buf++) {
 238                                 i *= 10;
 239                                 i += *buf - '0';
 240                                 len--;
 241                         }
 242                         if (c == 'H' || c == 'k') {
 243                                 if (i > 23)
 244                                         return (NULL);
 245                         } else if (i > 12)
 246                                 return (NULL);
 247
 248                         tm->tm_hour = i;
 249
 250                         break;
 251
 252                 case 'p':
 253                         /*
 254                          * XXX This is bogus if parsed before hour-related
 255                          * specifiers.
 256                          */
 257                         len = strlen(tptr->am);
 258                         if (strncasecmp(buf, tptr->am, len) == 0) {
 259                                 if (tm->tm_hour > 12)
 260                                         return (NULL);
 261                                 if (tm->tm_hour == 12)
 262                                         tm->tm_hour = 0;
 263                                 buf += len;
 264                                 break;
 265                         }
 266
 267                         len = strlen(tptr->pm);
 268                         if (strncasecmp(buf, tptr->pm, len) == 0) {
 269                                 if (tm->tm_hour > 12)
 270                                         return (NULL);
 271                                 if (tm->tm_hour != 12)
 272                                         tm->tm_hour += 12;
 273                                 buf += len;
 274                                 break;
 275                         }
 276
 277                         return (NULL);
 278
 279                 case 'A':
 280                 case 'a':
 281                         for (i = 0; i < asizeof(tptr->weekday); i++) {
 282                                 len = strlen(tptr->weekday[i]);
 283                                 if (strncasecmp(buf, tptr->weekday[i], len) ==
 284                                     0)
 285                                         break;
 286                                 len = strlen(tptr->wday[i]);
 287                                 if (strncasecmp(buf, tptr->wday[i], len) == 0)
 288                                         break;
 289                         }
 290                         if (i == asizeof(tptr->weekday))
 291                                 return (NULL);
 292
 293                         tm->tm_wday = i;
 294                         buf += len;
 295                         break;
 296
 297                 case 'U':
 298                 case 'W':
 299                         /*
 300                          * XXX This is bogus, as we can not assume any valid
 301                          * information present in the tm structure at this
 302                          * point to calculate a real value, so just check the
 303                          * range for now.
 304                          */
 305                         if (!isdigit(*buf))
 306                                 return (NULL);
 307
 308                         len = 2;
 309                         for (i = 0; len && isdigit(*buf); buf++) {
 310                                 i *= 10;
 311                                 i += *buf - '0';
 312                                 len--;
 313                         }
 314                         if (i > 53)
 315                                 return (NULL);
 316
 317                         break;
 318
 319                 case 'w':
 320                         if (!isdigit(*buf))
 321                                 return (NULL);
 322
 323                         i = *buf - '0';
 324                         if (i > 6)
 325                                 return (NULL);
 326
 327                         tm->tm_wday = i;
 328
 329                         break;
 330
 331                 case 'd':
 332                 case 'e':
 333                         /*
 334                          * The %e format has a space before single digits
 335                          * which we need to skip.
 336                          */
 337                         if (isspace(*buf))
 338                                 buf++;
 339                         /*
 340                          * The %e specifier is explicitly documented as not
 341                          * being zero-padded but there is no harm in allowing
 342                          * such padding.
 343                          *
 344                          * XXX The %e specifier may gobble one too many
 345                          * digits if used incorrectly.
 346                          */
 347                         if (!isdigit(*buf))
 348                                 return (NULL);
 349
 350                         len = 2;
 351                         for (i = 0; len && isdigit(*buf); buf++) {
 352                                 i *= 10;
 353                                 i += *buf - '0';
 354                                 len--;
 355                         }
 356                         if (i > 31)
 357                                 return (NULL);
 358
 359                         tm->tm_mday = i;
 360
 361                         break;
 362
 363                 case 'B':
 364                 case 'b':
 365                 case 'h':
 366                         for (i = 0; i < asizeof(tptr->month); i++) {
 367                                 len = strlen(tptr->month[i]);
 368                                 if (strncasecmp(buf, tptr->month[i], len) == 0)
 369                                         break;
 370                         }
 371                         /*
 372                          * Try the abbreviated month name if the full name
 373                          * wasn't found.
 374                          */
 375                         if (i == asizeof(tptr->month)) {
 376                                 for (i = 0; i < asizeof(tptr->month); i++) {
 377                                         len = strlen(tptr->mon[i]);
 378                                         if (strncasecmp(buf, tptr->mon[i],
 379                                             len) == 0)
 380                                                 break;
 381                                 }
 382                         }
 383                         if (i == asizeof(tptr->month))
 384                                 return (NULL);
 385
 386                         tm->tm_mon = i;
 387                         buf += len;
 388                         break;
 389
 390                 case 'm':
 391                         if (!isdigit(*buf))
 392                                 return (NULL);
 393
 394                         len = 2;
 395                         for (i = 0; len && isdigit(*buf); buf++) {
 396                                 i *= 10;
 397                                 i += *buf - '0';
 398                                 len--;
 399                         }
 400                         if (i < 1 || i > 12)
 401                                 return (NULL);
 402
 403                         tm->tm_mon = i - 1;
 404
 405                         break;
 406
 407                 case 's':
 408                         {
 409                         char *cp;
 410                         int sverrno;
 411                         time_t t;
 412
 413                         sverrno = errno;
 414                         errno = 0;
 415                         t = strtol(buf, &cp, 10);
 416                         if (errno == ERANGE) {
 417                                 errno = sverrno;
 418                                 return (NULL);
 419                         }
 420                         errno = sverrno;
 421                         buf = cp;
 422                         (void) gmtime_r(&t, tm);
 423                         *flagsp |= F_GMT;
 424                         }
 425                         break;
 426
 427                 case 'Y':
 428                 case 'y':
 429                         if (*buf == '\0' || isspace(*buf))
 430                                 break;
 431
 432                         if (!isdigit(*buf))
 433                                 return (NULL);
 434
 435                         len = (c == 'Y') ? 4 : 2;
 436                         for (i = 0; len && isdigit(*buf); buf++) {
 437                                 i *= 10;
 438                                 i += *buf - '0';
 439                                 len--;
 440                         }
 441                         if (c == 'Y')
 442                                 i -= 1900;
 443                         if (c == 'y' && i < 69)
 444                                 i += 100;
 445                         if (i < 0)
 446                                 return (NULL);
 447
 448                         tm->tm_year = i;
 449
 450                         break;
 451
 452                 case 'Z':
 453                         {
 454                         const char *cp = buf;
 455                         char *zonestr;
 456
 457                         while (isupper(*cp))
 458                                 ++cp;
 459                         if (cp - buf) {
 460                                 zonestr = alloca(cp - buf + 1);
 461                                 (void) strncpy(zonestr, buf, cp - buf);
 462                                 zonestr[cp - buf] = '\0';
 463                                 tzset();
 464                                 if (strcmp(zonestr, "GMT") == 0) {
 465                                         *flagsp |= F_GMT;
 466                                 } else if (0 == strcmp(zonestr, tzname[0])) {
 467                                         tm->tm_isdst = 0;
 468                                 } else if (0 == strcmp(zonestr, tzname[1])) {
 469                                         tm->tm_isdst = 1;
 470                                 } else {
 471                                         return (NULL);
 472                                 }
 473                                 buf += cp - buf;
 474                         }
 475                         }
 476                         break;
 477
 478                 case 'z':
 479                         {
 480                         int sign = 1;
 481
 482                         if (*buf != '+') {
 483                                 if (*buf == '-')
 484                                         sign = -1;
 485                                 else
 486                                         return (NULL);
 487                         }
 488                         buf++;
 489                         i = 0;
 490                         for (len = 4; len > 0; len--) {
 491                                 if (!isdigit(*buf))
 492                                         return (NULL);
 493                                 i *= 10;
 494                                 i += *buf - '0';
 495                                 buf++;
 496                         }
 497
 498                         tm->tm_hour -= sign * (i / 100);
 499                         tm->tm_min -= sign * (i % 100);
 500                         *flagsp |= F_GMT;
 501                         }
 502                         break;
 503                 case 'n':
 504                 case 't':
 505                         while (isspace(*buf))
 506                                 buf++;
 507                         break;
 508                 }
 509         }
 510
 511         if (!recurse) {
 512                 if (buf && (*flagsp & F_GMT)) {
 513                         time_t t = timegm(tm);
 514                         (void) localtime_r(&t, tm);
 515                 }
 516         }
 517
 518         return ((char *)buf);
 519 }
 520
 521 char *
 522 strptime(const char *_RESTRICT_KYWD buf, const char *_RESTRICT_KYWD fmt,
 523     struct tm *_RESTRICT_KYWD tm)
 524 {
 525         int     flags = 0;
 526
 527         (void) memset(tm, 0, sizeof (*tm));
 528
 529         return (__strptime(buf, fmt, tm, &flags, uselocale(NULL)));
 530 }
 531
 532 /*
 533  * This is used by Solaris, and is a variant that does not clear the
 534  * incoming tm.  It is triggered by -D_STRPTIME_DONTZERO.
 535  */
 536 char *
 537 __strptime_dontzero(const char *_RESTRICT_KYWD buf,
 538     const char *_RESTRICT_KYWD fmt, struct tm *_RESTRICT_KYWD tm)
 539 {
 540         int     flags = 0;
 541
 542         return (__strptime(buf, fmt, tm, &flags, uselocale(NULL)));
 543 }
 544
 545 /*
 546  * strptime_l is an extension that seems natural, and indeed, MacOS X
 547  * includes it within their <xlocale.h> and it is part of GNU libc as well.
 548  * For now we restrict it to the cases where strict namespaces are not
 549  * included.  We expect to see it in a future version of POSIX.  locale_t is
 550  * not a restrict, since the spec for it doesn't assume its a pointer.  We
 551  * therefore pass it analagously to the way strftime_l is specified.
 552  *
 553  * We are not providing a non-zeroing version at this time.
 554  */
 555 char *
 556 strptime_l(const char *_RESTRICT_KYWD buf, const char *_RESTRICT_KYWD fmt,
 557     struct tm *_RESTRICT_KYWD tm, locale_t loc)
 558 {
 559         int     flags =  0;
 560
 561         (void) memset(tm, 0, sizeof (*tm));
 562
 563         return (__strptime(buf, fmt, tm, &flags, loc));
 564 }