1 /* Parse a time duration and return a seconds count 2 Copyright (C) 2008-2015 Free Software Foundation, Inc. 3 Written by Bruce Korb <bkorb@gnu.org>, 2008. 4 5 This program is free software: you can redistribute it and/or modify 6 it under the terms of the GNU Lesser General Public License as published by 7 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public License 16 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 17 18 #include <config.h> 19 20 /* Specification. */ 21 #include "parse-duration.h" 22 23 #include <ctype.h> 24 #include <errno.h> 25 #include <limits.h> 26 #include <stdio.h> 27 #include <stdlib.h> 28 #include <string.h> 29 30 #include "intprops.h" 31 32 #ifndef NUL 33 #define NUL '\0' 34 #endif 35 36 #define cch_t char const 37 38 typedef enum { 39 NOTHING_IS_DONE, 40 YEAR_IS_DONE, 41 MONTH_IS_DONE, 42 WEEK_IS_DONE, 43 DAY_IS_DONE, 44 HOUR_IS_DONE, 45 MINUTE_IS_DONE, 46 SECOND_IS_DONE 47 } whats_done_t; 48 49 #define SEC_PER_MIN 60 50 #define SEC_PER_HR (SEC_PER_MIN * 60) 51 #define SEC_PER_DAY (SEC_PER_HR * 24) 52 #define SEC_PER_WEEK (SEC_PER_DAY * 7) 53 #define SEC_PER_MONTH (SEC_PER_DAY * 30) 54 #define SEC_PER_YEAR (SEC_PER_DAY * 365) 55 56 #undef MAX_DURATION 57 #define MAX_DURATION TYPE_MAXIMUM(time_t) 58 59 /* Wrapper around strtoul that does not require a cast. */ 60 static unsigned long 61 str_const_to_ul (cch_t * str, cch_t ** ppz, int base) 62 { 63 return strtoul (str, (char **)ppz, base); 64 } 65 66 /* Wrapper around strtol that does not require a cast. */ 67 static long 68 str_const_to_l (cch_t * str, cch_t ** ppz, int base) 69 { 70 return strtol (str, (char **)ppz, base); 71 } 72 73 /* Returns BASE + VAL * SCALE, interpreting BASE = BAD_TIME 74 with errno set as an error situation, and returning BAD_TIME 75 with errno set in an error situation. */ 76 static time_t 77 scale_n_add (time_t base, time_t val, int scale) 78 { 79 if (base == BAD_TIME) 80 { 81 if (errno == 0) 82 errno = EINVAL; 83 return BAD_TIME; 84 } 85 86 if (val > MAX_DURATION / scale) 87 { 88 errno = ERANGE; 89 return BAD_TIME; 90 } 91 92 val *= scale; 93 if (base > MAX_DURATION - val) 94 { 95 errno = ERANGE; 96 return BAD_TIME; 97 } 98 99 return base + val; 100 } 101 102 /* After a number HH has been parsed, parse subsequent :MM or :MM:SS. */ 103 static time_t 104 parse_hr_min_sec (time_t start, cch_t * pz) 105 { 106 int lpct = 0; 107 108 errno = 0; 109 110 /* For as long as our scanner pointer points to a colon *AND* 111 we've not looped before, then keep looping. (two iterations max) */ 112 while ((*pz == ':') && (lpct++ <= 1)) 113 { 114 unsigned long v = str_const_to_ul (pz+1, &pz, 10); 115 116 if (errno != 0) 117 return BAD_TIME; 118 119 start = scale_n_add (v, start, 60); 120 121 if (errno != 0) 122 return BAD_TIME; 123 } 124 125 /* allow for trailing spaces */ 126 while (isspace ((unsigned char)*pz)) 127 pz++; 128 if (*pz != NUL) 129 { 130 errno = EINVAL; 131 return BAD_TIME; 132 } 133 134 return start; 135 } 136 137 /* Parses a value and returns BASE + value * SCALE, interpreting 138 BASE = BAD_TIME with errno set as an error situation, and returning 139 BAD_TIME with errno set in an error situation. */ 140 static time_t 141 parse_scaled_value (time_t base, cch_t ** ppz, cch_t * endp, int scale) 142 { 143 cch_t * pz = *ppz; 144 time_t val; 145 146 if (base == BAD_TIME) 147 return base; 148 149 errno = 0; 150 val = str_const_to_ul (pz, &pz, 10); 151 if (errno != 0) 152 return BAD_TIME; 153 while (isspace ((unsigned char)*pz)) 154 pz++; 155 if (pz != endp) 156 { 157 errno = EINVAL; 158 return BAD_TIME; 159 } 160 161 *ppz = pz; 162 return scale_n_add (base, val, scale); 163 } 164 165 /* Parses the syntax YEAR-MONTH-DAY. 166 PS points into the string, after "YEAR", before "-MONTH-DAY". */ 167 static time_t 168 parse_year_month_day (cch_t * pz, cch_t * ps) 169 { 170 time_t res = 0; 171 172 res = parse_scaled_value (0, &pz, ps, SEC_PER_YEAR); 173 174 pz++; /* over the first '-' */ 175 ps = strchr (pz, '-'); 176 if (ps == NULL) 177 { 178 errno = EINVAL; 179 return BAD_TIME; 180 } 181 res = parse_scaled_value (res, &pz, ps, SEC_PER_MONTH); 182 183 pz++; /* over the second '-' */ 184 ps = pz + strlen (pz); 185 return parse_scaled_value (res, &pz, ps, SEC_PER_DAY); 186 } 187 188 /* Parses the syntax YYYYMMDD. */ 189 static time_t 190 parse_yearmonthday (cch_t * in_pz) 191 { 192 time_t res = 0; 193 char buf[8]; 194 cch_t * pz; 195 196 if (strlen (in_pz) != 8) 197 { 198 errno = EINVAL; 199 return BAD_TIME; 200 } 201 202 memcpy (buf, in_pz, 4); 203 buf[4] = NUL; 204 pz = buf; 205 res = parse_scaled_value (0, &pz, buf + 4, SEC_PER_YEAR); 206 207 memcpy (buf, in_pz + 4, 2); 208 buf[2] = NUL; 209 pz = buf; 210 res = parse_scaled_value (res, &pz, buf + 2, SEC_PER_MONTH); 211 212 memcpy (buf, in_pz + 6, 2); 213 buf[2] = NUL; 214 pz = buf; 215 return parse_scaled_value (res, &pz, buf + 2, SEC_PER_DAY); 216 } 217 218 /* Parses the syntax yy Y mm M ww W dd D. */ 219 static time_t 220 parse_YMWD (cch_t * pz) 221 { 222 time_t res = 0; 223 cch_t * ps = strchr (pz, 'Y'); 224 if (ps != NULL) 225 { 226 res = parse_scaled_value (0, &pz, ps, SEC_PER_YEAR); 227 pz++; 228 } 229 230 ps = strchr (pz, 'M'); 231 if (ps != NULL) 232 { 233 res = parse_scaled_value (res, &pz, ps, SEC_PER_MONTH); 234 pz++; 235 } 236 237 ps = strchr (pz, 'W'); 238 if (ps != NULL) 239 { 240 res = parse_scaled_value (res, &pz, ps, SEC_PER_WEEK); 241 pz++; 242 } 243 244 ps = strchr (pz, 'D'); 245 if (ps != NULL) 246 { 247 res = parse_scaled_value (res, &pz, ps, SEC_PER_DAY); 248 pz++; 249 } 250 251 while (isspace ((unsigned char)*pz)) 252 pz++; 253 if (*pz != NUL) 254 { 255 errno = EINVAL; 256 return BAD_TIME; 257 } 258 259 return res; 260 } 261 262 /* Parses the syntax HH:MM:SS. 263 PS points into the string, after "HH", before ":MM:SS". */ 264 static time_t 265 parse_hour_minute_second (cch_t * pz, cch_t * ps) 266 { 267 time_t res = 0; 268 269 res = parse_scaled_value (0, &pz, ps, SEC_PER_HR); 270 271 pz++; 272 ps = strchr (pz, ':'); 273 if (ps == NULL) 274 { 275 errno = EINVAL; 276 return BAD_TIME; 277 } 278 279 res = parse_scaled_value (res, &pz, ps, SEC_PER_MIN); 280 281 pz++; 282 ps = pz + strlen (pz); 283 return parse_scaled_value (res, &pz, ps, 1); 284 } 285 286 /* Parses the syntax HHMMSS. */ 287 static time_t 288 parse_hourminutesecond (cch_t * in_pz) 289 { 290 time_t res = 0; 291 char buf[4]; 292 cch_t * pz; 293 294 if (strlen (in_pz) != 6) 295 { 296 errno = EINVAL; 297 return BAD_TIME; 298 } 299 300 memcpy (buf, in_pz, 2); 301 buf[2] = NUL; 302 pz = buf; 303 res = parse_scaled_value (0, &pz, buf + 2, SEC_PER_HR); 304 305 memcpy (buf, in_pz + 2, 2); 306 buf[2] = NUL; 307 pz = buf; 308 res = parse_scaled_value (res, &pz, buf + 2, SEC_PER_MIN); 309 310 memcpy (buf, in_pz + 4, 2); 311 buf[2] = NUL; 312 pz = buf; 313 return parse_scaled_value (res, &pz, buf + 2, 1); 314 } 315 316 /* Parses the syntax hh H mm M ss S. */ 317 static time_t 318 parse_HMS (cch_t * pz) 319 { 320 time_t res = 0; 321 cch_t * ps = strchr (pz, 'H'); 322 if (ps != NULL) 323 { 324 res = parse_scaled_value (0, &pz, ps, SEC_PER_HR); 325 pz++; 326 } 327 328 ps = strchr (pz, 'M'); 329 if (ps != NULL) 330 { 331 res = parse_scaled_value (res, &pz, ps, SEC_PER_MIN); 332 pz++; 333 } 334 335 ps = strchr (pz, 'S'); 336 if (ps != NULL) 337 { 338 res = parse_scaled_value (res, &pz, ps, 1); 339 pz++; 340 } 341 342 while (isspace ((unsigned char)*pz)) 343 pz++; 344 if (*pz != NUL) 345 { 346 errno = EINVAL; 347 return BAD_TIME; 348 } 349 350 return res; 351 } 352 353 /* Parses a time (hours, minutes, seconds) specification in either syntax. */ 354 static time_t 355 parse_time (cch_t * pz) 356 { 357 cch_t * ps; 358 time_t res = 0; 359 360 /* 361 * Scan for a hyphen 362 */ 363 ps = strchr (pz, ':'); 364 if (ps != NULL) 365 { 366 res = parse_hour_minute_second (pz, ps); 367 } 368 369 /* 370 * Try for a 'H', 'M' or 'S' suffix 371 */ 372 else if (ps = strpbrk (pz, "HMS"), 373 ps == NULL) 374 { 375 /* Its a YYYYMMDD format: */ 376 res = parse_hourminutesecond (pz); 377 } 378 379 else 380 res = parse_HMS (pz); 381 382 return res; 383 } 384 385 /* Returns a substring of the given string, with spaces at the beginning and at 386 the end destructively removed, per SNOBOL. */ 387 static char * 388 trim (char * pz) 389 { 390 /* trim leading white space */ 391 while (isspace ((unsigned char)*pz)) 392 pz++; 393 394 /* trim trailing white space */ 395 { 396 char * pe = pz + strlen (pz); 397 while ((pe > pz) && isspace ((unsigned char)pe[-1])) 398 pe--; 399 *pe = NUL; 400 } 401 402 return pz; 403 } 404 405 /* 406 * Parse the year/months/days of a time period 407 */ 408 static time_t 409 parse_period (cch_t * in_pz) 410 { 411 char * pT; 412 char * ps; 413 char * pz = strdup (in_pz); 414 void * fptr = pz; 415 time_t res = 0; 416 417 if (pz == NULL) 418 { 419 errno = ENOMEM; 420 return BAD_TIME; 421 } 422 423 pT = strchr (pz, 'T'); 424 if (pT != NULL) 425 { 426 *(pT++) = NUL; 427 pz = trim (pz); 428 pT = trim (pT); 429 } 430 431 /* 432 * Scan for a hyphen 433 */ 434 ps = strchr (pz, '-'); 435 if (ps != NULL) 436 { 437 res = parse_year_month_day (pz, ps); 438 } 439 440 /* 441 * Try for a 'Y', 'M' or 'D' suffix 442 */ 443 else if (ps = strpbrk (pz, "YMWD"), 444 ps == NULL) 445 { 446 /* Its a YYYYMMDD format: */ 447 res = parse_yearmonthday (pz); 448 } 449 450 else 451 res = parse_YMWD (pz); 452 453 if ((errno == 0) && (pT != NULL)) 454 { 455 time_t val = parse_time (pT); 456 res = scale_n_add (res, val, 1); 457 } 458 459 free (fptr); 460 return res; 461 } 462 463 static time_t 464 parse_non_iso8601 (cch_t * pz) 465 { 466 whats_done_t whatd_we_do = NOTHING_IS_DONE; 467 468 time_t res = 0; 469 470 do { 471 time_t val; 472 473 errno = 0; 474 val = str_const_to_l (pz, &pz, 10); 475 if (errno != 0) 476 goto bad_time; 477 478 /* IF we find a colon, then we're going to have a seconds value. 479 We will not loop here any more. We cannot already have parsed 480 a minute value and if we've parsed an hour value, then the result 481 value has to be less than an hour. */ 482 if (*pz == ':') 483 { 484 if (whatd_we_do >= MINUTE_IS_DONE) 485 break; 486 487 val = parse_hr_min_sec (val, pz); 488 489 if ((whatd_we_do == HOUR_IS_DONE) && (val >= SEC_PER_HR)) 490 break; 491 492 return scale_n_add (res, val, 1); 493 } 494 495 { 496 unsigned int mult; 497 498 /* Skip over white space following the number we just parsed. */ 499 while (isspace ((unsigned char)*pz)) 500 pz++; 501 502 switch (*pz) 503 { 504 default: goto bad_time; 505 case NUL: 506 return scale_n_add (res, val, 1); 507 508 case 'y': case 'Y': 509 if (whatd_we_do >= YEAR_IS_DONE) 510 goto bad_time; 511 mult = SEC_PER_YEAR; 512 whatd_we_do = YEAR_IS_DONE; 513 break; 514 515 case 'M': 516 if (whatd_we_do >= MONTH_IS_DONE) 517 goto bad_time; 518 mult = SEC_PER_MONTH; 519 whatd_we_do = MONTH_IS_DONE; 520 break; 521 522 case 'W': 523 if (whatd_we_do >= WEEK_IS_DONE) 524 goto bad_time; 525 mult = SEC_PER_WEEK; 526 whatd_we_do = WEEK_IS_DONE; 527 break; 528 529 case 'd': case 'D': 530 if (whatd_we_do >= DAY_IS_DONE) 531 goto bad_time; 532 mult = SEC_PER_DAY; 533 whatd_we_do = DAY_IS_DONE; 534 break; 535 536 case 'h': 537 if (whatd_we_do >= HOUR_IS_DONE) 538 goto bad_time; 539 mult = SEC_PER_HR; 540 whatd_we_do = HOUR_IS_DONE; 541 break; 542 543 case 'm': 544 if (whatd_we_do >= MINUTE_IS_DONE) 545 goto bad_time; 546 mult = SEC_PER_MIN; 547 whatd_we_do = MINUTE_IS_DONE; 548 break; 549 550 case 's': 551 mult = 1; 552 whatd_we_do = SECOND_IS_DONE; 553 break; 554 } 555 556 res = scale_n_add (res, val, mult); 557 558 pz++; 559 while (isspace ((unsigned char)*pz)) 560 pz++; 561 if (*pz == NUL) 562 return res; 563 564 if (! isdigit ((unsigned char)*pz)) 565 break; 566 } 567 568 } while (whatd_we_do < SECOND_IS_DONE); 569 570 bad_time: 571 errno = EINVAL; 572 return BAD_TIME; 573 } 574 575 time_t 576 parse_duration (char const * pz) 577 { 578 while (isspace ((unsigned char)*pz)) 579 pz++; 580 581 switch (*pz) 582 { 583 case 'P': 584 return parse_period (pz + 1); 585 586 case 'T': 587 return parse_time (pz + 1); 588 589 default: 590 if (isdigit ((unsigned char)*pz)) 591 return parse_non_iso8601 (pz); 592 593 errno = EINVAL; 594 return BAD_TIME; 595 } 596 } 597 598 /* 599 * Local Variables: 600 * mode: C 601 * c-file-style: "gnu" 602 * indent-tabs-mode: nil 603 * End: 604 * end of parse-duration.c */ 605