Artifactspublic-v0

curl

master
ply4 git calls26 ms293 KiB3 cachedprotocol v2
1051 lines29 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 "strerror.h"
28#include "cfilters.h"
29#include "connect.h"
30#include "url.h"
31#include "curl_trc.h"
32#include "progress.h"
33#include "select.h"
34#include "curlx/strparse.h"
36CURLcode Curl_cf_def_connect(struct Curl_cfilter *cf,
37 struct Curl_easy *data, bool *done)
39 CURLcode result;
41 if(cf->connected) {
42 *done = TRUE;
43 return CURLE_OK;
44 }
46 if(cf->next) {
47 result = cf->next->cft->do_connect(cf->next, data, done);
48 if(result || !*done)
49 return result;
50 }
52 cf->connected = TRUE;
53 *done = TRUE;
54 return CURLE_OK;
57CURLcode Curl_cf_def_shutdown(struct Curl_cfilter *cf,
58 struct Curl_easy *data, bool *done)
60 (void)cf;
61 (void)data;
62 *done = TRUE;
63 return CURLE_OK;
66CURLcode Curl_cf_def_adjust_pollset(struct Curl_cfilter *cf,
67 struct Curl_easy *data,
68 struct easy_pollset *ps)
70 /* NOP */
71 (void)cf;
72 (void)data;
73 (void)ps;
74 return CURLE_OK;
77bool Curl_cf_def_data_pending(struct Curl_cfilter *cf,
78 const struct Curl_easy *data)
80 return cf->next ?
81 cf->next->cft->has_data_pending(cf->next, data) : FALSE;
84CURLcode Curl_cf_def_send(struct Curl_cfilter *cf, struct Curl_easy *data,
85 const uint8_t *buf, size_t len, bool eos,
86 size_t *pnwritten)
88 if(cf->next)
89 return cf->next->cft->do_send(cf->next, data, buf, len, eos, pnwritten);
90 *pnwritten = 0;
91 return CURLE_RECV_ERROR;
94CURLcode Curl_cf_def_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
95 char *buf, size_t len, size_t *pnread)
97 if(cf->next)
98 return cf->next->cft->do_recv(cf->next, data, buf, len, pnread);
99 *pnread = 0;
100 return CURLE_SEND_ERROR;
103bool Curl_cf_def_conn_is_alive(struct Curl_cfilter *cf,
104 struct Curl_easy *data,
105 bool *input_pending)
107 return cf->next ?
108 cf->next->cft->is_alive(cf->next, data, input_pending) :
109 FALSE; /* pessimistic in absence of data */
112CURLcode Curl_cf_def_conn_keep_alive(struct Curl_cfilter *cf,
113 struct Curl_easy *data)
115 return cf->next ?
116 cf->next->cft->keep_alive(cf->next, data) :
117 CURLE_OK;
120CURLcode Curl_cf_def_query(struct Curl_cfilter *cf,
121 struct Curl_easy *data,
122 int query, int *pres1, void *pres2)
124 return cf->next ?
125 cf->next->cft->query(cf->next, data, query, pres1, pres2) :
126 CURLE_UNKNOWN_OPTION;
129#ifdef CURLVERBOSE
130void Curl_conn_trc_filters(struct Curl_easy *data,
131 int8_t sockindex, const char *info)
133 if(CURL_TRC_M_is_verbose(data) && data->conn) {
134 struct Curl_cfilter *cf = data->conn->cfilter[sockindex];
136 if(cf) {
137 char msg[256], *buf;
138 int blen, n;
140 buf = msg;
141 blen = sizeof(msg) - 1;
142 n = curl_msnprintf(buf, blen, "%s [%d]", info, sockindex);
143 buf += n;
144 blen -= n;
145 for(; cf && blen; cf = cf->next) {
146 n = curl_msnprintf(buf, blen, "[%s%s]",
147 cf->connected ? "" : "!", cf->cft->name);
148 buf += n;
149 blen -= n;
150 }
151 CURL_TRC_M(data, "%s%s", msg, blen ? "" : "...");
152 }
153 else
154 CURL_TRC_M(data, "%s [%d][-]", info, sockindex);
155 }
157#endif /* CURLVERBOSE */
159void Curl_conn_cf_discard_chain(struct Curl_cfilter **pcf,
160 struct Curl_easy *data)
162 struct Curl_cfilter *cfn, *cf = *pcf;
164 if(cf) {
165 *pcf = NULL;
166 while(cf) {
167 cfn = cf->next;
168 /* prevent destroying filter to mess with its sub-chain, since
169 * we have the reference now and will call destroy on it.
170 */
171 cf->next = NULL;
172 cf->cft->destroy(cf, data);
173 curlx_free(cf);
174 cf = cfn;
175 }
176 }
179void Curl_conn_cf_discard_all(struct Curl_easy *data,
180 struct connectdata *conn, int8_t sockindex)
182 conn->connect_start_ms = -1;
183 conn->shutdown.start_ms[sockindex] = -1;
184 Curl_conn_cf_discard_chain(&conn->cfilter[sockindex], data);
187CURLcode Curl_cf_recv(struct Curl_easy *data, int8_t sockindex, char *buf,
188 size_t len, size_t *pnread)
190 struct Curl_cfilter *cf;
192 DEBUGASSERT(data);
193 DEBUGASSERT(data->conn);
194 cf = data->conn->cfilter[sockindex];
195 while(cf && !cf->connected)
196 cf = cf->next;
197 if(cf)
198 return cf->cft->do_recv(cf, data, buf, len, pnread);
199 failf(data, "recv: no filter connected");
200 DEBUGASSERT(0);
201 *pnread = 0;
202 return CURLE_FAILED_INIT;
205CURLcode Curl_cf_send(struct Curl_easy *data, int8_t sockindex,
206 const uint8_t *buf, size_t len, bool eos,
207 size_t *pnwritten)
209 struct Curl_cfilter *cf;
211 DEBUGASSERT(data);
212 DEBUGASSERT(data->conn);
213 cf = data->conn->cfilter[sockindex];
214 while(cf && !cf->connected)
215 cf = cf->next;
216 if(cf) {
217 return cf->cft->do_send(cf, data, buf, len, eos, pnwritten);
218 }
219 failf(data, "send: no filter connected");
220 DEBUGASSERT(0);
221 *pnwritten = 0;
222 return CURLE_FAILED_INIT;
225struct cf_io_ctx {
226 struct Curl_easy *data;
227 struct Curl_cfilter *cf;
228};
230static CURLcode cf_bufq_reader(void *writer_ctx,
231 unsigned char *buf, size_t blen,
232 size_t *pnread)
234 struct cf_io_ctx *io = writer_ctx;
235 return Curl_conn_cf_recv(io->cf, io->data, (char *)buf, blen, pnread);
238CURLcode Curl_cf_recv_bufq(struct Curl_cfilter *cf,
239 struct Curl_easy *data,
240 struct bufq *bufq,
241 size_t maxlen,
242 size_t *pnread)
244 struct cf_io_ctx io;
246 if(!cf || !data) {
247 *pnread = 0;
248 return CURLE_BAD_FUNCTION_ARGUMENT;
249 }
250 io.data = data;
251 io.cf = cf;
252 return Curl_bufq_sipn(bufq, maxlen, cf_bufq_reader, &io, pnread);
255static CURLcode cf_bufq_writer(void *writer_ctx,
256 const uint8_t *buf, size_t buflen,
257 size_t *pnwritten)
259 struct cf_io_ctx *io = writer_ctx;
260 return Curl_conn_cf_send(io->cf, io->data, buf, buflen, FALSE, pnwritten);
263CURLcode Curl_cf_send_bufq(struct Curl_cfilter *cf,
264 struct Curl_easy *data,
265 struct bufq *bufq,
266 const unsigned char *buf, size_t blen,
267 size_t *pnwritten)
269 struct cf_io_ctx io;
271 if(!cf || !data) {
272 *pnwritten = 0;
273 return CURLE_BAD_FUNCTION_ARGUMENT;
274 }
275 io.data = data;
276 io.cf = cf;
277 if(buf && blen)
278 return Curl_bufq_write_pass(bufq, buf, blen, cf_bufq_writer, &io,
279 pnwritten);
280 else
281 return Curl_bufq_pass(bufq, cf_bufq_writer, &io, pnwritten);
284CURLcode Curl_cf_create(struct Curl_cfilter **pcf,
285 const struct Curl_cftype *cft,
286 void *ctx)
288 struct Curl_cfilter *cf;
289 CURLcode result = CURLE_OUT_OF_MEMORY;
291 DEBUGASSERT(cft);
292 cf = curlx_calloc(1, sizeof(*cf));
293 if(!cf)
294 goto out;
296 cf->cft = cft;
297 cf->ctx = ctx;
298 result = CURLE_OK;
299out:
300 *pcf = cf;
301 return result;
304void Curl_conn_cf_add(struct Curl_easy *data,
305 struct connectdata *conn,
306 int8_t sockindex,
307 struct Curl_cfilter *cf)
309 DEBUGASSERT(conn);
310 DEBUGASSERT(!cf->conn);
311 DEBUGASSERT(!cf->next);
313 cf->next = conn->cfilter[sockindex];
314 cf->conn = conn;
315 cf->sockindex = sockindex;
316 conn->cfilter[sockindex] = cf;
317 CURL_TRC_CF(data, cf, "added");
320void Curl_conn_cf_insert_after(struct Curl_cfilter *cf_at,
321 struct Curl_cfilter *cf_new)
323 struct Curl_cfilter *tail, **pnext;
325 DEBUGASSERT(cf_at);
326 DEBUGASSERT(cf_new);
327 DEBUGASSERT(!cf_new->conn);
329 tail = cf_at->next;
330 cf_at->next = cf_new;
331 do {
332 cf_new->conn = cf_at->conn;
333 cf_new->sockindex = cf_at->sockindex;
334 pnext = &cf_new->next;
335 cf_new = cf_new->next;
336 } while(cf_new);
337 *pnext = tail;
340bool Curl_conn_cf_discard(struct Curl_cfilter **pcf,
341 struct Curl_easy *data)
343 struct Curl_cfilter *cf = pcf ? *pcf : NULL;
344 bool found = FALSE;
345 if(cf) {
346 if(cf->conn) {
347 /* unlink if present in connection filter chain */
348 struct Curl_cfilter **pprev = &cf->conn->cfilter[cf->sockindex];
349 while(*pprev) {
350 if(*pprev == *pcf) {
351 *pprev = (*pcf)->next;
352 cf->next = NULL;
353 found = TRUE;
354 break;
355 }
356 pprev = &(*pprev)->next;
357 }
358 }
359 Curl_conn_cf_discard_chain(pcf, data);
360 }
361 return found;
364CURLcode Curl_conn_cf_connect(struct Curl_cfilter *cf,
365 struct Curl_easy *data,
366 bool *done)
368 if(cf)
369 return cf->cft->do_connect(cf, data, done);
370 return CURLE_FAILED_INIT;
373CURLcode Curl_conn_cf_send(struct Curl_cfilter *cf, struct Curl_easy *data,
374 const uint8_t *buf, size_t len, bool eos,
375 size_t *pnwritten)
377 if(cf)
378 return cf->cft->do_send(cf, data, buf, len, eos, pnwritten);
379 *pnwritten = 0;
380 return CURLE_SEND_ERROR;
383CURLcode Curl_conn_cf_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
384 char *buf, size_t len, size_t *pnread)
386 if(cf)
387 return cf->cft->do_recv(cf, data, buf, len, pnread);
388 *pnread = 0;
389 return CURLE_RECV_ERROR;
392static CURLcode cf_cntrl_all(struct connectdata *conn,
393 struct Curl_easy *data,
394 bool ignore_result,
395 int event, int arg1, void *arg2)
397 CURLcode result = CURLE_OK;
398 int i;
400 for(i = 0; i < (int)CURL_ARRAYSIZE(conn->cfilter); ++i) {
401 result = Curl_conn_cf_cntrl(conn->cfilter[i], data, ignore_result,
402 event, arg1, arg2);
403 if(!ignore_result && result)
404 break;
405 }
406 return result;
409bool Curl_conn_cf_is_ip_connected(struct Curl_cfilter *cf,
410 struct Curl_easy *data)
412 if(cf) {
413 int value = 0;
414 if(!cf->cft->query(cf, data, CF_QUERY_REALLY_CONNECTED, &value, NULL))
415 return !!value;
416 }
417 return FALSE;
420void Curl_conn_cntrl_update_info(struct Curl_easy *data,
421 struct connectdata *conn)
423 cf_cntrl_all(conn, data, TRUE, CF_CTRL_CONN_INFO_UPDATE, 0, NULL);
426void Curl_conn_cntrl_report_stats(struct Curl_easy *data,
427 struct connectdata *conn,
428 int sockindex)
430 if((unsigned)sockindex < CURL_ARRAYSIZE(conn->cfilter))
431 (void)Curl_conn_cf_cntrl(conn->cfilter[sockindex], data, TRUE,
432 CF_CTRL_REPORT_STATS, 0, NULL);
435void Curl_conn_remove_setup_filters(struct Curl_easy *data,
436 int8_t sockindex)
438 struct Curl_cfilter **anchor = &data->conn->cfilter[sockindex];
439 while(*anchor) {
440 struct Curl_cfilter *cf = *anchor;
441 if(cf->connected && (cf->cft->flags & CF_TYPE_SETUP)) {
442 *anchor = cf->next;
443 cf->next = NULL;
444 CURL_TRC_CF(data, cf, "removing connected setup filter");
445 cf->cft->destroy(cf, data);
446 curlx_free(cf);
447 }
448 else
449 anchor = &cf->next;
450 }
453bool Curl_conn_is_setup(struct connectdata *conn, int8_t sockindex)
455 if(!CONN_SOCK_IDX_VALID(sockindex))
456 return FALSE;
457 return !!conn->cfilter[sockindex];
460bool Curl_conn_is_connected(struct connectdata *conn, int8_t sockindex)
462 struct Curl_cfilter *cf;
464 if(!CONN_SOCK_IDX_VALID(sockindex))
465 return FALSE;
466 cf = conn->cfilter[sockindex];
467 if(cf)
468 return (bool)cf->connected;
469 else if(conn->scheme->flags & PROTOPT_NONETWORK)
470 return TRUE;
471 return FALSE;
474bool Curl_conn_is_ip_connected(struct Curl_easy *data, int8_t sockindex)
476 struct Curl_cfilter *cf;
478 if(!CONN_SOCK_IDX_VALID(sockindex))
479 return FALSE;
480 cf = data->conn->cfilter[sockindex];
481 while(cf) {
482 if(cf->connected)
483 return TRUE;
484 if(cf->cft->flags & CF_TYPE_IP_CONNECT)
485 return FALSE;
486 cf = cf->next;
487 }
488 return FALSE;
491#ifndef CURL_DISABLE_PROXY
492static bool cf_is_tunneling(struct Curl_cfilter *cf)
494 for(; cf; cf = cf->next) {
495 if((cf->cft->flags & CF_TYPE_PROXY))
496 return TRUE;
497 }
498 return FALSE;
501bool Curl_conn_is_tunneling(struct connectdata *conn, int8_t sockindex)
503 if(!CONN_SOCK_IDX_VALID(sockindex))
504 return FALSE;
505 return conn ? cf_is_tunneling(conn->cfilter[sockindex]) : FALSE;
507#else
508bool Curl_conn_is_tunneling(struct connectdata *conn, int8_t sockindex)
510 (void)conn;
511 (void)sockindex;
512 return FALSE;
514#endif /* CURL_DISABLE_PROXY */
516static bool cf_is_ssl(struct Curl_cfilter *cf)
518 for(; cf; cf = cf->next) {
519 /* A tunneling proxy does not offer end2end encryption, even if
520 * it does SSL itself (e.g. QUIC H3 proxy) */
521 if((cf->cft->flags & CF_TYPE_SSL) && !(cf->cft->flags & CF_TYPE_PROXY))
522 return TRUE;
523 if(cf->cft->flags & CF_TYPE_IP_CONNECT)
524 return FALSE;
525 }
526 return FALSE;
529bool Curl_conn_is_ssl(struct connectdata *conn, int8_t sockindex)
531 if(!CONN_SOCK_IDX_VALID(sockindex))
532 return FALSE;
533 return conn ? cf_is_ssl(conn->cfilter[sockindex]) : FALSE;
536bool Curl_conn_get_ssl_info(struct Curl_easy *data,
537 struct connectdata *conn, int8_t sockindex,
538 int query,
539 struct curl_tlssessioninfo *info)
541 if(!CONN_SOCK_IDX_VALID(sockindex))
542 return FALSE;
543 if(Curl_conn_is_ssl(conn, sockindex)) {
544 struct Curl_cfilter *cf = conn->cfilter[sockindex];
545 CURLcode result = cf ?
546 cf->cft->query(cf, data, query, NULL, (void *)info) :
547 CURLE_UNKNOWN_OPTION;
548 return !result;
549 }
550 return FALSE;
553CURLcode Curl_conn_get_ip_info(struct Curl_easy *data,
554 struct connectdata *conn, int8_t sockindex,
555 bool *is_ipv6, struct ip_quadruple *ipquad)
557 struct Curl_cfilter *cf;
558 if(!CONN_SOCK_IDX_VALID(sockindex))
559 return CURLE_BAD_FUNCTION_ARGUMENT;
560 cf = conn ? conn->cfilter[sockindex] : NULL;
561 return Curl_conn_cf_get_ip_info(cf, data, is_ipv6, ipquad);
564bool Curl_conn_is_multiplex(struct connectdata *conn, int8_t sockindex)
566 struct Curl_cfilter *cf;
568 if(!conn || !CONN_SOCK_IDX_VALID(sockindex))
569 return FALSE;
570 for(cf = conn->cfilter[sockindex]; cf; cf = cf->next) {
571 if(cf->cft->flags & CF_TYPE_MULTIPLEX)
572 return TRUE;
573 if(cf->cft->flags & (CF_TYPE_IP_CONNECT | CF_TYPE_SSL))
574 return FALSE;
575 }
576 return FALSE;
579unsigned char Curl_conn_get_transport(struct Curl_easy *data,
580 struct connectdata *conn)
582 struct Curl_cfilter *cf = conn->cfilter[FIRSTSOCKET];
583 return Curl_conn_cf_get_transport(cf, data);
586int Curl_socktype_for_transport(uint8_t transport)
588 switch(transport) {
589 case TRNSPRT_TCP:
590 return SOCK_STREAM;
591 case TRNSPRT_UNIX:
592 return SOCK_STREAM;
593 default: /* UDP and QUIC */
594 return SOCK_DGRAM;
595 }
598int Curl_protocol_for_transport(uint8_t transport)
600 switch(transport) {
601 case TRNSPRT_TCP:
602 return IPPROTO_TCP;
603 case TRNSPRT_UNIX:
604 return IPPROTO_IP;
605 default: /* UDP and QUIC */
606 return IPPROTO_UDP;
607 }
610uint8_t Curl_conn_cf_http_version(struct Curl_easy *data,
611 struct Curl_cfilter *cf)
613 CURLcode result = CURLE_UNKNOWN_OPTION;
614 uint8_t v = 0;
616 for(; cf; cf = cf->next) {
617 if(cf->cft->flags & CF_TYPE_HTTP) {
618 int value = 0;
619 result = cf->cft->query(cf, data, CF_QUERY_HTTP_VERSION, &value, NULL);
620 if(!result && ((value < 0) || (value > 255)))
621 result = CURLE_FAILED_INIT;
622 else
623 v = (uint8_t)value;
624 break;
625 }
626 if(cf->cft->flags & (CF_TYPE_IP_CONNECT | CF_TYPE_SSL))
627 break;
628 }
629 return (uint8_t)(result ? 0 : v);
632uint8_t Curl_conn_http_version(struct Curl_easy *data,
633 struct connectdata *conn)
635 return Curl_conn_cf_http_version(data, conn->cfilter[FIRSTSOCKET]);
638bool Curl_conn_data_pending(struct Curl_easy *data, int8_t sockindex)
640 struct Curl_cfilter *cf;
642 (void)data;
643 DEBUGASSERT(data);
644 DEBUGASSERT(data->conn);
645 if(!CONN_SOCK_IDX_VALID(sockindex))
646 return FALSE;
648 cf = data->conn->cfilter[sockindex];
649 while(cf && !cf->connected) {
650 cf = cf->next;
651 }
652 if(cf) {
653 return cf->cft->has_data_pending(cf, data);
654 }
655 return FALSE;
658bool Curl_conn_cf_needs_flush(struct Curl_cfilter *cf,
659 struct Curl_easy *data)
661 CURLcode result;
662 int pending = 0;
663 result = cf ? cf->cft->query(cf, data, CF_QUERY_NEED_FLUSH,
664 &pending, NULL) : CURLE_UNKNOWN_OPTION;
665 return (result || !pending) ? FALSE : TRUE;
668bool Curl_conn_needs_flush(struct Curl_easy *data, int8_t sockindex)
670 if(!CONN_SOCK_IDX_VALID(sockindex))
671 return FALSE;
672 return Curl_conn_cf_needs_flush(data->conn->cfilter[sockindex], data);
675CURLcode Curl_conn_cf_adjust_pollset(struct Curl_cfilter *cf,
676 struct Curl_easy *data,
677 struct easy_pollset *ps)
679 CURLcode result = CURLE_OK;
680 /* Go through all filters, top to bottom, and let them manage the pollset
681 * - connected filters can do so
682 * - CF_TYPE_DNS filters can
683 * - unconnected filters without next or connect next can
684 */
685 for(; cf && !result; cf = cf->next) {
686 if(cf->shutdown)
687 continue;
688 if(cf->connected || (cf->cft->flags & CF_TYPE_DNS) ||
689 !cf->next || cf->next->connected)
690 result = cf->cft->adjust_pollset(cf, data, ps);
691 }
692 return result;
695CURLcode Curl_conn_adjust_pollset(struct Curl_easy *data,
696 struct connectdata *conn,
697 struct easy_pollset *ps)
699 CURLcode result = CURLE_OK;
700 const bool want_io = !!ps->n;
701 int8_t i;
703 DEBUGASSERT(data);
704 DEBUGASSERT(conn);
705 /* During connect time, connection filters may add sockets to the pollset
706 * even when the transfer neither wants to send nor receive. And those
707 * sockets, when having events, are served. The same applies to a
708 * filter chain whose shutdown has started.
709 * Once a filter chain is connected however and before its shutdown
710 * starts, a transfer that neither wants to send nor receive
711 * will never call the connection filters. Any sockets added by the filters
712 * will not change state and POLLIN/POLLOUT events will trigger forever,
713 * making us busy loop. See #21671.
714 * Gate each filter chain on its own state, so that one chain being in
715 * connect or shutdown does not add poll events for the other. Check
716 * against the transfer's own interest, before any chain added sockets
717 * of its own. */
718 for(i = 0; (i < (int)CURL_ARRAYSIZE(conn->cfilter)) && !result; ++i) {
719 if(conn->cfilter[i] &&
720 (want_io || !conn->cfilter[i]->connected ||
721 CURL_CONN_IN_SHUTDOWN(conn, i)))
722 result = Curl_conn_cf_adjust_pollset(conn->cfilter[i], data, ps);
723 }
724 return result;
727/*
728 * Return values:
729 * -1 = error
730 * 0 = timeout
731 * N = number of structures with non zero revent fields
732 */
733int Curl_conn_cf_poll(struct Curl_cfilter *cf,
734 struct Curl_easy *data,
735 timediff_t timeout_ms)
737 struct easy_pollset ps;
738 int rc;
739 CURLcode result;
741 DEBUGASSERT(cf);
742 DEBUGASSERT(data);
743 DEBUGASSERT(data->conn);
744 Curl_pollset_init(&ps);
746 result = Curl_conn_cf_adjust_pollset(cf, data, &ps);
747 if(!result)
748 rc = Curl_pollset_poll(data, &ps, timeout_ms);
749 else
750 rc = -1;
751 Curl_pollset_cleanup(&ps);
752 return rc;
755void Curl_conn_get_current_host(struct Curl_easy *data, int8_t sockindex,
756 const char **phost, int *pport)
758 struct Curl_cfilter *cf, *cf_proxy = NULL;
759 int portarg = -1;
761 if(!data->conn) {
762 DEBUGASSERT(0);
763 *phost = "";
764 if(pport)
765 *pport = -1;
766 return;
767 }
769 cf = CONN_SOCK_IDX_VALID(sockindex) ? data->conn->cfilter[sockindex] : NULL;
770 /* Find the "lowest" tunneling proxy filter that has not connected yet. */
771 while(cf && !cf->connected) {
772 if((cf->cft->flags & (CF_TYPE_IP_CONNECT | CF_TYPE_PROXY)) ==
773 (CF_TYPE_IP_CONNECT | CF_TYPE_PROXY))
774 cf_proxy = cf;
775 cf = cf->next;
776 }
777 /* cf_proxy (!= NULL) is not connected yet. It is talking
778 * to an interim host and any authentication or other things apply
779 * to this interim host and port. */
780 if(!cf_proxy || cf_proxy->cft->query(cf_proxy, data, CF_QUERY_HOST_PORT,
781 &portarg, CURL_UNCONST(phost))) {
782 /* Everything connected or query unsuccessful, the overall
783 * connection's destination is the answer */
784 *phost = data->conn->origin->hostname;
785 portarg = data->conn->origin->port;
786 }
787 if(pport)
788 *pport = portarg;
791CURLcode Curl_cf_def_cntrl(struct Curl_cfilter *cf,
792 struct Curl_easy *data,
793 int event, int arg1, void *arg2)
795 (void)cf;
796 (void)data;
797 (void)event;
798 (void)arg1;
799 (void)arg2;
800 return CURLE_OK;
803CURLcode Curl_conn_cf_cntrl(struct Curl_cfilter *cf,
804 struct Curl_easy *data,
805 bool ignore_result,
806 int event, int arg1, void *arg2)
808 CURLcode result = CURLE_OK;
810 for(; cf; cf = cf->next) {
811 if(cf->cft->cntrl == Curl_cf_def_cntrl)
812 continue;
813 result = cf->cft->cntrl(cf, data, event, arg1, arg2);
814 if(!ignore_result && result)
815 break;
816 }
817 return result;
820curl_socket_t Curl_conn_cf_get_socket(struct Curl_cfilter *cf,
821 struct Curl_easy *data)
823 curl_socket_t sock;
824 if(cf && !cf->cft->query(cf, data, CF_QUERY_SOCKET, NULL, &sock))
825 return sock;
826 return CURL_SOCKET_BAD;
829unsigned char Curl_conn_cf_get_transport(struct Curl_cfilter *cf,
830 struct Curl_easy *data)
832 int transport = 0;
833 if(cf && !cf->cft->query(cf, data, CF_QUERY_TRANSPORT, &transport, NULL))
834 return (unsigned char)transport;
835 return (unsigned char)(data->conn ? data->conn->transport_wanted : 0);
838const char *Curl_conn_cf_get_alpn_negotiated(struct Curl_cfilter *cf,
839 struct Curl_easy *data)
841 const char *alpn = NULL;
842 CURL_TRC_CF(data, cf, "query ALPN");
843 if(cf && !cf->cft->query(cf, data, CF_QUERY_ALPN_NEGOTIATED, NULL,
844 CURL_UNCONST(&alpn)))
845 return alpn;
846 return NULL;
849static const struct Curl_sockaddr_ex *cf_get_remote_addr(
850 struct Curl_cfilter *cf, struct Curl_easy *data)
852 const struct Curl_sockaddr_ex *remote_addr = NULL;
853 if(cf &&
854 !cf->cft->query(cf, data, CF_QUERY_REMOTE_ADDR, NULL,
855 CURL_UNCONST(&remote_addr)))
856 return remote_addr;
857 return NULL;
860CURLcode Curl_conn_cf_get_ip_info(struct Curl_cfilter *cf,
861 struct Curl_easy *data,
862 bool *is_ipv6, struct ip_quadruple *ipquad)
864 CURLcode result = CURLE_UNKNOWN_OPTION;
865 if(cf) {
866 int ipv6 = 0;
867 result = cf->cft->query(cf, data, CF_QUERY_IP_INFO, &ipv6, ipquad);
868 *is_ipv6 = !!ipv6;
869 }
870 return result;
873curl_socket_t Curl_conn_get_first_socket(struct Curl_easy *data)
875 struct Curl_cfilter *cf;
877 if(!data->conn)
878 return CURL_SOCKET_BAD;
880 cf = data->conn->cfilter[FIRSTSOCKET];
881 /* if the top filter has not connected, ask it (and its sub-filters)
882 * for the socket. Otherwise conn->sock[sockindex] should have it. */
883 if(cf && !cf->connected)
884 return Curl_conn_cf_get_socket(cf, data);
885 return data->conn->sock[FIRSTSOCKET];
888const struct Curl_sockaddr_ex *Curl_conn_get_remote_addr(
889 struct Curl_easy *data, int8_t sockindex)
891 struct Curl_cfilter *cf =
892 (data->conn && CONN_SOCK_IDX_VALID(sockindex)) ?
893 data->conn->cfilter[sockindex] : NULL;
894 return cf ? cf_get_remote_addr(cf, data) : NULL;
897CURLcode Curl_conn_ev_data_setup(struct Curl_easy *data)
899 return cf_cntrl_all(data->conn, data, FALSE, CF_CTRL_DATA_SETUP, 0, NULL);
902CURLcode Curl_conn_flush(struct Curl_easy *data, int8_t sockindex)
904 if(!CONN_SOCK_IDX_VALID(sockindex))
905 return CURLE_BAD_FUNCTION_ARGUMENT;
906 return Curl_conn_cf_cntrl(data->conn->cfilter[sockindex], data, FALSE,
907 CF_CTRL_FLUSH, 0, NULL);
910/**
911 * Notify connection filters that the transfer represented by `data`
912 * is done with sending data (e.g. has uploaded everything).
913 */
914void Curl_conn_ev_data_done_send(struct Curl_easy *data)
916 cf_cntrl_all(data->conn, data, TRUE, CF_CTRL_DATA_DONE_SEND, 0, NULL);
919/**
920 * Notify connection filters that the transfer represented by `data`
921 * is finished - eventually premature, e.g. before being complete.
922 */
923void Curl_conn_ev_data_done(struct Curl_easy *data, bool premature)
925 cf_cntrl_all(data->conn, data, TRUE, CF_CTRL_DATA_DONE, premature, NULL);
928CURLcode Curl_conn_ev_data_pause(struct Curl_easy *data, bool do_pause)
930 return cf_cntrl_all(data->conn, data, FALSE,
931 CF_CTRL_DATA_PAUSE, do_pause, NULL);
934bool Curl_conn_is_alive(struct Curl_easy *data, struct connectdata *conn,
935 bool *input_pending)
937 struct Curl_cfilter *cf = conn->cfilter[FIRSTSOCKET];
938 return cf && !cf->conn->bits.close &&
939 cf->cft->is_alive(cf, data, input_pending);
942CURLcode Curl_conn_keep_alive(struct Curl_easy *data,
943 struct connectdata *conn)
945 CURLcode result = CURLE_OK;
946 int i;
948 for(i = 0; (i < (int)CURL_ARRAYSIZE(conn->cfilter)) && !result; ++i) {
949 struct Curl_cfilter *cf = conn->cfilter[i];
950 if(cf)
951 result = cf->cft->keep_alive(cf, data);
952 }
953 return result;
956size_t Curl_conn_get_max_concurrent(struct Curl_easy *data,
957 struct connectdata *conn,
958 int8_t sockindex)
960 struct Curl_cfilter *cf;
961 CURLcode result;
962 int n = -1;
964 if(!CONN_SOCK_IDX_VALID(sockindex))
965 return 0;
967 cf = conn->cfilter[sockindex];
968 result = cf ? cf->cft->query(cf, data, CF_QUERY_MAX_CONCURRENT,
969 &n, NULL) : CURLE_UNKNOWN_OPTION;
970 /* If no filter answered the query, the default is a non-multiplexed
971 * connection with limit 1. Otherwise, the query may return 0
972 * for connections that are in shutdown, e.g. server HTTP/2 GOAWAY. */
973 return (result || n < 0) ? 1 : (size_t)n;
976int Curl_conn_get_stream_error(struct Curl_easy *data,
977 struct connectdata *conn,
978 int8_t sockindex)
980 struct Curl_cfilter *cf;
981 CURLcode result;
982 int n = 0;
984 if(!CONN_SOCK_IDX_VALID(sockindex))
985 return 0;
987 cf = conn->cfilter[sockindex];
988 result = cf ? cf->cft->query(cf, data, CF_QUERY_STREAM_ERROR,
989 &n, NULL) : CURLE_UNKNOWN_OPTION;
990 return (result || n < 0) ? 0 : n;
993int8_t Curl_conn_sockindex(struct Curl_easy *data, curl_socket_t sockfd)
995 if(data && data->conn &&
996 sockfd != CURL_SOCKET_BAD && sockfd == data->conn->sock[SECONDARYSOCKET])
997 return SECONDARYSOCKET;
998 return FIRSTSOCKET;
1001CURLcode Curl_conn_recv(struct Curl_easy *data, int8_t sockindex,
1002 char *buf, size_t len, size_t *pnread)
1004 DEBUGASSERT(data);
1005 DEBUGASSERT(data->conn);
1006 if(!CONN_SOCK_IDX_VALID(sockindex))
1007 return CURLE_BAD_FUNCTION_ARGUMENT;
1008 if(data && data->conn && data->conn->recv[sockindex])
1009 return data->conn->recv[sockindex](data, sockindex, buf, len, pnread);
1010 *pnread = 0;
1011 return CURLE_FAILED_INIT;
1014CURLcode Curl_conn_send(struct Curl_easy *data, int8_t sockindex,
1015 const void *buf, size_t len, bool eos,
1016 size_t *pnwritten)
1018 size_t write_len = len;
1020 DEBUGASSERT(data);
1021 DEBUGASSERT(data->conn);
1022 DEBUGASSERT(CONN_SOCK_IDX_VALID(sockindex));
1023 if(!CONN_SOCK_IDX_VALID(sockindex))
1024 return CURLE_BAD_FUNCTION_ARGUMENT;
1025#ifdef DEBUGBUILD
1026 if(write_len) {
1027 /* Allow debug builds to override this logic to force short sends */
1028 const char *p = getenv("CURL_SMALLSENDS");
1029 if(p) {
1030 curl_off_t altsize;
1031 if(!curlx_str_number(&p, &altsize, write_len)) {
1032 write_len = (size_t)altsize;
1033 if(write_len != len)
1034 eos = FALSE;
1038#endif
1039 if(data && data->conn && data->conn->send[sockindex]) {
1040 CURLcode result = data->conn->send[sockindex](data, sockindex, buf,
1041 write_len, eos, pnwritten);
1042 if(!result && (*pnwritten > write_len)) {
1043 DEBUGASSERT(0);
1044 *pnwritten = 0;
1045 return CURLE_SEND_ERROR;
1047 return result;
1049 *pnwritten = 0;
1050 return CURLE_FAILED_INIT;
Diagnostics4 git calls · 26 ms
CallStatusSizeTime026 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 · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=21
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
fetch2006.4 KiB · hit21 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=6565
git.response.cache=HIT
git.response.duration_ms=21
git.fetch.wants=532be6d6ffa973662858682f9a1c6766fd7a5b03
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=6565
git.pkt.payload.max=6544
git.sideband.band1.bytes=6543
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
a5e2f1938f93fda9
Request
e7bb8b9c…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format