Artifactspublic-v0

curl

master
ply4 git calls43 ms290 KiB3 cachedprotocol v2
381 lines9.5 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 "socketpair.h"
27#include "urldata.h"
28#include "rand.h"
29#include "curlx/nonblock.h"
31#ifndef CURL_DISABLE_SOCKETPAIR
33/* choose implementation */
34#ifdef USE_EVENTFD
36#include <sys/eventfd.h>
38static int wakeup_eventfd(curl_socket_t socks[2], bool nonblocking)
40 int efd = eventfd(0, nonblocking ? EFD_CLOEXEC | EFD_NONBLOCK : EFD_CLOEXEC);
41 if(efd == -1) {
42 socks[0] = socks[1] = CURL_SOCKET_BAD;
43 return -1;
44 }
45 socks[0] = socks[1] = efd;
46 return 0;
49#elif defined(HAVE_PIPE)
51#ifdef HAVE_FCNTL
52#include <fcntl.h>
53#endif
55static int wakeup_pipe(curl_socket_t socks[2], bool nonblocking)
57#ifdef HAVE_PIPE2
58 return pipe2(socks, (nonblocking ? O_NONBLOCK : 0) | O_CLOEXEC) ? -1 : 0;
59#else
60#if defined(__APPLE__) && defined(HAVE_BUILTIN_AVAILABLE) && \
61 ((defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && \
62 __MAC_OS_X_VERSION_MAX_ALLOWED >= 270000) || \
63 (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && \
64 __IPHONE_OS_VERSION_MAX_ALLOWED >= 270000) || \
65 (defined(__TV_OS_VERSION_MAX_ALLOWED) && \
66 __TV_OS_VERSION_MAX_ALLOWED >= 270000) || \
67 (defined(__WATCH_OS_VERSION_MAX_ALLOWED) && \
68 __WATCH_OS_VERSION_MAX_ALLOWED >= 270000) || \
69 (defined(__VISION_OS_VERSION_MAX_ALLOWED) && \
70 __VISION_OS_VERSION_MAX_ALLOWED >= 270000))
71 if(__builtin_available(macOS 27, iOS 27, tvOS 27, watchOS 27, visionOS 27,
72 macCatalyst 27, *))
73 return pipe2(socks, (nonblocking ? O_NONBLOCK : 0) | O_CLOEXEC) ? -1 : 0;
74 else
75#endif
76 if(pipe(socks))
77 return -1;
78#ifdef HAVE_FCNTL
79 if(fcntl(socks[0], F_SETFD, FD_CLOEXEC) ||
80 fcntl(socks[1], F_SETFD, FD_CLOEXEC)) {
81 sclose(socks[0]);
82 sclose(socks[1]);
83 socks[0] = socks[1] = CURL_SOCKET_BAD;
84 return -1;
85 }
86#endif
87 if(nonblocking) {
88 if(curlx_nonblock(socks[0], TRUE) < 0 ||
89 curlx_nonblock(socks[1], TRUE) < 0) {
90 sclose(socks[0]);
91 sclose(socks[1]);
92 socks[0] = socks[1] = CURL_SOCKET_BAD;
93 return -1;
94 }
95 }
96 return 0;
97#endif /* HAVE_PIPE2 */
100#elif defined(HAVE_SOCKETPAIR) /* !USE_EVENTFD && !HAVE_PIPE */
102#ifndef USE_UNIX_SOCKETS
103#error "unsupported Unix domain and socketpair build combo"
104#endif
106static int wakeup_socketpair(curl_socket_t socks[2], bool nonblocking)
108 int type = SOCK_STREAM;
109#ifdef SOCK_CLOEXEC
110 type |= SOCK_CLOEXEC;
111#endif
112#ifdef CURL_USE_SOCK_NONBLOCK
113 if(nonblocking)
114 type |= SOCK_NONBLOCK;
115#endif
117 if(CURL_SOCKETPAIR(AF_UNIX, type, 0, socks))
118 return -1;
119#ifndef CURL_USE_SOCK_NONBLOCK
120 if(nonblocking) {
121 if(curlx_nonblock(socks[0], TRUE) < 0 ||
122 curlx_nonblock(socks[1], TRUE) < 0) {
123 sclose(socks[0]);
124 sclose(socks[1]);
125 socks[0] = socks[1] = CURL_SOCKET_BAD;
126 return -1;
127 }
128 }
129#endif
130#ifdef USE_SO_NOSIGPIPE
131 if(Curl_sock_nosigpipe(socks[1]) < 0) {
132 sclose(socks[0]);
133 sclose(socks[1]);
134 socks[0] = socks[1] = CURL_SOCKET_BAD;
135 return -1;
136 }
137#endif /* USE_SO_NOSIGPIPE */
139 return 0;
142#else /* !USE_EVENTFD && !HAVE_PIPE && !HAVE_SOCKETPAIR */
144#ifdef HAVE_NETDB_H
145#include <netdb.h>
146#endif
147#ifdef HAVE_NETINET_IN_H
148#include <netinet/in.h> /* for IPPROTO_TCP */
149#endif
150#ifdef HAVE_ARPA_INET_H
151#include <arpa/inet.h>
152#endif
154#ifndef INADDR_LOOPBACK
155#define INADDR_LOOPBACK 0x7f000001
156#endif
158#include "select.h" /* for Curl_poll */
160static int wakeup_inet(curl_socket_t socks[2], bool nonblocking)
162 union {
163 struct sockaddr_in inaddr;
164 struct sockaddr addr;
165 } a;
166 curl_socket_t listener;
167 curl_socklen_t addrlen = sizeof(a.inaddr);
168 int reuse = 1;
169 struct pollfd pfd[1];
171 listener = CURL_SOCKET(AF_INET, SOCK_STREAM, IPPROTO_TCP);
172 if(listener == CURL_SOCKET_BAD)
173 return -1;
175 memset(&a, 0, sizeof(a));
176 a.inaddr.sin_family = AF_INET;
177 a.inaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
178 a.inaddr.sin_port = 0;
180 socks[0] = socks[1] = CURL_SOCKET_BAD;
182#if defined(_WIN32) || defined(__CYGWIN__)
183 /* do not set SO_REUSEADDR on Windows */
184 (void)reuse;
185#ifdef SO_EXCLUSIVEADDRUSE
186 {
187 int exclusive = 1;
188 if(setsockopt(listener, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
189 (char *)&exclusive, (curl_socklen_t)sizeof(exclusive)) == -1)
190 goto error;
191 }
192#endif
193#else
194 if(setsockopt(listener, SOL_SOCKET, SO_REUSEADDR,
195 (char *)&reuse, (curl_socklen_t)sizeof(reuse)) == -1)
196 goto error;
197#endif
198 if(bind(listener, &a.addr, sizeof(a.inaddr)) == -1)
199 goto error;
200 if(getsockname(listener, &a.addr, &addrlen) == -1 ||
201 addrlen < (int)sizeof(a.inaddr))
202 goto error;
203 if(listen(listener, 1) == -1)
204 goto error;
205 socks[0] = CURL_SOCKET(AF_INET, SOCK_STREAM, 0);
206 if(socks[0] == CURL_SOCKET_BAD)
207 goto error;
208 if(connect(socks[0], &a.addr, sizeof(a.inaddr)) == -1)
209 goto error;
211 /* use non-blocking accept to make sure we do not block forever */
212 if(curlx_nonblock(listener, TRUE) < 0)
213 goto error;
214 pfd[0].fd = listener;
215 pfd[0].events = POLLIN;
216 pfd[0].revents = 0;
217 (void)Curl_poll(pfd, 1, 1000); /* one second */
218 socks[1] = CURL_ACCEPT(listener, NULL, NULL);
219 if(socks[1] == CURL_SOCKET_BAD)
220 goto error;
221 else {
222 struct curltime start = curlx_now();
223 char rnd[9];
224 char check[sizeof(rnd)];
225 char *p = &check[0];
226 size_t s = sizeof(check);
228 if(Curl_rand(NULL, (unsigned char *)rnd, sizeof(rnd)))
229 goto error;
231 /* write data to the socket */
232 swrite(socks[0], rnd, sizeof(rnd));
233 /* verify that we read the correct data */
234 do {
235 ssize_t nread;
237 /* Do not block forever */
238 if(curlx_timediff_ms(curlx_now(), start) > (60 * 1000))
239 goto error;
241 pfd[0].fd = socks[1];
242 pfd[0].events = POLLIN;
243 pfd[0].revents = 0;
244 (void)Curl_poll(pfd, 1, 1000); /* one second */
246 nread = sread(socks[1], p, s);
247 if(!nread) { /* unexpected close before getting complete `check` */
248 goto error;
249 }
250 else if(nread == -1) { /* error or close */
251 int sockerr = SOCKERRNO;
252 if(SOCK_EAGAIN(sockerr)
253#ifndef USE_WINSOCK
254 || (sockerr == SOCKEINTR) || (sockerr == SOCKEINPROGRESS)
255#endif
256 ) {
257 continue;
258 }
259 goto error;
260 }
261 s -= nread;
262 if(s) {
263 p += nread;
264 continue;
265 }
266 if(memcmp(rnd, check, sizeof(check)))
267 goto error;
268 break;
269 } while(1);
270 }
272 if(nonblocking)
273 if(curlx_nonblock(socks[0], TRUE) < 0 ||
274 curlx_nonblock(socks[1], TRUE) < 0)
275 goto error;
276#ifdef USE_SO_NOSIGPIPE
277 if(Curl_sock_nosigpipe(socks[1]) < 0)
278 goto error;
279#endif
280 sclose(listener);
281 return 0;
283error:
284 sclose(listener);
285 sclose(socks[0]);
286 sclose(socks[1]);
287 socks[0] = socks[1] = CURL_SOCKET_BAD;
288 return -1;
291#endif /* choose implementation */
293int Curl_wakeup_init(curl_socket_t socks[2], bool nonblocking)
295#ifdef USE_EVENTFD
296 return wakeup_eventfd(socks, nonblocking);
297#elif defined(HAVE_PIPE)
298 return wakeup_pipe(socks, nonblocking);
299#elif defined(HAVE_SOCKETPAIR)
300 return wakeup_socketpair(socks, nonblocking);
301#else
302 return wakeup_inet(socks, nonblocking);
303#endif
306#if defined(USE_EVENTFD) || defined(HAVE_PIPE)
308#define wakeup_write write
309#define wakeup_read read
310#define wakeup_close close
312#else /* !USE_EVENTFD && !HAVE_PIPE */
314#define wakeup_write swrite
315#define wakeup_read sread
316#define wakeup_close sclose
318#endif
320int Curl_wakeup_signal(curl_socket_t socks[2])
322 int sockerr = 0;
323#ifdef USE_EVENTFD
324 const uint64_t buf[1] = { 1 };
325#else
326 const char buf[1] = { 1 };
327#endif
329 while(1) {
330 sockerr = 0;
331 if(wakeup_write(socks[1], buf, sizeof(buf)) < 0) {
332 sockerr = SOCKERRNO;
333#ifndef USE_WINSOCK
334 if(sockerr == SOCKEINTR)
335 continue;
336#endif
337 if(SOCK_EAGAIN(sockerr))
338 sockerr = 0; /* wakeup is already ongoing */
339 }
340 break;
341 }
342 return sockerr;
345CURLcode Curl_wakeup_consume(curl_socket_t socks[2], bool all)
347 char buf[64];
348 ssize_t rc;
349 CURLcode result = CURLE_OK;
351 do {
352 rc = wakeup_read(socks[0], buf, sizeof(buf));
353 if(!rc)
354 break;
355 else if(rc < 0) {
356 int sockerr = SOCKERRNO;
357#ifndef USE_WINSOCK
358 if(sockerr == SOCKEINTR)
359 continue;
360#endif
361 if(SOCK_EAGAIN(sockerr))
362 break;
363 result = CURLE_READ_ERROR;
364 break;
365 }
366 } while(all);
367 return result;
370void Curl_wakeup_destroy(curl_socket_t socks[2])
372#ifndef USE_EVENTFD
373 if(socks[1] != CURL_SOCKET_BAD)
374 wakeup_close(socks[1]);
375#endif
376 if(socks[0] != CURL_SOCKET_BAD)
377 wakeup_close(socks[0]);
378 socks[0] = socks[1] = CURL_SOCKET_BAD;
381#endif /* !CURL_DISABLE_SOCKETPAIR */
Diagnostics4 git calls · 43 ms
CallStatusSizeTime043 ms
discover200152 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
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 · hit17 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=4
git.response.bytes=293470
git.response.cache=HIT
git.response.duration_ms=17
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
fetch2003.1 KiB · hit23 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=3178
git.response.cache=HIT
git.response.duration_ms=23
git.fetch.wants=ee23608f7c87788274110f22bead4b4b0faf23eb
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=3178
git.pkt.payload.max=3157
git.sideband.band1.bytes=3156
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
a5e2406cfb79cf56
Request
e07a28a9…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format