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/*
25 * The Strict-Transport-Security header is defined in RFC 6797:
26 * https://datatracker.ietf.org/doc/html/rfc6797
27 */
28#include "curl_setup.h"
30#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_HSTS)
31#include "urldata.h"
32#include "llist.h"
33#include "hsts.h"
34#include "curl_fopen.h"
35#include "curl_get_line.h"
36#include "parsedate.h"
37#include "curl_share.h"
38#include "curlx/strparse.h"
39#include "curlx/strcopy.h"
41#define MAX_HSTS_LINE 4095
42#define MAX_HSTS_HOSTLEN 2048
43#define MAX_HSTS_DATELEN 17
44#define UNLIMITED "unlimited"
46#define CAP_HSTS_MAX_AGE (2*365*24*3600) /* two years cap */
48#if defined(DEBUGBUILD) || defined(UNITTESTS)
49/* to play well with debug builds, we can *set* a fixed time this will
50 return */
51time_t deltatime; /* allow for "adjustments" for unit test purposes */
52static time_t hsts_debugtime(void *unused)
53{
54 const char *timestr = getenv("CURL_TIME");
55 (void)unused;
56 if(timestr) {
57 curl_off_t val;
58 if(!curlx_str_number(×tr, &val, TIME_T_MAX))
59 val += (curl_off_t)deltatime;
60 return (time_t)val;
61 }
62 return time(NULL);
63}
64#undef time
65#define time(x) hsts_debugtime(x)
66#endif
68struct hsts *Curl_hsts_init(void)
69{
70 struct hsts *h = curlx_calloc(1, sizeof(struct hsts));
71 if(h) {
72 Curl_llist_init(&h->list, NULL);
73 }
74 return h;
75}
77#define hsts_free(x) curlx_free(x)
79void Curl_hsts_cleanup(struct hsts **hp)
80{
81 struct hsts *h = *hp;
82 if(h) {
83 struct Curl_llist_node *e;
84 struct Curl_llist_node *n;
85 for(e = Curl_llist_head(&h->list); e; e = n) {
86 struct stsentry *sts = Curl_node_elem(e);
87 n = Curl_node_next(e);
88 hsts_free(sts);
89 }
90 curlx_free(h->filename);
91 curlx_free(h);
92 *hp = NULL;
93 }
94}
96/* append the new entry to the list after possibly removing an old entry
97 first */
98static void hsts_append(struct hsts *h, struct stsentry *sts)
99{
100 if(Curl_llist_count(&h->list) == MAX_HSTS_ENTRIES) {
101 /* It is full. Remove the first entry in the list */
102 struct Curl_llist_node *e = Curl_llist_head(&h->list);
103 struct stsentry *oldsts = Curl_node_elem(e);
104 Curl_node_remove(e);
105 hsts_free(oldsts);
106 }
107 Curl_llist_append(&h->list, sts, &sts->node);
108}
110static CURLcode hsts_create(struct hsts *h,
111 const char *hostname,
112 size_t hlen,
113 bool subdomains,
114 curl_off_t expires)
115{
116 DEBUGASSERT(h);
117 DEBUGASSERT(hostname);
119 if(hlen && (hostname[hlen - 1] == '.'))
120 /* strip off any trailing dot */
121 --hlen;
122 if(hlen) {
123 struct stsentry *sts = curlx_calloc(1, sizeof(struct stsentry) + hlen);
124 if(!sts)
125 return CURLE_OUT_OF_MEMORY;
126 /* the null-terminator is already there */
127 memcpy(sts->host, hostname, hlen);
128 sts->expires = expires;
129 sts->includeSubDomains = subdomains;
130 hsts_append(h, sts);
131 }
132 return CURLE_OK;
133}
135/* Copy all live entries from src into dst. Used by curl_easy_duphandle so the
136 * clone inherits entries learned at runtime. E.g. Strict-Transport-Security.
137 */
138CURLcode Curl_hsts_copy(struct hsts *dst, struct hsts *src)
139{
140 struct Curl_llist_node *e;
141 time_t now = time(NULL);
142 for(e = Curl_llist_head(&src->list); e; e = Curl_node_next(e)) {
143 struct stsentry *sts = Curl_node_elem(e);
144 if(sts->expires > now) {
145 CURLcode result = hsts_create(dst, sts->host, strlen(sts->host),
146 sts->includeSubDomains != 0, sts->expires);
147 if(result)
148 return result;
149 }
150 }
151 return CURLE_OK;
152}
154/*
155 * Return the matching HSTS entry, or NULL if the given hostname is not
156 * currently an HSTS one.
157 *
158 * The 'subdomain' argument tells the function if subdomain matching should be
159 * attempted.
160 *
161 * @unittest 1660
162 */
163UNITTEST struct stsentry *hsts_check(struct hsts *h, const char *hostname,
164 size_t hlen, bool subdomain);
165UNITTEST struct stsentry *hsts_check(struct hsts *h, const char *hostname,
166 size_t hlen, bool subdomain)
167{
168 struct stsentry *bestsub = NULL;
169 if(h) {
170 time_t now = time(NULL);
171 struct Curl_llist_node *e;
172 struct Curl_llist_node *n;
173 size_t blen = 0;
175 if((hlen > MAX_HSTS_HOSTLEN) || !hlen)
176 return NULL;
177 if(hostname[hlen - 1] == '.')
178 /* remove the trailing dot */
179 --hlen;
181 for(e = Curl_llist_head(&h->list); e; e = n) {
182 struct stsentry *sts = Curl_node_elem(e);
183 size_t ntail;
184 n = Curl_node_next(e);
185 if(sts->expires <= now) {
186 /* remove expired entries */
187 Curl_node_remove(&sts->node);
188 hsts_free(sts);
189 continue;
190 }
191 ntail = strlen(sts->host);
192 if((subdomain && sts->includeSubDomains) && (ntail < hlen)) {
193 size_t offs = hlen - ntail;
194 if((hostname[offs - 1] == '.') &&
195 curl_strnequal(&hostname[offs], sts->host, ntail) &&
196 (ntail > blen)) {
197 /* save the tail match with the longest tail */
198 bestsub = sts;
199 blen = ntail;
200 }
201 }
202 /* avoid curl_strequal because the hostname is not null-terminated */
203 if((hlen == ntail) && curl_strnequal(hostname, sts->host, hlen))
204 return sts;
205 }
206 }
207 return bestsub;
208}
210CURLcode Curl_hsts_parse(struct hsts *h, const char *hostname,
211 const char *header)
212{
213 const char *p = header;
214 curl_off_t expires = 0;
215 bool gotma = FALSE;
216 bool gotinc = FALSE;
217 bool subdomains = FALSE;
218 struct stsentry *sts;
219 time_t now = time(NULL);
220 size_t hlen = strlen(hostname);
222 if(Curl_host_is_ipnum(hostname))
223 /* "explicit IP address identification of all forms is excluded."
224 / RFC 6797 */
225 return CURLE_OK;
227 do {
228 struct Curl_str word;
229 struct Curl_str val = { 0 };
230 int rc;
231 bool assign = FALSE;
233 do {
234 curlx_str_passblanks(&p);
235 if(*p == ';')
236 p++;
237 else
238 break;
239 } while(1);
240 if(curlx_str_cspn(&p, &word, ";=\r\n \t"))
241 break;
243 curlx_str_passblanks(&p);
244 if(!curlx_str_single(&p, '=')) {
245 assign = TRUE;
246 curlx_str_passblanks(&p);
248 if(*p == '\"') {
249 if(curlx_str_quotedword(&p, &val, MAX_HSTS_LINE))
250 break;
251 }
252 else {
253 if(curlx_str_cspn(&p, &val, ", ;\r\n"))
254 break;
255 }
256 }
258 if(assign && curlx_str_casecompare(&word, "max-age")) {
259 const char *vp = curlx_str(&val);
260 if(gotma)
261 return CURLE_BAD_FUNCTION_ARGUMENT;
262 rc = curlx_str_number(&vp, &expires, CAP_HSTS_MAX_AGE);
263 if(rc == STRE_OVERFLOW)
264 expires = CAP_HSTS_MAX_AGE;
265 else if(rc)
266 /* invalid max-age */
267 return CURLE_BAD_FUNCTION_ARGUMENT;
269 gotma = TRUE;
270 }
271 else if(curlx_str_casecompare(&word, "includesubdomains")) {
272 if(gotinc)
273 return CURLE_BAD_FUNCTION_ARGUMENT;
274 subdomains = TRUE;
275 gotinc = TRUE;
276 }
277 } while(*p);
279 if(!gotma)
280 /* max-age is mandatory */
281 return CURLE_BAD_FUNCTION_ARGUMENT;
283 if(!expires) {
284 /* remove the entry if present verbatim (without subdomain match) */
285 sts = hsts_check(h, hostname, hlen, FALSE);
286 if(sts) {
287 Curl_node_remove(&sts->node);
288 hsts_free(sts);
289 }
290 return CURLE_OK;
291 }
293 if(CURL_OFF_T_MAX - now < expires)
294 /* would overflow, use maximum value */
295 expires = CURL_OFF_T_MAX;
296 else
297 expires += now;
299 /* check if it already exists */
300 sts = hsts_check(h, hostname, hlen, FALSE);
301 if(sts) {
302 /* update these fields */
303 sts->expires = expires;
304 sts->includeSubDomains = subdomains;
305 }
306 else
307 return hsts_create(h, hostname, hlen, subdomains, expires);
309 return CURLE_OK;
310}
312/*
313 * Send this HSTS entry to the write callback.
314 */
315static CURLcode hsts_push(struct Curl_easy *data,
316 struct curl_index *i,
317 struct stsentry *sts,
318 bool *stop)
319{
320 struct curl_hstsentry e;
321 CURLSTScode sc;
322 struct tm stamp;
323 CURLcode result;
325 e.name = (char *)sts->host;
326 e.namelen = strlen(sts->host);
327 e.includeSubDomains = sts->includeSubDomains;
329 if(sts->expires != TIME_T_MAX) {
330 result = curlx_gmtime((time_t)sts->expires, &stamp);
331 if(result)
332 return result;
334 curl_msnprintf(e.expire, sizeof(e.expire), "%d%02d%02d %02d:%02d:%02d",
335 stamp.tm_year + 1900, stamp.tm_mon + 1, stamp.tm_mday,
336 stamp.tm_hour, stamp.tm_min, stamp.tm_sec);
337 }
338 else
339 curlx_strcopy(e.expire, sizeof(e.expire), STRCONST(UNLIMITED));
341 sc = data->set.hsts_write(data, &e, i, data->set.hsts_write_userp);
342 *stop = (sc != CURLSTS_OK);
343 return sc == CURLSTS_FAIL ? CURLE_BAD_FUNCTION_ARGUMENT : CURLE_OK;
344}
346/*
347 * Write this single hsts entry to a single output line
348 */
349static void hsts_out(struct stsentry *sts, FILE *fp)
350{
351 struct tm stamp;
352 if(sts->expires != TIME_T_MAX) {
353 CURLcode result = curlx_gmtime((time_t)sts->expires, &stamp);
354 if(!result)
355 /* skip the entry if the date function fails */
356 curl_mfprintf(fp, "%s%s \"%d%02d%02d %02d:%02d:%02d\"\n",
357 sts->includeSubDomains ? "." : "", sts->host,
358 stamp.tm_year + 1900, stamp.tm_mon + 1, stamp.tm_mday,
359 stamp.tm_hour, stamp.tm_min, stamp.tm_sec);
360 }
361 else
362 curl_mfprintf(fp, "%s%s \"%s\"\n",
363 sts->includeSubDomains ? "." : "", sts->host, UNLIMITED);
364}
366/*
367 * Curl_https_save() writes the HSTS cache to file and callback.
368 */
369CURLcode Curl_hsts_save(struct Curl_easy *data, struct hsts *h,
370 const char *file)
371{
372 struct Curl_llist_node *e;
373 struct Curl_llist_node *n;
374 CURLcode result = CURLE_OK;
375 FILE *out;
376 char *tempstore = NULL;
378 if(!h)
379 /* no cache activated */
380 return CURLE_OK;
382 /* if no new name is given, use the one we stored from the load */
383 if(!file && h->filename)
384 file = h->filename;
386 if((h->flags & CURLHSTS_READONLYFILE) || !file || !file[0])
387 /* marked as read-only, no file or zero length filename */
388 goto skipsave;
390 result = Curl_fopen(data, file, &out, &tempstore);
391 if(!result) {
392 fputs("# Your HSTS cache. https://curl.se/docs/hsts.html\n"
393 "# This file was generated by libcurl! Edit at your own risk.\n",
394 out);
395 for(e = Curl_llist_head(&h->list); e; e = n) {
396 struct stsentry *sts = Curl_node_elem(e);
397 n = Curl_node_next(e);
398 hsts_out(sts, out);
399 }
400 curlx_fclose(out);
401 if(!result && tempstore && curlx_rename(tempstore, file))
402 result = CURLE_WRITE_ERROR;
404 if(result && tempstore)
405 unlink(tempstore);
406 }
407 curlx_free(tempstore);
408skipsave:
409 if(data->set.hsts_write) {
410 /* if there is a write callback */
411 struct curl_index i; /* count */
412 i.total = Curl_llist_count(&h->list);
413 i.index = 0;
414 for(e = Curl_llist_head(&h->list); e; e = n) {
415 struct stsentry *sts = Curl_node_elem(e);
416 bool stop;
417 n = Curl_node_next(e);
418 result = hsts_push(data, &i, sts, &stop);
419 if(result || stop)
420 break;
421 i.index++;
422 }
423 }
424 return result;
425}
427/* only returns SERIOUS errors */
428static CURLcode hsts_add_host_expire(struct hsts *h,
429 const char *host, size_t hostlen,
430 const char *expire, size_t explen,
431 bool subdomain) /* default */
432{
433 CURLcode result = CURLE_OK;
434 struct stsentry *e;
435 char dbuf[MAX_HSTS_DATELEN + 1];
436 time_t expires = 0;
437 time_t now = time(NULL);
439 /* The date parser works on a null-terminated string. */
440 if(explen > MAX_HSTS_DATELEN)
441 return CURLE_BAD_FUNCTION_ARGUMENT;
442 memcpy(dbuf, expire, explen);
443 dbuf[explen] = 0;
445 if(!strcmp(dbuf, UNLIMITED))
446 expires = TIME_T_MAX;
447 else
448 Curl_getdate_capped(dbuf, &expires);
450 if(expires <= now)
451 /* this entry already expired */
452 return CURLE_OK;
454 if(host[0] == '.') {
455 host++;
456 hostlen--;
457 subdomain = TRUE;
458 }
459 if(hostlen && (host[hostlen - 1] == '.'))
460 /* strip off any trailing dot */
461 hostlen--;
463 if(hostlen) {
464 /* only add it if not already present */
465 e = hsts_check(h, host, hostlen, FALSE);
466 if(!e)
467 result = hsts_create(h, host, hostlen, subdomain, expires);
468 /* 'host' is not necessarily null-terminated */
469 else if((hostlen == strlen(e->host) &&
470 curl_strnequal(host, e->host, hostlen))) {
471 /* the same hostname, use the largest expire time and keep the strictest
472 subdomain policy */
473 if(expires > e->expires)
474 e->expires = expires;
475 if(subdomain)
476 e->includeSubDomains = TRUE;
477 }
478 }
479 return result;
480}
482/* only returns SERIOUS errors */
483static CURLcode hsts_add(struct hsts *h, const char *line)
484{
485 /* Example lines:
486 example.com "20191231 10:00:00"
487 .example.net "20191231 10:00:00"
488 */
489 struct Curl_str host;
490 struct Curl_str date;
492 if(curlx_str_word(&line, &host, MAX_HSTS_HOSTLEN) ||
493 curlx_str_singlespace(&line) ||
494 curlx_str_quotedword(&line, &date, MAX_HSTS_DATELEN) ||
495 curlx_str_newline(&line))
496 ;
497 else {
498 return hsts_add_host_expire(h, curlx_str(&host), curlx_strlen(&host),
499 curlx_str(&date), curlx_strlen(&date),
500 FALSE);
501 }
503 return CURLE_OK;
504}
506/*
507 * Load HSTS data from callback.
508 *
509 */
510static CURLcode hsts_pull(struct Curl_easy *data, struct hsts *h)
511{
512 /* if the HSTS read callback is set, use it */
513 if(data->set.hsts_read) {
514 CURLSTScode sc;
515 DEBUGASSERT(h);
516 do {
517 char buffer[MAX_HSTS_HOSTLEN + 1];
518 struct curl_hstsentry e;
519 e.name = buffer;
520 e.namelen = sizeof(buffer) - 1;
521 e.includeSubDomains = FALSE; /* default */
522 e.expire[0] = 0;
523 e.expire[MAX_HSTS_DATELEN] = 0;
524 e.name[0] = 0; /* to make it clean */
525 e.name[MAX_HSTS_HOSTLEN] = 0;
526 sc = data->set.hsts_read(data, &e, data->set.hsts_read_userp);
527 if(sc == CURLSTS_OK) {
528 CURLcode result;
529 const char *date = e.expire;
530 if(!e.name[0] || e.expire[MAX_HSTS_DATELEN] ||
531 e.name[MAX_HSTS_HOSTLEN])
532 /* bail out if no name was stored or if a null-terminator is gone */
533 return CURLE_BAD_FUNCTION_ARGUMENT;
534 if(!date[0])
535 date = UNLIMITED;
536 result = hsts_add_host_expire(h, e.name, strlen(e.name),
537 date, strlen(date),
538 /* bitfield to bool conversion: */
539 e.includeSubDomains ? TRUE : FALSE);
540 if(result)
541 return result;
542 }
543 else if(sc == CURLSTS_FAIL)
544 return CURLE_ABORTED_BY_CALLBACK;
545 } while(sc == CURLSTS_OK);
546 }
547 return CURLE_OK;
548}
550/*
551 * Load the HSTS cache from the given file. The text based line-oriented file
552 * format is documented here: https://curl.se/docs/hsts.html
553 *
554 * This function only returns error on major problems that prevent hsts
555 * handling to work completely. It will ignore individual syntactical errors
556 * etc.
557 */
558static CURLcode hsts_load(struct hsts *h, const char *file)
559{
560 CURLcode result = CURLE_OK;
561 FILE *fp;
563 /* we need a private copy of the filename so that the hsts cache file
564 name survives an easy handle reset */
565 curlx_free(h->filename);
566 h->filename = curlx_strdup(file);
567 if(!h->filename)
568 return CURLE_OUT_OF_MEMORY;
570 fp = curlx_fopen(file, FOPEN_READTEXT);
571 if(fp) {
572 curlx_struct_stat stat;
573 if((curlx_fstat(fileno(fp), &stat) == -1) || !S_ISDIR(stat.st_mode)) {
574 struct dynbuf buf;
575 bool eof = FALSE;
576 curlx_dyn_init(&buf, MAX_HSTS_LINE);
577 do {
578 result = Curl_get_line(&buf, fp, &eof);
579 if(!result) {
580 const char *lineptr = curlx_dyn_ptr(&buf);
581 curlx_str_passblanks(&lineptr);
583 /* Skip empty or commented lines, since we know the line will have
584 a trailing newline from Curl_get_line we can treat length 1 as
585 empty. */
586 if((*lineptr == '#') || strlen(lineptr) <= 1)
587 continue;
589 hsts_add(h, lineptr);
590 }
591 } while(!result && !eof);
592 curlx_dyn_free(&buf); /* free the line buffer */
593 }
594 curlx_fclose(fp);
595 }
596 return result;
597}
599/*
600 * Curl_hsts_loadfile() loads HSTS from file
601 */
602CURLcode Curl_hsts_loadfile(struct Curl_easy *data,
603 struct hsts *h, const char *file)
604{
605 DEBUGASSERT(h);
606 (void)data;
607 return hsts_load(h, file);
608}
610/*
611 * Curl_hsts_loadcb() loads HSTS from callback
612 */
613CURLcode Curl_hsts_loadcb(struct Curl_easy *data, struct hsts *h)
614{
615 if(h)
616 return hsts_pull(data, h);
617 return CURLE_OK;
618}
620CURLcode Curl_hsts_loadfiles(struct Curl_easy *data)
621{
622 CURLcode result = CURLE_OK;
623 struct curl_slist *l = data->state.hstslist;
624 if(l) {
625 Curl_share_lock(data, CURL_LOCK_DATA_HSTS, CURL_LOCK_ACCESS_SINGLE);
627 while(l) {
628 result = Curl_hsts_loadfile(data, data->hsts, l->data);
629 if(result)
630 break;
631 l = l->next;
632 }
633 Curl_share_unlock(data, CURL_LOCK_DATA_HSTS);
634 }
635 return result;
636}
638bool Curl_hsts_applies(struct hsts *h, const struct Curl_peer *dest)
639{
640 return !!hsts_check(h, dest->hostname, strlen(dest->hostname), TRUE);
641}
643#if defined(DEBUGBUILD) || defined(UNITTESTS)
644#undef time
645#endif
647#endif /* CURL_DISABLE_HTTP || CURL_DISABLE_HSTS */
Diagnostics4 git calls · 48 ms
CallStatusSizeTime048 ms
discover200152 B2 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=2 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 · hit2 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=2 git.response.bytes=149 git.response.cache=HIT git.response.duration_ms=2 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 · hit24 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=293470 git.response.cache=HIT git.response.duration_ms=24 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
fetch2006.1 KiB · hit22 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=22 git.response.bytes=6237 git.response.cache=HIT git.response.duration_ms=22 git.fetch.wants=1cce1e5fb950ef903c3b66ebd23baaa4151e3ce1 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=6237 git.pkt.payload.max=6216 git.sideband.band1.bytes=6215 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
- a5e1e1e02cf9d96e
- Request
- 95d18e4c…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format