Artifactspublic-v0

curl

master
ply4 git calls343 ms292 KiB2 cachedprotocol v2
656 lines18 KiBexecutableRaw
1#!/usr/bin/env perl
2#***************************************************************************
3# _ _ ____ _
4# Project ___| | | | _ \| |
5# / __| | | | |_) | |
6# | (__| |_| | _ <| |___
7# \___|\___/|_| \_\_____|
8#
9# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
11# This software is licensed as described in the file COPYING, which
12# you should have received as part of this distribution. The terms
13# are also available at https://curl.se/docs/copyright.html.
15# You may opt to use, copy, modify, merge, publish, distribute and/or sell
16# copies of the Software, and permit persons to whom the Software is
17# furnished to do so, under the terms of the COPYING file.
19# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20# KIND, either express or implied.
22# SPDX-License-Identifier: curl
24###########################################################################
25use strict;
26use warnings;
28# Usage:
29# perl mk-lib1521.pl < ../../include/curl/curl.h lib1521.c
31# minimum and maximum long signed values
32my $minlong = "LONG_MIN";
33my $maxlong = "LONG_MAX";
34# maximum curl_off_t
35my $maxofft = "CURL_OFF_T_MAX";
36my $line = "";
37my $incomment = 0;
39# Options allowed to return CURLE_BAD_FUNCTION_ARGUMENT if given a string they
40# do not recognize as valid
41my @bad_function_argument = (
42 'CURLOPT_DNS_LOCAL_IP4',
43 'CURLOPT_DNS_LOCAL_IP6',
44 'CURLOPT_DNS_SERVERS',
45 'CURLOPT_ECH',
46 'CURLOPT_PROXY_TLSAUTH_TYPE',
47 'CURLOPT_SSLENGINE',
48 'CURLOPT_TLSAUTH_TYPE',
49);
51# Options allowed to return CURLE_UNSUPPORTED_PROTOCOL if given a string they
52# do not recognize as valid
53my @unsupported_protocol = (
54 'CURLOPT_PROTOCOLS_STR',
55 'CURLOPT_REDIR_PROTOCOLS_STR',
56 );
58# Options allowed to return CURLE_SSL_ENGINE_NOTFOUND if given a string they
59# do not recognize as valid
60my @ssl_engine_notfound = (
61 'CURLOPT_SSLENGINE',
62 );
64# Options allowed to return CURLE_UNSUPPORTED_PROTOCOL if given a bad
65# numerical input they do not recognize as valid
66my @unsupported_protocol_num = (
67 'CURLOPT_HTTP_VERSION',
68 );
70# Options allowed to return CURLE_NOT_BUILT_IN if given a bad
71# numerical input they do not recognize as valid
72my @not_built_in_num = (
73 'CURLOPT_HTTPAUTH',
74 'CURLOPT_PROXYAUTH',
75 'CURLOPT_SOCKS5_AUTH',
76 );
79# Generate a set of string checks
82my $allowedstringerrors = <<MOO
83 switch(result) {
84 case CURLE_BAD_FUNCTION_ARGUMENT:
85MOO
86 ;
88for my $o (@bad_function_argument) {
89 $allowedstringerrors .= <<MOO
90 if(!strcmp("$o", name))
91 return;
92MOO
93 ;
96$allowedstringerrors .= <<MOO
97 break;
98MOO
99 ;
101$allowedstringerrors .= <<MOO
102 case CURLE_UNSUPPORTED_PROTOCOL:
103MOO
104 ;
105for my $o (@unsupported_protocol) {
106 $allowedstringerrors .= <<MOO
107 if(!strcmp("$o", name))
108 return;
109MOO
110 ;
112$allowedstringerrors .= <<MOO
113 break;
114MOO
115 ;
117$allowedstringerrors .= <<MOO
118 case CURLE_SSL_ENGINE_NOTFOUND:
119MOO
120 ;
121for my $o (@ssl_engine_notfound) {
122 $allowedstringerrors .= <<MOO
123 if(!strcmp("$o", name))
124 return;
125MOO
126 ;
128$allowedstringerrors .= <<MOO
129 break;
130 default:
131 break;
132 }
133MOO
134 ;
137# Generate a set of string checks
140my $allowednumerrors = <<MOO
141 switch(result) {
142 case CURLE_UNSUPPORTED_PROTOCOL:
143MOO
144 ;
146for my $o (@unsupported_protocol_num) {
147 $allowednumerrors .= <<MOO
148 if(!strcmp("$o", name))
149 return;
150MOO
151 ;
154$allowednumerrors .= <<MOO
155 break;
156 case CURLE_NOT_BUILT_IN:
157MOO
158 ;
160for my $o (@not_built_in_num) {
161 $allowednumerrors .= <<MOO
162 if(!strcmp("$o", name))
163 return;
164MOO
165 ;
168$allowednumerrors .= <<MOO
169 break;
170 default:
171 break;
172 }
173MOO
174 ;
176if(!$ARGV[0]) {
177 die "missing target filename";
180use File::Temp qw/ :mktemp /;
182my ($fh, $tempfile) = mkstemp("lib1521-XXXXX");
184print $fh <<HEADER
185/***************************************************************************
186 * _ _ ____ _
187 * Project ___| | | | _ \\| |
188 * / __| | | | |_) | |
189 * | (__| |_| | _ <| |___
190 * \\___|\\___/|_| \\_\\_____|
191 *
192 * Copyright (C) Daniel Stenberg, <daniel\@haxx.se>, et al.
193 *
194 * This software is licensed as described in the file COPYING, which
195 * you should have received as part of this distribution. The terms
196 * are also available at https://curl.se/docs/copyright.html.
197 *
198 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
199 * copies of the Software, and permit persons to whom the Software is
200 * furnished to do so, under the terms of the COPYING file.
201 *
202 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
203 * KIND, either express or implied.
204 *
205 * SPDX-License-Identifier: curl
206 *
207 ***************************************************************************/
208#include "first.h"
210/* This source code is generated by mk-lib1521.pl ! */
212struct t1521_testdata {
213 const char *blaha;
214};
216#define LO $minlong
217#define HI $maxlong
218#define OFF_LO ((curl_off_t)(LO))
219#define OFF_HI ((curl_off_t)($maxofft))
220#define OFF_NO ((curl_off_t)0)
222static size_t writecb(char *buffer, size_t size, size_t nitems,
223 void *outstream)
225 (void)buffer;
226 (void)size;
227 (void)nitems;
228 (void)outstream;
229 return 0;
232static size_t readcb(char *buffer,
233 size_t size,
234 size_t nitems,
235 void *instream)
237 (void)buffer;
238 (void)size;
239 (void)nitems;
240 (void)instream;
241 return 0;
244static void errlongzero(const char *name, CURLcode result, int lineno)
246 curl_mprintf("%s set to 0 returned %d, \\"%s\\" on line %d\\n",
247 name, (int)result, curl_easy_strerror(result), lineno);
250static void errlong(const char *name, CURLcode result, int lineno)
252$allowednumerrors
253 curl_mprintf("%s set to non-zero returned %d, \\"%s\\" on line %d\\n",
254 name, (int)result, curl_easy_strerror(result), lineno);
257static void errneg(const char *name, CURLcode result, int lineno)
259 curl_mprintf("%s set to -1 returned %d, \\"%s\\" on line %d\\n",
260 name, (int)result, curl_easy_strerror(result), lineno);
263static void errstring(const char *name, CURLcode result, int lineno)
265 /* allow this set of options to return CURLE_BAD_FUNCTION_ARGUMENT
266 when given a strange string input */
267$allowedstringerrors
268 curl_mprintf("%s set to a string returned %d, \\"%s\\" on line %d\\n",
269 name, (int)result, curl_easy_strerror(result), lineno);
272static void err(const char *name, CURLcode result, int lineno)
274 curl_mprintf("%s returned %d, \\"%s\\" on line %d\\n",
275 name, (int)result, curl_easy_strerror(result), lineno);
278static void errnull(const char *name, CURLcode result, int lineno)
280 curl_mprintf("%s set to NULL returned %d, \\"%s\\" on line %d\\n",
281 name, (int)result, curl_easy_strerror(result), lineno);
284static void t1521_geterr(const char *name, CURLcode result, int lineno)
286 curl_mprintf("CURLINFO_%s returned %d, \\"%s\\" on line %d\\n",
287 name, (int)result, curl_easy_strerror(result), lineno);
290static curl_progress_callback progresscb;
291static curl_write_callback headercb;
292static curl_debug_callback debugcb;
293static curl_trailer_callback trailercb;
294static curl_ssl_ctx_callback ssl_ctx_cb;
295static curl_ioctl_callback ioctlcb;
296static curl_sockopt_callback sockoptcb;
297static curl_opensocket_callback opensocketcb;
298static curl_seek_callback seekcb;
299static curl_sshkeycallback ssh_keycb;
300static curl_sshhostkeycallback ssh_hostkeycb;
301static curl_chunk_bgn_callback chunk_bgn_cb;
302static curl_chunk_end_callback chunk_end_cb;
303static curl_fnmatch_callback fnmatch_cb;
304static curl_closesocket_callback closesocketcb;
305static curl_xferinfo_callback xferinfocb;
306static curl_hstsread_callback hstsreadcb;
307static curl_hstswrite_callback hstswritecb;
308static curl_resolver_start_callback resolver_start_cb;
309static curl_prereq_callback prereqcb;
310static curl_conv_callback conv_from_network_cb;
311static curl_conv_callback conv_to_network_cb;
312static curl_conv_callback conv_from_utf8_cb;
313typedef size_t (*interleave_callback)(void *ptr, size_t size, size_t nmemb,
314 void *userdata);
315static interleave_callback interleavecb;
317/* long options that are okay to return
318 CURLE_BAD_FUNCTION_ARGUMENT */
319static bool bad_long(CURLcode res, int check)
321 if(res != CURLE_BAD_FUNCTION_ARGUMENT)
322 return 0; /* not okay */
324 if(check < CURLOPTTYPE_OBJECTPOINT) {
325 /* LONG */
326 return 1;
327 }
328 else if((check >= CURLOPTTYPE_OFF_T) &&
329 (check < CURLOPTTYPE_BLOB)) {
330 /* OFF_T */
331 return 1;
332 }
333 return 0;
336/* long options that should handle -1 */
337static bool bad_neg(int check)
339 switch(check) {
340 case CURLOPT_DNS_CACHE_TIMEOUT:
341 case CURLOPT_INFILESIZE:
342 case CURLOPT_INFILESIZE_LARGE:
343 case CURLOPT_MAXREDIRS:
344 case CURLOPT_POSTFIELDSIZE:
345 case CURLOPT_POSTFIELDSIZE_LARGE:
346 case CURLOPT_RESUME_FROM:
347 case CURLOPT_RESUME_FROM_LARGE:
348 return TRUE;
349 }
350 return FALSE;
353/* macro to check the first setopt of an option which then is allowed to get a
354 non-existing function return code back */
355#define present(x) \\
356 (((x) != CURLE_NOT_BUILT_IN) && \\
357 ((x) != CURLE_UNKNOWN_OPTION))
359static CURLcode test_lib1521(const char *URL)
361 CURL *curl = NULL;
362 CURL *dep = NULL;
363 CURLSH *share = NULL;
364 char errorbuffer[CURL_ERROR_SIZE];
365 const char *stringpointerextra = "moooo";
366 struct curl_slist *slist = NULL;
367 struct curl_httppost *httppost = NULL;
368 curl_mime *mimepost = NULL;
369 FILE *stream = stderr;
370 struct t1521_testdata object;
371 CURLU *curlu = (CURLU *)&object;
372 const char *charp;
373 long val;
374 curl_off_t oval;
375 double dval;
376 curl_socket_t sockfd;
377 const struct curl_certinfo *certinfo;
378 struct curl_tlssessioninfo *tlssession;
379 struct curl_blob blob = { CURL_UNCONST("silly"), 5, 0 };
380 CURLcode result = CURLE_OK;
381 (void)URL;
382 global_init(CURL_GLOBAL_ALL);
383 easy_init(dep);
384 easy_init(curl);
385 share = curl_share_init();
386 if(!share) {
387 result = CURLE_OUT_OF_MEMORY;
388 goto test_cleanup;
389 }
391HEADER
392 ;
394my $infomode = 0;
396while(<STDIN>) {
397 s/^\s*(.*?)\s*$/$1/; # Trim.
398 # Remove multi-line comment trail.
399 if($incomment) {
400 if($_ !~ /.*?\*\/\s*(.*)$/) {
401 next;
402 }
403 $_ = $1;
404 $incomment = 0;
405 }
406 if($line ne "") {
407 # Unfold line.
408 $_ = "$line $1";
409 $line = "";
410 }
411 # Remove comments.
412 while($_ =~ /^(.*?)\/\*.*?\*\/(.*)$/) {
413 $_ = "$1 $2";
414 }
415 s/^\s*(.*?)\s*$/$1/; # Trim again.
416 if($_ =~ /^(.*)\/\*/) {
417 $_ = $1;
418 $incomment = 1;
419 }
420 # Ignore preprocessor directives and blank lines.
421 if($_ =~ /^(?:#|$)/) {
422 next;
423 }
424 # Handle lines that may be continued as if they were folded.
425 if($_ !~ /[;,{}]$/) {
426 # Folded line.
427 $line = $_;
428 next;
429 }
430 if($_ =~ / CURL_DEPRECATED\(/) {
431 # Drop deprecation info.
432 if($_ !~ /^(.*?) CURL_DEPRECATED\(.*?"\)(.*)$/) {
433 # Needs unfolding.
434 $line = $_;
435 next;
436 }
437 $_ = $1 . $2;
438 }
439 if($_ =~ /^CURLOPT(?:DEPRECATED)?\(/ && $_ !~ /\),$/) {
440 # Multi-line CURLOPTs need unfolding.
441 $line = $_;
442 next;
443 }
444 if($_ =~ /^CURLOPT(?:DEPRECATED)?\(([^ ]*), ([^ ]*), (\d*)[,)]/) {
445 my ($name, $type, $val) = ($1, $2, $3);
446 my $w = " ";
447 my $w2 = "$w$w";
448 my $w3 = "$w$w$w";
449 my $opt = $name;
450 $opt =~ s/^CURLOPT_//;
451 my $exists = "${w}{\n";
452 # the first check for an option
453 my $fpref = "${exists}${w2}CURLcode first =\n${w3}curl_easy_setopt(curl, $name,";
454 my $ifpresent = "${w2}if(present(first)) {\n";
455 my $pref = "${w3}result =\n" .
456 "${w3} curl_easy_setopt(curl, $name,";
457 my $ignoreset = "${w3}/* set string again to check for leaks */\n" .
458 "${w3}(void)curl_easy_setopt(curl, $name,";
459 my $i = ' ' x (length($w) + 21);
460 my $fcheck = <<MOO
461 if(first && present(first)) /* first setopt check only */
462 err("$name", first, __LINE__);
463MOO
464 ;
465 my $fstringcheck = <<MOO
466 if(first && present(first)) /* first setopt check only */
467 errstring("$name", first, __LINE__);
468MOO
469 ;
470 my $check = <<MOO
471 if(result)
472 err("$name", result, __LINE__);
473MOO
474 ;
475 my $flongcheckzero = <<MOO
476 if(first && present(first) && !bad_long(first,
477 $name))
478 errlongzero("$name", first, __LINE__);
479MOO
480 ;
482 my $longcheck = <<MOO
483 if(result && !bad_long(result, $name))
484 errlong("$name", result, __LINE__);
485MOO
486 ;
488 my $negcheck = <<MOO
489 if(result && bad_neg($name))
490 errneg("$name", result, __LINE__);
491MOO
492 ;
494 my $nullcheck = <<MOO
495 if(result)
496 errnull(\"$name\", result, __LINE__);
497MOO
498 ;
500 print $fh "\n /****** Verify $name ******/\n";
501 if($type eq "CURLOPTTYPE_STRINGPOINT") {
502 print $fh "${fpref} \"string\");\n$fstringcheck";
503 print $fh "$ifpresent";
504 print $fh "${ignoreset} \"\");\n";
505 print $fh "${pref} NULL);\n$nullcheck";
506 }
507 elsif(($type eq "CURLOPTTYPE_LONG") ||
508 ($type eq "CURLOPTTYPE_VALUES")) {
509 print $fh "${fpref} 0L);\n$flongcheckzero";
510 print $fh "$ifpresent";
511 print $fh "${pref} 22L);\n$longcheck";
512 print $fh "${pref} LO);\n$longcheck";
513 print $fh "${pref} -1L);\n$negcheck";
514 print $fh "${pref} HI);\n$longcheck";
515 }
516 elsif($type eq "CURLOPTTYPE_OFF_T") {
517 print $fh "${fpref} OFF_NO);\n$flongcheckzero";
518 print $fh "$ifpresent";
519 my $lvl = " " x 25;
520 print $fh "${pref}\n${lvl}(curl_off_t)22);\n$longcheck";
521 print $fh "${pref} OFF_HI);\n$longcheck";
522 print $fh "${pref} OFF_LO);\n$longcheck";
523 }
524 elsif(($type eq "CURLOPTTYPE_OBJECTPOINT") ||
525 ($type eq "CURLOPTTYPE_CBPOINT")) {
526 if($name =~ /DEPENDS/) {
527 print $fh "${fpref} dep);\n$fcheck";
528 }
529 elsif($name =~ "SHARE") {
530 print $fh "${fpref} share);\n$fcheck";
531 }
532 elsif($name eq "CURLOPT_ERRORBUFFER") {
533 print $fh "${fpref} errorbuffer);\n$fcheck";
534 }
535 elsif(($name eq "CURLOPT_POSTFIELDS") ||
536 ($name eq "CURLOPT_COPYPOSTFIELDS")) {
537 # set size to zero to avoid it being "illegal"
538 print $fh " (void)curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 0L);\n";
539 print $fh "${fpref} stringpointerextra);\n$fcheck";
540 }
541 elsif($name eq "CURLOPT_HTTPPOST") {
542 print $fh "${fpref} httppost);\n$fcheck";
543 }
544 elsif($name eq "CURLOPT_MIMEPOST") {
545 print $fh "${fpref} mimepost);\n$fcheck";
546 }
547 elsif($name eq "CURLOPT_STDERR") {
548 print $fh "${fpref} stream);\n$fcheck";
549 }
550 elsif($name eq "CURLOPT_CURLU") {
551 print $fh "${fpref} curlu);\n$fcheck";
552 }
553 else {
554 print $fh "${fpref} &object);\n$fcheck";
555 }
556 print $fh "$ifpresent";
557 print $fh "${pref} NULL);\n$nullcheck";
558 }
559 elsif($type eq "CURLOPTTYPE_SLISTPOINT") {
560 print $fh "${fpref} slist);\n$fcheck";
561 print $fh "$ifpresent";
562 print $fh "${pref} NULL);\n$nullcheck";
563 }
564 elsif($type eq "CURLOPTTYPE_FUNCTIONPOINT") {
565 if($name =~ /([^ ]*)FUNCTION/) {
566 my $l = lc($1);
567 $l =~ s/^curlopt_//;
568 print $fh "${fpref}\n$i${l}cb);\n$fcheck";
569 }
570 else {
571 print $fh "${fpref} &func);\n$fcheck";
572 }
573 print $fh "$ifpresent";
574 print $fh "${pref} NULL);\n$nullcheck";
575 }
576 elsif($type eq "CURLOPTTYPE_BLOB") {
577 print $fh "${fpref} &blob);\n$check";
578 print $fh "$ifpresent";
579 print $fh "${pref} NULL);\n$nullcheck";
580 }
581 else {
582 print STDERR "\nUnknown type: $type\n";
583 exit 22; # exit to make this noticed!
584 }
586 print $fh <<MOO
587 } /* end of secondary checks */
588 } /* end of single setopt */
589MOO
590 ;
591 }
592 elsif($_ =~ /^CURLINFO_NONE/) {
593 $infomode = 1;
594 }
595 elsif($infomode &&
596 ($_ =~ /^CURLINFO_([^ ]*) *= *CURLINFO_([^ ]*)/)) {
597 my ($info, $type) = ($1, $2);
598 my $c = " result = curl_easy_getinfo(curl, CURLINFO_$info,";
599 my $check = " if(result)\n t1521_geterr(\"$info\", result, __LINE__);\n";
600 if($type eq "STRING") {
601 print $fh "$c &charp);\n$check";
602 }
603 elsif($type eq "LONG") {
604 print $fh "$c &val);\n$check";
605 }
606 elsif($type eq "OFF_T") {
607 print $fh "$c &oval);\n$check";
608 }
609 elsif($type eq "DOUBLE") {
610 print $fh "$c &dval);\n$check";
611 }
612 elsif($type eq "SLIST") {
613 print $fh "$c &slist);\n$check";
614 print $fh " if(slist)\n curl_slist_free_all(slist);\n";
615 }
616 elsif($type eq "SOCKET") {
617 print $fh "$c &sockfd);\n$check";
618 }
619 elsif($type eq "PTR") {
620 if($info eq "CERTINFO") {
621 print $fh "$c &certinfo);\n$check";
622 }
623 elsif(($info eq "TLS_SESSION") ||
624 ($info eq "TLS_SSL_PTR")) {
625 print $fh "$c &tlssession);\n$check";
626 }
627 else {
628 print STDERR "$info/$type is unsupported\n";
629 }
630 }
631 else {
632 print STDERR "$type is unsupported\n";
633 }
634 }
637print $fh <<FOOTER
639 /* NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange) */
640 curl_easy_setopt(curl, (CURLoption)1, 0L);
641 result = CURLE_OK;
642test_cleanup:
643 curl_easy_cleanup(curl);
644 curl_easy_cleanup(dep);
645 curl_share_cleanup(share);
646 curl_global_cleanup();
648 if(!result)
649 puts("ok");
650 return result;
652FOOTER
653 ;
655close($fh);
656rename($tempfile, $ARGV[0]);
Diagnostics4 git calls · 343 ms
CallStatusSizeTime0343 ms
discover200152 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
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 · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=337
git.response.bytes=293470
git.response.cache=HIT
git.response.duration_ms=3
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
fetch2005.0 KiB337 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=5120
git.response.cache=MISS
git.response.duration_ms=337
git.fetch.wants=eae379af8ebd28e081aed030eaa9ec725c2c7d85
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=5120
git.pkt.payload.max=5099
git.sideband.band1.bytes=5098
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
a5e329ce48d34628
Request
3eb50557…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format