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#if !defined(CURL_DISABLE_PROXY) && !defined(CURL_DISABLE_HTTP)
28#include "urldata.h"
29#include "cfilters.h"
30#include "curl_trc.h"
31#include "bufq.h"
32#include "select.h"
33#include "vquic/capsule.h"
34#include "vquic/cf-capsule.h"
36/* send/recv buffer: 4 chunks of 16KB = 64KB, enough for large datagrams */
37#define CAPSULE_RECV_CHUNKS 4
38#define CAPSULE_SEND_CHUNKS 4
39#define CAPSULE_CHUNK_SIZE (16 * 1024)
41struct cf_capsule_ctx {
42 struct bufq recvbuf;
43 struct bufq sendbuf;
44};
46static void cf_capsule_destroy(struct Curl_cfilter *cf,
47 struct Curl_easy *data)
48{
49 struct cf_capsule_ctx *ctx = cf->ctx;
50 (void)data;
51 if(ctx) {
52 Curl_bufq_free(&ctx->recvbuf);
53 Curl_bufq_free(&ctx->sendbuf);
54 curlx_safefree(ctx);
55 }
56}
58static CURLcode cf_capsule_connect(struct Curl_cfilter *cf,
59 struct Curl_easy *data,
60 bool *done)
61{
62 if(cf->connected) {
63 *done = TRUE;
64 return CURLE_OK;
65 }
66 if(cf->next) {
67 CURLcode result = cf->next->cft->do_connect(cf->next, data, done);
68 if(!result && *done)
69 cf->connected = TRUE;
70 return result;
71 }
72 *done = FALSE;
73 return CURLE_OK;
74}
76static CURLcode cf_capsule_flush(struct Curl_cfilter *cf,
77 struct Curl_easy *data)
78{
79 struct cf_capsule_ctx *ctx = cf->ctx;
80 CURLcode result = CURLE_OK;
81 size_t nwritten;
83 if(Curl_bufq_is_empty(&ctx->sendbuf))
84 return CURLE_OK;
86 result = Curl_cf_send_bufq(cf->next, data, &ctx->sendbuf, NULL, 0,
87 &nwritten);
88 if(result) {
89 if(result == CURLE_AGAIN) {
90 CURL_TRC_CF(data, cf, "flush send buffer(%zu) -> EAGAIN",
91 Curl_bufq_len(&ctx->sendbuf));
92 }
93 return result;
94 }
95 return Curl_bufq_is_empty(&ctx->sendbuf) ? CURLE_OK : CURLE_AGAIN;
96}
98static CURLcode cf_capsule_send(struct Curl_cfilter *cf,
99 struct Curl_easy *data,
100 const uint8_t *buf, size_t len,
101 bool eos, size_t *pnwritten)
102{
103 struct cf_capsule_ctx *ctx = cf->ctx;
104 CURLcode result;
106 (void)eos;
107 *pnwritten = 0;
109 if(Curl_bufq_is_full(&ctx->sendbuf)) {
110 result = cf_capsule_flush(cf, data);
111 if(result)
112 return result;
113 }
115 /* encapsulate new payload into a capsule */
116 result = Curl_capsule_encap_udp_datagram(&ctx->sendbuf, buf, len);
117 if(result)
118 return result;
120 result = cf_capsule_flush(cf, data);
121 if(result == CURLE_AGAIN) {
122 /* Could not send it (or all), report success nevertheless as we
123 * have the payload buffered now and will flush it later. */
124 result = CURLE_OK;
125 }
127 if(!result)
128 *pnwritten = len;
129 return result;
130}
132static CURLcode cf_capsule_recv(struct Curl_cfilter *cf,
133 struct Curl_easy *data,
134 char *buf, size_t len,
135 size_t *pnread)
136{
137 struct cf_capsule_ctx *ctx = cf->ctx;
138 CURLcode result;
139 size_t nread;
141 *pnread = 0;
143 /* fill our receive buffer from the filter below */
144 while(!Curl_bufq_is_full(&ctx->recvbuf)) {
145 result = Curl_cf_recv_bufq(cf->next, data, &ctx->recvbuf, 0, &nread);
146 if(result == CURLE_AGAIN)
147 break;
148 if(result)
149 return result;
150 if(!nread)
151 break;
152 }
154 /* try to extract a complete capsule datagram */
155 *pnread = Curl_capsule_process_udp_raw(cf, data, &ctx->recvbuf,
156 (unsigned char *)buf, len,
157 &result);
158 return result;
159}
161static bool cf_capsule_data_pending(struct Curl_cfilter *cf,
162 const struct Curl_easy *data)
163{
164 struct cf_capsule_ctx *ctx = cf->ctx;
166 if(ctx && !Curl_bufq_is_empty(&ctx->recvbuf))
167 return TRUE;
168 return cf->next ? cf->next->cft->has_data_pending(cf->next, data) : FALSE;
169}
171static CURLcode cf_capsule_cntrl(struct Curl_cfilter *cf,
172 struct Curl_easy *data,
173 int event, int arg1, void *arg2)
174{
175 CURLcode result = CURLE_OK;
177 (void)arg1;
178 (void)arg2;
179 switch(event) {
180 case CF_CTRL_FLUSH:
181 result = cf_capsule_flush(cf, data);
182 break;
183 default:
184 break;
185 }
186 return result;
187}
189static CURLcode cf_capsule_query(struct Curl_cfilter *cf,
190 struct Curl_easy *data,
191 int query, int *pres1, void *pres2)
192{
193 struct cf_capsule_ctx *ctx = cf->ctx;
195 (void)pres2;
196 switch(query) {
197 case CF_QUERY_NEED_FLUSH: {
198 if(!Curl_bufq_is_empty(&ctx->sendbuf)) {
199 *pres1 = TRUE;
200 return CURLE_OK;
201 }
202 break;
203 }
204 default:
205 break;
206 }
207 return cf->next ?
208 cf->next->cft->query(cf->next, data, query, pres1, pres2) :
209 CURLE_UNKNOWN_OPTION;
210}
212static CURLcode cf_capsule_adjust_pollset(struct Curl_cfilter *cf,
213 struct Curl_easy *data,
214 struct easy_pollset *ps)
215{
216 struct cf_capsule_ctx *ctx = cf->ctx;
218 if(!Curl_bufq_is_empty(&ctx->sendbuf)) {
219 curl_socket_t sock = Curl_conn_cf_get_socket(cf, data);
220 if(sock != CURL_SOCKET_BAD)
221 return Curl_pollset_add_out(data, ps, sock);
222 }
223 return CURLE_OK;
224}
226static CURLcode cf_capsule_shutdown(struct Curl_cfilter *cf,
227 struct Curl_easy *data, bool *done)
228{
229 CURLcode result = CURLE_OK;
231 if(!cf->connected || cf->shutdown) {
232 *done = TRUE;
233 }
234 else {
235 result = cf_capsule_flush(cf, data);
236 *done = !result;
237 if(result == CURLE_AGAIN)
238 result = CURLE_OK;
239 }
240 return result;
241}
243struct Curl_cftype Curl_cft_capsule = {
244 "CAPSULE",
245 0,
246 0,
247 cf_capsule_destroy,
248 cf_capsule_connect,
249 cf_capsule_shutdown,
250 cf_capsule_adjust_pollset,
251 cf_capsule_data_pending,
252 cf_capsule_send,
253 cf_capsule_recv,
254 cf_capsule_cntrl,
255 Curl_cf_def_conn_is_alive,
256 Curl_cf_def_conn_keep_alive,
257 cf_capsule_query,
258};
260static CURLcode cf_capsule_create(struct Curl_cfilter **pcf,
261 struct Curl_easy *data,
262 struct connectdata *conn)
263{
264 struct Curl_cfilter *cf = NULL;
265 struct cf_capsule_ctx *ctx;
266 CURLcode result;
268 (void)data;
269 (void)conn;
270 *pcf = NULL;
271 ctx = curlx_calloc(1, sizeof(*ctx));
272 if(!ctx) {
273 result = CURLE_OUT_OF_MEMORY;
274 goto out;
275 }
277 Curl_bufq_init2(&ctx->recvbuf, CAPSULE_CHUNK_SIZE, CAPSULE_RECV_CHUNKS,
278 BUFQ_OPT_SOFT_LIMIT);
279 Curl_bufq_init2(&ctx->sendbuf, CAPSULE_CHUNK_SIZE, CAPSULE_SEND_CHUNKS,
280 BUFQ_OPT_SOFT_LIMIT);
282 result = Curl_cf_create(&cf, &Curl_cft_capsule, ctx);
284out:
285 *pcf = (!result) ? cf : NULL;
286 if(result && ctx) {
287 Curl_bufq_free(&ctx->recvbuf);
288 Curl_bufq_free(&ctx->sendbuf);
289 curlx_free(ctx);
290 }
291 return result;
292}
294CURLcode Curl_cf_capsule_insert_after(struct Curl_cfilter *cf_at,
295 struct Curl_easy *data)
296{
297 struct Curl_cfilter *cf;
298 CURLcode result;
300 result = cf_capsule_create(&cf, data, cf_at->conn);
301 if(!result)
302 Curl_conn_cf_insert_after(cf_at, cf);
303 return result;
304}
306#endif /* !CURL_DISABLE_PROXY && !CURL_DISABLE_HTTP */
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=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=20 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=86Open pack map
fetch2002.5 KiB · hit20 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=2529 git.response.cache=HIT git.response.duration_ms=20 git.fetch.wants=3ff7827bba93b503bb60e0a066dba6f694592c76 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=2529 git.pkt.payload.max=2508 git.sideband.band1.bytes=2507 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
- a5e3264e0be198f1
- Request
- 9fb00af8…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format