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 ***************************************************************************/
25#include "curl_setup.h"
27#if !defined(CURL_DISABLE_PROXY) && !defined(CURL_DISABLE_HTTP)
29#ifdef HAVE_ARPA_INET_H
30#include <arpa/inet.h> /* for htons() */
31#endif
33#include <curl/curl.h>
34#include "urldata.h"
35#include "curlx/dynbuf.h"
36#include "cfilters.h"
37#include "curl_trc.h"
38#include "bufq.h"
39#include "vquic/capsule.h"
42/**
43 * Convert 64-bit value from network byte order to host byte order
44 */
45static uint64_t capsule_ntohll(uint64_t value)
46{
47#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
48 return value;
49#elif (defined(__GNUC__) || defined(__clang__)) && \
50 defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
51 return __builtin_bswap64(value);
52#else
53 union {
54 uint64_t u64;
55 uint32_t u32[2];
56 } src, dst;
58 src.u64 = value;
59 dst.u32[0] = ntohl(src.u32[1]);
60 dst.u32[1] = ntohl(src.u32[0]);
61 return dst.u64;
62#endif
63}
65/**
66 * Encode a variable-length integer into a plain buffer.
67 * @param buf Output buffer (must have at least 8 bytes)
68 * @param value Value to encode (must be <= 0x3FFFFFFFFFFFFFFF)
69 * @return Number of bytes written
70 */
71static size_t capsule_encode_varint_buf(uint8_t *buf, uint64_t value)
72{
73 DEBUGASSERT(value <= 0x3FFFFFFFFFFFFFFF);
75 if(value <= 0x3F) {
76 buf[0] = (uint8_t)value;
77 return 1;
78 }
79 else if(value <= 0x3FFF) {
80 uint16_t encoded = (uint16_t)value & 0x3FFF;
81 encoded = ntohs(encoded | 0x4000);
82 memcpy(buf, &encoded, 2);
83 return 2;
84 }
85 else if(value <= 0x3FFFFFFF) {
86 uint32_t encoded = (uint32_t)value & 0x3FFFFFFF;
87 encoded = ntohl(encoded | 0x80000000);
88 memcpy(buf, &encoded, 4);
89 return 4;
90 }
91 else {
92 uint64_t encoded = (uint64_t)value & 0x3FFFFFFFFFFFFFFF;
93 encoded = capsule_ntohll(encoded | 0xC000000000000000);
94 memcpy(buf, &encoded, 8);
95 return 8;
96 }
97}
99static CURLcode capsule_peek_u8(struct bufq *recvbufq,
100 size_t offset,
101 uint8_t *pbyte)
102{
103 const unsigned char *peek = NULL;
104 size_t peeklen = 0;
106 if(!Curl_bufq_peek_at(recvbufq, offset, &peek, &peeklen) || !peeklen)
107 return CURLE_AGAIN;
108 *pbyte = peek[0];
109 return CURLE_OK;
110}
112static CURLcode capsule_decode_varint_at(struct bufq *recvbufq,
113 size_t offset,
114 uint64_t *pvalue,
115 size_t *pconsumed)
116{
117 uint8_t first_byte, byte;
118 uint64_t value;
119 size_t nbytes;
120 size_t i;
121 CURLcode result;
123 result = capsule_peek_u8(recvbufq, offset, &first_byte);
124 if(result)
125 return result;
127 nbytes = (size_t)1 << (first_byte >> 6); /* 1, 2, 4 or 8 bytes */
128 value = first_byte & 0x3F;
130 for(i = 1; i < nbytes; ++i) {
131 result = capsule_peek_u8(recvbufq, offset + i, &byte);
132 if(result)
133 return result;
134 value = (value << 8) | byte;
135 }
137 *pvalue = value;
138 *pconsumed = nbytes;
139 return CURLE_OK;
140}
142/**
143 * Write the capsule header (type + varint length + context ID) into `hdr`.
144 * @param hdr Output buffer (must be >= HTTP_CAPSULE_HEADER_MAX_SIZE)
145 * @param hdrlen Size of `hdr` in bytes
146 * @param payload_len Length of the UDP payload that follows
147 * @return Number of header bytes written, or 0 on error
148 *
149 * @unittest 3400
150 */
151UNITTEST size_t capsule_encap_udp_hdr(uint8_t *hdr, size_t hdrlen,
152 size_t payload_len);
153UNITTEST size_t capsule_encap_udp_hdr(uint8_t *hdr, size_t hdrlen,
154 size_t payload_len)
155{
156 size_t off = 0;
157 DEBUGASSERT(hdrlen >= HTTP_CAPSULE_HEADER_MAX_SIZE);
158 if(hdrlen < HTTP_CAPSULE_HEADER_MAX_SIZE)
159 return 0;
160 hdr[off++] = 0; /* capsule type: HTTP Datagram */
161 off += capsule_encode_varint_buf(hdr + off, (uint64_t)payload_len + 1);
162 hdr[off++] = 0; /* context ID */
163 return off;
164}
166CURLcode Curl_capsule_encap_udp_datagram(struct bufq *q,
167 const void *buf, size_t blen)
168{
169 CURLcode result;
170 uint8_t hdr[HTTP_CAPSULE_HEADER_MAX_SIZE];
171 size_t hdr_len, nwritten;
173 hdr_len = capsule_encap_udp_hdr(hdr, sizeof(hdr), blen);
174 DEBUGASSERT(hdr_len);
175 if(!hdr_len)
176 return CURLE_FAILED_INIT;
178 result = Curl_bufq_write(q, hdr, hdr_len, &nwritten);
179 if(!result && (nwritten != hdr_len))
180 return CURLE_WRITE_ERROR;
181 if(!result) {
182 result = Curl_bufq_write(q, buf, blen, &nwritten);
183 if(!result && (nwritten != blen))
184 return CURLE_WRITE_ERROR;
185 }
186 if(result == CURLE_AGAIN)
187 return CURLE_WRITE_ERROR;
188 return result;
189}
191size_t Curl_capsule_process_udp_raw(struct Curl_cfilter *cf,
192 struct Curl_easy *data,
193 struct bufq *recvbufq,
194 unsigned char *buf, size_t len,
195 CURLcode *err)
196{
197 const unsigned char *context_id, *capsule_type;
198 size_t read_size, varint_len;
199 uint64_t capsule_length;
200 size_t offset, payload_len;
201 size_t bytes_read = 0;
202 CURLcode result = CURLE_OK;
204 if(!len) {
205 *err = CURLE_BAD_FUNCTION_ARGUMENT;
206 return 0;
207 }
209 if(Curl_bufq_is_empty(recvbufq)) {
210 *err = CURLE_AGAIN;
211 return 0;
212 }
214 if(!Curl_bufq_peek(recvbufq, &capsule_type, &read_size) || !read_size) {
215 *err = CURLE_AGAIN;
216 return 0;
217 }
219 if(capsule_type[0]) {
220 infof(data, "Error! Invalid capsule type: %d", capsule_type[0]);
221 Curl_bufq_skip(recvbufq, 1);
222 *err = CURLE_RECV_ERROR;
223 return 0;
224 }
226 offset = 1;
227 result = capsule_decode_varint_at(recvbufq, offset, &capsule_length,
228 &varint_len);
229 if(result == CURLE_AGAIN) {
230 *err = CURLE_AGAIN;
231 return 0;
232 }
233 else if(result) {
234 *err = CURLE_RECV_ERROR;
235 return 0;
236 }
237 offset += varint_len;
239 if(!Curl_bufq_peek_at(recvbufq, offset, &context_id, &read_size) ||
240 !read_size) {
241 *err = CURLE_AGAIN;
242 return 0;
243 }
245 if(*context_id) {
246 infof(data, "Error! Invalid context ID: %02x", *context_id);
247 Curl_bufq_skip(recvbufq, offset + 1);
248 *err = CURLE_RECV_ERROR;
249 return 0;
250 }
251 offset += 1;
253 if(!capsule_length) {
254 infof(data, "Error! Invalid capsule length: 0");
255 Curl_bufq_skip(recvbufq, offset);
256 *err = CURLE_RECV_ERROR;
257 return 0;
258 }
259 if(capsule_length - 1 > (uint64_t)(SIZE_MAX - offset)) {
260 infof(data, "Error! Capsule length too large: %" CURL_FORMAT_CURL_OFF_T,
261 (curl_off_t)capsule_length);
262 *err = CURLE_RECV_ERROR;
263 return 0;
264 }
265 payload_len = (size_t)(capsule_length - 1);
267 if(payload_len > len) {
268 infof(data, "UDP payload does not fit destination buffer: %zu > %zu",
269 payload_len, len);
270 Curl_bufq_skip(recvbufq, offset + payload_len);
271 *err = CURLE_RECV_ERROR;
272 return 0;
273 }
275 if(Curl_bufq_len(recvbufq) < offset + payload_len) {
276 if(Curl_bufq_is_full(recvbufq)) {
277 infof(data, "Error! Capsule does not fit the receive buffer: %zu",
278 payload_len);
279 *err = CURLE_RECV_ERROR;
280 return 0;
281 }
282 *err = CURLE_AGAIN;
283 return 0;
284 }
286 Curl_bufq_skip(recvbufq, offset);
287 if(!payload_len) {
288 *err = CURLE_OK;
289 return 0;
290 }
291 result = Curl_bufq_read(recvbufq, buf, payload_len, &bytes_read);
292 if(result || (bytes_read != payload_len)) {
293 infof(data, "Error! Read less than expected %zu %zu",
294 payload_len, bytes_read);
295 *err = CURLE_RECV_ERROR;
296 return 0;
297 }
299 if(cf && data) {
300 CURL_TRC_CF(data, cf, "Processed UDP capsule raw: size=%zu "
301 "length_left %zu", payload_len, Curl_bufq_len(recvbufq));
302 }
303 *err = CURLE_OK;
304 return bytes_read;
305}
307#endif /* !CURL_DISABLE_PROXY && !CURL_DISABLE_HTTP */
Diagnostics4 git calls · 148 ms
CallStatusSizeTime0148 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=143 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
fetch2002.8 KiB143 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=2916 git.response.cache=MISS git.response.duration_ms=143 git.fetch.wants=e6456062c1d7d681df55128533703d477c4b8ae8 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=2916 git.pkt.payload.max=2895 git.sideband.band1.bytes=2894 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
- a5e30be70f78ee28
- Request
- e8356a86…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format