master
1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 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.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 * SPDX-License-Identifier: curl
22 *
23 ***************************************************************************/
24#include "curl_setup.h"
26#include "parsedate.h"
27#include "curlx/strparse.h"
28#include "curlx/strcopy.h"
30/* A brief summary of the date string formats this parser groks:
32 RFC 2616 3.3.1
34 Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123
35 Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
36 Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format
38 we support dates without week day name:
40 06 Nov 1994 08:49:37 GMT
41 06-Nov-94 08:49:37 GMT
42 Nov 6 08:49:37 1994
44 without the time zone:
46 06 Nov 1994 08:49:37
47 06-Nov-94 08:49:37
49 weird order:
51 1994 Nov 6 08:49:37 (GNU date fails)
52 GMT 08:49:37 06-Nov-94 Sunday
53 94 6 Nov 08:49:37 (GNU date fails)
55 time left out:
57 1994 Nov 6
58 06-Nov-94
59 Sun Nov 6 94
61 unusual separators:
63 1994.Nov.6
64 Sun/Nov/6/94/GMT
66 commonly used time zone names:
68 Sun, 06 Nov 1994 08:49:37 CET
69 06 Nov 1994 08:49:37 EST
71 time zones specified using RFC822 style:
73 Sun, 12 Sep 2004 15:05:58 -0700
74 Sat, 11 Sep 2004 21:32:11 +0200
76 compact numerical date strings:
78 20040912 15:05:58 -0700
79 20040911 +0200
80 */
82#if !defined(CURL_DISABLE_PARSEDATE) || !defined(CURL_DISABLE_FTP) || \
83 !defined(CURL_DISABLE_FILE) || defined(USE_GNUTLS)
84/* These names are also used by FTP and FILE code */
85const char * const Curl_wkday[] = {
86 "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"
87};
88const char * const Curl_month[] = {
89 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
90 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
91};
92#endif
94#define PARSEDATE_OK 0
95#define PARSEDATE_FAIL (-1)
97#ifndef CURL_DISABLE_PARSEDATE
99#if SIZEOF_TIME_T < 5
100#define PARSEDATE_LATER 1
101#endif
102#if SIZEOF_TIME_T < 5 || defined(HAVE_TIME_T_UNSIGNED)
103#define PARSEDATE_SOONER 2
104#endif
106struct tzinfo {
107 uint32_t tz;
108 int16_t offset; /* +/- in minutes */
109};
111#define DST (-60) /* offset for daylight savings time */
113/* alpha-sorted list of single-letter time zones, A - Z */
114static const int16_t tzone[] = {
115 -1 * 60, /* Alpha */
116 -2 * 60, /* Bravo */
117 -3 * 60, /* Charlie */
118 -4 * 60, /* Delta */
119 -5 * 60, /* Echo */
120 -6 * 60, /* Foxtrot */
121 -7 * 60, /* Golf */
122 -8 * 60, /* Hotel */
123 -9 * 60, /* India */
124 -1, /* J - not a timezone */
125 -10 * 60, /* Kilo */
126 -11 * 60, /* Lima */
127 -12 * 60, /* Mike */
128 60, /* November */
129 2 * 60, /* Oscar */
130 3 * 60, /* Papa */
131 4 * 60, /* Quebec */
132 5 * 60, /* Romeo */
133 6 * 60, /* Sierra */
134 7 * 60, /* Tango */
135 8 * 60, /* Uniform */
136 9 * 60, /* Victor */
137 10 * 60, /* Whiskey */
138 11 * 60, /* X-ray */
139 12 * 60, /* Yankee */
140 0 /* Zulu, zero meridian, a.k.a. UTC */
141};
143/* two-letter time zones
145 11 * 60, NT - Nome spellchecker:disable-line
146 0, UT - Universal Time
148*/
150#define MKTZ(a,b,c,d) (((a)<<24) | ((b)<<16) | ((c)<<8) | (d))
152/* three-letter time zones */
153static const struct tzinfo tzthree[] = {
154 { MKTZ('A', 'D', 'T', '\0'), 240 + DST }, /* Atlantic Daylight */
155 { MKTZ('A', 'S', 'T', '\0'), 240 }, /* Atlantic Standard */
156 { MKTZ('B', 'S', 'T', '\0'), 0 + DST }, /* British Summer */
157 { MKTZ('C', 'A', 'T', '\0'), 600 }, /* Central Alaska */
158 { MKTZ('C', 'C', 'T', '\0'), -480 }, /* China Coast, USSR Zone 7 */
159 { MKTZ('C', 'D', 'T', '\0'), 360 + DST }, /* Central Daylight */
160 { MKTZ('C', 'E', 'T', '\0'), -60 }, /* Central European */
161 { MKTZ('C', 'S', 'T', '\0'), 360 }, /* Central Standard */
162 { MKTZ('E', 'D', 'T', '\0'), 300 + DST }, /* Eastern Daylight */
163 { MKTZ('E', 'E', 'T', '\0'), -120 }, /* Eastern Europe, USSR Zone 1 */
164 { MKTZ('E', 'S', 'T', '\0'), 300 }, /* Eastern Standard */
165 { MKTZ('F', 'S', 'T', '\0'), -60 + DST }, /* French Summer */
166 { MKTZ('F', 'W', 'T', '\0'), -60 }, /* French Winter */
167 { MKTZ('G', 'M', 'T', '\0'), 0 }, /* Greenwich Mean */
168 { MKTZ('G', 'S', 'T', '\0'), -600 }, /* Guam Standard, USSR Zone 9 */
169 { MKTZ('H', 'D', 'T', '\0'), 600 + DST }, /* Hawaii Daylight */
170 { MKTZ('H', 'S', 'T', '\0'), 600 }, /* Hawaii Standard */
171 { MKTZ('J', 'S', 'T', '\0'), -540 }, /* Japan Standard, USSR Zone 8 */
172 { MKTZ('M', 'D', 'T', '\0'), 420 + DST }, /* Mountain Daylight */
173 { MKTZ('M', 'E', 'T', '\0'), -60 }, /* Middle European */
174 { MKTZ('M', 'S', 'T', '\0'), 420 }, /* Mountain Standard */
175 { MKTZ('N', 'Z', 'T', '\0'), -720 }, /* New Zealand */
176 { MKTZ('P', 'D', 'T', '\0'), 480 + DST }, /* Pacific Daylight */
177 { MKTZ('P', 'S', 'T', '\0'), 480 }, /* Pacific Standard */
178 { MKTZ('U', 'T', 'C', '\0'), 0 }, /* Universal (Coordinated) */
179 { MKTZ('W', 'A', 'T', '\0'), 60 }, /* West Africa */
180 { MKTZ('W', 'E', 'T', '\0'), 0 }, /* Western European */
181 { MKTZ('Y', 'D', 'T', '\0'), 540 + DST }, /* Yukon Daylight */
182 { MKTZ('Y', 'S', 'T', '\0'), 540 }, /* Yukon Standard */
183};
185/* four-letter time zones */
186static const struct tzinfo tzfoura[] = {
187 { MKTZ('A', 'H', 'S', 'T'), 600 }, /* Alaska-Hawaii Standard */
188 { MKTZ('C', 'E', 'S', 'T'), -60 + DST }, /* Central European Summer */
189 { MKTZ('E', 'A', 'D', 'T'), -600 + DST }, /* Eastern Australian Daylight */
190 { MKTZ('E', 'A', 'S', 'T'), -600 }, /* Eastern Australian Standard */
191 { MKTZ('I', 'D', 'L', 'E'), -720 }, /* International Date Line East */
192 { MKTZ('I', 'D', 'L', 'W'), 720 }, /* International Date Line West */
193 { MKTZ('M', 'E', 'S', 'T'), -60 + DST }, /* Middle European Summer */
194 { MKTZ('M', 'E', 'S', 'Z'), -60 + DST }, /* Middle European Summer */
195 { MKTZ('M', 'E', 'W', 'T'), -60 }, /* Middle European Winter */
196 { MKTZ('N', 'Z', 'D', 'T'), -720 + DST }, /* New Zealand Daylight */
197 { MKTZ('N', 'Z', 'S', 'T'), -720 }, /* New Zealand Standard */
198 { MKTZ('W', 'A', 'D', 'T'), -420 + DST }, /* West Australian Daylight */
199 { MKTZ('W', 'A', 'S', 'T'), -420 }, /* spellchecker:disable-line */
200 /* West Australian Standard */
201};
203#define LOWERCASE(x) ((x) | 0x20)
205/* returns:
206 -1 no day
207 0 monday - 6 sunday
209 @unittest 4781
210*/
211UNITTEST int checkday(const char *check, size_t len);
212UNITTEST int checkday(const char *check, size_t len)
213{
214 int day = -1;
215 if(len < 3)
216 return -1; /* too short */
218 switch(LOWERCASE(check[1])) {
219 case 'o': /* monday */
220 if((LOWERCASE(check[0]) == 'm') && LOWERCASE(check[2]) == 'n')
221 day = 0;
222 break;
223 case 'u': /* tuesday or sunday */
224 if((LOWERCASE(check[0]) == 't') && LOWERCASE(check[2]) == 'e')
225 day = 1;
226 else if((LOWERCASE(check[0]) == 's') && LOWERCASE(check[2]) == 'n')
227 day = 6;
228 break;
229 case 'e': /* wednesday */
230 if((LOWERCASE(check[0]) == 'w') && LOWERCASE(check[2]) == 'd')
231 day = 2;
232 break;
233 case 'h': /* thursday */
234 if((LOWERCASE(check[0]) == 't') && LOWERCASE(check[2]) == 'u')
235 day = 3;
236 break;
237 case 'r': /* friday */
238 if((LOWERCASE(check[0]) == 'f') && LOWERCASE(check[2]) == 'i')
239 day = 4;
240 break;
241 case 'a': /* saturday */
242 if((LOWERCASE(check[0]) == 's') && LOWERCASE(check[2]) == 't')
243 day = 5;
244 break;
245 }
246 if((len > 3) && (day != -1)) {
247 /* when more than three letters are provided, verify the tail name case
248 insensitively */
249 static const char * const daysuffix[] = {
250 /* without the leading three letters */
251 "day", "sday", "nesday", "rsday", "day", "urday", "day"
252 };
254 size_t wlen = strlen(daysuffix[day]);
255 if(((len - 3) != wlen) ||
256 !curl_strnequal(&check[3], daysuffix[day], wlen))
257 return -1;
258 }
259 return day;
260}
262/* @unittest 4781 */
264UNITTEST int checkmonth(const char *check, size_t len);
265UNITTEST int checkmonth(const char *check, size_t len)
266{
267 if(len != 3)
268 return -1; /* not a month */
270 switch(LOWERCASE(check[2])) {
271 case 'n': /* jan, jun */
272 if(LOWERCASE(check[0]) == 'j') {
273 uint8_t c2 = LOWERCASE(check[1]);
274 if(c2 == 'a')
275 return 0;
276 else if(c2 == 'u')
277 return 5;
278 }
279 break;
280 case 'b': /* feb */
281 if((LOWERCASE(check[0]) == 'f') && LOWERCASE(check[1]) == 'e')
282 return 1;
283 break;
284 case 'r': /* mar, apr */
285 if(LOWERCASE(check[0]) == 'm') {
286 if(LOWERCASE(check[1]) == 'a')
287 return 2;
288 }
289 else if((LOWERCASE(check[0]) == 'a') && LOWERCASE(check[1]) == 'p')
290 return 3;
291 break;
292 case 'y': /* may */
293 if((LOWERCASE(check[0]) == 'm') && LOWERCASE(check[1]) == 'a')
294 return 4;
295 break;
296 case 'l': /* jul */
297 if((LOWERCASE(check[0]) == 'j') && LOWERCASE(check[1]) == 'u')
298 return 6;
299 break;
300 case 'g': /* aug */
301 if((LOWERCASE(check[0]) == 'a') && LOWERCASE(check[1]) == 'u')
302 return 7;
303 break;
304 case 'p': /* sep */
305 if((LOWERCASE(check[0]) == 's') && LOWERCASE(check[1]) == 'e')
306 return 8;
307 break;
308 case 't': /* oct */
309 if((LOWERCASE(check[0]) == 'o') && LOWERCASE(check[1]) == 'c')
310 return 9;
311 break;
312 case 'v': /* nov */
313 if((LOWERCASE(check[0]) == 'n') && LOWERCASE(check[1]) == 'o')
314 return 10;
315 break;
316 case 'c': /* dec */
317 if((LOWERCASE(check[0]) == 'd') && LOWERCASE(check[1]) == 'e')
318 return 11;
319 break;
320 }
321 return -1; /* return the offset or -1, no real offset is -1 */
322}
324static int tzcompare(const void *m1, const void *m2)
325{
326 const struct tzinfo *tz1 = m1;
327 const struct tzinfo *tz2 = m2;
328 return tz1->tz - tz2->tz;
329}
331/* return the time zone offset between GMT and the input one, in number of
332 seconds or -1 if the timezone was not found/legal
334 @unittest 4781
335*/
336UNITTEST int checktz(const char *check, size_t len);
337UNITTEST int checktz(const char *check, size_t len)
338{
339 char first;
340 if(len > 4)
341 return -1;
342 first = check[0];
343 if(first < 'A')
344 return -1;
345 if(len == 1) {
346 /* short-cut single letter names */
347 if((first > 'Z') || (first == 'J'))
348 return -1; /* no such tz */
349 return tzone[first - 'A'] * 60;
350 }
351 else if(len == 2) {
352 /* two-letter names */
353 if(check[1] == 'T') {
354 if(first == 'N')
355 return 11 * 60 * 60;
356 else if(first == 'U')
357 return 0;
358 }
359 return -1; /* nope */
360 }
361 else if(len == 3) {
362 /* three-letter name */
363 const struct tzinfo *what;
364 struct tzinfo find;
365 if(first > 'Y')
366 return -1;
367 find.tz = MKTZ(first, check[1], check[2], 0);
368 what = bsearch(&find, tzthree, CURL_ARRAYSIZE(tzthree),
369 sizeof(tzthree[0]), tzcompare);
370 if(what)
371 return what->offset * 60;
372 }
373 else {
374 /* four-letter name */
375 const struct tzinfo *what;
376 struct tzinfo find;
377 if(first > 'W')
378 return -1;
379 find.tz = MKTZ(first, check[1], check[2], check[3]);
380 what = bsearch(&find, tzfoura, CURL_ARRAYSIZE(tzfoura),
381 sizeof(tzfoura[0]), tzcompare);
382 if(what)
383 return what->offset * 60;
384 }
385 return -1;
386}
388static void skip(const char **date)
389{
390 /* skip everything that are not letters or digits */
391 while(**date && !ISALNUM(**date))
392 (*date)++;
393}
395/* each field is exactly -1 when unknown */
396struct when {
397 int wday; /* day of the week, 0-6 (mon-sun) */
398 int mon; /* month of the year, 0-11 */
399 int mday; /* day of month, 1 - 31 */
400 int dsecs; /* number of seconds into the day */
401 int year; /* year, >= 1583 */
402 int tzoff; /* time zone offset in seconds */
403};
405/* (1969 / 4) - (1969 / 100) + (1969 / 400) = 492 - 19 + 4 = 477 */
406#define LEAP_DAYS_BEFORE_1969 477
407#define SECONDS_PER_DAY 86400
409/*
410 * time2epoch: time stamp to seconds since epoch in GMT time zone. Similar to
411 * mktime but for GMT only.
412 */
413static curl_off_t time2epoch(struct when *w)
414{
415 static const int cumulative_days[12] = {
416 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
417 };
418 int y = w->year - (w->mon <= 1);
419 int leap_days = (y / 4) - (y / 100) + (y / 400) - LEAP_DAYS_BEFORE_1969;
420 curl_off_t days = (curl_off_t)(w->year - 1970) * 365 + leap_days +
421 cumulative_days[w->mon] + w->mday - 1;
423 return (days * SECONDS_PER_DAY) + w->dsecs;
424}
426/* Returns the value of a single-digit or two-digit decimal number, return
427 then pointer to after the number. The 'date' pointer is known to point to a
428 digit. */
429static int oneortwodigit(const char *date, const char **endp)
430{
431 int num = date[0] - '0';
432 if(ISDIGIT(date[1])) {
433 *endp = &date[2];
434 return (num * 10) + (date[1] - '0');
435 }
436 *endp = &date[1];
437 return num;
438}
440/* HH:MM:SS or HH:MM and accept single-digits too */
441static bool match_time(const char *date, struct when *w, char **endp)
442{
443 const char *p;
444 int hh, mm, ss = 0;
445 hh = oneortwodigit(date, &p);
446 if((hh < 24) && (*p == ':') && ISDIGIT(p[1])) {
447 mm = oneortwodigit(&p[1], &p);
448 if(mm < 60) {
449 if((*p == ':') && ISDIGIT(p[1])) {
450 ss = oneortwodigit(&p[1], &p);
451 if(ss <= 60) {
452 /* valid HH:MM:SS */
453 goto match;
454 }
455 }
456 else {
457 /* valid HH:MM */
458 goto match;
459 }
460 }
461 }
462 return FALSE; /* not a time string */
463match:
464 w->dsecs = (hh * 3600) + (mm * 60) + ss;
465 *endp = (char *)CURL_UNCONST(p);
466 return TRUE;
467}
469/*
470 * parsedate()
471 *
472 * Returns:
473 *
474 * PARSEDATE_OK - a fine conversion
475 * PARSEDATE_FAIL - failed to convert
476 * PARSEDATE_LATER - time overflow at the far end of time_t
477 * PARSEDATE_SOONER - time underflow at the low end of time_t
478 */
480/* Wednesday is the longest name this parser knows about */
481#define NAME_LEN 10
483static void initwhen(struct when *w)
484{
485 w->wday = w->mon = w->mday = w->dsecs = w->year = w->tzoff = -1;
486}
488static int datestring(const char **datep, struct when *w)
489{
490 /* a name coming up */
491 size_t len = 0;
492 const char *p = *datep;
493 while(ISALPHA(p[len]) && (len < NAME_LEN))
494 len++;
496 if(len != NAME_LEN) {
497 if(w->wday == -1) {
498 w->wday = checkday(p, len);
499 if(w->wday != -1)
500 goto found;
501 }
502 if(w->mon == -1) {
503 w->mon = checkmonth(p, len);
504 if(w->mon != -1)
505 goto found;
506 }
507 if(w->tzoff == -1) {
508 /* this must be a time zone string */
509 w->tzoff = checktz(p, len);
510 if(w->tzoff != -1)
511 goto found;
512 }
513 }
514 return PARSEDATE_FAIL; /* bad string */
515found:
516 *datep += len;
517 return PARSEDATE_OK;
518}
520static int datenum(const char *indate, const char **datep, struct when *w)
521{
522 /* a digit */
523 unsigned int val;
524 char *end;
525 const char *date = *datep;
527 if((w->dsecs == -1) && match_time(date, w, &end)) {
528 /* time stamp */
529 date = end;
530 }
531 else {
532 bool found = FALSE;
533 curl_off_t lval;
534 int num_digits = 0;
535 const char *p = *datep;
536 if(curlx_str_number(&p, &lval, 99999999))
537 return PARSEDATE_FAIL;
539 /* we know num_digits cannot be larger than 8 */
540 num_digits = (int)(p - *datep);
541 val = (unsigned int)lval;
543 if((w->tzoff == -1) &&
544 (num_digits == 4) &&
545 (val <= 1400) &&
546 (indate < date) &&
547 (date[-1] == '+' || date[-1] == '-')) {
548 /* four digits and a value less than or equal to 1400 (to take into
549 account all sorts of funny time zone diffs) and it is preceded
550 with a plus or minus. This is a time zone indication. 1400 is
551 picked since +1300 is frequently used and +1400 is mentioned as
552 an edge number in the document "ISO C 200X Proposal: Timezone
553 Functions" at http://david.tribble.com/text/c0xtimezone.html If
554 anyone has a more authoritative source for the exact maximum time
555 zone offsets, please speak up! */
556 found = TRUE;
557 w->tzoff = ((val / 100 * 60) + (val % 100)) * 60;
559 /* the + and - prefix indicates the local time compared to GMT,
560 this we need their reversed math to get what we want */
561 w->tzoff = date[-1] == '+' ? -w->tzoff : w->tzoff;
562 }
564 else if((num_digits == 8) && (w->year == -1) &&
565 (w->mon == -1) && (w->mday == -1)) {
566 /* 8 digits, no year, month or day yet. This is YYYYMMDD */
567 found = TRUE;
568 w->year = val / 10000;
569 w->mon = ((val % 10000) / 100) - 1; /* month is 0 - 11 */
570 if(w->mon > 11)
571 return PARSEDATE_FAIL;
572 w->mday = val % 100;
573 }
575 if(!found && (w->mday == -1)) {
576 if((val > 0) && (val < 32)) {
577 w->mday = val;
578 found = TRUE;
579 }
580 }
582 if(!found && (w->year == -1)) {
583 w->year = val;
584 found = TRUE;
585 if(w->year < 100) {
586 if(w->year > 70)
587 w->year += 1900;
588 else
589 w->year += 2000;
590 }
591 }
593 if(!found)
594 return PARSEDATE_FAIL;
596 date = p;
597 }
598 *datep = date;
599 return PARSEDATE_OK;
600}
602static bool datecheck(struct when *w)
603{
604 if(w->dsecs == -1)
605 w->dsecs = 0; /* no time available, make it zero */
607 if((w->mday == -1) || (w->mon == -1) || (w->year == -1) ||
608 /* lacks vital info, fail */
609 (w->year < 1583) ||
610 /* The Gregorian calendar was introduced 1582 */
611 (w->mday > 31) /* too long month */ )
612 return TRUE;
614 return FALSE;
615}
617static void tzadjust(curl_off_t *tp, struct when *w)
618{
619 if(w->tzoff == -1) /* unknown tz means no offset */
620 w->tzoff = 0;
622 /* Add the time zone diff between local time zone and GMT. */
623 if((w->tzoff > 0) && (*tp > (curl_off_t)(CURL_OFF_T_MAX - w->tzoff)))
624 *tp = CURL_OFF_T_MAX;
625 else
626 *tp += w->tzoff;
627 /* this needs no minimum check since we require a year > 1582 */
628}
630static int mktimet(curl_off_t seconds, time_t *output)
631{
632#if SIZEOF_TIME_T < 5
633 if(seconds > TIME_T_MAX) {
634 *output = TIME_T_MAX;
635 return PARSEDATE_LATER;
636 }
637 else if(seconds < TIME_T_MIN) {
638 *output = TIME_T_MIN;
639 return PARSEDATE_SOONER;
640 }
641#elif defined(HAVE_TIME_T_UNSIGNED)
642 if(seconds < 0) {
643 *output = 0;
644 return PARSEDATE_SOONER;
645 }
646#endif
647 *output = (time_t)seconds;
648 return PARSEDATE_OK;
649}
651static int parsedate(const char *date, time_t *output)
652{
653 curl_off_t seconds = 0;
654 const char *indate = date; /* save the original pointer */
655 int part = 0; /* max 6 parts */
656 int rc = 0;
657 struct when w;
658 initwhen(&w);
660 while(*date && (part < 6)) {
661 skip(&date);
663 if(ISALPHA(*date))
664 rc = datestring(&date, &w);
665 else if(ISDIGIT(*date))
666 rc = datenum(indate, &date, &w);
667 if(rc)
668 return rc;
670 part++;
671 }
673 if(datecheck(&w))
674 return PARSEDATE_FAIL;
676 seconds = time2epoch(&w); /* get number of seconds */
677 tzadjust(&seconds, &w); /* handle the time zone offset */
678 rc = mktimet(seconds, output); /* squeeze seconds into a time_t */
680 return rc;
681}
682#else
683/* disabled */
684static int parsedate(const char *date, time_t *output)
685{
686 (void)date;
687 *output = 0;
688 return PARSEDATE_OK; /* a lie */
689}
690#endif
692time_t curl_getdate(const char *p, const time_t *unused)
693{
694 time_t parsed = -1;
695 int rc;
696 (void)unused; /* legacy argument from the past that we ignore */
698 if(!p)
699 return -1;
701 rc = parsedate(p, &parsed);
702 if(rc == PARSEDATE_OK) {
703 if(parsed == (time_t)-1)
704 /* avoid returning -1 for a working scenario */
705 parsed++;
706 return parsed;
707 }
708 /* everything else is fail */
709 return -1;
710}
712/* Curl_getdate_capped() differs from curl_getdate() in that this will return
713 TIME_T_MAX in case the parsed time value was too big, instead of an
714 error. Returns non-zero on error. */
716int Curl_getdate_capped(const char *p, time_t *tp)
717{
718 int rc = parsedate(p, tp);
719 return (rc == PARSEDATE_FAIL);
720}
Diagnostics4 git calls · 28 ms
CallStatusSizeTime028 ms
discover200152 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 git.response.bytes=152 git.server.agent=gitty/1.0 git.server.object_format=sha1 git.server.caps=agent ls-refs fetch object-format git.server.fetch=shallow filter sideband-all git.protocol.version=2 git.pkt.frames=8 git.pkt.data=6 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=152 git.pkt.payload.max=34
ls-refs200149 B · hit3 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 git.response.bytes=149 git.response.cache=HIT git.response.duration_ms=3 git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=149 git.pkt.payload.max=78 git.ls_refs.count=2 git.ls_refs.head=refs/heads/master
fetchblob:none · deepen 10200287 KiB · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=293470 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=blob:none git.fetch.filter.requested=tree:0 git.fetch.filter.fallback=blob:none git.fetch.filter.learned=false git.fetch.wants=31c911efe5652725e930f4d2e60c9060e5f6646d git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=10 git.pkt.data=8 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=293470 git.pkt.payload.max=65516 git.sideband.band1.bytes=293354 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=87 git.pack.bytes=293354 git.pack.ofs_delta=0 git.pack.ref_delta=1 git.pack.chain.max=1 git.pack.trailer=6a646bcda6740bab42e321b51998b52ea15146c0 git.pack.full=86Open pack map
fetch2007.0 KiB · hit23 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=23 git.response.bytes=7160 git.response.cache=HIT git.response.duration_ms=23 git.fetch.wants=f5f9ec3a2c2d272e5a49328eb4ca0dc967a76369 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=7160 git.pkt.payload.max=7139 git.sideband.band1.bytes=7138 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0
Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.
- Remote
- https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/curl.git
- Ref
- refs/heads/master
- Commit
- 31c911efe5652725e930f4d2e60c9060e5f6646d
- cf-ray
- a5e2f6dc1bfc3a24
- Request
- d9ffb74e…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format