master
1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9 *
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.se/docs/copyright.html.
13 *
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 * SPDX-License-Identifier: curl
22 *
23 ***************************************************************************/
24#include "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)
38{
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;
55}
57CURLcode Curl_cf_def_shutdown(struct Curl_cfilter *cf,
58 struct Curl_easy *data, bool *done)
59{
60 (void)cf;
61 (void)data;
62 *done = TRUE;
63 return CURLE_OK;
64}
66CURLcode Curl_cf_def_adjust_pollset(struct Curl_cfilter *cf,
67 struct Curl_easy *data,
68 struct easy_pollset *ps)
69{
70 /* NOP */
71 (void)cf;
72 (void)data;
73 (void)ps;
74 return CURLE_OK;
75}
77bool Curl_cf_def_data_pending(struct Curl_cfilter *cf,
78 const struct Curl_easy *data)
79{
80 return cf->next ?
81 cf->next->cft->has_data_pending(cf->next, data) : FALSE;
82}
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)
87{
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;
92}
94CURLcode Curl_cf_def_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
95 char *buf, size_t len, size_t *pnread)
96{
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;
101}
103bool Curl_cf_def_conn_is_alive(struct Curl_cfilter *cf,
104 struct Curl_easy *data,
105 bool *input_pending)
106{
107 return cf->next ?
108 cf->next->cft->is_alive(cf->next, data, input_pending) :
109 FALSE; /* pessimistic in absence of data */
110}
112CURLcode Curl_cf_def_conn_keep_alive(struct Curl_cfilter *cf,
113 struct Curl_easy *data)
114{
115 return cf->next ?
116 cf->next->cft->keep_alive(cf->next, data) :
117 CURLE_OK;
118}
120CURLcode Curl_cf_def_query(struct Curl_cfilter *cf,
121 struct Curl_easy *data,
122 int query, int *pres1, void *pres2)
123{
124 return cf->next ?
125 cf->next->cft->query(cf->next, data, query, pres1, pres2) :
126 CURLE_UNKNOWN_OPTION;
127}
129#ifdef CURLVERBOSE
130void Curl_conn_trc_filters(struct Curl_easy *data,
131 int8_t sockindex, const char *info)
132{
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 }
156}
157#endif /* CURLVERBOSE */
159void Curl_conn_cf_discard_chain(struct Curl_cfilter **pcf,
160 struct Curl_easy *data)
161{
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 }
177}
179void Curl_conn_cf_discard_all(struct Curl_easy *data,
180 struct connectdata *conn, int8_t sockindex)
181{
182 conn->connect_start_ms = -1;
183 conn->shutdown.start_ms[sockindex] = -1;
184 Curl_conn_cf_discard_chain(&conn->cfilter[sockindex], data);
185}
187CURLcode Curl_cf_recv(struct Curl_easy *data, int8_t sockindex, char *buf,
188 size_t len, size_t *pnread)
189{
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;
203}
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)
208{
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;
223}
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)
233{
234 struct cf_io_ctx *io = writer_ctx;
235 return Curl_conn_cf_recv(io->cf, io->data, (char *)buf, blen, pnread);
236}
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)
243{
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);
253}
255static CURLcode cf_bufq_writer(void *writer_ctx,
256 const uint8_t *buf, size_t buflen,
257 size_t *pnwritten)
258{
259 struct cf_io_ctx *io = writer_ctx;
260 return Curl_conn_cf_send(io->cf, io->data, buf, buflen, FALSE, pnwritten);
261}
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)
268{
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);
282}
284CURLcode Curl_cf_create(struct Curl_cfilter **pcf,
285 const struct Curl_cftype *cft,
286 void *ctx)
287{
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;
302}
304void Curl_conn_cf_add(struct Curl_easy *data,
305 struct connectdata *conn,
306 int8_t sockindex,
307 struct Curl_cfilter *cf)
308{
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");
318}
320void Curl_conn_cf_insert_after(struct Curl_cfilter *cf_at,
321 struct Curl_cfilter *cf_new)
322{
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;
338}
340bool Curl_conn_cf_discard(struct Curl_cfilter **pcf,
341 struct Curl_easy *data)
342{
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;
362}
364CURLcode Curl_conn_cf_connect(struct Curl_cfilter *cf,
365 struct Curl_easy *data,
366 bool *done)
367{
368 if(cf)
369 return cf->cft->do_connect(cf, data, done);
370 return CURLE_FAILED_INIT;
371}
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)
376{
377 if(cf)
378 return cf->cft->do_send(cf, data, buf, len, eos, pnwritten);
379 *pnwritten = 0;
380 return CURLE_SEND_ERROR;
381}
383CURLcode Curl_conn_cf_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
384 char *buf, size_t len, size_t *pnread)
385{
386 if(cf)
387 return cf->cft->do_recv(cf, data, buf, len, pnread);
388 *pnread = 0;
389 return CURLE_RECV_ERROR;
390}
392static CURLcode cf_cntrl_all(struct connectdata *conn,
393 struct Curl_easy *data,
394 bool ignore_result,
395 int event, int arg1, void *arg2)
396{
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;
407}
409bool Curl_conn_cf_is_ip_connected(struct Curl_cfilter *cf,
410 struct Curl_easy *data)
411{
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;
418}
420void Curl_conn_cntrl_update_info(struct Curl_easy *data,
421 struct connectdata *conn)
422{
423 cf_cntrl_all(conn, data, TRUE, CF_CTRL_CONN_INFO_UPDATE, 0, NULL);
424}
426void Curl_conn_cntrl_report_stats(struct Curl_easy *data,
427 struct connectdata *conn,
428 int sockindex)
429{
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);
433}
435void Curl_conn_remove_setup_filters(struct Curl_easy *data,
436 int8_t sockindex)
437{
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 }
451}
453bool Curl_conn_is_setup(struct connectdata *conn, int8_t sockindex)
454{
455 if(!CONN_SOCK_IDX_VALID(sockindex))
456 return FALSE;
457 return !!conn->cfilter[sockindex];
458}
460bool Curl_conn_is_connected(struct connectdata *conn, int8_t sockindex)
461{
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;
472}
474bool Curl_conn_is_ip_connected(struct Curl_easy *data, int8_t sockindex)
475{
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;
489}
491#ifndef CURL_DISABLE_PROXY
492static bool cf_is_tunneling(struct Curl_cfilter *cf)
493{
494 for(; cf; cf = cf->next) {
495 if((cf->cft->flags & CF_TYPE_PROXY))
496 return TRUE;
497 }
498 return FALSE;
499}
501bool Curl_conn_is_tunneling(struct connectdata *conn, int8_t sockindex)
502{
503 if(!CONN_SOCK_IDX_VALID(sockindex))
504 return FALSE;
505 return conn ? cf_is_tunneling(conn->cfilter[sockindex]) : FALSE;
506}
507#else
508bool Curl_conn_is_tunneling(struct connectdata *conn, int8_t sockindex)
509{
510 (void)conn;
511 (void)sockindex;
512 return FALSE;
513}
514#endif /* CURL_DISABLE_PROXY */
516static bool cf_is_ssl(struct Curl_cfilter *cf)
517{
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;
527}
529bool Curl_conn_is_ssl(struct connectdata *conn, int8_t sockindex)
530{
531 if(!CONN_SOCK_IDX_VALID(sockindex))
532 return FALSE;
533 return conn ? cf_is_ssl(conn->cfilter[sockindex]) : FALSE;
534}
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)
540{
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;
551}
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)
556{
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);
562}
564bool Curl_conn_is_multiplex(struct connectdata *conn, int8_t sockindex)
565{
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;
577}
579unsigned char Curl_conn_get_transport(struct Curl_easy *data,
580 struct connectdata *conn)
581{
582 struct Curl_cfilter *cf = conn->cfilter[FIRSTSOCKET];
583 return Curl_conn_cf_get_transport(cf, data);
584}
586int Curl_socktype_for_transport(uint8_t transport)
587{
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 }
596}
598int Curl_protocol_for_transport(uint8_t transport)
599{
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 }
608}
610uint8_t Curl_conn_cf_http_version(struct Curl_easy *data,
611 struct Curl_cfilter *cf)
612{
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);
630}
632uint8_t Curl_conn_http_version(struct Curl_easy *data,
633 struct connectdata *conn)
634{
635 return Curl_conn_cf_http_version(data, conn->cfilter[FIRSTSOCKET]);
636}
638bool Curl_conn_data_pending(struct Curl_easy *data, int8_t sockindex)
639{
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;
656}
658bool Curl_conn_cf_needs_flush(struct Curl_cfilter *cf,
659 struct Curl_easy *data)
660{
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;
666}
668bool Curl_conn_needs_flush(struct Curl_easy *data, int8_t sockindex)
669{
670 if(!CONN_SOCK_IDX_VALID(sockindex))
671 return FALSE;
672 return Curl_conn_cf_needs_flush(data->conn->cfilter[sockindex], data);
673}
675CURLcode Curl_conn_cf_adjust_pollset(struct Curl_cfilter *cf,
676 struct Curl_easy *data,
677 struct easy_pollset *ps)
678{
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;
693}
695CURLcode Curl_conn_adjust_pollset(struct Curl_easy *data,
696 struct connectdata *conn,
697 struct easy_pollset *ps)
698{
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;
725}
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)
736{
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;
753}
755void Curl_conn_get_current_host(struct Curl_easy *data, int8_t sockindex,
756 const char **phost, int *pport)
757{
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;
789}
791CURLcode Curl_cf_def_cntrl(struct Curl_cfilter *cf,
792 struct Curl_easy *data,
793 int event, int arg1, void *arg2)
794{
795 (void)cf;
796 (void)data;
797 (void)event;
798 (void)arg1;
799 (void)arg2;
800 return CURLE_OK;
801}
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)
807{
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;
818}
820curl_socket_t Curl_conn_cf_get_socket(struct Curl_cfilter *cf,
821 struct Curl_easy *data)
822{
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;
827}
829unsigned char Curl_conn_cf_get_transport(struct Curl_cfilter *cf,
830 struct Curl_easy *data)
831{
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);
836}
838const char *Curl_conn_cf_get_alpn_negotiated(struct Curl_cfilter *cf,
839 struct Curl_easy *data)
840{
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;
847}
849static const struct Curl_sockaddr_ex *cf_get_remote_addr(
850 struct Curl_cfilter *cf, struct Curl_easy *data)
851{
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;
858}
860CURLcode Curl_conn_cf_get_ip_info(struct Curl_cfilter *cf,
861 struct Curl_easy *data,
862 bool *is_ipv6, struct ip_quadruple *ipquad)
863{
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;
871}
873curl_socket_t Curl_conn_get_first_socket(struct Curl_easy *data)
874{
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];
886}
888const struct Curl_sockaddr_ex *Curl_conn_get_remote_addr(
889 struct Curl_easy *data, int8_t sockindex)
890{
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;
895}
897CURLcode Curl_conn_ev_data_setup(struct Curl_easy *data)
898{
899 return cf_cntrl_all(data->conn, data, FALSE, CF_CTRL_DATA_SETUP, 0, NULL);
900}
902CURLcode Curl_conn_flush(struct Curl_easy *data, int8_t sockindex)
903{
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);
908}
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)
915{
916 cf_cntrl_all(data->conn, data, TRUE, CF_CTRL_DATA_DONE_SEND, 0, NULL);
917}
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)
924{
925 cf_cntrl_all(data->conn, data, TRUE, CF_CTRL_DATA_DONE, premature, NULL);
926}
928CURLcode Curl_conn_ev_data_pause(struct Curl_easy *data, bool do_pause)
929{
930 return cf_cntrl_all(data->conn, data, FALSE,
931 CF_CTRL_DATA_PAUSE, do_pause, NULL);
932}
934bool Curl_conn_is_alive(struct Curl_easy *data, struct connectdata *conn,
935 bool *input_pending)
936{
937 struct Curl_cfilter *cf = conn->cfilter[FIRSTSOCKET];
938 return cf && !cf->conn->bits.close &&
939 cf->cft->is_alive(cf, data, input_pending);
940}
942CURLcode Curl_conn_keep_alive(struct Curl_easy *data,
943 struct connectdata *conn)
944{
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;
954}
956size_t Curl_conn_get_max_concurrent(struct Curl_easy *data,
957 struct connectdata *conn,
958 int8_t sockindex)
959{
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;
974}
976int Curl_conn_get_stream_error(struct Curl_easy *data,
977 struct connectdata *conn,
978 int8_t sockindex)
979{
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;
991}
993int8_t Curl_conn_sockindex(struct Curl_easy *data, curl_socket_t sockfd)
994{
995 if(data && data->conn &&
996 sockfd != CURL_SOCKET_BAD && sockfd == data->conn->sock[SECONDARYSOCKET])
997 return SECONDARYSOCKET;
998 return FIRSTSOCKET;
999}
1001CURLcode Curl_conn_recv(struct Curl_easy *data, int8_t sockindex,
1002 char *buf, size_t len, size_t *pnread)
1003{
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;
1012}
1014CURLcode Curl_conn_send(struct Curl_easy *data, int8_t sockindex,
1015 const void *buf, size_t len, bool eos,
1016 size_t *pnwritten)
1017{
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;
1035 }
1036 }
1037 }
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;
1046 }
1047 return result;
1048 }
1049 *pnwritten = 0;
1050 return CURLE_FAILED_INIT;
1051}
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=86Open 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