Artifactspublic-v0

curl

master
ply4 git calls30 ms292 KiB3 cachedprotocol v2
781 lines20 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 "curl_trc.h"
27#include "urldata.h"
28#include "cfilters.h"
29#include "multiif.h"
31#include "cf-recvbuf.h"
32#include "cf-socket.h"
33#include "cf-setup.h"
34#include "http2.h"
35#include "http_proxy.h"
36#include "cf-h1-proxy.h"
37#include "cf-h2-proxy.h"
38#include "cf-haproxy.h"
39#include "cf-https-connect.h"
40#include "cf-ip-happy.h"
41#include "progress.h"
42#include "socks.h"
43#include "curlx/strparse.h"
44#include "vdns/cf-dns.h"
45#include "vtls/vtls.h"
46#include "vquic/vquic.h"
47#include "curlx/strcopy.h"
49static void trc_write(struct Curl_easy *data, curl_infotype type,
50 const char *ptr, size_t size)
52 if(data->set.verbose) {
53 if(data->set.fdebug) {
54 struct Curl_mapi_guard guard;
55 CURL_CBAPI_START(&guard, data, easy_fdebug);
56 (void)(*data->set.fdebug)(data, type, CURL_UNCONST(ptr), size,
57 data->set.debugdata);
58 CURL_CBAPI_END(&guard);
59 }
60 else {
61 static const char s_infotype[CURLINFO_END][3] = {
62 "* ", "< ", "> ", "{ ", "} ", "{ ", "} " };
63 switch(type) {
64 case CURLINFO_TEXT:
65 case CURLINFO_HEADER_OUT:
66 case CURLINFO_HEADER_IN:
67 fwrite(s_infotype[type], 2, 1, data->set.err);
68 fwrite(ptr, size, 1, data->set.err);
69 break;
70 default: /* nada */
71 break;
72 }
73 }
74 }
77/* max length we trace before ending in '...' */
78#define TRC_LINE_MAX 2048
80#define CURL_TRC_FMT_IDSC "[x-%" CURL_FORMAT_CURL_OFF_T "] "
81#define CURL_TRC_FMT_IDSD "[%" CURL_FORMAT_CURL_OFF_T "-x] "
82#define CURL_TRC_FMT_IDSDC "[%" CURL_FORMAT_CURL_OFF_T "-%" \
83 CURL_FORMAT_CURL_OFF_T "] "
85static struct curl_trc_feat Curl_trc_feat_ids = {
86 "LIB-IDS",
87 CURL_LOG_LVL_NONE,
88};
89#define CURL_TRC_IDS(data) \
90 (Curl_trc_is_verbose(data) && \
91 Curl_trc_feat_ids.log_level >= CURL_LOG_LVL_INFO)
93static size_t trc_print_ids(struct Curl_easy *data, char *buf, size_t maxlen)
95 curl_off_t cid = data->state.last_conn_id;
96 if(data->id >= 0) {
97 if(cid >= 0)
98 return curl_msnprintf(buf, maxlen, CURL_TRC_FMT_IDSDC, data->id, cid);
99 else
100 return curl_msnprintf(buf, maxlen, CURL_TRC_FMT_IDSD, data->id);
101 }
102 else if(cid >= 0)
103 return curl_msnprintf(buf, maxlen, CURL_TRC_FMT_IDSC, cid);
104 else {
105 return curl_msnprintf(buf, maxlen, "[x-x] ");
106 }
109static size_t trc_end_buf(char *buf, size_t len, size_t maxlen, bool addnl)
111 /* make sure we end the trace line in `buf` properly. It needs
112 * to end with a null-terminator '\0' or '\n\0' */
113 if(len >= (maxlen - (addnl ? 2 : 1))) {
114 len = maxlen - 5;
115 buf[len++] = '.';
116 buf[len++] = '.';
117 buf[len++] = '.';
118 buf[len++] = '\n';
119 }
120 else if(addnl)
121 buf[len++] = '\n';
122 buf[len] = '\0';
123 return len;
126void Curl_debug(struct Curl_easy *data, curl_infotype type,
127 const char *ptr, size_t size)
129 if(data->set.verbose) {
130 static const char s_infotype[CURLINFO_END][3] = {
131 "* ", "< ", "> ", "{ ", "} ", "{ ", "} " };
132 char buf[TRC_LINE_MAX];
133 size_t len;
134 if(data->set.fdebug) {
135 struct Curl_mapi_guard guard;
136 if(CURL_TRC_IDS(data) && (size < TRC_LINE_MAX)) {
137 len = trc_print_ids(data, buf, TRC_LINE_MAX);
138 len += curl_msnprintf(buf + len, TRC_LINE_MAX - len, "%.*s",
139 (int)size, ptr);
140 len = trc_end_buf(buf, len, TRC_LINE_MAX, FALSE);
141 CURL_CBAPI_START(&guard, data, easy_fdebug);
142 (void)(*data->set.fdebug)(data, type, buf, len, data->set.debugdata);
143 CURL_CBAPI_END(&guard);
144 }
145 else {
146 CURL_CBAPI_START(&guard, data, easy_fdebug);
147 (void)(*data->set.fdebug)(data, type, CURL_UNCONST(ptr),
148 size, data->set.debugdata);
149 CURL_CBAPI_END(&guard);
150 }
151 }
152 else {
153 switch(type) {
154 case CURLINFO_TEXT:
155 case CURLINFO_HEADER_OUT:
156 case CURLINFO_HEADER_IN:
157#ifndef CURL_DISABLE_VERBOSE_STRINGS
158 if(CURL_TRC_IDS(data)) {
159 len = trc_print_ids(data, buf, TRC_LINE_MAX);
160 fwrite(buf, len, 1, data->set.err);
161 }
162#endif
163 fwrite(s_infotype[type], 2, 1, data->set.err);
164 fwrite(ptr, size, 1, data->set.err);
165 break;
166 default: /* nada */
167 break;
168 }
169 }
170 }
173/* Curl_failf() is for messages stating why we failed.
174 * The message SHALL NOT include any LF or CR.
175 */
176void Curl_failf(struct Curl_easy *data, const char *fmt, ...)
178 DEBUGASSERT(!strchr(fmt, '\n'));
179 if(data->set.verbose || data->set.errorbuffer) {
180 va_list ap;
181 size_t len;
182 char error[CURL_ERROR_SIZE + 2];
183 va_start(ap, fmt);
184 len = curl_mvsnprintf(error, CURL_ERROR_SIZE, fmt, ap);
186 if(data->set.errorbuffer && !data->state.errorbuf) {
187 curlx_strcopy(data->set.errorbuffer, CURL_ERROR_SIZE, error, len);
188 data->state.errorbuf = TRUE; /* wrote error string */
189 }
190 error[len++] = '\n';
191 error[len] = '\0';
192 trc_write(data, CURLINFO_TEXT, error, len);
193 va_end(ap);
194 }
197void Curl_reset_fail(struct Curl_easy *data)
199 if(data->set.errorbuffer)
200 data->set.errorbuffer[0] = 0;
201 data->state.errorbuf = FALSE;
204#ifdef CURLVERBOSE
205struct curl_trc_feat Curl_trc_feat_multi = {
206 "MULTI",
207 CURL_LOG_LVL_NONE,
208};
209struct curl_trc_feat Curl_trc_feat_read = {
210 "READ",
211 CURL_LOG_LVL_NONE,
212};
213struct curl_trc_feat Curl_trc_feat_write = {
214 "WRITE",
215 CURL_LOG_LVL_NONE,
216};
217struct curl_trc_feat Curl_trc_feat_dns = {
218 "DNS",
219 CURL_LOG_LVL_NONE,
220};
221#ifndef CURL_DISABLE_DOH
222struct curl_trc_feat Curl_trc_feat_doh = {
223 "DoH",
224 CURL_LOG_LVL_NONE,
225};
226#endif
227struct curl_trc_feat Curl_trc_feat_timer = {
228 "TIMER",
229 CURL_LOG_LVL_NONE,
230};
231#ifdef USE_THREADS
232struct curl_trc_feat Curl_trc_feat_threads = {
233 "THREADS",
234 CURL_LOG_LVL_NONE,
235};
236#endif
237#endif
239#ifndef CURL_DISABLE_VERBOSE_STRINGS
241static void trc_infof(struct Curl_easy *data,
242 struct curl_trc_feat *feat,
243 const char *opt_id, int opt_id_idx,
244 const char * const fmt, va_list ap) CURL_PRINTF(5, 0);
246static void trc_infof(struct Curl_easy *data,
247 struct curl_trc_feat *feat,
248 const char *opt_id, int opt_id_idx,
249 const char * const fmt, va_list ap)
251 size_t len = 0;
252 char buf[TRC_LINE_MAX];
254 if(CURL_TRC_IDS(data))
255 len += trc_print_ids(data, buf + len, TRC_LINE_MAX - len);
256 if(feat)
257 len += curl_msnprintf(buf + len, TRC_LINE_MAX - len, "[%s] ", feat->name);
258 if(opt_id) {
259 if(opt_id_idx > 0)
260 len += curl_msnprintf(buf + len, TRC_LINE_MAX - len, "[%s-%d] ",
261 opt_id, opt_id_idx);
262 else
263 len += curl_msnprintf(buf + len, TRC_LINE_MAX - len, "[%s] ", opt_id);
264 }
265 len += curl_mvsnprintf(buf + len, TRC_LINE_MAX - len, fmt, ap);
266 len = trc_end_buf(buf, len, TRC_LINE_MAX, TRUE);
267 trc_write(data, CURLINFO_TEXT, buf, len);
270void Curl_infof(struct Curl_easy *data, const char *fmt, ...)
272 DEBUGASSERT(!strchr(fmt, '\n'));
273 if(Curl_trc_is_verbose(data)) {
274 va_list ap;
275 va_start(ap, fmt);
276 trc_infof(data, data->state.feat, NULL, 0, fmt, ap);
277 va_end(ap);
278 }
281void Curl_trc_cf_infof(struct Curl_easy *data, const struct Curl_cfilter *cf,
282 const char *fmt, ...)
284 DEBUGASSERT(cf);
285 if(Curl_trc_cf_is_verbose(cf, data)) {
286 va_list ap;
287 va_start(ap, fmt);
288 trc_infof(data, data->state.feat, cf->cft->name, cf->sockindex, fmt, ap);
289 va_end(ap);
290 }
293void Curl_trc_feat_infof(struct Curl_easy *data,
294 struct curl_trc_feat *feat,
295 const char *fmt, ...)
297 DEBUGASSERT(feat);
298 if(Curl_trc_ft_is_verbose(data, feat)) {
299 va_list ap;
300 va_start(ap, fmt);
301 trc_infof(data, feat, NULL, 0, fmt, ap);
302 va_end(ap);
303 }
306static const char * const Curl_trc_timer_names[] = {
307 "100_TIMEOUT",
308 "ASYNC_NAME",
309 "CONNECTTIMEOUT",
310 "HAPPY_EYEBALLS",
311 "MULTI_PENDING",
312 "SPEEDCHECK",
313 "TIMEOUT",
314 "TOOFAST",
315 "QUIC",
316 "FTP_ACCEPT",
317 "ALPN_EYEBALLS",
318 "SHUTDOWN",
319 "SERVER_RESPONSE",
320};
322static const char *trc_timer_name(int tid)
324 if((tid >= 0) && ((size_t)tid < CURL_ARRAYSIZE(Curl_trc_timer_names)))
325 return Curl_trc_timer_names[(size_t)tid];
326 return "TIMER-???";
329void Curl_trc_timer(struct Curl_easy *data, int tid, const char *fmt, ...)
331 DEBUGASSERT(!strchr(fmt, '\n'));
332 if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_timer)) {
333 const char *tname = trc_timer_name(tid);
334 va_list ap;
335 va_start(ap, fmt);
336 trc_infof(data, &Curl_trc_feat_timer, tname, 0, fmt, ap);
337 va_end(ap);
338 }
341void Curl_trc_easy_timers(struct Curl_easy *data)
343 if(CURL_TRC_TIMER_is_verbose(data) && data->multi) {
344 if(data->state.timeouts.first < EXPIRE_LAST) {
345 struct expire_timers *timeouts = &data->state.timeouts;
346 timediff_t base_us =
347 Curl_timeouts_offset_us(&data->multi->timeouts, Curl_pgrs_now(data));
348 uint8_t id = data->state.timeouts.first;
349 for(; id < EXPIRE_LAST; id = timeouts->next[id]) {
350 CURL_TRC_TIMER(data, id, "expires in %" FMT_TIMEDIFF_T "us",
351 timeouts->offset_us[id] - base_us);
352 }
353 }
354 }
357static const char * const Curl_trc_mstate_names[] = {
358 "INIT",
359 "PENDING",
360 "SETUP",
361 "CONNECT",
362 "CONNECTING",
363 "PROTOCONNECT",
364 "PROTOCONNECTING",
365 "DO",
366 "DOING",
367 "DOING_MORE",
368 "DID",
369 "PERFORMING",
370 "RATELIMITING",
371 "DONE",
372 "COMPLETED",
373 "MSGSENT",
374};
376const char *Curl_trc_mstate_name(int state)
378 if((state >= 0) && ((size_t)state < CURL_ARRAYSIZE(Curl_trc_mstate_names)))
379 return Curl_trc_mstate_names[(size_t)state];
380 return "?";
383void Curl_trc_multi(struct Curl_easy *data, const char *fmt, ...)
385 DEBUGASSERT(!strchr(fmt, '\n'));
386 if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_multi)) {
387 const char *sname = (data->id >= 0) ?
388 Curl_trc_mstate_name(data->mstate) : NULL;
389 va_list ap;
390 va_start(ap, fmt);
391 trc_infof(data, &Curl_trc_feat_multi, sname, 0, fmt, ap);
392 va_end(ap);
393 }
396void Curl_trc_read(struct Curl_easy *data, const char *fmt, ...)
398 DEBUGASSERT(!strchr(fmt, '\n'));
399 if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_read)) {
400 va_list ap;
401 va_start(ap, fmt);
402 trc_infof(data, &Curl_trc_feat_read, NULL, 0, fmt, ap);
403 va_end(ap);
404 }
407void Curl_trc_write(struct Curl_easy *data, const char *fmt, ...)
409 DEBUGASSERT(!strchr(fmt, '\n'));
410 if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_write)) {
411 va_list ap;
412 va_start(ap, fmt);
413 trc_infof(data, &Curl_trc_feat_write, NULL, 0, fmt, ap);
414 va_end(ap);
415 }
418void Curl_trc_dns(struct Curl_easy *data, const char *fmt, ...)
420 DEBUGASSERT(!strchr(fmt, '\n'));
421 if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_dns)) {
422 va_list ap;
423 va_start(ap, fmt);
424 trc_infof(data, &Curl_trc_feat_dns, NULL, 0, fmt, ap);
425 va_end(ap);
426 }
429#ifndef CURL_DISABLE_FTP
430struct curl_trc_feat Curl_trc_feat_ftp = {
431 "FTP",
432 CURL_LOG_LVL_NONE,
433};
435void Curl_trc_ftp(struct Curl_easy *data, const char *fmt, ...)
437 DEBUGASSERT(!strchr(fmt, '\n'));
438 if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_ftp)) {
439 va_list ap;
440 va_start(ap, fmt);
441 trc_infof(data, &Curl_trc_feat_ftp, NULL, 0, fmt, ap);
442 va_end(ap);
443 }
445#endif /* !CURL_DISABLE_FTP */
447#ifndef CURL_DISABLE_SMTP
448struct curl_trc_feat Curl_trc_feat_smtp = {
449 "SMTP",
450 CURL_LOG_LVL_NONE,
451};
453void Curl_trc_smtp(struct Curl_easy *data, const char *fmt, ...)
455 DEBUGASSERT(!strchr(fmt, '\n'));
456 if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_smtp)) {
457 va_list ap;
458 va_start(ap, fmt);
459 trc_infof(data, &Curl_trc_feat_smtp, NULL, 0, fmt, ap);
460 va_end(ap);
461 }
463#endif /* !CURL_DISABLE_SMTP */
465#ifdef USE_SSL
466struct curl_trc_feat Curl_trc_feat_ssls = {
467 "SSLS",
468 CURL_LOG_LVL_NONE,
469};
471void Curl_trc_ssls(struct Curl_easy *data, const char *fmt, ...)
473 DEBUGASSERT(!strchr(fmt, '\n'));
474 if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_ssls)) {
475 va_list ap;
476 va_start(ap, fmt);
477 trc_infof(data, &Curl_trc_feat_ssls, NULL, 0, fmt, ap);
478 va_end(ap);
479 }
481#endif /* USE_SSL */
483#ifdef USE_SSH
484struct curl_trc_feat Curl_trc_feat_ssh = {
485 "SSH",
486 CURL_LOG_LVL_NONE,
487};
489void Curl_trc_ssh(struct Curl_easy *data, const char *fmt, ...)
491 DEBUGASSERT(!strchr(fmt, '\n'));
492 if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_ssh)) {
493 va_list ap;
494 va_start(ap, fmt);
495 trc_infof(data, &Curl_trc_feat_ssh, NULL, 0, fmt, ap);
496 va_end(ap);
497 }
499#endif /* USE_SSH */
501#if !defined(CURL_DISABLE_WEBSOCKETS) && !defined(CURL_DISABLE_HTTP)
502struct curl_trc_feat Curl_trc_feat_ws = {
503 "WS",
504 CURL_LOG_LVL_NONE,
505};
507void Curl_trc_ws(struct Curl_easy *data, const char *fmt, ...)
509 DEBUGASSERT(!strchr(fmt, '\n'));
510 if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_ws)) {
511 va_list ap;
512 va_start(ap, fmt);
513 trc_infof(data, &Curl_trc_feat_ws, NULL, 0, fmt, ap);
514 va_end(ap);
515 }
517#endif /* !CURL_DISABLE_WEBSOCKETS && !CURL_DISABLE_HTTP */
519#define TRC_CT_NONE 0
520#define TRC_CT_PROTOCOL (1 << 0)
521#define TRC_CT_NETWORK (1 << 1)
522#define TRC_CT_PROXY (1 << 2)
523#define TRC_CT_INTERNALS (1 << 3)
525struct trc_feat_def {
526 struct curl_trc_feat *feat;
527 unsigned int category;
528};
530static struct trc_feat_def trc_feats[] = {
531 { &Curl_trc_feat_ids, TRC_CT_INTERNALS },
532 { &Curl_trc_feat_multi, TRC_CT_NETWORK },
533 { &Curl_trc_feat_read, TRC_CT_NONE },
534 { &Curl_trc_feat_write, TRC_CT_NONE },
535 { &Curl_trc_feat_dns, TRC_CT_NETWORK },
536#ifndef CURL_DISABLE_DOH
537 { &Curl_trc_feat_doh, TRC_CT_NETWORK },
538#endif
539 { &Curl_trc_feat_timer, TRC_CT_NETWORK },
540#ifdef USE_THREADS
541 { &Curl_trc_feat_threads, TRC_CT_NONE },
542#endif
543#ifndef CURL_DISABLE_FTP
544 { &Curl_trc_feat_ftp, TRC_CT_PROTOCOL },
545#endif
546#ifndef CURL_DISABLE_SMTP
547 { &Curl_trc_feat_smtp, TRC_CT_PROTOCOL },
548#endif
549#ifdef USE_SSL
550 { &Curl_trc_feat_ssls, TRC_CT_NETWORK },
551#endif
552#ifdef USE_SSH
553 { &Curl_trc_feat_ssh, TRC_CT_PROTOCOL },
554#endif
555#if !defined(CURL_DISABLE_WEBSOCKETS) && !defined(CURL_DISABLE_HTTP)
556 { &Curl_trc_feat_ws, TRC_CT_PROTOCOL },
557#endif
558};
560struct trc_cft_def {
561 struct Curl_cftype *cft;
562 unsigned int category;
563};
565static struct trc_cft_def trc_cfts[] = {
566 { &Curl_cft_dns, TRC_CT_NETWORK },
567 { &Curl_cft_tcp, TRC_CT_NETWORK },
568 { &Curl_cft_udp, TRC_CT_NETWORK },
569 { &Curl_cft_unix, TRC_CT_NETWORK },
570 { &Curl_cft_tcp_accept, TRC_CT_NETWORK },
571 { &Curl_cft_ip_happy, TRC_CT_NETWORK },
572#ifndef CURL_DISABLE_WEBSOCKETS
573 { &Curl_cft_recvbuf, TRC_CT_PROTOCOL },
574#endif
575 { &Curl_cft_setup, TRC_CT_PROTOCOL },
576#if !defined(CURL_DISABLE_HTTP) && defined(USE_NGHTTP2)
577 { &Curl_cft_nghttp2, TRC_CT_PROTOCOL },
578#endif
579#ifdef USE_SSL
580 { &Curl_cft_ssl, TRC_CT_NETWORK },
581#ifndef CURL_DISABLE_PROXY
582 { &Curl_cft_ssl_proxy, TRC_CT_PROXY },
583#endif
584#endif
585#ifndef CURL_DISABLE_PROXY
586#ifndef CURL_DISABLE_HTTP
587 { &Curl_cft_h1_proxy, TRC_CT_PROXY },
588#ifdef USE_NGHTTP2
589 { &Curl_cft_h2_proxy, TRC_CT_PROXY },
590#endif
591#if defined(USE_PROXY_HTTP3) && defined(USE_NGHTTP3)
592 { &Curl_cft_h3_proxy, TRC_CT_PROXY },
593#endif
594 { &Curl_cft_http_proxy, TRC_CT_PROXY },
595#endif /* !CURL_DISABLE_HTTP */
596 { &Curl_cft_haproxy, TRC_CT_PROXY },
597 { &Curl_cft_socks_proxy, TRC_CT_PROXY },
598#endif /* !CURL_DISABLE_PROXY */
599#if !defined(CURL_DISABLE_HTTP) && defined(USE_HTTP3)
600 { &Curl_cft_http3, TRC_CT_PROTOCOL },
601#endif
602#ifndef CURL_DISABLE_HTTP
603 { &Curl_cft_http_connect, TRC_CT_PROTOCOL },
604#endif
605};
607static void trc_apply_level_by_name(struct Curl_str *token, int lvl)
609 size_t i;
611 for(i = 0; i < CURL_ARRAYSIZE(trc_cfts); ++i) {
612 if(curlx_str_casecompare(token, trc_cfts[i].cft->name)) {
613 trc_cfts[i].cft->log_level = lvl;
614 break;
615 }
616 }
617 for(i = 0; i < CURL_ARRAYSIZE(trc_feats); ++i) {
618 if(curlx_str_casecompare(token, trc_feats[i].feat->name)) {
619 trc_feats[i].feat->log_level = lvl;
620 break;
621 }
622 }
625static void trc_apply_level_by_category(unsigned int category, int lvl)
627 size_t i;
629 for(i = 0; i < CURL_ARRAYSIZE(trc_cfts); ++i) {
630 if(!category || (trc_cfts[i].category & category))
631 trc_cfts[i].cft->log_level = lvl;
632 }
633 for(i = 0; i < CURL_ARRAYSIZE(trc_feats); ++i) {
634 if(!category || (trc_feats[i].category & category))
635 trc_feats[i].feat->log_level = lvl;
636 }
639static CURLcode trc_opt(const char *config)
641 struct Curl_str out;
642 while(!curlx_str_until(&config, &out, 32, ',')) {
643 int lvl = CURL_LOG_LVL_INFO;
644 const char *token = curlx_str(&out);
646 if(*token == '-') {
647 lvl = CURL_LOG_LVL_NONE;
648 curlx_str_nudge(&out, 1);
649 }
650 else if(*token == '+')
651 curlx_str_nudge(&out, 1);
653 if(curlx_str_casecompare(&out, "all"))
654 trc_apply_level_by_category(TRC_CT_NONE, lvl);
655 else if(curlx_str_casecompare(&out, "protocol"))
656 trc_apply_level_by_category(TRC_CT_PROTOCOL, lvl);
657 else if(curlx_str_casecompare(&out, "network"))
658 trc_apply_level_by_category(TRC_CT_NETWORK, lvl);
659 else if(curlx_str_casecompare(&out, "proxy"))
660 trc_apply_level_by_category(TRC_CT_PROXY, lvl);
661 else
662 trc_apply_level_by_name(&out, lvl);
664 if(curlx_str_single(&config, ','))
665 break;
666 }
667 return CURLE_OK;
670CURLcode Curl_trc_opt(const char *config)
672 CURLcode result = config ? trc_opt(config) : CURLE_OK;
673#ifdef DEBUGBUILD
674 /* CURL_DEBUG can override anything */
675 if(!result) {
676 const char *dbg_config = getenv("CURL_DEBUG");
677 if(dbg_config)
678 result = trc_opt(dbg_config);
679 }
680#endif /* DEBUGBUILD */
681 return result;
684CURLcode Curl_trc_init(void)
686#ifdef DEBUGBUILD
687 return Curl_trc_opt(NULL);
688#else
689 return CURLE_OK;
690#endif
693#else /* CURL_DISABLE_VERBOSE_STRINGS */
695CURLcode Curl_trc_init(void)
697 return CURLE_OK;
700void Curl_infof(struct Curl_easy *data, const char *fmt, ...)
702 (void)data;
703 (void)fmt;
706void Curl_trc_cf_infof(struct Curl_easy *data, const struct Curl_cfilter *cf,
707 const char *fmt, ...)
709 (void)data;
710 (void)cf;
711 (void)fmt;
714void Curl_trc_multi(struct Curl_easy *data, const char *fmt, ...)
716 (void)data;
717 (void)fmt;
720void Curl_trc_write(struct Curl_easy *data, const char *fmt, ...)
722 (void)data;
723 (void)fmt;
726void Curl_trc_dns(struct Curl_easy *data, const char *fmt, ...)
728 (void)data;
729 (void)fmt;
732void Curl_trc_timer(struct Curl_easy *data, int tid, const char *fmt, ...)
734 (void)data;
735 (void)tid;
736 (void)fmt;
739void Curl_trc_read(struct Curl_easy *data, const char *fmt, ...)
741 (void)data;
742 (void)fmt;
745#ifndef CURL_DISABLE_FTP
746void Curl_trc_ftp(struct Curl_easy *data, const char *fmt, ...)
748 (void)data;
749 (void)fmt;
751#endif
752#ifndef CURL_DISABLE_SMTP
753void Curl_trc_smtp(struct Curl_easy *data, const char *fmt, ...)
755 (void)data;
756 (void)fmt;
758#endif
759#if !defined(CURL_DISABLE_WEBSOCKETS) && !defined(CURL_DISABLE_HTTP)
760void Curl_trc_ws(struct Curl_easy *data, const char *fmt, ...)
762 (void)data;
763 (void)fmt;
765#endif
766#ifdef USE_SSH
767void Curl_trc_ssh(struct Curl_easy *data, const char *fmt, ...)
769 (void)data;
770 (void)fmt;
772#endif
773#ifdef USE_SSL
774void Curl_trc_ssls(struct Curl_easy *data, const char *fmt, ...)
776 (void)data;
777 (void)fmt;
779#endif
781#endif /* !CURL_DISABLE_VERBOSE_STRINGS */
Diagnostics4 git calls · 30 ms
CallStatusSizeTime030 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 · 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 · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=25
git.response.bytes=293470
git.response.cache=HIT
git.response.duration_ms=2
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
fetch2004.8 KiB · hit25 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=4920
git.response.cache=HIT
git.response.duration_ms=25
git.fetch.wants=62bac14fe6d73d357a598840e5504be449d9d8a5
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=4920
git.pkt.payload.max=4899
git.sideband.band1.bytes=4898
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
a5e1b737bb925b65
Request
fcfe410e…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format