Artifactspublic-v0

curl

master
ply4 git calls24 ms292 KiB3 cachedprotocol v2
713 lines19 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#include "urldata.h"
27#include "getinfo.h"
28#include "cfilters.h"
29#include "vtls/vtls.h"
30#include "connect.h" /* Curl_getconnectinfo() */
31#include "bufref.h"
32#include "url.h" /* Curl_uc_to_curlcode() */
33#include "curlx/strparse.h"
35/*
36 * Initialize statistical and informational data.
37 *
38 * This function is called in curl_easy_reset, curl_easy_duphandle and at the
39 * beginning of a perform session. It must reset the session-info variables,
40 * in particular all variables in struct PureInfo.
41 */
42void Curl_initinfo(struct Curl_easy *data)
44 struct Progress *pro = &data->progress;
45 struct PureInfo *info = &data->info;
47 memset(&pro->delta, 0, sizeof(pro->delta));
48 memset(&pro->total, 0, sizeof(pro->total));
49 pro->startransfer_added = FALSE;
51 info->httpcode = 0;
52 info->httpproxycode = 0;
53 info->httpversion = 0;
54 info->filetime = -1; /* -1 is an illegal time and thus means unknown */
55 info->timecond = FALSE;
57 info->header_size = 0;
58 info->request_size = 0;
59 info->proxyauthavail = 0;
60 info->httpauthavail = 0;
61 info->proxyauthpicked = 0;
62 info->httpauthpicked = 0;
63 info->numconnects = 0;
65 curlx_safefree(info->contenttype);
66 curlx_safefree(info->wouldredirect);
67 curlx_safefree(info->effective_url);
69 memset(&info->primary, 0, sizeof(info->primary));
70 info->retry_after = 0;
72 info->conn_scheme = 0;
73 info->conn_protocol = 0;
74 info->used_proxy = 0;
76#ifdef USE_SSL
77 Curl_ssl_free_certinfo(data);
78#endif
81static CURLcode effective_url(struct Curl_easy *data,
82 const char **param_charp)
84 const char *s = Curl_bufref_ptr(&data->state.url);
85 /* never return the URL unfiltered */
86 *param_charp = s ? NULL : "";
87 if(s) {
88 char *url = NULL;
89 /* Make a copy of the URL without credentials */
90 CURLU *u = curl_url();
91 CURLUcode uc;
92 if(!u)
93 return CURLE_OUT_OF_MEMORY;
95 uc = curl_url_set(u, CURLUPART_URL, s,
96 CURLU_NON_SUPPORT_SCHEME |
97 (data->set.path_as_is ? CURLU_PATH_AS_IS : 0));
98 if(!uc)
99 uc = curl_url_set(u, CURLUPART_USER, NULL, 0);
100 if(!uc)
101 uc = curl_url_set(u, CURLUPART_PASSWORD, NULL, 0);
102 if(!uc)
103 uc = curl_url_get(u, CURLUPART_URL, &url, CURLU_GET_EMPTY);
105 curl_url_cleanup(u);
107 if(uc || !url)
108 return uc ? Curl_uc_to_curlcode(uc) : CURLE_OUT_OF_MEMORY;
109 if(strcmp(url, s)) {
110 /* they are different */
111 curlx_free(data->info.effective_url);
112 data->info.effective_url = url;
113 *param_charp = url;
114 }
115 else {
116 curl_free(url);
117 *param_charp = s;
118 }
119 }
120 return CURLE_OK;
123static CURLcode getinfo_char(struct Curl_easy *data, CURLINFO info,
124 const char **param_charp)
126 switch(info) {
127 case CURLINFO_EFFECTIVE_URL:
128 return effective_url(data, param_charp);
129 case CURLINFO_EFFECTIVE_METHOD: {
130 const char *m = CURL_EASY_STR(data, STRING_CUSTOMREQUEST);
131 if(!m) {
132 if(data->set.opt_no_body)
133 m = "HEAD";
134#ifndef CURL_DISABLE_HTTP
135 else {
136 switch(data->state.httpreq) {
137 case HTTPREQ_POST:
138 case HTTPREQ_POST_FORM:
139 case HTTPREQ_POST_MIME:
140 m = "POST";
141 break;
142 case HTTPREQ_PUT:
143 m = "PUT";
144 break;
145 default: /* this should never happen */
146 case HTTPREQ_GET:
147 m = "GET";
148 break;
149 case HTTPREQ_HEAD:
150 m = "HEAD";
151 break;
152 }
153 }
154#endif
155 }
156 *param_charp = m;
157 }
158 break;
159 case CURLINFO_CONTENT_TYPE:
160 *param_charp = data->info.contenttype;
161 break;
162 case CURLINFO_PRIVATE:
163 *param_charp = (const char *)data->set.private_data;
164 break;
165 case CURLINFO_FTP_ENTRY_PATH:
166 /* Return the entrypath string from the most recent connection.
167 This pointer was copied from the connectdata structure by FTP.
168 The actual string may be freed by subsequent libcurl calls so
169 it must be copied to a safer area before the next libcurl call.
170 Callers must never free it themselves. */
171 *param_charp = data->state.most_recent_ftp_entrypath;
172 break;
173 case CURLINFO_REDIRECT_URL:
174 /* Return the URL this request would have been redirected to if that
175 option had been enabled! */
176 *param_charp = data->info.wouldredirect;
177 break;
178 case CURLINFO_REFERER:
179 /* Return the referrer header for this request, or NULL if unset */
180 *param_charp = Curl_bufref_ptr(&data->state.referer);
181 break;
182 case CURLINFO_PRIMARY_IP:
183 /* Return the ip address of the most recent (primary) connection */
184 *param_charp = data->info.primary.remote_ip;
185 break;
186 case CURLINFO_LOCAL_IP:
187 /* Return the source/local ip address of the most recent (primary)
188 connection */
189 *param_charp = data->info.primary.local_ip;
190 break;
191 case CURLINFO_RTSP_SESSION_ID:
192#ifndef CURL_DISABLE_RTSP
193 *param_charp = CURL_EASY_STR(data, STRING_RTSP_SESSION_ID);
194#else
195 *param_charp = NULL;
196#endif
197 break;
198 case CURLINFO_SCHEME:
199 *param_charp = data->info.conn_scheme;
200 break;
201 case CURLINFO_CAPATH:
202#ifdef CURL_CA_PATH
203 *param_charp = CURL_CA_PATH;
204#else
205 *param_charp = NULL;
206#endif
207 break;
208 case CURLINFO_CAINFO:
209#ifdef CURL_CA_BUNDLE
210 *param_charp = CURL_CA_BUNDLE;
211#else
212 *param_charp = NULL;
213#endif
214 break;
215 default:
216 return CURLE_UNKNOWN_OPTION;
217 }
219 return CURLE_OK;
222static CURLcode getinfo_long(struct Curl_easy *data, CURLINFO info,
223 long *param_longp)
225 curl_socket_t sockfd;
227 union {
228 unsigned long *to_ulong;
229 long *to_long;
230 } lptr;
232#ifdef DEBUGBUILD
233 const char *envstr;
235 /* use another variable for this to allow different values */
236 switch(info) {
237 case CURLINFO_LOCAL_PORT:
238 envstr = getenv("CURL_TIME");
239 if(envstr) {
240 curl_off_t val;
241 curlx_str_number(&envstr, &val, TIME_T_MAX);
242 *param_longp = (long)val;
243 return CURLE_OK;
244 }
245 break;
246 case CURLINFO_HEADER_SIZE:
247 case CURLINFO_REQUEST_SIZE:
248 envstr = getenv("CURL_DEBUG_SIZE");
249 if(envstr) {
250 curl_off_t val;
251 curlx_str_number(&envstr, &val, LONG_MAX);
252 *param_longp = (long)val;
253 return CURLE_OK;
254 }
255 break;
256 default:
257 break;
258 }
259#endif
261 switch(info) {
262 case CURLINFO_RESPONSE_CODE:
263 *param_longp = data->info.httpcode;
264 break;
265 case CURLINFO_HTTP_CONNECTCODE:
266 *param_longp = data->info.httpproxycode;
267 break;
268 case CURLINFO_FILETIME:
269 if(data->info.filetime > LONG_MAX)
270 *param_longp = LONG_MAX;
271#if !defined(MSDOS) && !defined(__AMIGA__)
272 else if(data->info.filetime < LONG_MIN)
273 *param_longp = LONG_MIN;
274#endif
275 else
276 *param_longp = (long)data->info.filetime;
277 break;
278 case CURLINFO_HEADER_SIZE:
279 *param_longp = (long)data->info.header_size;
280 break;
281 case CURLINFO_REQUEST_SIZE:
282 *param_longp = (long)data->info.request_size;
283 break;
284 case CURLINFO_SSL_VERIFYRESULT:
285 *param_longp = data->set.ssl.certverifyresult;
286 break;
287 case CURLINFO_PROXY_SSL_VERIFYRESULT:
288#ifndef CURL_DISABLE_PROXY
289 *param_longp = data->set.proxy_ssl.certverifyresult;
290#else
291 *param_longp = 0;
292#endif
293 break;
294 case CURLINFO_REDIRECT_COUNT:
295 *param_longp = data->state.followlocation;
296 break;
297 case CURLINFO_HTTPAUTH_AVAIL:
298 lptr.to_long = param_longp;
299 *lptr.to_ulong = data->info.httpauthavail;
300 break;
301 case CURLINFO_PROXYAUTH_AVAIL:
302 lptr.to_long = param_longp;
303 *lptr.to_ulong = data->info.proxyauthavail;
304 break;
305 case CURLINFO_HTTPAUTH_USED:
306 lptr.to_long = param_longp;
307 *lptr.to_ulong = data->info.httpauthpicked;
308 break;
309 case CURLINFO_PROXYAUTH_USED:
310 lptr.to_long = param_longp;
311 *lptr.to_ulong = data->info.proxyauthpicked;
312 break;
313 case CURLINFO_OS_ERRNO:
314 *param_longp = data->state.os_errno;
315 break;
316 case CURLINFO_NUM_CONNECTS:
317#if SIZEOF_LONG < SIZEOF_CURL_OFF_T
318 if(data->info.numconnects > LONG_MAX)
319 *param_longp = LONG_MAX;
320 else
321#endif
322 *param_longp = (long)data->info.numconnects;
323 break;
324 case CURLINFO_LASTSOCKET:
325 sockfd = Curl_getconnectinfo(data, NULL);
327 /* note: this is not a good conversion for systems with 64-bit sockets and
328 32-bit longs */
329 if(sockfd != CURL_SOCKET_BAD)
330 *param_longp = (long)sockfd;
331 else
332 /* this interface is documented to return -1 in case of badness, which
333 may not be the same as the CURL_SOCKET_BAD value */
334 *param_longp = -1;
335 break;
336 case CURLINFO_PRIMARY_PORT:
337 /* Return the (remote) port of the most recent (primary) connection */
338 if(CUR_IP_QUAD_HAS_PORTS(&data->info.primary))
339 *param_longp = data->info.primary.remote_port;
340 else
341 *param_longp = -1;
342 break;
343 case CURLINFO_LOCAL_PORT:
344 /* Return the local port of the most recent (primary) connection */
345 if(CUR_IP_QUAD_HAS_PORTS(&data->info.primary))
346 *param_longp = data->info.primary.local_port;
347 else
348 *param_longp = -1;
349 break;
350 case CURLINFO_PROXY_ERROR:
351 *param_longp = (long)data->info.pxcode;
352 break;
353 case CURLINFO_CONDITION_UNMET:
354 if(data->info.httpcode == 304)
355 *param_longp = 1L;
356 else
357 /* return if the condition prevented the document to get transferred */
358 *param_longp = data->info.timecond ? 1L : 0L;
359 break;
360#ifndef CURL_DISABLE_RTSP
361 case CURLINFO_RTSP_CLIENT_CSEQ:
362 *param_longp = data->state.rtsp_next_client_CSeq;
363 break;
364 case CURLINFO_RTSP_SERVER_CSEQ:
365 *param_longp = data->state.rtsp_next_server_CSeq;
366 break;
367 case CURLINFO_RTSP_CSEQ_RECV:
368 *param_longp = data->state.rtsp_CSeq_recv;
369 break;
370#else
371 case CURLINFO_RTSP_CLIENT_CSEQ:
372 case CURLINFO_RTSP_SERVER_CSEQ:
373 case CURLINFO_RTSP_CSEQ_RECV:
374 *param_longp = 0;
375 break;
376#endif
377 case CURLINFO_HTTP_VERSION:
378 switch(data->info.httpversion) {
379 case 10:
380 *param_longp = CURL_HTTP_VERSION_1_0;
381 break;
382 case 11:
383 *param_longp = CURL_HTTP_VERSION_1_1;
384 break;
385 case 20:
386 *param_longp = CURL_HTTP_VERSION_2_0;
387 break;
388 case 30:
389 *param_longp = CURL_HTTP_VERSION_3;
390 break;
391 default:
392 *param_longp = CURL_HTTP_VERSION_NONE;
393 break;
394 }
395 break;
396 case CURLINFO_PROTOCOL:
397 *param_longp = (long)data->info.conn_protocol;
398 break;
399 case CURLINFO_USED_PROXY:
400 *param_longp =
401#ifdef CURL_DISABLE_PROXY
402 0
403#else
404 data->info.used_proxy
405#endif
406 ;
407 break;
408 default:
409 return CURLE_UNKNOWN_OPTION;
410 }
412 return CURLE_OK;
415#define DOUBLE_SECS(x) ((double)(x) / 1000000)
417static CURLcode getinfo_offt(struct Curl_easy *data, CURLINFO info,
418 curl_off_t *param_offt)
420#ifdef DEBUGBUILD
421 const char *envstr;
422 switch(info) {
423 case CURLINFO_TOTAL_TIME_T:
424 case CURLINFO_NAMELOOKUP_TIME_T:
425 case CURLINFO_CONNECT_TIME_T:
426 case CURLINFO_APPCONNECT_TIME_T:
427 case CURLINFO_PRETRANSFER_TIME_T:
428 case CURLINFO_POSTTRANSFER_TIME_T:
429 case CURLINFO_QUEUE_TIME_T:
430 case CURLINFO_STARTTRANSFER_TIME_T:
431 case CURLINFO_REDIRECT_TIME_T:
432 case CURLINFO_SPEED_DOWNLOAD_T:
433 case CURLINFO_SPEED_UPLOAD_T:
434 envstr = getenv("CURL_TIME");
435 if(envstr) {
436 curl_off_t val;
437 curlx_str_number(&envstr, &val, CURL_OFF_T_MAX);
438 *param_offt = (curl_off_t)val;
439 return CURLE_OK;
440 }
441 break;
442 default:
443 break;
444 }
445#endif
446 switch(info) {
447 case CURLINFO_FILETIME_T:
448 *param_offt = (curl_off_t)data->info.filetime;
449 break;
450 case CURLINFO_SIZE_DELIVERED:
451 *param_offt = data->progress.deliver;
452 break;
453 case CURLINFO_SIZE_UPLOAD_T:
454 *param_offt = data->progress.ul.cur_size;
455 break;
456 case CURLINFO_SIZE_DOWNLOAD_T:
457 *param_offt = data->progress.dl.cur_size;
458 break;
459 case CURLINFO_SPEED_DOWNLOAD_T:
460 *param_offt = data->progress.dl.speed;
461 break;
462 case CURLINFO_SPEED_UPLOAD_T:
463 *param_offt = data->progress.ul.speed;
464 break;
465 case CURLINFO_CONTENT_LENGTH_DOWNLOAD_T:
466 *param_offt = data->progress.dl_size_known ?
467 data->progress.dl.total_size : -1;
468 break;
469 case CURLINFO_CONTENT_LENGTH_UPLOAD_T:
470 *param_offt = data->progress.ul_size_known ?
471 data->progress.ul.total_size : -1;
472 break;
473 case CURLINFO_TOTAL_TIME_T:
474 *param_offt = data->progress.total.spent_us;
475 break;
476 case CURLINFO_NAMELOOKUP_TIME_T:
477 *param_offt = data->progress.total.nslookup_us;
478 break;
479 case CURLINFO_CONNECT_TIME_T:
480 *param_offt = data->progress.total.connect_us;
481 break;
482 case CURLINFO_APPCONNECT_TIME_T:
483 *param_offt = data->progress.total.appconnect_us;
484 break;
485 case CURLINFO_PRETRANSFER_TIME_T:
486 *param_offt = data->progress.total.pretransfer_us;
487 break;
488 case CURLINFO_POSTTRANSFER_TIME_T:
489 *param_offt = data->progress.total.posttransfer_us;
490 break;
491 case CURLINFO_STARTTRANSFER_TIME_T:
492 *param_offt = data->progress.total.starttransfer_us;
493 break;
494 case CURLINFO_QUEUE_TIME_T:
495 *param_offt = data->progress.total.queued_us;
496 break;
497 case CURLINFO_REDIRECT_TIME_T:
498 *param_offt = data->progress.delta.startredirect_us;
499 break;
500 case CURLINFO_RETRY_AFTER:
501 *param_offt = data->info.retry_after;
502 break;
503 case CURLINFO_XFER_ID:
504 *param_offt = data->id;
505 break;
506 case CURLINFO_CONN_ID:
507 *param_offt = data->state.last_conn_id;
508 break;
509 case CURLINFO_EARLYDATA_SENT_T:
510 *param_offt = data->progress.earlydata_sent;
511 break;
512 default:
513 return CURLE_UNKNOWN_OPTION;
514 }
516 return CURLE_OK;
519static CURLcode getinfo_double(struct Curl_easy *data, CURLINFO info,
520 double *param_doublep)
522#ifdef DEBUGBUILD
523 const char *envstr;
525 switch(info) {
526 case CURLINFO_TOTAL_TIME:
527 case CURLINFO_NAMELOOKUP_TIME:
528 case CURLINFO_CONNECT_TIME:
529 case CURLINFO_APPCONNECT_TIME:
530 case CURLINFO_PRETRANSFER_TIME:
531 case CURLINFO_STARTTRANSFER_TIME:
532 case CURLINFO_REDIRECT_TIME:
533 case CURLINFO_SPEED_DOWNLOAD:
534 case CURLINFO_SPEED_UPLOAD:
535 envstr = getenv("CURL_TIME");
536 if(envstr) {
537 curl_off_t val;
538 curlx_str_number(&envstr, &val, CURL_OFF_T_MAX);
539 *param_doublep = (double)val;
540 return CURLE_OK;
541 }
542 break;
543 default:
544 break;
545 }
546#endif
547 switch(info) {
548 case CURLINFO_TOTAL_TIME:
549 *param_doublep = DOUBLE_SECS(data->progress.total.spent_us);
550 break;
551 case CURLINFO_NAMELOOKUP_TIME:
552 *param_doublep = DOUBLE_SECS(data->progress.total.nslookup_us);
553 break;
554 case CURLINFO_CONNECT_TIME:
555 *param_doublep = DOUBLE_SECS(data->progress.total.connect_us);
556 break;
557 case CURLINFO_APPCONNECT_TIME:
558 *param_doublep = DOUBLE_SECS(data->progress.total.appconnect_us);
559 break;
560 case CURLINFO_PRETRANSFER_TIME:
561 *param_doublep = DOUBLE_SECS(data->progress.total.pretransfer_us);
562 break;
563 case CURLINFO_STARTTRANSFER_TIME:
564 *param_doublep = DOUBLE_SECS(data->progress.total.starttransfer_us);
565 break;
566 case CURLINFO_SIZE_UPLOAD:
567 *param_doublep = (double)data->progress.ul.cur_size;
568 break;
569 case CURLINFO_SIZE_DOWNLOAD:
570 *param_doublep = (double)data->progress.dl.cur_size;
571 break;
572 case CURLINFO_SPEED_DOWNLOAD:
573 *param_doublep = (double)data->progress.dl.speed;
574 break;
575 case CURLINFO_SPEED_UPLOAD:
576 *param_doublep = (double)data->progress.ul.speed;
577 break;
578 case CURLINFO_CONTENT_LENGTH_DOWNLOAD:
579 *param_doublep = data->progress.dl_size_known ?
580 (double)data->progress.dl.total_size : -1;
581 break;
582 case CURLINFO_CONTENT_LENGTH_UPLOAD:
583 *param_doublep = data->progress.ul_size_known ?
584 (double)data->progress.ul.total_size : -1;
585 break;
586 case CURLINFO_REDIRECT_TIME:
587 *param_doublep = DOUBLE_SECS(data->progress.delta.startredirect_us);
588 break;
590 default:
591 return CURLE_UNKNOWN_OPTION;
592 }
594 return CURLE_OK;
597static CURLcode getinfo_slist(struct Curl_easy *data, CURLINFO info,
598 struct curl_slist **param_slistp)
600 union {
601 struct curl_certinfo *to_certinfo;
602 struct curl_slist *to_slist;
603 } ptr;
605 switch(info) {
606 case CURLINFO_SSL_ENGINES:
607 *param_slistp = Curl_ssl_engines_list(data);
608 break;
609 case CURLINFO_COOKIELIST:
610 *param_slistp = Curl_cookie_list(data);
611 break;
612 case CURLINFO_CERTINFO:
613 /* Return the a pointer to the certinfo struct. Not really an slist
614 pointer but we can pretend it is here */
615 ptr.to_certinfo = &data->info.certs;
616 *param_slistp = ptr.to_slist;
617 break;
618 case CURLINFO_TLS_SESSION:
619 case CURLINFO_TLS_SSL_PTR: {
620 int query = (info == CURLINFO_TLS_SSL_PTR) ?
621 CF_QUERY_SSL_INFO : CF_QUERY_SSL_CTX_INFO;
622 struct curl_tlssessioninfo **tsip = (struct curl_tlssessioninfo **)
623 param_slistp;
624 struct curl_tlssessioninfo *tsi = &data->tsi;
626 /* we are exposing a pointer to internal memory with unknown
627 * lifetime here. */
628 *tsip = tsi;
629 if(!Curl_conn_get_ssl_info(data, data->conn, FIRSTSOCKET, query, tsi)) {
630 tsi->backend = Curl_ssl_backend();
631 tsi->internals = NULL;
632 }
633 }
634 break;
635 default:
636 return CURLE_UNKNOWN_OPTION;
637 }
639 return CURLE_OK;
642static CURLcode getinfo_socket(struct Curl_easy *data, CURLINFO info,
643 curl_socket_t *param_socketp)
645 switch(info) {
646 case CURLINFO_ACTIVESOCKET:
647 *param_socketp = Curl_getconnectinfo(data, NULL);
648 break;
649 default:
650 return CURLE_UNKNOWN_OPTION;
651 }
653 return CURLE_OK;
656CURLcode Curl_getinfo(struct Curl_easy *data, CURLINFO info, ...)
658 va_list arg;
659 long *param_longp = NULL;
660 double *param_doublep = NULL;
661 curl_off_t *param_offt = NULL;
662 const char **param_charp = NULL;
663 struct curl_slist **param_slistp = NULL;
664 curl_socket_t *param_socketp = NULL;
665 int type;
666 CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
668 if(!data)
669 return CURLE_BAD_FUNCTION_ARGUMENT;
671 va_start(arg, info);
673 type = CURLINFO_TYPEMASK & (int)info;
674 switch(type) {
675 case CURLINFO_STRING:
676 param_charp = va_arg(arg, const char **);
677 if(param_charp)
678 result = getinfo_char(data, info, param_charp);
679 break;
680 case CURLINFO_LONG:
681 param_longp = va_arg(arg, long *);
682 if(param_longp)
683 result = getinfo_long(data, info, param_longp);
684 break;
685 case CURLINFO_DOUBLE:
686 param_doublep = va_arg(arg, double *);
687 if(param_doublep)
688 result = getinfo_double(data, info, param_doublep);
689 break;
690 case CURLINFO_OFF_T:
691 param_offt = va_arg(arg, curl_off_t *);
692 if(param_offt)
693 result = getinfo_offt(data, info, param_offt);
694 break;
695 case CURLINFO_SLIST:
696 param_slistp = va_arg(arg, struct curl_slist **);
697 if(param_slistp)
698 result = getinfo_slist(data, info, param_slistp);
699 break;
700 case CURLINFO_SOCKET:
701 param_socketp = va_arg(arg, curl_socket_t *);
702 if(param_socketp)
703 result = getinfo_socket(data, info, param_socketp);
704 break;
705 default:
706 result = CURLE_UNKNOWN_OPTION;
707 break;
708 }
710 va_end(arg);
712 return result;
Diagnostics4 git calls · 24 ms
CallStatusSizeTime024 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=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 · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=18
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.2 KiB · hit18 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=5311
git.response.cache=HIT
git.response.duration_ms=18
git.fetch.wants=16d2c7535404ee994dcf418060f7c010a1464d47
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=5311
git.pkt.payload.max=5290
git.sideband.band1.bytes=5289
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
a5e2c0b0787989da
Request
f2122447…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format