Artifactspublic-v0

curl

master
ply4 git calls85 ms291 KiB3 cachedprotocol v2
510 lines17 KiBRaw
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 "unitcheck.h"
25#include "urlapi-int.h"
26#include "curlx/dynbuf.h"
28static CURLcode test_unit1675(const char *arg)
30 UNITTEST_BEGIN_SIMPLE
32 /* Test ipv4_normalize */
33 {
34 struct dynbuf host;
35 int fails = 0;
36 unsigned int i;
37 struct ipv4_test {
38 const char *in;
39 const char *out;
40 };
41 static const struct ipv4_test tests[] = {
42 { "0x.0x.0x.0x", NULL }, /* invalid hex */
43 { "0x.0x.0x", NULL }, /* invalid hex */
44 { "0x.0x", NULL }, /* invalid hex */
45 { "0x", NULL }, /* invalid hex */
46 { "0", "0.0.0.0" },
47 { "00", "0.0.0.0" },
48 { "00000000000", "0.0.0.0" },
49 { "127.0.0.1", "127.0.0.1" },
50 { "0177.0.0.1", "127.0.0.1" },
51 { "00177.0.0.1", "127.0.0.1" },
52 { "0x7f.0.0.1", "127.0.0.1" },
53 { "0x07f.0.0.1", "127.0.0.1" },
54 { "1", "0.0.0.1" },
55 { "010", "0.0.0.8" },
56 { "001", "0.0.0.1" },
57 { "127", "0.0.0.127" },
58 { "127.1", "127.0.0.1" },
59 { "127.0.1", "127.0.0.1" },
60 { "1.16777215", "1.255.255.255" },
61 { "1.16777216", NULL }, /* overflow */
62 { "1.1.65535", "1.1.255.255" },
63 { "1.1.65536", NULL }, /* overflow */
64 { "0x7f000001", "127.0.0.1" },
65 { "0x7F000001", "127.0.0.1" },
66 { "0x7g000001", NULL }, /* bad hex */
67 { "2130706433", "127.0.0.1" },
68 { "017700000001", "127.0.0.1" },
69 { "000000000017700000001", "127.0.0.1" },
70 { "192.168.0.1", "192.168.0.1" },
71 { "0300.0250.0000.0001", "192.168.0.1" },
72 { "0xc0.0xa8.0.1", "192.168.0.1" },
73 { "0xc0a80001", "192.168.0.1" },
74 { "3232235521", "192.168.0.1" },
75 { "4294967294", "255.255.255.254" },
76 { "4294967295", "255.255.255.255" },
77 { "037777777777", "255.255.255.255" },
78 { "0xFFFFFFFF", "255.255.255.255" },
79 { "0xFFFFFfff", "255.255.255.255" },
80 { "1.2.3.4.5", NULL }, /* too many parts */
81 { "256.0.0.1", NULL }, /* overflow */
82 { "1.256.0.1", NULL }, /* overflow */
83 { "1.1.256.1", NULL }, /* overflow */
84 { "1.0.0.256", NULL }, /* overflow */
85 { "0x100.0.0.1", NULL }, /* overflow */
86 { "1.0x100.0.1", NULL }, /* overflow */
87 { "1.1.0x100.1", NULL }, /* overflow */
88 { "1.1.1.0x100", NULL }, /* overflow */
89 { "0400.0.0.1", NULL }, /* overflow */
90 { "4.0400.0.1", NULL }, /* overflow */
91 { "4.4.0400.1", NULL }, /* overflow */
92 { "4.4.4.0400", NULL }, /* overflow */
93 { "4294967296", NULL }, /* overflow */
94 { "040000000000", NULL }, /* overflow */
95 { "0x100000000", NULL }, /* overflow */
96 { "1.2.3.-4", NULL }, /* negative */
97 { "1.2.-3.4", NULL }, /* negative */
98 { "1.-2.3.4", NULL }, /* negative */
99 { "-1.2.3.4", NULL }, /* negative */
100 { "-12", NULL }, /* negative */
101 { "-12.1", NULL }, /* negative */
102 { "-12.2.3", NULL }, /* negative */
103 { " 1.2.3.4", NULL }, /* space */
104 { "1. 2.3.4", NULL }, /* space */
105 { "1.2. 3.4", NULL }, /* space */
106 { "1.2.3. 4", NULL }, /* space */
107 };
109 curlx_dyn_init(&host, 256);
110 for(i = 0; i < CURL_ARRAYSIZE(tests); i++) {
111 int rc;
112 curlx_dyn_reset(&host);
113 if(curlx_dyn_add(&host, tests[i].in)) {
114 curlx_dyn_free(&host);
115 return CURLE_OUT_OF_MEMORY;
116 }
117 rc = ipv4_normalize(&host);
118 if(tests[i].out) {
119 if((rc != HOST_IPV4) ||
120 strcmp(curlx_dyn_ptr(&host), tests[i].out)) {
121 curl_mfprintf(stderr, "ipv4_normalize('%s') failed: "
122 "expected '%s', got '%s'\n",
123 tests[i].in, tests[i].out, curlx_dyn_ptr(&host));
124 fails++;
125 }
126 }
127 else if(rc == HOST_IPV4) {
128 curl_mfprintf(stderr, "ipv4_normalize('%s') succeeded unexpectedly:"
129 " got '%s'\n",
130 tests[i].in, curlx_dyn_ptr(&host));
131 fails++;
132 }
133 }
134 curlx_dyn_free(&host);
135 abort_if(fails, "ipv4_normalize tests failed");
136 }
138 /* Test urlencode_str */
139 {
140 struct dynbuf out;
141 int fails = 0;
142 unsigned int i;
143 struct urlencode_test {
144 const char *in;
145 bool relative;
146 unsigned int query;
147 const char *out;
148 };
149 static const struct urlencode_test tests[] = {
150 { "http://leave\x01/hello\x01world", FALSE, QUERY_NO,
151 "http://leave\x01/hello%01world" },
152 { "http://leave/hello\x01world", FALSE, QUERY_NO,
153 "http://leave/hello%01world" },
154 { "http://le ave/hello\x01world", FALSE, QUERY_NO,
155 "http://le ave/hello%01world" },
156 { "hello\x01world", TRUE, QUERY_NO, "hello%01world" },
157 { "hello\xf0world", TRUE, QUERY_NO, "hello%F0world" },
158 { "hello world", TRUE, QUERY_NO, "hello%20world" },
159 { "hello%20world", TRUE, QUERY_NO, "hello%20world" },
160 { "hello world", TRUE, QUERY_YES, "hello+world" },
161 { "a+b c", TRUE, QUERY_NO, "a+b%20c" },
162 { "a%20b%20c", TRUE, QUERY_NO, "a%20b%20c" },
163 { "a%aab%aac", TRUE, QUERY_NO, "a%AAb%AAc" },
164 { "a%aab%AAc", TRUE, QUERY_NO, "a%AAb%AAc" },
165 { "w%w%x", TRUE, QUERY_NO, "w%w%x" },
166 { "w%wf%xf", TRUE, QUERY_NO, "w%wf%xf" },
167 { "w%fw%fw", TRUE, QUERY_NO, "w%fw%fw" },
168 { "a+b c", TRUE, QUERY_YES, "a+b+c" },
169 { "/foo/bar", TRUE, QUERY_NO, "/foo/bar" },
170 { "/foo/bar", TRUE, QUERY_YES, "/foo/bar" },
171 { "/foo/ bar", TRUE, QUERY_NO, "/foo/%20bar" },
172 { "/foo/ bar", TRUE, QUERY_YES, "/foo/+bar" },
173 { "~-._", TRUE, QUERY_NO, "~-._" },
174 { "~-._", TRUE, QUERY_YES, "~-._" },
175 { "foo bar?foo bar", TRUE, QUERY_NO, "foo%20bar?foo%20bar" },
176 { "foo bar?foo bar", TRUE, QUERY_NOT_YET, "foo%20bar?foo+bar" },
177 };
179 curlx_dyn_init(&out, 256);
180 for(i = 0; i < CURL_ARRAYSIZE(tests); i++) {
181 CURLUcode uc;
182 curlx_dyn_reset(&out);
183 uc = urlencode_str(&out, tests[i].in, strlen(tests[i].in),
184 tests[i].relative, tests[i].query);
185 if(uc || strcmp(curlx_dyn_ptr(&out), tests[i].out)) {
186 curl_mfprintf(stderr, "urlencode_str('%s', query=%u) failed:"
187 " expected '%s', got '%s'\n",
188 tests[i].in, tests[i].query, tests[i].out,
189 uc ? "error" : curlx_dyn_ptr(&out));
190 fails++;
191 }
192 }
193 curlx_dyn_free(&out);
194 abort_if(fails, "urlencode_str tests failed");
195 }
197 /* Test ipv6_parse */
198 {
199 struct Curl_URL u;
200 int fails = 0;
201 unsigned int i;
202 struct ipv6_test {
203 const char *in;
204 const char *out_host;
205 const char *out_zone;
206 };
207 static const struct ipv6_test tests[] = {
208 { "[::1]", "[::1]", NULL },
209 { "[fe80::1%eth0]", "[fe80::1]", "eth0" },
210 { "[fe80::1%25eth0]", "[fe80::1]", "25eth0" },
211 { "[::1", NULL, NULL }, /* missing bracket */
212 { "[]", NULL, NULL }, /* empty */
213 };
215 for(i = 0; i < CURL_ARRAYSIZE(tests); i++) {
216 CURLUcode uc;
217 char hostname[256];
218 memset(&u, 0, sizeof(u));
219 curlx_strcopy(hostname, sizeof(hostname),
220 tests[i].in, strlen(tests[i].in));
221 uc = ipv6_parse(&u, hostname, strlen(hostname));
222 if(tests[i].out_host) {
223 if(uc || strcmp(hostname, tests[i].out_host)) {
224 curl_mfprintf(stderr, "ipv6_parse('%s') host failed:"
225 " expected '%s', got '%s'\n",
226 tests[i].in, tests[i].out_host,
227 uc ? "error" : hostname);
228 fails++;
229 }
230 if(!uc && tests[i].out_zone &&
231 (!u.zoneid || strcmp(u.zoneid, tests[i].out_zone))) {
232 curl_mfprintf(stderr, "ipv6_parse('%s') zone failed:"
233 " expected '%s', got '%s'\n",
234 tests[i].in, tests[i].out_zone,
235 u.zoneid ? u.zoneid : "(null)");
236 fails++;
237 }
238 }
239 else if(!uc) {
240 curl_mfprintf(stderr, "ipv6_parse('%s') succeeded unexpectedly\n",
241 tests[i].in);
242 fails++;
243 }
244 curlx_free(u.host);
245 curlx_free(u.zoneid);
246 }
247 abort_if(fails, "ipv6_parse tests failed");
248 }
250 /* Test parse_file */
251 {
252 CURLU *u;
253 const char *path;
254 size_t pathlen;
255 int fails = 0;
256 unsigned int i;
257 struct file_test {
258 const char *in;
259 const char *out_path;
260 bool fine;
261 };
262 static const struct file_test tests[] = {
263 { "file:///etc/hosts", "/etc/hosts", TRUE },
264 { "file://localhost/etc/hosts", "/etc/hosts", TRUE },
265 { "file://apple/etc/hosts", "/etc/hosts", FALSE },
266 { "file:foo", NULL, FALSE },
267 { "file:./", NULL, FALSE },
268 { "file:?q", NULL, FALSE },
269 { "file:#f", NULL, FALSE },
270#ifdef _WIN32
271 { "file:///c:/windows/system32", "c:/windows/system32", TRUE },
272 { "file://localhost/c:/windows/system32", "c:/windows/system32", TRUE },
273#endif
274 };
276 for(i = 0; i < CURL_ARRAYSIZE(tests); i++) {
277 CURLUcode uc;
278 u = curl_url();
279 if(!u)
280 return CURLE_OUT_OF_MEMORY;
282 uc = parse_file(tests[i].in, strlen(tests[i].in), u, &path, &pathlen);
283 if(!tests[i].fine && !uc) {
284 curl_mfprintf(stderr, "Unexpectedly fine for input '%s'\n",
285 tests[i].in);
286 fails++;
287 }
288 if(tests[i].fine &&
289 (uc ||
290 strncmp(path, tests[i].out_path, pathlen) ||
291 strlen(tests[i].out_path) != pathlen)) {
292 curl_mfprintf(stderr, "parse_file('%s') failed:"
293 " expected path '%s'; got path '%.*s'\n",
294 tests[i].in, tests[i].out_path,
295 (int)pathlen, path);
296 fails++;
297 }
298 curl_url_cleanup(u);
299 }
300 abort_if(fails, "parse_file tests failed");
301 }
303 /* Test same origin check. For now, we can only do that when
304 * schemes are supported by libcurl. */
305#ifndef CURL_DISABLE_HTTP
306 {
307 CURLU *base, *href;
308 int fails = 0;
309 unsigned int i;
310 bool match;
311 struct origin_test {
312 const char *base;
313 const char *scheme;
314 const char *host;
315 const char *port;
316 const char *path;
317 bool expect_match;
318 };
319 static const struct origin_test tests[] = {
320 { "http://host:123/x", "http", "host", "123", "/y", TRUE },
321 { "http://host:123/x", NULL, "host", "123", "/y", TRUE },
322 { "http://host:123/x", NULL, NULL, NULL, "/y", TRUE },
323 { "http://host:80/x", "http", "host", "123", "/y", FALSE },
324 { "http://host:80/x", "http", "host", NULL, "/y", TRUE },
325 { "http://host/x", "http", "host", "80", "/y", TRUE },
326#ifdef USE_SSL
327 { "http://host:123/x", "https", "host", "123", "/y", FALSE },
328 { "https://host/x", "http", "host", "443", "/y", FALSE },
329 { "https://host/x", "https", "host", "443", "/y", TRUE },
330#endif
331 };
333 for(i = 0; i < CURL_ARRAYSIZE(tests); i++) {
334 CURLUcode uc;
335 base = curl_url();
336 href = curl_url();
337 if(!base || !href) {
338 curl_mfprintf(stderr, "%u: failed to allocate memory\n", i);
339 fails++;
340 goto loop_end;
341 }
342 uc = curl_url_set(base, CURLUPART_URL, tests[i].base, 0);
343 if(uc) {
344 curl_mfprintf(stderr, "failed to parse %u base %s -> %d\n", i,
345 tests[i].base, (int)uc);
346 fails++;
347 goto loop_end;
348 }
349 if(tests[i].scheme)
350 uc = curl_url_set(href, CURLUPART_SCHEME, tests[i].scheme, 0);
351 if(!uc && tests[i].host)
352 uc = curl_url_set(href, CURLUPART_HOST, tests[i].host, 0);
353 if(!uc && tests[i].port)
354 uc = curl_url_set(href, CURLUPART_PORT, tests[i].port, 0);
355 if(!uc && tests[i].path)
356 uc = curl_url_set(href, CURLUPART_PATH, tests[i].path, 0);
357 if(uc) {
358 curl_mfprintf(stderr, "failed to parse %u href %s://%s:%s%s -> %d\n",
359 i, tests[i].scheme, tests[i].host, tests[i].port,
360 tests[i].path, (int)uc);
361 fails++;
362 goto loop_end;
363 }
365 match = Curl_url_same_origin(base, href);
366 if(match != tests[i].expect_match) {
367 curl_mfprintf(stderr, "ERROR: %u base %s and href %s://%s:%s%s %s\n",
368 i, tests[i].base, tests[i].scheme, tests[i].host,
369 tests[i].port, tests[i].path,
370 match ? "matched" : "did not match");
371 fails++;
372 }
374loop_end:
375 curl_url_cleanup(base);
376 curl_url_cleanup(href);
377 }
378 abort_if(fails, "same_origin tests failed");
379 }
380#endif /* !CURL_DISABLE_HTTP */
382 /* Test parse_hostname_login */
383 {
384 struct Curl_URL u;
385 int fails = 0;
386 unsigned int i;
387 struct test {
388 CURLUcode uc;
389 const char *in;
390 const char *scheme;
391 unsigned int flags;
392 const char *user;
393 const char *password;
394 const char *options;
395 size_t offset;
396 };
397 static const struct test tests[] = {
398 { CURLUE_OK, "foo:bar@host", NULL, 0, "foo", "bar", "o", 8 },
399 { CURLUE_OK, "foo:bar;abc@host", "imap", 0, "foo", "bar", "abc", 12 },
400 { CURLUE_OK, "foo:bar;abc@host", NULL, 0, "foo", "bar;abc", "o", 12 },
401 { CURLUE_USER_NOT_ALLOWED, "foo:bar@host", NULL, CURLU_DISALLOW_USER,
402 NULL, NULL, NULL, 0 },
403 { CURLUE_OK, "host", NULL, 0, NULL, NULL, NULL, 0 },
404 };
406 for(i = 0; i < CURL_ARRAYSIZE(tests); i++) {
407 CURLUcode uc;
408 size_t offset = 0;
409 memset(&u, 0, sizeof(u));
410 u.scheme = CURL_UNCONST(tests[i].scheme);
411 u.user = curlx_strdup("u");
412 u.password = curlx_strdup("p");
413 u.options = curlx_strdup("o");
414 uc = parse_hostname_login(&u, tests[i].in, strlen(tests[i].in),
415 tests[i].flags, &offset);
416 if(uc != tests[i].uc ||
417 !!u.user != !!tests[i].user ||
418 (u.user && tests[i].user &&
419 strcmp(u.user, tests[i].user)) ||
420 !!u.password != !!tests[i].password ||
421 (u.password && tests[i].password &&
422 strcmp(u.password, tests[i].password)) ||
423 !!u.options != !!tests[i].options ||
424 (u.options && tests[i].options &&
425 strcmp(u.options, tests[i].options)) ||
426 offset != tests[i].offset) {
427 curl_mfprintf(stderr, "%u: parse_hostname_login('%s') host failed:"
428 " expected '%d/%s/%s/%s/%zu', got '%d/%s/%s/%s/%zu'\n",
429 i, tests[i].in, (int)tests[i].uc, tests[i].user,
430 tests[i].password, tests[i].options, tests[i].offset,
431 (int)uc, u.user, u.password, u.options, offset);
432 fails++;
433 }
434 curlx_safefree(u.user);
435 curlx_safefree(u.password);
436 curlx_safefree(u.options);
437 }
438 abort_if(fails, "parse_hostname_login tests failed");
439 }
441 /* Test that CURLUPART_HOST normalizes legacy numeric IPv4 forms the
442 same way the full URL parser does */
443 {
444 int fails = 0;
445 unsigned int i;
446 struct host_test {
447 const char *host;
448 const char *out;
449 };
450 static const struct host_test tests[] = {
451 { "2130706433", "127.0.0.1" },
452 { "0177.1", "127.0.0.1" },
453 { "0x7f.1", "127.0.0.1" },
454 { "0xc0a80001", "192.168.0.1" },
455 { "127.0.0.1", "127.0.0.1" },
456 { "example.com", "example.com" },
457 { "0", "0.0.0.0" },
458 { "1", "0.0.0.1" },
459 { "7", "0.0.0.7" },
460 { "9", "0.0.0.9" },
461 { "00", "0.0.0.0" },
462 };
464 for(i = 0; i < CURL_ARRAYSIZE(tests); i++) {
465 CURLU *viaurl = curl_url();
466 CURLU *viahost = curl_url();
467 CURLUcode uc1, uc2;
468 char *urlbuf = curl_maprintf("http://%s/", tests[i].host);
469 char *gothost1 = NULL;
470 char *gothost2 = NULL;
472 if(!viaurl || !viahost || !urlbuf) {
473 curl_mfprintf(stderr, "%u: failed to allocate memory\n", i);
474 fails++;
475 goto host_loop_end;
476 }
478 uc1 = curl_url_set(viaurl, CURLUPART_URL, urlbuf, 0);
479 if(!uc1)
480 uc1 = curl_url_get(viaurl, CURLUPART_HOST, &gothost1, 0);
482 curl_url_set(viahost, CURLUPART_SCHEME, "http", 0);
483 uc2 = curl_url_set(viahost, CURLUPART_HOST, tests[i].host, 0);
484 if(!uc2)
485 uc2 = curl_url_get(viahost, CURLUPART_HOST, &gothost2, 0);
487 if(uc1 || uc2 ||
488 strcmp(gothost1, tests[i].out) ||
489 strcmp(gothost2, tests[i].out)) {
490 curl_mfprintf(stderr, "host '%s' mismatch: full-URL -> '%s' (%d), "
491 "CURLUPART_HOST -> '%s' (%d), expected '%s'\n",
492 tests[i].host,
493 uc1 ? "error" : gothost1, (int)uc1,
494 uc2 ? "error" : gothost2, (int)uc2,
495 tests[i].out);
496 fails++;
497 }
499host_loop_end:
500 curl_free(gothost1);
501 curl_free(gothost2);
502 curl_free(urlbuf);
503 curl_url_cleanup(viaurl);
504 curl_url_cleanup(viahost);
505 }
506 abort_if(fails, "CURLUPART_HOST ipv4 normalization parity tests failed");
507 }
509 UNITTEST_END_SIMPLE
Diagnostics4 git calls · 85 ms
CallStatusSizeTime085 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 · hit30 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=30
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=86
Open pack map
fetch2003.8 KiB · hit52 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=52
git.response.bytes=3910
git.response.cache=HIT
git.response.duration_ms=52
git.fetch.wants=632b0b36e2b746f0195e5a8691aae91d5925a2dd
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=3910
git.pkt.payload.max=3889
git.sideband.band1.bytes=3888
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
a5e2000e1888a9c0
Request
ebdd34fa…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format