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 "first.h"
26#include "testtrace.h"
28#ifdef USE_OPENSSL
29#include <openssl/ssl.h>
30#endif
31#ifdef USE_WOLFSSL
32#include <wolfssl/options.h>
33#include <wolfssl/version.h>
34#include <wolfssl/ssl.h>
35#endif
36#ifdef USE_GNUTLS
37#include <gnutls/gnutls.h>
38#endif
39#ifdef USE_MBEDTLS
40#include <mbedtls/ssl.h>
41#endif
42#ifdef USE_RUSTLS
43#include <rustls.h>
44#endif
45#ifdef USE_SCHANNEL
46#include <sspi.h> /* for CtxtHandle, QueryContextAttributes() */
47#include <schannel.h> /* for SecPkgContext_ConnectionInfo,
48 SECPKG_ATTR_CONNECTION_INFO */
49#endif
51static int verbose_d = 1;
53struct transfer_d {
54 size_t idx;
55 CURL *curl;
56 char filename[128];
57 FILE *out;
58 curl_off_t recv_size;
59 curl_off_t fail_at;
60 curl_off_t pause_at;
61 curl_off_t abort_at;
62 int started;
63 int paused;
64 int resumed;
65 int done;
66 int checked_ssl;
67 CURLcode result;
68};
70static size_t transfer_count_d = 1;
71static struct transfer_d *transfer_d;
72static int forbid_reuse_d = 0;
74static struct transfer_d *get_transfer_for_easy_d(CURL *curl)
75{
76 size_t i;
77 for(i = 0; i < transfer_count_d; ++i) {
78 if(curl == transfer_d[i].curl)
79 return &transfer_d[i];
80 }
81 return NULL;
82}
84static size_t my_write_d_cb(char *buf, size_t nitems, size_t buflen,
85 void *userdata)
86{
87 struct transfer_d *t = userdata;
88 curl_off_t blen = nitems * buflen;
89 size_t nwritten;
91 curl_mfprintf(stderr, "[t-%zu] RECV %" CURL_FORMAT_CURL_OFF_T " bytes, "
92 "total=%" CURL_FORMAT_CURL_OFF_T ", "
93 "pause_at=%" CURL_FORMAT_CURL_OFF_T "\n",
94 t->idx, blen, t->recv_size, t->pause_at);
95 if(!t->out) {
96 curl_msnprintf(t->filename, sizeof(t->filename) - 1, "download_%zu.data",
97 t->idx);
98 t->out = curlx_fopen(t->filename, "wb");
99 if(!t->out)
100 return 0;
101 }
103 if(!t->resumed &&
104 t->recv_size < t->pause_at &&
105 ((t->recv_size + (curl_off_t)blen) >= t->pause_at)) {
106 curl_mfprintf(stderr, "[t-%zu] PAUSE\n", t->idx);
107 t->paused = 1;
108 return CURL_WRITEFUNC_PAUSE;
109 }
111 nwritten = fwrite(buf, buflen, nitems, t->out);
112 if(nwritten < nitems) {
113 curl_mfprintf(stderr, "[t-%zu] write failure\n", t->idx);
114 return 0;
115 }
116 t->recv_size += blen;
117 if(t->fail_at > 0 && t->recv_size >= t->fail_at) {
118 curl_mfprintf(stderr, "[t-%zu] FAIL by write callback at "
119 "%" CURL_FORMAT_CURL_OFF_T " bytes\n", t->idx, t->recv_size);
120 return CURL_WRITEFUNC_ERROR;
121 }
123 return (size_t)blen;
124}
126static int my_progress_d_cb(void *userdata,
127 curl_off_t dltotal, curl_off_t dlnow,
128 curl_off_t ultotal, curl_off_t ulnow)
129{
130 struct transfer_d *t = userdata;
131 (void)ultotal;
132 (void)ulnow;
133 (void)dltotal;
134 if(t->abort_at > 0 && dlnow >= t->abort_at) {
135 curl_mfprintf(stderr, "[t-%zu] ABORT by progress_cb at "
136 "%" CURL_FORMAT_CURL_OFF_T " bytes\n", t->idx, dlnow);
137 return 1;
138 }
140#if defined(USE_OPENSSL) || defined(USE_GNUTLS) || defined(USE_WOLFSSL) || \
141 defined(USE_MBEDTLS) || defined(USE_RUSTLS) || defined(USE_SCHANNEL)
142 if(!t->checked_ssl && dlnow > 0) {
143 struct curl_tlssessioninfo *tls;
144 CURLcode result;
146 t->checked_ssl = TRUE;
147 result = curl_easy_getinfo(t->curl, CURLINFO_TLS_SSL_PTR, &tls);
148 if(result) {
149 curl_mfprintf(stderr, "[t-%zu] info CURLINFO_TLS_SSL_PTR failed: %d\n",
150 t->idx, (int)result);
151 DEBUGASSERT(0);
152 }
153 else {
154 switch(tls->backend) {
155#ifdef USE_OPENSSL
156 case CURLSSLBACKEND_OPENSSL: {
157 const char *version = SSL_get_version((SSL *)tls->internals);
158 DEBUGASSERT(version);
159 DEBUGASSERT(strcmp(version, "unknown"));
160 curl_mfprintf(stderr, "[t-%zu] info OpenSSL using %s\n",
161 t->idx, version);
162 break;
163 }
164#endif
165#ifdef USE_WOLFSSL
166 case CURLSSLBACKEND_WOLFSSL: {
167 const char *version = wolfSSL_get_version((WOLFSSL *)tls->internals);
168 DEBUGASSERT(version);
169 DEBUGASSERT(strcmp(version, "unknown"));
170 curl_mfprintf(stderr, "[t-%zu] info wolfSSL using %s\n",
171 t->idx, version);
172 break;
173 }
174#endif
175#ifdef USE_GNUTLS
176 case CURLSSLBACKEND_GNUTLS: {
177 gnutls_protocol_t v = gnutls_protocol_get_version(
178 (gnutls_session_t)tls->internals);
179 DEBUGASSERT(v);
180 curl_mfprintf(stderr, "[t-%zu] info GnuTLS using %s\n",
181 t->idx, gnutls_protocol_get_name(v));
182 break;
183 }
184#endif
185#ifdef USE_MBEDTLS
186 case CURLSSLBACKEND_MBEDTLS: {
187 const char *version =
188 mbedtls_ssl_get_version((mbedtls_ssl_context *)tls->internals);
189 DEBUGASSERT(version);
190 DEBUGASSERT(strcmp(version, "unknown"));
191 curl_mfprintf(stderr, "[t-%zu] info mbedTLS using %s\n",
192 t->idx, version);
193 break;
194 }
195#endif
196#ifdef USE_RUSTLS
197 case CURLSSLBACKEND_RUSTLS: {
198 int v = rustls_connection_get_protocol_version(
199 (struct rustls_connection *)tls->internals);
200 DEBUGASSERT(v);
201 curl_mfprintf(stderr, "[t-%zu] info rustls TLS version 0x%x\n",
202 t->idx, (unsigned int)v);
203 break;
204 }
205#endif
206#ifdef USE_SCHANNEL
207 case CURLSSLBACKEND_SCHANNEL: {
208 CtxtHandle *ctxt_handle = (CtxtHandle *)tls->internals;
209 SecPkgContext_ConnectionInfo info;
210 SECURITY_STATUS sspi_status;
211 sspi_status = QueryContextAttributes(ctxt_handle,
212 SECPKG_ATTR_CONNECTION_INFO,
213 &info);
214 DEBUGASSERT(sspi_status == SEC_E_OK);
215 (void)sspi_status;
216 curl_mfprintf(stderr, "[t-%zu] info Schannel TLS version 0x%08lx\n",
217 t->idx, (unsigned long)info.dwProtocol);
218 break;
219 }
220#endif
221 default:
222 curl_mfprintf(stderr, "[t-%zu] info SSL_PTR backend=%d, ptr=%p\n",
223 t->idx, (int)tls->backend, tls->internals);
224 break;
225 }
226 }
227 }
228#endif
229 return 0;
230}
232static int setup_hx_download(CURL *curl, const char *url, struct transfer_d *t,
233 long http_version, struct curl_slist *host,
234 CURLSH *share, int use_earlydata,
235 int fresh_connect, const char *cafile)
236{
237 curl_easy_setopt(curl, CURLOPT_SHARE, share);
238 curl_easy_setopt(curl, CURLOPT_URL, url);
239 curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, http_version);
240 if(cafile)
241 curl_easy_setopt(curl, CURLOPT_CAINFO, cafile);
242 curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "");
243 curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, (long)(128 * 1024));
244 curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_write_d_cb);
245 curl_easy_setopt(curl, CURLOPT_WRITEDATA, t);
246 curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
247 curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, my_progress_d_cb);
248 curl_easy_setopt(curl, CURLOPT_XFERINFODATA, t);
249 if(use_earlydata)
250 curl_easy_setopt(curl, CURLOPT_SSL_OPTIONS, CURLSSLOPT_EARLYDATA);
251 if(forbid_reuse_d)
252 curl_easy_setopt(curl, CURLOPT_FORBID_REUSE, 1L);
253 if(host)
254 curl_easy_setopt(curl, CURLOPT_RESOLVE, host);
255 if(fresh_connect)
256 curl_easy_setopt(curl, CURLOPT_FRESH_CONNECT, 1L);
258 /* please be verbose */
259 if(verbose_d) {
260 curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
261 curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb);
262 }
264 /* wait for pipe connection to confirm */
265 curl_easy_setopt(curl, CURLOPT_PIPEWAIT, 1L);
267 return 0; /* all is good */
268}
270static void usage_hx_download(const char *msg)
271{
272 if(msg)
273 curl_mfprintf(stderr, "%s\n", msg);
274 curl_mfprintf(stderr,
275 "usage: [options] url\n"
276 " download a URL with following options:\n"
277 " -a abort paused transfer\n"
278 " -m number max parallel downloads\n"
279 " -e use TLS early data when possible\n"
280 " -f forbid connection reuse\n"
281 " -n number total downloads\n");
282 curl_mfprintf(stderr,
283 " -A number abort transfer after `number` response bytes\n"
284 " -F number fail writing response after `number` response bytes\n"
285 " -M number max concurrent connections to a host\n"
286 " -P number pause transfer after `number` response bytes\n"
287 " -r <host>:<port>:<addr> resolve information\n"
288 " -S share connections between easy handles\n"
289 " -T number max concurrent connections total\n"
290 " -V http_version (http/1.1, h2, h3) http version to use\n"
291 " -6 use IPv6 for resolving the FIRST URL\n"
292 );
293}
295/*
296 * Download a file over HTTP/2, take care of server push.
297 */
298static CURLcode test_cli_hx_download(const char *URL)
299{
300 CURLM *multi = NULL;
301 struct CURLMsg *m;
302 CURLSH *share = NULL;
303 const char *url;
304 size_t i, n, max_parallel = 1;
305 size_t active_transfers;
306 size_t pause_offset = 0;
307 size_t abort_offset = 0;
308 size_t fail_offset = 0;
309 int abort_paused = 0, use_earlydata = 0;
310 struct transfer_d *t = NULL;
311 long http_version = CURL_HTTP_VERSION_2_0;
312 int ch;
313 struct curl_slist *host = NULL;
314 char *resolve = NULL;
315 size_t max_host_conns = 0;
316 size_t max_total_conns = 0;
317 int fresh_connect = 0;
318 int share_connect = 0;
319 char *cafile = NULL;
320 bool first_ipv6 = FALSE;
321 CURLcode result = CURLE_OK;
323 (void)URL;
325 while((ch = cgetopt(test_argc, test_argv, "aefhm:n:xA:C:F:M:P:r:ST:V:6"))
326 != -1) {
327 const char *opt = coptarg;
328 curl_off_t num;
329 switch(ch) {
330 case 'h':
331 usage_hx_download(NULL);
332 result = (CURLcode)2;
333 goto optcleanup;
334 case 'a':
335 abort_paused = 1;
336 break;
337 case 'e':
338 use_earlydata = 1;
339 break;
340 case 'f':
341 forbid_reuse_d = 1;
342 break;
343 case 'm':
344 if(!curlx_str_number(&opt, &num, LONG_MAX))
345 max_parallel = (size_t)num;
346 break;
347 case 'n':
348 if(!curlx_str_number(&opt, &num, LONG_MAX))
349 transfer_count_d = (size_t)num;
350 break;
351 case 'x':
352 fresh_connect = 1;
353 break;
354 case 'A':
355 if(!curlx_str_number(&opt, &num, LONG_MAX))
356 abort_offset = (size_t)num;
357 break;
358 case 'C':
359 curlx_free(cafile);
360 cafile = curlx_strdup(coptarg);
361 break;
362 case 'F':
363 if(!curlx_str_number(&opt, &num, LONG_MAX))
364 fail_offset = (size_t)num;
365 break;
366 case 'M':
367 if(!curlx_str_number(&opt, &num, LONG_MAX))
368 max_host_conns = (size_t)num;
369 break;
370 case 'P':
371 if(!curlx_str_number(&opt, &num, LONG_MAX))
372 pause_offset = (size_t)num;
373 break;
374 case 'r':
375 curlx_free(resolve);
376 resolve = curlx_strdup(coptarg);
377 break;
378 case 'S':
379 share_connect = 1;
380 break;
381 case 'T':
382 if(!curlx_str_number(&opt, &num, LONG_MAX))
383 max_total_conns = (size_t)num;
384 break;
385 case 'V': {
386 if(!strcmp("http/1.1", coptarg))
387 http_version = CURL_HTTP_VERSION_1_1;
388 else if(!strcmp("h2", coptarg))
389 http_version = CURL_HTTP_VERSION_2_0;
390 else if(!strcmp("h3", coptarg))
391 http_version = CURL_HTTP_VERSION_3ONLY;
392 else {
393 usage_hx_download("invalid http version");
394 result = (CURLcode)1;
395 goto optcleanup;
396 }
397 break;
398 }
399 case '6':
400 first_ipv6 = TRUE;
401 break;
402 default:
403 usage_hx_download("invalid option");
404 result = (CURLcode)1;
405 goto optcleanup;
406 }
407 }
408 test_argc -= coptind;
409 test_argv += coptind;
411 curl_global_trace("ids,time,http/2,http/3");
413 if(test_argc != 1) {
414 usage_hx_download("not enough arguments");
415 result = (CURLcode)2;
416 goto optcleanup;
417 }
418 url = test_argv[0];
420 if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
421 curl_mfprintf(stderr, "curl_global_init() failed\n");
422 result = (CURLcode)3;
423 goto optcleanup;
424 }
426 if(resolve)
427 host = curl_slist_append(NULL, resolve);
429 share = curl_share_init();
430 if(!share) {
431 curl_mfprintf(stderr, "error allocating share\n");
432 result = (CURLcode)1;
433 goto cleanup;
434 }
435 curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
436 curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
437 curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
438 if(share_connect)
439 curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_CONNECT);
440 curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_PSL);
441 curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_HSTS);
443 transfer_d = curlx_calloc(transfer_count_d, sizeof(*transfer_d));
444 if(!transfer_d) {
445 curl_mfprintf(stderr, "error allocating transfer structs\n");
446 result = (CURLcode)1;
447 goto cleanup;
448 }
450 multi = curl_multi_init();
451 curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
452 curl_multi_setopt(multi, CURLMOPT_MAX_TOTAL_CONNECTIONS,
453 (long)max_total_conns);
454 curl_multi_setopt(multi, CURLMOPT_MAX_HOST_CONNECTIONS,
455 (long)max_host_conns);
457 active_transfers = 0;
458 for(i = 0; i < transfer_count_d; ++i) {
459 t = &transfer_d[i];
460 t->idx = i;
461 t->abort_at = (curl_off_t)abort_offset;
462 t->fail_at = (curl_off_t)fail_offset;
463 t->pause_at = (curl_off_t)pause_offset;
464 }
466 n = (max_parallel < transfer_count_d) ? max_parallel : transfer_count_d;
467 for(i = 0; i < n; ++i) {
468 t = &transfer_d[i];
469 t->curl = curl_easy_init();
470 if(!t->curl ||
471 setup_hx_download(t->curl, url, t, http_version, host, share,
472 use_earlydata, fresh_connect, cafile)) {
473 curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
474 result = (CURLcode)1;
475 goto cleanup;
476 }
477 if(!i && first_ipv6)
478 curl_easy_setopt(t->curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);
479 curl_multi_add_handle(multi, t->curl);
480 t->started = 1;
481 ++active_transfers;
482 curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx);
483 }
485 do {
486 int still_running; /* keep number of running handles */
487 CURLMcode mresult = curl_multi_perform(multi, &still_running);
489 if(still_running) {
490 /* wait for activity, timeout or "nothing" */
491 mresult = curl_multi_poll(multi, NULL, 0, 500, NULL);
492 }
494 if(mresult)
495 break;
497 do {
498 int msgq = 0;
499 m = curl_multi_info_read(multi, &msgq);
500 if(m && (m->msg == CURLMSG_DONE)) {
501 CURL *easy = m->easy_handle;
502 --active_transfers;
503 curl_multi_remove_handle(multi, easy);
504 t = get_transfer_for_easy_d(easy);
505 if(t) {
506 t->done = 1;
507 t->result = m->data.result;
508 curl_mfprintf(stderr, "[t-%zu] FINISHED with result %d\n",
509 t->idx, (int)t->result);
510 if(use_earlydata) {
511 curl_off_t sent;
512 curl_easy_getinfo(easy, CURLINFO_EARLYDATA_SENT_T, &sent);
513 curl_mfprintf(stderr, "[t-%zu] EarlyData: "
514 "%" CURL_FORMAT_CURL_OFF_T "\n", t->idx, sent);
515 }
516 }
517 else {
518 curl_easy_cleanup(easy);
519 curl_mfprintf(stderr, "unknown FINISHED???\n");
520 }
521 }
523 /* nothing happening, maintenance */
524 if(abort_paused) {
525 /* abort paused transfers */
526 for(i = 0; i < transfer_count_d; ++i) {
527 t = &transfer_d[i];
528 if(!t->done && t->paused && t->curl) {
529 curl_multi_remove_handle(multi, t->curl);
530 t->done = 1;
531 active_transfers--;
532 curl_mfprintf(stderr, "[t-%zu] ABORTED\n", t->idx);
533 }
534 }
535 }
536 else {
537 /* resume one paused transfer */
538 for(i = 0; i < transfer_count_d; ++i) {
539 t = &transfer_d[i];
540 if(!t->done && t->paused) {
541 t->resumed = 1;
542 t->paused = 0;
543 curl_easy_pause(t->curl, CURLPAUSE_CONT);
544 curl_mfprintf(stderr, "[t-%zu] RESUMED\n", t->idx);
545 break;
546 }
547 }
548 }
550 while(active_transfers < max_parallel) {
551 for(i = 0; i < transfer_count_d; ++i) {
552 t = &transfer_d[i];
553 if(!t->started) {
554 t->curl = curl_easy_init();
555 if(!t->curl ||
556 setup_hx_download(t->curl, url, t, http_version, host, share,
557 use_earlydata, fresh_connect, cafile)) {
558 curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
559 result = (CURLcode)1;
560 goto cleanup;
561 }
562 curl_multi_add_handle(multi, t->curl);
563 t->started = 1;
564 ++active_transfers;
565 curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx);
566 break;
567 }
568 }
569 /* all started */
570 if(i == transfer_count_d)
571 break;
572 }
573 } while(m);
575 } while(active_transfers); /* as long as we have transfers going */
577cleanup:
579 curl_multi_cleanup(multi);
581 if(transfer_d) {
582 for(i = 0; i < transfer_count_d; ++i) {
583 t = &transfer_d[i];
584 if(t->out) {
585 curlx_fclose(t->out);
586 t->out = NULL;
587 }
588 if(t->curl) {
589 curl_easy_cleanup(t->curl);
590 t->curl = NULL;
591 }
592 if(t->result)
593 result = t->result;
594 else /* on success we expect SSL to have been checked */
595 DEBUGASSERT(t->checked_ssl);
596 }
597 curlx_free(transfer_d);
598 }
600 curl_share_cleanup(share);
601 curl_slist_free_all(host);
603 curl_global_cleanup();
605optcleanup:
607 curlx_free(resolve);
608 curlx_free(cafile);
610 return result;
611}
Diagnostics4 git calls · 51 ms
CallStatusSizeTime051 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 · hit26 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=26 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
fetch2005.3 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=5413 git.response.cache=HIT git.response.duration_ms=22 git.fetch.wants=6afa539142828cfda4c9ad950826e6753028d10b 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=5413 git.pkt.payload.max=5392 git.sideband.band1.bytes=5391 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
- a5e34e3428d914c2
- Request
- 14e8375f…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format