Annotation of embedaddon/curl/lib/parsedate.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
! 9: *
! 10: * This software is licensed as described in the file COPYING, which
! 11: * you should have received as part of this distribution. The terms
! 12: * are also available at https://curl.haxx.se/docs/copyright.html.
! 13: *
! 14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 15: * copies of the Software, and permit persons to whom the Software is
! 16: * furnished to do so, under the terms of the COPYING file.
! 17: *
! 18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 19: * KIND, either express or implied.
! 20: *
! 21: ***************************************************************************/
! 22: /*
! 23: A brief summary of the date string formats this parser groks:
! 24:
! 25: RFC 2616 3.3.1
! 26:
! 27: Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123
! 28: Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
! 29: Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format
! 30:
! 31: we support dates without week day name:
! 32:
! 33: 06 Nov 1994 08:49:37 GMT
! 34: 06-Nov-94 08:49:37 GMT
! 35: Nov 6 08:49:37 1994
! 36:
! 37: without the time zone:
! 38:
! 39: 06 Nov 1994 08:49:37
! 40: 06-Nov-94 08:49:37
! 41:
! 42: weird order:
! 43:
! 44: 1994 Nov 6 08:49:37 (GNU date fails)
! 45: GMT 08:49:37 06-Nov-94 Sunday
! 46: 94 6 Nov 08:49:37 (GNU date fails)
! 47:
! 48: time left out:
! 49:
! 50: 1994 Nov 6
! 51: 06-Nov-94
! 52: Sun Nov 6 94
! 53:
! 54: unusual separators:
! 55:
! 56: 1994.Nov.6
! 57: Sun/Nov/6/94/GMT
! 58:
! 59: commonly used time zone names:
! 60:
! 61: Sun, 06 Nov 1994 08:49:37 CET
! 62: 06 Nov 1994 08:49:37 EST
! 63:
! 64: time zones specified using RFC822 style:
! 65:
! 66: Sun, 12 Sep 2004 15:05:58 -0700
! 67: Sat, 11 Sep 2004 21:32:11 +0200
! 68:
! 69: compact numerical date strings:
! 70:
! 71: 20040912 15:05:58 -0700
! 72: 20040911 +0200
! 73:
! 74: */
! 75:
! 76: #include "curl_setup.h"
! 77:
! 78: #include <limits.h>
! 79:
! 80: #include <curl/curl.h>
! 81: #include "strcase.h"
! 82: #include "warnless.h"
! 83: #include "parsedate.h"
! 84:
! 85: /*
! 86: * parsedate()
! 87: *
! 88: * Returns:
! 89: *
! 90: * PARSEDATE_OK - a fine conversion
! 91: * PARSEDATE_FAIL - failed to convert
! 92: * PARSEDATE_LATER - time overflow at the far end of time_t
! 93: * PARSEDATE_SOONER - time underflow at the low end of time_t
! 94: */
! 95:
! 96: static int parsedate(const char *date, time_t *output);
! 97:
! 98: #define PARSEDATE_OK 0
! 99: #define PARSEDATE_FAIL -1
! 100: #define PARSEDATE_LATER 1
! 101: #define PARSEDATE_SOONER 2
! 102:
! 103: #if !defined(CURL_DISABLE_PARSEDATE) || !defined(CURL_DISABLE_FTP) || \
! 104: !defined(CURL_DISABLE_FILE)
! 105: /* These names are also used by FTP and FILE code */
! 106: const char * const Curl_wkday[] =
! 107: {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
! 108: const char * const Curl_month[]=
! 109: { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
! 110: "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
! 111: #endif
! 112:
! 113: #ifndef CURL_DISABLE_PARSEDATE
! 114: static const char * const weekday[] =
! 115: { "Monday", "Tuesday", "Wednesday", "Thursday",
! 116: "Friday", "Saturday", "Sunday" };
! 117:
! 118: struct tzinfo {
! 119: char name[5];
! 120: int offset; /* +/- in minutes */
! 121: };
! 122:
! 123: /* Here's a bunch of frequently used time zone names. These were supported
! 124: by the old getdate parser. */
! 125: #define tDAYZONE -60 /* offset for daylight savings time */
! 126: static const struct tzinfo tz[]= {
! 127: {"GMT", 0}, /* Greenwich Mean */
! 128: {"UT", 0}, /* Universal Time */
! 129: {"UTC", 0}, /* Universal (Coordinated) */
! 130: {"WET", 0}, /* Western European */
! 131: {"BST", 0 tDAYZONE}, /* British Summer */
! 132: {"WAT", 60}, /* West Africa */
! 133: {"AST", 240}, /* Atlantic Standard */
! 134: {"ADT", 240 tDAYZONE}, /* Atlantic Daylight */
! 135: {"EST", 300}, /* Eastern Standard */
! 136: {"EDT", 300 tDAYZONE}, /* Eastern Daylight */
! 137: {"CST", 360}, /* Central Standard */
! 138: {"CDT", 360 tDAYZONE}, /* Central Daylight */
! 139: {"MST", 420}, /* Mountain Standard */
! 140: {"MDT", 420 tDAYZONE}, /* Mountain Daylight */
! 141: {"PST", 480}, /* Pacific Standard */
! 142: {"PDT", 480 tDAYZONE}, /* Pacific Daylight */
! 143: {"YST", 540}, /* Yukon Standard */
! 144: {"YDT", 540 tDAYZONE}, /* Yukon Daylight */
! 145: {"HST", 600}, /* Hawaii Standard */
! 146: {"HDT", 600 tDAYZONE}, /* Hawaii Daylight */
! 147: {"CAT", 600}, /* Central Alaska */
! 148: {"AHST", 600}, /* Alaska-Hawaii Standard */
! 149: {"NT", 660}, /* Nome */
! 150: {"IDLW", 720}, /* International Date Line West */
! 151: {"CET", -60}, /* Central European */
! 152: {"MET", -60}, /* Middle European */
! 153: {"MEWT", -60}, /* Middle European Winter */
! 154: {"MEST", -60 tDAYZONE}, /* Middle European Summer */
! 155: {"CEST", -60 tDAYZONE}, /* Central European Summer */
! 156: {"MESZ", -60 tDAYZONE}, /* Middle European Summer */
! 157: {"FWT", -60}, /* French Winter */
! 158: {"FST", -60 tDAYZONE}, /* French Summer */
! 159: {"EET", -120}, /* Eastern Europe, USSR Zone 1 */
! 160: {"WAST", -420}, /* West Australian Standard */
! 161: {"WADT", -420 tDAYZONE}, /* West Australian Daylight */
! 162: {"CCT", -480}, /* China Coast, USSR Zone 7 */
! 163: {"JST", -540}, /* Japan Standard, USSR Zone 8 */
! 164: {"EAST", -600}, /* Eastern Australian Standard */
! 165: {"EADT", -600 tDAYZONE}, /* Eastern Australian Daylight */
! 166: {"GST", -600}, /* Guam Standard, USSR Zone 9 */
! 167: {"NZT", -720}, /* New Zealand */
! 168: {"NZST", -720}, /* New Zealand Standard */
! 169: {"NZDT", -720 tDAYZONE}, /* New Zealand Daylight */
! 170: {"IDLE", -720}, /* International Date Line East */
! 171: /* Next up: Military timezone names. RFC822 allowed these, but (as noted in
! 172: RFC 1123) had their signs wrong. Here we use the correct signs to match
! 173: actual military usage.
! 174: */
! 175: {"A", 1 * 60}, /* Alpha */
! 176: {"B", 2 * 60}, /* Bravo */
! 177: {"C", 3 * 60}, /* Charlie */
! 178: {"D", 4 * 60}, /* Delta */
! 179: {"E", 5 * 60}, /* Echo */
! 180: {"F", 6 * 60}, /* Foxtrot */
! 181: {"G", 7 * 60}, /* Golf */
! 182: {"H", 8 * 60}, /* Hotel */
! 183: {"I", 9 * 60}, /* India */
! 184: /* "J", Juliet is not used as a timezone, to indicate the observer's local
! 185: time */
! 186: {"K", 10 * 60}, /* Kilo */
! 187: {"L", 11 * 60}, /* Lima */
! 188: {"M", 12 * 60}, /* Mike */
! 189: {"N", -1 * 60}, /* November */
! 190: {"O", -2 * 60}, /* Oscar */
! 191: {"P", -3 * 60}, /* Papa */
! 192: {"Q", -4 * 60}, /* Quebec */
! 193: {"R", -5 * 60}, /* Romeo */
! 194: {"S", -6 * 60}, /* Sierra */
! 195: {"T", -7 * 60}, /* Tango */
! 196: {"U", -8 * 60}, /* Uniform */
! 197: {"V", -9 * 60}, /* Victor */
! 198: {"W", -10 * 60}, /* Whiskey */
! 199: {"X", -11 * 60}, /* X-ray */
! 200: {"Y", -12 * 60}, /* Yankee */
! 201: {"Z", 0}, /* Zulu, zero meridian, a.k.a. UTC */
! 202: };
! 203:
! 204: /* returns:
! 205: -1 no day
! 206: 0 monday - 6 sunday
! 207: */
! 208:
! 209: static int checkday(const char *check, size_t len)
! 210: {
! 211: int i;
! 212: const char * const *what;
! 213: bool found = FALSE;
! 214: if(len > 3)
! 215: what = &weekday[0];
! 216: else
! 217: what = &Curl_wkday[0];
! 218: for(i = 0; i<7; i++) {
! 219: if(strcasecompare(check, what[0])) {
! 220: found = TRUE;
! 221: break;
! 222: }
! 223: what++;
! 224: }
! 225: return found?i:-1;
! 226: }
! 227:
! 228: static int checkmonth(const char *check)
! 229: {
! 230: int i;
! 231: const char * const *what;
! 232: bool found = FALSE;
! 233:
! 234: what = &Curl_month[0];
! 235: for(i = 0; i<12; i++) {
! 236: if(strcasecompare(check, what[0])) {
! 237: found = TRUE;
! 238: break;
! 239: }
! 240: what++;
! 241: }
! 242: return found?i:-1; /* return the offset or -1, no real offset is -1 */
! 243: }
! 244:
! 245: /* return the time zone offset between GMT and the input one, in number
! 246: of seconds or -1 if the timezone wasn't found/legal */
! 247:
! 248: static int checktz(const char *check)
! 249: {
! 250: unsigned int i;
! 251: const struct tzinfo *what;
! 252: bool found = FALSE;
! 253:
! 254: what = tz;
! 255: for(i = 0; i< sizeof(tz)/sizeof(tz[0]); i++) {
! 256: if(strcasecompare(check, what->name)) {
! 257: found = TRUE;
! 258: break;
! 259: }
! 260: what++;
! 261: }
! 262: return found?what->offset*60:-1;
! 263: }
! 264:
! 265: static void skip(const char **date)
! 266: {
! 267: /* skip everything that aren't letters or digits */
! 268: while(**date && !ISALNUM(**date))
! 269: (*date)++;
! 270: }
! 271:
! 272: enum assume {
! 273: DATE_MDAY,
! 274: DATE_YEAR,
! 275: DATE_TIME
! 276: };
! 277:
! 278: /* this is a clone of 'struct tm' but with all fields we don't need or use
! 279: cut out */
! 280: struct my_tm {
! 281: int tm_sec;
! 282: int tm_min;
! 283: int tm_hour;
! 284: int tm_mday;
! 285: int tm_mon;
! 286: int tm_year; /* full year */
! 287: };
! 288:
! 289: /* struct tm to time since epoch in GMT time zone.
! 290: * This is similar to the standard mktime function but for GMT only, and
! 291: * doesn't suffer from the various bugs and portability problems that
! 292: * some systems' implementations have.
! 293: *
! 294: * Returns 0 on success, otherwise non-zero.
! 295: */
! 296: static void my_timegm(struct my_tm *tm, time_t *t)
! 297: {
! 298: static const int month_days_cumulative [12] =
! 299: { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
! 300: int month, year, leap_days;
! 301:
! 302: year = tm->tm_year;
! 303: month = tm->tm_mon;
! 304: if(month < 0) {
! 305: year += (11 - month) / 12;
! 306: month = 11 - (11 - month) % 12;
! 307: }
! 308: else if(month >= 12) {
! 309: year -= month / 12;
! 310: month = month % 12;
! 311: }
! 312:
! 313: leap_days = year - (tm->tm_mon <= 1);
! 314: leap_days = ((leap_days / 4) - (leap_days / 100) + (leap_days / 400)
! 315: - (1969 / 4) + (1969 / 100) - (1969 / 400));
! 316:
! 317: *t = ((((time_t) (year - 1970) * 365
! 318: + leap_days + month_days_cumulative[month] + tm->tm_mday - 1) * 24
! 319: + tm->tm_hour) * 60 + tm->tm_min) * 60 + tm->tm_sec;
! 320: }
! 321:
! 322: /*
! 323: * parsedate()
! 324: *
! 325: * Returns:
! 326: *
! 327: * PARSEDATE_OK - a fine conversion
! 328: * PARSEDATE_FAIL - failed to convert
! 329: * PARSEDATE_LATER - time overflow at the far end of time_t
! 330: * PARSEDATE_SOONER - time underflow at the low end of time_t
! 331: */
! 332:
! 333: static int parsedate(const char *date, time_t *output)
! 334: {
! 335: time_t t = 0;
! 336: int wdaynum = -1; /* day of the week number, 0-6 (mon-sun) */
! 337: int monnum = -1; /* month of the year number, 0-11 */
! 338: int mdaynum = -1; /* day of month, 1 - 31 */
! 339: int hournum = -1;
! 340: int minnum = -1;
! 341: int secnum = -1;
! 342: int yearnum = -1;
! 343: int tzoff = -1;
! 344: struct my_tm tm;
! 345: enum assume dignext = DATE_MDAY;
! 346: const char *indate = date; /* save the original pointer */
! 347: int part = 0; /* max 6 parts */
! 348:
! 349: while(*date && (part < 6)) {
! 350: bool found = FALSE;
! 351:
! 352: skip(&date);
! 353:
! 354: if(ISALPHA(*date)) {
! 355: /* a name coming up */
! 356: char buf[32]="";
! 357: size_t len;
! 358: if(sscanf(date, "%31[ABCDEFGHIJKLMNOPQRSTUVWXYZ"
! 359: "abcdefghijklmnopqrstuvwxyz]", buf))
! 360: len = strlen(buf);
! 361: else
! 362: len = 0;
! 363:
! 364: if(wdaynum == -1) {
! 365: wdaynum = checkday(buf, len);
! 366: if(wdaynum != -1)
! 367: found = TRUE;
! 368: }
! 369: if(!found && (monnum == -1)) {
! 370: monnum = checkmonth(buf);
! 371: if(monnum != -1)
! 372: found = TRUE;
! 373: }
! 374:
! 375: if(!found && (tzoff == -1)) {
! 376: /* this just must be a time zone string */
! 377: tzoff = checktz(buf);
! 378: if(tzoff != -1)
! 379: found = TRUE;
! 380: }
! 381:
! 382: if(!found)
! 383: return PARSEDATE_FAIL; /* bad string */
! 384:
! 385: date += len;
! 386: }
! 387: else if(ISDIGIT(*date)) {
! 388: /* a digit */
! 389: int val;
! 390: char *end;
! 391: int len = 0;
! 392: if((secnum == -1) &&
! 393: (3 == sscanf(date, "%02d:%02d:%02d%n",
! 394: &hournum, &minnum, &secnum, &len))) {
! 395: /* time stamp! */
! 396: date += len;
! 397: }
! 398: else if((secnum == -1) &&
! 399: (2 == sscanf(date, "%02d:%02d%n", &hournum, &minnum, &len))) {
! 400: /* time stamp without seconds */
! 401: date += len;
! 402: secnum = 0;
! 403: }
! 404: else {
! 405: long lval;
! 406: int error;
! 407: int old_errno;
! 408:
! 409: old_errno = errno;
! 410: errno = 0;
! 411: lval = strtol(date, &end, 10);
! 412: error = errno;
! 413: if(errno != old_errno)
! 414: errno = old_errno;
! 415:
! 416: if(error)
! 417: return PARSEDATE_FAIL;
! 418:
! 419: #if LONG_MAX != INT_MAX
! 420: if((lval > (long)INT_MAX) || (lval < (long)INT_MIN))
! 421: return PARSEDATE_FAIL;
! 422: #endif
! 423:
! 424: val = curlx_sltosi(lval);
! 425:
! 426: if((tzoff == -1) &&
! 427: ((end - date) == 4) &&
! 428: (val <= 1400) &&
! 429: (indate< date) &&
! 430: ((date[-1] == '+' || date[-1] == '-'))) {
! 431: /* four digits and a value less than or equal to 1400 (to take into
! 432: account all sorts of funny time zone diffs) and it is preceded
! 433: with a plus or minus. This is a time zone indication. 1400 is
! 434: picked since +1300 is frequently used and +1400 is mentioned as
! 435: an edge number in the document "ISO C 200X Proposal: Timezone
! 436: Functions" at http://david.tribble.com/text/c0xtimezone.html If
! 437: anyone has a more authoritative source for the exact maximum time
! 438: zone offsets, please speak up! */
! 439: found = TRUE;
! 440: tzoff = (val/100 * 60 + val%100)*60;
! 441:
! 442: /* the + and - prefix indicates the local time compared to GMT,
! 443: this we need their reversed math to get what we want */
! 444: tzoff = date[-1]=='+'?-tzoff:tzoff;
! 445: }
! 446:
! 447: if(((end - date) == 8) &&
! 448: (yearnum == -1) &&
! 449: (monnum == -1) &&
! 450: (mdaynum == -1)) {
! 451: /* 8 digits, no year, month or day yet. This is YYYYMMDD */
! 452: found = TRUE;
! 453: yearnum = val/10000;
! 454: monnum = (val%10000)/100-1; /* month is 0 - 11 */
! 455: mdaynum = val%100;
! 456: }
! 457:
! 458: if(!found && (dignext == DATE_MDAY) && (mdaynum == -1)) {
! 459: if((val > 0) && (val<32)) {
! 460: mdaynum = val;
! 461: found = TRUE;
! 462: }
! 463: dignext = DATE_YEAR;
! 464: }
! 465:
! 466: if(!found && (dignext == DATE_YEAR) && (yearnum == -1)) {
! 467: yearnum = val;
! 468: found = TRUE;
! 469: if(yearnum < 100) {
! 470: if(yearnum > 70)
! 471: yearnum += 1900;
! 472: else
! 473: yearnum += 2000;
! 474: }
! 475: if(mdaynum == -1)
! 476: dignext = DATE_MDAY;
! 477: }
! 478:
! 479: if(!found)
! 480: return PARSEDATE_FAIL;
! 481:
! 482: date = end;
! 483: }
! 484: }
! 485:
! 486: part++;
! 487: }
! 488:
! 489: if(-1 == secnum)
! 490: secnum = minnum = hournum = 0; /* no time, make it zero */
! 491:
! 492: if((-1 == mdaynum) ||
! 493: (-1 == monnum) ||
! 494: (-1 == yearnum))
! 495: /* lacks vital info, fail */
! 496: return PARSEDATE_FAIL;
! 497:
! 498: #ifdef HAVE_TIME_T_UNSIGNED
! 499: if(yearnum < 1970) {
! 500: /* only positive numbers cannot return earlier */
! 501: *output = TIME_T_MIN;
! 502: return PARSEDATE_SOONER;
! 503: }
! 504: #endif
! 505:
! 506: #if (SIZEOF_TIME_T < 5)
! 507:
! 508: #ifdef HAVE_TIME_T_UNSIGNED
! 509: /* an unsigned 32 bit time_t can only hold dates to 2106 */
! 510: if(yearnum > 2105) {
! 511: *output = TIME_T_MAX;
! 512: return PARSEDATE_LATER;
! 513: }
! 514: #else
! 515: /* a signed 32 bit time_t can only hold dates to the beginning of 2038 */
! 516: if(yearnum > 2037) {
! 517: *output = TIME_T_MAX;
! 518: return PARSEDATE_LATER;
! 519: }
! 520: if(yearnum < 1903) {
! 521: *output = TIME_T_MIN;
! 522: return PARSEDATE_SOONER;
! 523: }
! 524: #endif
! 525:
! 526: #else
! 527: /* The Gregorian calendar was introduced 1582 */
! 528: if(yearnum < 1583)
! 529: return PARSEDATE_FAIL;
! 530: #endif
! 531:
! 532: if((mdaynum > 31) || (monnum > 11) ||
! 533: (hournum > 23) || (minnum > 59) || (secnum > 60))
! 534: return PARSEDATE_FAIL; /* clearly an illegal date */
! 535:
! 536: tm.tm_sec = secnum;
! 537: tm.tm_min = minnum;
! 538: tm.tm_hour = hournum;
! 539: tm.tm_mday = mdaynum;
! 540: tm.tm_mon = monnum;
! 541: tm.tm_year = yearnum;
! 542:
! 543: /* my_timegm() returns a time_t. time_t is often 32 bits, sometimes even on
! 544: architectures that feature 64 bit 'long' but ultimately time_t is the
! 545: correct data type to use.
! 546: */
! 547: my_timegm(&tm, &t);
! 548:
! 549: /* Add the time zone diff between local time zone and GMT. */
! 550: if(tzoff == -1)
! 551: tzoff = 0;
! 552:
! 553: if((tzoff > 0) && (t > TIME_T_MAX - tzoff)) {
! 554: *output = TIME_T_MAX;
! 555: return PARSEDATE_LATER; /* time_t overflow */
! 556: }
! 557:
! 558: t += tzoff;
! 559:
! 560: *output = t;
! 561:
! 562: return PARSEDATE_OK;
! 563: }
! 564: #else
! 565: /* disabled */
! 566: static int parsedate(const char *date, time_t *output)
! 567: {
! 568: (void)date;
! 569: *output = 0;
! 570: return PARSEDATE_OK; /* a lie */
! 571: }
! 572: #endif
! 573:
! 574: time_t curl_getdate(const char *p, const time_t *now)
! 575: {
! 576: time_t parsed = -1;
! 577: int rc = parsedate(p, &parsed);
! 578: (void)now; /* legacy argument from the past that we ignore */
! 579:
! 580: if(rc == PARSEDATE_OK) {
! 581: if(parsed == -1)
! 582: /* avoid returning -1 for a working scenario */
! 583: parsed++;
! 584: return parsed;
! 585: }
! 586: /* everything else is fail */
! 587: return -1;
! 588: }
! 589:
! 590: /* Curl_getdate_capped() differs from curl_getdate() in that this will return
! 591: TIME_T_MAX in case the parsed time value was too big, instead of an
! 592: error. */
! 593:
! 594: time_t Curl_getdate_capped(const char *p)
! 595: {
! 596: time_t parsed = -1;
! 597: int rc = parsedate(p, &parsed);
! 598:
! 599: switch(rc) {
! 600: case PARSEDATE_OK:
! 601: if(parsed == -1)
! 602: /* avoid returning -1 for a working scenario */
! 603: parsed++;
! 604: return parsed;
! 605: case PARSEDATE_LATER:
! 606: /* this returns the maximum time value */
! 607: return parsed;
! 608: default:
! 609: return -1; /* everything else is fail */
! 610: }
! 611: /* UNREACHABLE */
! 612: }
! 613:
! 614: /*
! 615: * Curl_gmtime() is a gmtime() replacement for portability. Do not use the
! 616: * gmtime_r() or gmtime() functions anywhere else but here.
! 617: *
! 618: */
! 619:
! 620: CURLcode Curl_gmtime(time_t intime, struct tm *store)
! 621: {
! 622: const struct tm *tm;
! 623: #ifdef HAVE_GMTIME_R
! 624: /* thread-safe version */
! 625: tm = (struct tm *)gmtime_r(&intime, store);
! 626: #else
! 627: tm = gmtime(&intime);
! 628: if(tm)
! 629: *store = *tm; /* copy the pointed struct to the local copy */
! 630: #endif
! 631:
! 632: if(!tm)
! 633: return CURLE_BAD_FUNCTION_ARGUMENT;
! 634: return CURLE_OK;
! 635: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parsedate.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib