Artifactspublic-v0

curl

master
ply4 git calls29 ms293 KiB3 cachedprotocol v2
647 lines18 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 "curl_setup.h"
26#ifdef HAVE_NETINET_IN_H
27#include <netinet/in.h>
28#endif
29#ifdef HAVE_NETINET_IN6_H
30#include <netinet/in6.h>
31#endif
32#ifdef HAVE_NETDB_H
33#include <netdb.h>
34#endif
35#ifdef HAVE_ARPA_INET_H
36#include <arpa/inet.h>
37#endif
38#ifdef HAVE_SYS_UN_H
39#include <sys/un.h>
40#endif
42#ifdef __VMS
43#include <in.h>
44#include <inet.h>
45#endif
47#include <stddef.h> /* for offsetof() */
49#include "curl_addrinfo.h"
50#include "fake_addrinfo.h"
51#include "curlx/inet_pton.h"
52#include "curlx/strparse.h"
54/*
55 * Curl_freeaddrinfo()
56 *
57 * This is used to free a linked list of Curl_addrinfo structs along
58 * with all its associated allocated storage. This function should be
59 * called once for each successful call to Curl_getaddrinfo_ex() or to
60 * any function call which actually allocates a Curl_addrinfo struct.
61 */
63#if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 910) && \
64 defined(__OPTIMIZE__) && defined(__unix__) && defined(__i386__)
65 /* workaround icc 9.1 optimizer issue */
66# define vqualifier volatile
67#else
68# define vqualifier
69#endif
71void Curl_freeaddrinfo(struct Curl_addrinfo *cahead)
73 struct Curl_addrinfo *vqualifier canext;
74 struct Curl_addrinfo *ca;
76 for(ca = cahead; ca; ca = canext) {
77 canext = ca->ai_next;
78 curlx_free(ca);
79 }
82struct Curl_addrinfo *Curl_addrinfo_get(struct Curl_addrinfo *ai,
83 int ai_family,
84 unsigned int n)
86 unsigned int i;
87 for(i = 0; ai; ai = ai->ai_next) {
88 if(ai->ai_family == ai_family) {
89 if(i == n)
90 return ai;
91 ++i;
92 }
93 }
94 return NULL;
97#ifdef HAVE_GETADDRINFO
98/*
99 * Curl_getaddrinfo_ex()
100 *
101 * This is a wrapper function around system's getaddrinfo(), with
102 * the only difference that instead of returning a linked list of
103 * addrinfo structs this one returns a linked list of Curl_addrinfo
104 * ones. The memory allocated by this function *MUST* be free'd with
105 * Curl_freeaddrinfo(). For each successful call to this function
106 * there must be an associated call later to Curl_freeaddrinfo().
107 *
108 * There should be no single call to system's getaddrinfo() in the
109 * whole library, any such call should be 'routed' through this one.
110 */
111int Curl_getaddrinfo_ex(const char *nodename,
112 const char *servname,
113 const struct addrinfo *hints,
114 struct Curl_addrinfo **result)
116 const struct addrinfo *ai;
117 struct addrinfo *aihead;
118 struct Curl_addrinfo *cafirst = NULL;
119 struct Curl_addrinfo *calast = NULL;
120 struct Curl_addrinfo *ca;
121 size_t ss_size;
122 int error;
124 *result = NULL; /* assume failure */
126 error = CURL_GETADDRINFO(nodename, servname, hints, &aihead);
127 if(error)
128 return error;
130 /* traverse the addrinfo list */
132 for(ai = aihead; ai; ai = ai->ai_next) {
133 size_t namelen = ai->ai_canonname ? strlen(ai->ai_canonname) + 1 : 0;
134 /* ignore elements with unsupported address family,
135 settle family-specific sockaddr structure size. */
136 if(ai->ai_family == AF_INET)
137 ss_size = sizeof(struct sockaddr_in);
138#ifdef USE_IPV6
139 else if(ai->ai_family == AF_INET6)
140 ss_size = sizeof(struct sockaddr_in6);
141#endif
142 else
143 continue;
145 /* ignore elements without required address info */
146 if(!ai->ai_addr || !(ai->ai_addrlen > 0))
147 continue;
149 /* ignore elements with bogus address size */
150 if((size_t)ai->ai_addrlen < ss_size)
151 continue;
153 ca = curlx_malloc(sizeof(struct Curl_addrinfo) + ss_size + namelen);
154 if(!ca) {
155 error = EAI_MEMORY;
156 break;
157 }
159 /* copy each structure member individually, member ordering,
160 size, or padding might be different for each platform. */
162 ca->ai_flags = ai->ai_flags;
163 ca->ai_family = ai->ai_family;
164 ca->ai_socktype = ai->ai_socktype;
165 ca->ai_protocol = ai->ai_protocol;
166 ca->ai_addrlen = (curl_socklen_t)ss_size;
167 ca->ai_addr = NULL;
168 ca->ai_canonname = NULL;
169 ca->ai_next = NULL;
171 ca->ai_addr = (void *)((char *)ca + sizeof(struct Curl_addrinfo));
172 memcpy(ca->ai_addr, ai->ai_addr, ss_size);
174 if(namelen) {
175 ca->ai_canonname = (void *)((char *)ca->ai_addr + ss_size);
176 memcpy(ca->ai_canonname, ai->ai_canonname, namelen);
177 }
179 /* if the return list is empty, this becomes the first element */
180 if(!cafirst)
181 cafirst = ca;
183 /* add this element last in the return list */
184 if(calast)
185 calast->ai_next = ca;
186 calast = ca;
187 }
189 /* destroy the addrinfo list */
190 if(aihead)
191 CURL_FREEADDRINFO(aihead);
193 /* if we failed, also destroy the Curl_addrinfo list */
194 if(error) {
195 Curl_freeaddrinfo(cafirst);
196 cafirst = NULL;
197 }
198 else if(!cafirst) {
199#ifdef EAI_NONAME
200 /* rfc3493 conformant */
201 error = EAI_NONAME;
202#else
203 /* rfc3493 obsoleted */
204 error = EAI_NODATA;
205#endif
206#ifdef USE_WINSOCK
207 SET_SOCKERRNO(error);
208#endif
209 }
211 *result = cafirst;
213 /* This is not a CURLcode */
214 return error;
216#endif /* HAVE_GETADDRINFO */
218/*
219 * Curl_he2ai()
220 *
221 * This function returns a pointer to the first element of a newly allocated
222 * Curl_addrinfo struct linked list filled with the data of a given hostent.
223 * Curl_addrinfo is meant to work like the addrinfo struct does for an IPv6
224 * stack, but usable also for IPv4, all hosts and environments.
225 *
226 * The memory allocated by this function *MUST* be free'd later on calling
227 * Curl_freeaddrinfo(). For each successful call to this function there
228 * must be an associated call later to Curl_freeaddrinfo().
229 *
230 * Curl_addrinfo defined in "lib/curl_addrinfo.h"
231 *
232 * struct Curl_addrinfo {
233 * int ai_flags;
234 * int ai_family;
235 * int ai_socktype;
236 * int ai_protocol;
237 * curl_socklen_t ai_addrlen; * Follow rfc3493 struct addrinfo *
238 * char *ai_canonname;
239 * struct sockaddr *ai_addr;
240 * struct Curl_addrinfo *ai_next;
241 * };
242 *
243 * hostent defined in <netdb.h>
244 *
245 * struct hostent {
246 * char *h_name;
247 * char **h_aliases;
248 * int h_addrtype;
249 * int h_length;
250 * char **h_addr_list;
251 * };
252 *
253 * for backward compatibility:
254 *
255 * #define h_addr h_addr_list[0]
256 */
257#if !(defined(HAVE_GETADDRINFO) && defined(HAVE_GETADDRINFO_THREADSAFE))
258struct Curl_addrinfo *Curl_he2ai(const struct hostent *he, int port)
260 struct Curl_addrinfo *ai;
261 struct Curl_addrinfo *prevai = NULL;
262 struct Curl_addrinfo *firstai = NULL;
263 struct sockaddr_in *addr;
264#ifdef USE_IPV6
265 struct sockaddr_in6 *addr6;
266#endif
267 CURLcode result = CURLE_OK;
268 int i;
269 char *curr;
271 if(!he)
272 /* no input == no output! */
273 return NULL;
275 DEBUGASSERT(he->h_name && he->h_addr_list);
277 for(i = 0; (curr = he->h_addr_list[i]) != NULL; i++) {
278 size_t ss_size;
279 size_t namelen = strlen(he->h_name) + 1; /* include null-terminator */
280#ifdef USE_IPV6
281 if(he->h_addrtype == AF_INET6)
282 ss_size = sizeof(struct sockaddr_in6);
283 else
284#endif
285 ss_size = sizeof(struct sockaddr_in);
287 /* allocate memory to hold the struct, the address and the name */
288 ai = curlx_calloc(1, sizeof(struct Curl_addrinfo) + ss_size + namelen);
289 if(!ai) {
290 result = CURLE_OUT_OF_MEMORY;
291 break;
292 }
293 /* put the address after the struct */
294 ai->ai_addr = (void *)((char *)ai + sizeof(struct Curl_addrinfo));
295 /* then put the name after the address */
296 ai->ai_canonname = (char *)ai->ai_addr + ss_size;
297 memcpy(ai->ai_canonname, he->h_name, namelen);
299 if(!firstai)
300 /* store the pointer we want to return from this function */
301 firstai = ai;
303 if(prevai)
304 /* make the previous entry point to this */
305 prevai->ai_next = ai;
307 ai->ai_family = he->h_addrtype;
309 /* we return all names as STREAM, so when using this address for TFTP
310 the type must be ignored and conn->socktype be used instead! */
311 ai->ai_socktype = SOCK_STREAM;
313 ai->ai_addrlen = (curl_socklen_t)ss_size;
315 /* leave the rest of the struct filled with zero */
317 switch(ai->ai_family) {
318 case AF_INET:
319 addr = (void *)ai->ai_addr; /* storage area for this info */
321 memcpy(&addr->sin_addr, curr, sizeof(struct in_addr));
322 addr->sin_family = (CURL_SA_FAMILY_T)he->h_addrtype;
323 addr->sin_port = htons((unsigned short)port);
324 break;
326#ifdef USE_IPV6
327 case AF_INET6:
328 addr6 = (void *)ai->ai_addr; /* storage area for this info */
330 memcpy(&addr6->sin6_addr, curr, sizeof(struct in6_addr));
331 addr6->sin6_family = (CURL_SA_FAMILY_T)he->h_addrtype;
332 addr6->sin6_port = htons((unsigned short)port);
333 break;
334#endif
335 }
337 prevai = ai;
338 }
340 if(result) {
341 Curl_freeaddrinfo(firstai);
342 firstai = NULL;
343 }
345 return firstai;
347#endif
349/*
350 * ip2addr()
351 *
352 * This function takes an Internet address, in binary form, as input parameter
353 * along with its address family and the string version of the address, and it
354 * returns a Curl_addrinfo chain filled in correctly with information for the
355 * given address/host
356 */
357static CURLcode ip2addr(struct Curl_addrinfo **addrp, int af,
358 const void *inaddr, const char *hostname, int port)
360 struct Curl_addrinfo *ai;
361 size_t addrsize;
362 size_t namelen;
363 struct sockaddr_in *addr;
364#ifdef USE_IPV6
365 struct sockaddr_in6 *addr6;
366#endif
368 DEBUGASSERT(inaddr && hostname);
370 namelen = strlen(hostname) + 1;
371 *addrp = NULL;
373 if(af == AF_INET)
374 addrsize = sizeof(struct sockaddr_in);
375#ifdef USE_IPV6
376 else if(af == AF_INET6)
377 addrsize = sizeof(struct sockaddr_in6);
378#endif
379 else
380 return CURLE_BAD_FUNCTION_ARGUMENT;
382 /* allocate memory to hold the struct, the address and the name */
383 ai = curlx_calloc(1, sizeof(struct Curl_addrinfo) + addrsize + namelen);
384 if(!ai)
385 return CURLE_OUT_OF_MEMORY;
386 /* put the address after the struct */
387 ai->ai_addr = (void *)((char *)ai + sizeof(struct Curl_addrinfo));
388 /* then put the name after the address */
389 ai->ai_canonname = (char *)ai->ai_addr + addrsize;
390 memcpy(ai->ai_canonname, hostname, namelen);
391 ai->ai_family = af;
392 ai->ai_socktype = SOCK_STREAM;
393 ai->ai_addrlen = (curl_socklen_t)addrsize;
394 /* leave the rest of the struct filled with zero */
396 switch(af) {
397 case AF_INET:
398 addr = (void *)ai->ai_addr; /* storage area for this info */
400 memcpy(&addr->sin_addr, inaddr, sizeof(struct in_addr));
401 addr->sin_family = (CURL_SA_FAMILY_T)af;
402 addr->sin_port = htons((unsigned short)port);
403 break;
405#ifdef USE_IPV6
406 case AF_INET6:
407 addr6 = (void *)ai->ai_addr; /* storage area for this info */
409 memcpy(&addr6->sin6_addr, inaddr, sizeof(struct in6_addr));
410 addr6->sin6_family = (CURL_SA_FAMILY_T)af;
411 addr6->sin6_port = htons((unsigned short)port);
412 break;
413#endif
414 }
415 *addrp = ai;
416 return CURLE_OK;
419/*
420 * Given an IPv4 or IPv6 dotted string address, this converts it to a proper
421 * allocated Curl_addrinfo struct and returns it.
422 */
423CURLcode Curl_str2addr(const char *dotted, uint16_t port,
424 struct Curl_addrinfo **addrp)
426 struct in_addr in;
427 if(curlx_inet_pton(AF_INET, dotted, &in) > 0)
428 /* This is a dotted IP address 123.123.123.123-style */
429 return ip2addr(addrp, AF_INET, &in, dotted, port);
430#ifdef USE_IPV6
431 {
432 struct in6_addr in6;
433 if(curlx_inet_pton(AF_INET6, dotted, &in6) > 0)
434 /* This is a dotted IPv6 address ::1-style */
435 return ip2addr(addrp, AF_INET6, &in6, dotted, port);
436 }
437#endif
438 return CURLE_BAD_FUNCTION_ARGUMENT; /* bad input format */
441bool Curl_is_ipv4addr(const char *address)
443 struct in_addr in;
444 return (curlx_inet_pton(AF_INET, address, &in) > 0);
447bool Curl_is_ipaddr(const char *address)
449 if(Curl_is_ipv4addr(address))
450 return TRUE;
451#ifdef USE_IPV6
452 {
453 struct in6_addr in6;
454 if(curlx_inet_pton(AF_INET6, address, &in6) > 0)
455 /* This is a dotted IPv6 address ::1-style */
456 return TRUE;
457 }
458#endif
459 return FALSE;
462bool Curl_looks_like_ipv6(const char *s, size_t len, bool maybe_url_encoded,
463 struct Curl_str *host, struct Curl_str *zone)
465 const char *zonep = NULL;
466 size_t i = 0, hlen = 0, zlen = 0;
468 if(host)
469 memset(host, 0, sizeof(*host));
470 if(zone)
471 memset(zone, 0, sizeof(*zone));
473 for(i = 0; i < len; ++i, ++hlen) {
474 if(!s[i] || !(ISXDIGIT(s[i]) || (s[i] == ':') || (s[i] == '.')))
475 break;
476 }
478 if((i < len) && (s[i] == '%')) { /* address followed by a zone? */
479 i += 1;
480 if(maybe_url_encoded && !strncmp("25", s + i, 2))
481 i += 2;
482 zonep = s + i;
483 for(; i < len; ++i, ++zlen) {
484 /* Allow unreserved characters as defined in RFC 3986 */
485 if(!s[i] || !(ISALPHA(s[i]) || ISXDIGIT(s[i]) || (s[i] == '-') ||
486 (s[i] == '.') || (s[i] == '_') || (s[i] == '~')))
487 break;
488 }
489 }
491 if(i != len)
492 return FALSE; /* invalid chars in zone */
493 if(host && hlen) {
494 host->str = s;
495 host->len = hlen;
496 }
497 if(zone && zlen) {
498 zone->str = zonep;
499 zone->len = zlen;
500 }
501 return TRUE;
504#ifdef USE_UNIX_SOCKETS
505/**
506 * Given a path to a Unix domain socket, return a newly allocated Curl_addrinfo
507 * struct initialized with this path.
508 * Returns CURLE_TOO_LARGE when path is too long.
509 */
510CURLcode Curl_unix2addr(const char *path, bool abstract,
511 struct Curl_addrinfo **paddr)
513 struct Curl_addrinfo *ai;
514 struct sockaddr_un *sa_un;
515 size_t path_len;
517 *paddr = NULL;
519 /* sun_path must be able to store the null-terminated path */
520 path_len = strlen(path) + 1;
521 if(path_len > sizeof(sa_un->sun_path))
522 return CURLE_TOO_LARGE;
524 ai = curlx_calloc(1,
525 sizeof(struct Curl_addrinfo) + sizeof(struct sockaddr_un));
526 if(!ai)
527 return CURLE_OUT_OF_MEMORY;
529 ai->ai_addr = (void *)((char *)ai + sizeof(struct Curl_addrinfo));
530 sa_un = (void *)ai->ai_addr;
531 sa_un->sun_family = AF_UNIX;
533 ai->ai_family = AF_UNIX;
534 ai->ai_socktype = SOCK_STREAM; /* assume reliable transport for HTTP */
535 ai->ai_addrlen = (curl_socklen_t)
536 ((offsetof(struct sockaddr_un, sun_path) + path_len) & 0x7FFFFFFF);
538 /* Abstract Unix domain socket have NULL prefix instead of suffix */
539 if(abstract)
540 memcpy(sa_un->sun_path + 1, path, path_len - 1);
541 else
542 memcpy(sa_un->sun_path, path, path_len); /* copy NUL byte */
544 *paddr = ai;
545 return CURLE_OK;
547#endif
549#if defined(CURL_MEMDEBUG) && defined(HAVE_GETADDRINFO) && \
550 defined(HAVE_FREEADDRINFO)
551/*
552 * curl_dbg_freeaddrinfo()
553 *
554 * This is strictly for memory tracing and are using the same style as the
555 * family otherwise present in memdebug.c. I put these ones here since they
556 * require a bunch of structs I did not want to include in memdebug.c
557 */
558void curl_dbg_freeaddrinfo(struct addrinfo *freethis,
559 int line, const char *source)
561 curl_dbg_log("ADDR %s:%d freeaddrinfo(%p)\n",
562 source, line, (void *)freethis);
563#ifdef USE_LWIPSOCK
564 lwip_freeaddrinfo(freethis);
565#elif defined(USE_FAKE_GETADDRINFO)
566 {
567 const char *env = getenv("CURL_DNS_SERVER");
568 if(env)
569 r_freeaddrinfo(freethis);
570 else
571 /* !checksrc! disable BANNEDFUNC 1 */
572 freeaddrinfo(freethis);
573 }
574#else
575 /* !checksrc! disable BANNEDFUNC 1 */
576 freeaddrinfo(freethis);
577#endif
579#endif /* CURL_MEMDEBUG && HAVE_FREEADDRINFO */
581#if defined(CURL_MEMDEBUG) && defined(HAVE_GETADDRINFO)
582/*
583 * curl_dbg_getaddrinfo()
584 *
585 * This is strictly for memory tracing and are using the same style as the
586 * family otherwise present in memdebug.c. I put these ones here since they
587 * require a bunch of structs I did not want to include in memdebug.c
588 */
589int curl_dbg_getaddrinfo(const char *hostname,
590 const char *service,
591 const struct addrinfo *hints,
592 struct addrinfo **result,
593 int line, const char *source)
595#ifdef USE_LWIPSOCK
596 int res = lwip_getaddrinfo(hostname, service, hints, result);
597#elif defined(USE_FAKE_GETADDRINFO)
598 int res;
599 const char *env = getenv("CURL_DNS_SERVER");
600 if(env)
601 res = r_getaddrinfo(hostname, service, hints, result);
602 else
603 /* !checksrc! disable BANNEDFUNC 1 */
604 res = getaddrinfo(hostname, service, hints, result);
605#else
606 /* !checksrc! disable BANNEDFUNC 1 */
607 int res = getaddrinfo(hostname, service, hints, result);
608#endif
609 if(res == 0)
610 /* success */
611 curl_dbg_log("ADDR %s:%d getaddrinfo() = %p\n", source, line,
612 (void *)*result);
613 else
614 curl_dbg_log("ADDR %s:%d getaddrinfo() failed\n", source, line);
615 return res;
617#endif /* CURL_MEMDEBUG && HAVE_GETADDRINFO */
619#if defined(HAVE_GETADDRINFO) && defined(USE_RESOLVE_ON_IPS)
620/*
621 * Works around the sin6_port is always zero bug on iOS 9.3.2 and macOS
622 * 10.11.5.
623 */
624void Curl_addrinfo_set_port(struct Curl_addrinfo *addrinfo, int port)
626 struct Curl_addrinfo *ca;
627 struct sockaddr_in *addr;
628#ifdef USE_IPV6
629 struct sockaddr_in6 *addr6;
630#endif
631 for(ca = addrinfo; ca; ca = ca->ai_next) {
632 switch(ca->ai_family) {
633 case AF_INET:
634 addr = (void *)ca->ai_addr; /* storage area for this info */
635 addr->sin_port = htons((unsigned short)port);
636 break;
638#ifdef USE_IPV6
639 case AF_INET6:
640 addr6 = (void *)ca->ai_addr; /* storage area for this info */
641 addr6->sin6_port = htons((unsigned short)port);
642 break;
643#endif
644 }
645 }
647#endif
Diagnostics4 git calls · 29 ms
CallStatusSizeTime029 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=23
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.7 KiB · hit23 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=5804
git.response.cache=HIT
git.response.duration_ms=23
git.fetch.wants=d578ab727545af45efd05b4d09756b6c6f081495
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=5804
git.pkt.payload.max=5783
git.sideband.band1.bytes=5782
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
a5e1cd755babc6f8
Request
730e46de…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format