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 } 565