Artifactspublic-v0

curl

master
ply4 git calls28 ms289 KiB3 cachedprotocol v2
336 lines8.9 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#if defined(USE_SSL) && defined(USE_SSLS_EXPORT)
28#include "urldata.h"
29#include "curl_trc.h"
30#include "vtls/vtls_scache.h"
31#include "vtls/vtls_spack.h"
32#include "curlx/strdup.h"
34#define CURL_SPACK_VERSION 0x01
35#define CURL_SPACK_IETF_ID 0x02
36#define CURL_SPACK_VALID_UNTIL 0x03
37#define CURL_SPACK_TICKET 0x04
38#define CURL_SPACK_ALPN 0x05
39#define CURL_SPACK_EARLYDATA 0x06
40#define CURL_SPACK_QUICTP 0x07
41#define CURL_SPACK_SECTRUST 0x08
43static CURLcode spack_enc8(struct dynbuf *buf, uint8_t b)
45 return curlx_dyn_addn(buf, &b, 1);
48static CURLcode spack_dec8(uint8_t *val, const uint8_t **src,
49 const uint8_t *end)
51 if(end - *src < 1)
52 return CURLE_READ_ERROR;
53 *val = **src;
54 *src += 1;
55 return CURLE_OK;
58static CURLcode spack_enc16(struct dynbuf *buf, uint16_t val)
60 uint8_t nval[2];
61 nval[0] = (uint8_t)(val >> 8);
62 nval[1] = (uint8_t)val;
63 return curlx_dyn_addn(buf, nval, sizeof(nval));
66static CURLcode spack_dec16(uint16_t *val, const uint8_t **src,
67 const uint8_t *end)
69 if(end - *src < 2)
70 return CURLE_READ_ERROR;
71 *val = (uint16_t)((*src)[0] << 8 | (*src)[1]);
72 *src += 2;
73 return CURLE_OK;
76static CURLcode spack_enc32(struct dynbuf *buf, uint32_t val)
78 uint8_t nval[4];
79 nval[0] = (uint8_t)(val >> 24);
80 nval[1] = (uint8_t)(val >> 16);
81 nval[2] = (uint8_t)(val >> 8);
82 nval[3] = (uint8_t)val;
83 return curlx_dyn_addn(buf, nval, sizeof(nval));
86static CURLcode spack_dec32(uint32_t *val, const uint8_t **src,
87 const uint8_t *end)
89 if(end - *src < 4)
90 return CURLE_READ_ERROR;
91 *val = (uint32_t)(*src)[0] << 24 | (uint32_t)(*src)[1] << 16 |
92 (uint32_t)(*src)[2] << 8 | (*src)[3];
93 *src += 4;
94 return CURLE_OK;
97static CURLcode spack_enc64(struct dynbuf *buf, uint64_t val)
99 uint8_t nval[8];
100 nval[0] = (uint8_t)(val >> 56);
101 nval[1] = (uint8_t)(val >> 48);
102 nval[2] = (uint8_t)(val >> 40);
103 nval[3] = (uint8_t)(val >> 32);
104 nval[4] = (uint8_t)(val >> 24);
105 nval[5] = (uint8_t)(val >> 16);
106 nval[6] = (uint8_t)(val >> 8);
107 nval[7] = (uint8_t)val;
108 return curlx_dyn_addn(buf, nval, sizeof(nval));
111static CURLcode spack_dec64(uint64_t *val, const uint8_t **src,
112 const uint8_t *end)
114 if(end - *src < 8)
115 return CURLE_READ_ERROR;
116 *val = (uint64_t)(*src)[0] << 56 | (uint64_t)(*src)[1] << 48 |
117 (uint64_t)(*src)[2] << 40 | (uint64_t)(*src)[3] << 32 |
118 (uint64_t)(*src)[4] << 24 | (uint64_t)(*src)[5] << 16 |
119 (uint64_t)(*src)[6] << 8 | (*src)[7];
120 *src += 8;
121 return CURLE_OK;
124static CURLcode spack_encstr16(struct dynbuf *buf, const char *s)
126 size_t slen = strlen(s);
127 CURLcode result;
128 if(slen > UINT16_MAX)
129 return CURLE_BAD_FUNCTION_ARGUMENT;
130 result = spack_enc16(buf, (uint16_t)slen);
131 if(!result) {
132 result = curlx_dyn_addn(buf, s, slen);
133 }
134 return result;
137static CURLcode spack_decstr16(char **val, const uint8_t **src,
138 const uint8_t *end)
140 uint16_t slen;
141 CURLcode result;
143 *val = NULL;
144 result = spack_dec16(&slen, src, end);
145 if(result)
146 return result;
147 if(end - *src < slen)
148 return CURLE_READ_ERROR;
149 *val = curlx_memdup0((const char *)(*src), slen);
150 *src += slen;
151 return *val ? CURLE_OK : CURLE_OUT_OF_MEMORY;
154static CURLcode spack_encdata16(struct dynbuf *buf, const uint8_t *data,
155 size_t data_len)
157 CURLcode result;
158 if(data_len > UINT16_MAX)
159 return CURLE_BAD_FUNCTION_ARGUMENT;
160 result = spack_enc16(buf, (uint16_t)data_len);
161 if(!result) {
162 result = curlx_dyn_addn(buf, data, data_len);
163 }
164 return result;
167static CURLcode spack_decdata16(uint8_t **val, size_t *val_len,
168 const uint8_t **src, const uint8_t *end)
170 uint16_t data_len;
171 CURLcode result;
173 *val = NULL;
174 result = spack_dec16(&data_len, src, end);
175 if(result)
176 return result;
177 if(end - *src < data_len)
178 return CURLE_READ_ERROR;
179 *val = curlx_memdup0((const char *)(*src), data_len);
180 *val_len = data_len;
181 *src += data_len;
182 return *val ? CURLE_OK : CURLE_OUT_OF_MEMORY;
185CURLcode Curl_ssl_session_pack(struct Curl_easy *data,
186 struct Curl_ssl_session *s,
187 struct dynbuf *buf)
189 CURLcode result;
190 DEBUGASSERT(s->sdata);
191 DEBUGASSERT(s->sdata_len);
193 if(s->valid_until < 0)
194 return CURLE_BAD_FUNCTION_ARGUMENT;
196 result = spack_enc8(buf, CURL_SPACK_VERSION);
197 if(!result)
198 result = spack_enc8(buf, CURL_SPACK_TICKET);
199 if(!result)
200 result = spack_encdata16(buf, s->sdata, s->sdata_len);
201 if(!result)
202 result = spack_enc8(buf, CURL_SPACK_IETF_ID);
203 if(!result)
204 result = spack_enc16(buf, (uint16_t)s->ietf_tls_id);
205 if(!result)
206 result = spack_enc8(buf, CURL_SPACK_VALID_UNTIL);
207 if(!result)
208 result = spack_enc64(buf, (uint64_t)s->valid_until);
209 if(!result && s->alpn) {
210 result = spack_enc8(buf, CURL_SPACK_ALPN);
211 if(!result)
212 result = spack_encstr16(buf, s->alpn);
213 }
214 if(!result && s->earlydata_max) {
215 if(s->earlydata_max > UINT32_MAX)
216 result = CURLE_BAD_FUNCTION_ARGUMENT;
217 if(!result)
218 result = spack_enc8(buf, CURL_SPACK_EARLYDATA);
219 if(!result)
220 result = spack_enc32(buf, (uint32_t)s->earlydata_max);
221 }
222 if(!result && s->sectrust_verified) {
223 result = spack_enc8(buf, CURL_SPACK_SECTRUST);
224 }
225 if(!result && s->quic_tp && s->quic_tp_len) {
226 result = spack_enc8(buf, CURL_SPACK_QUICTP);
227 if(!result)
228 result = spack_encdata16(buf, s->quic_tp, s->quic_tp_len);
229 }
231 if(result)
232 CURL_TRC_SSLS(data, "error packing data: %d", (int)result);
233 return result;
236CURLcode Curl_ssl_session_unpack(struct Curl_easy *data,
237 const void *bufv, size_t buflen,
238 struct Curl_ssl_session **ps)
240 struct Curl_ssl_session *s = NULL;
241 const unsigned char *buf = (const unsigned char *)bufv;
242 const unsigned char *end = buf + buflen;
243 uint8_t val8, *pval8;
244 uint16_t val16;
245 uint32_t val32;
246 uint64_t val64;
247 size_t dlen;
248 CURLcode result;
250 DEBUGASSERT(ps);
251 DEBUGASSERT(buf);
252 DEBUGASSERT(buflen);
253 *ps = NULL;
255 result = spack_dec8(&val8, &buf, end);
256 if(result)
257 goto out;
258 if(val8 != CURL_SPACK_VERSION) {
259 result = CURLE_READ_ERROR;
260 goto out;
261 }
263 s = curlx_calloc(1, sizeof(*s));
264 if(!s) {
265 result = CURLE_OUT_OF_MEMORY;
266 goto out;
267 }
269 while(buf < end) {
270 result = spack_dec8(&val8, &buf, end);
271 if(result)
272 goto out;
274 switch(val8) {
275 case CURL_SPACK_ALPN:
276 curlx_free(s->alpn);
277 result = spack_decstr16(&s->alpn, &buf, end);
278 if(result)
279 goto out;
280 break;
281 case CURL_SPACK_EARLYDATA:
282 result = spack_dec32(&val32, &buf, end);
283 if(result)
284 goto out;
285 s->earlydata_max = val32;
286 break;
287 case CURL_SPACK_IETF_ID:
288 result = spack_dec16(&val16, &buf, end);
289 if(result)
290 goto out;
291 s->ietf_tls_id = val16;
292 break;
293 case CURL_SPACK_QUICTP: {
294 result = spack_decdata16(&pval8, &dlen, &buf, end);
295 if(result)
296 goto out;
297 curlx_free(s->quic_tp);
298 s->quic_tp = pval8;
299 s->quic_tp_len = dlen;
300 break;
301 }
302 case CURL_SPACK_TICKET: {
303 result = spack_decdata16(&pval8, &dlen, &buf, end);
304 if(result)
305 goto out;
306 curlx_free(s->sdata);
307 s->sdata = pval8;
308 s->sdata_len = dlen;
309 break;
310 }
311 case CURL_SPACK_VALID_UNTIL:
312 result = spack_dec64(&val64, &buf, end);
313 if(result)
314 goto out;
315 s->valid_until = (curl_off_t)val64;
316 break;
317 case CURL_SPACK_SECTRUST:
318 s->sectrust_verified = TRUE;
319 break;
320 default: /* unknown tag */
321 result = CURLE_READ_ERROR;
322 goto out;
323 }
324 }
326out:
327 if(result) {
328 CURL_TRC_SSLS(data, "error unpacking data: %d", (int)result);
329 Curl_ssl_session_destroy(s);
330 }
331 else
332 *ps = s;
333 return result;
336#endif /* USE_SSL && USE_SSLS_EXPORT */
Diagnostics4 git calls · 28 ms
CallStatusSizeTime028 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=23
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
fetch2002.4 KiB · hit23 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=2489
git.response.cache=HIT
git.response.duration_ms=23
git.fetch.wants=b53b46b0a19d197d2f6524a9b2cd11b2b4aca076
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=2489
git.pkt.payload.max=2468
git.sideband.band1.bytes=2467
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
a5e368da7db7724e
Request
929b0ddd…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format