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 "first.h"
26#define THREADS 2
28/* struct containing data of a thread */
29struct t506_Tdata {
30 CURLSH *share;
31 char *url;
32};
34struct t506_userdata {
35 const char *text;
36 int share_counter;
37 int dns_counter;
38 int cookie_counter;
39};
41static int locks[3];
43/* lock callback */
44static void t506_test_lock(CURL *curl, curl_lock_data data,
45 curl_lock_access laccess, void *useptr)
46{
47 const char *what;
48 struct t506_userdata *user = (struct t506_userdata *)useptr;
49 int locknum, *pcounter;
51 (void)curl;
52 (void)laccess;
54 switch(data) {
55 case CURL_LOCK_DATA_SHARE:
56 what = "share";
57 locknum = 0;
58 pcounter = &user->share_counter;
59 break;
60 case CURL_LOCK_DATA_DNS:
61 what = "dns";
62 locknum = 1;
63 pcounter = &user->dns_counter;
64 break;
65 case CURL_LOCK_DATA_COOKIE:
66 what = "cookie";
67 locknum = 2;
68 pcounter = &user->cookie_counter;
69 break;
70 default:
71 curl_mfprintf(stderr, "lock: no such data: %d\n", (int)data);
72 return;
73 }
75 /* detect locking of locked locks */
76 if(locks[locknum]) {
77 curl_mprintf("lock: double locked %s\n", what);
78 return;
79 }
80 locks[locknum]++;
82 curl_mprintf("lock: %-6s [%s]: %d\n", what, user->text, *pcounter);
83 (*pcounter)++;
84}
86/* unlock callback */
87static void t506_test_unlock(CURL *curl, curl_lock_data data, void *useptr)
88{
89 const char *what;
90 struct t506_userdata *user = (struct t506_userdata *)useptr;
91 int locknum, *pcounter;
92 (void)curl;
93 switch(data) {
94 case CURL_LOCK_DATA_SHARE:
95 what = "share";
96 locknum = 0;
97 pcounter = &user->share_counter;
98 break;
99 case CURL_LOCK_DATA_DNS:
100 what = "dns";
101 locknum = 1;
102 pcounter = &user->dns_counter;
103 break;
104 case CURL_LOCK_DATA_COOKIE:
105 what = "cookie";
106 pcounter = &user->cookie_counter;
107 locknum = 2;
108 break;
109 default:
110 curl_mfprintf(stderr, "unlock: no such data: %d\n", (int)data);
111 return;
112 }
114 /* detect unlocking of unlocked locks */
115 if(!locks[locknum]) {
116 curl_mprintf("unlock: double unlocked %s\n", what);
117 return;
118 }
119 locks[locknum]--;
121 curl_mprintf("unlock: %-6s [%s]: %d\n", what, user->text, *pcounter);
122 (*pcounter)++;
123}
125/* build host entry */
126static struct curl_slist *sethost(struct curl_slist *headers)
127{
128 (void)headers;
129 return curl_slist_append(NULL, "Host: www.host.foo.com");
130}
132/* the dummy thread function */
133static void *t506_test_fire(void *ptr)
134{
135 CURLcode result;
136 struct curl_slist *headers;
137 struct t506_Tdata *tdata = (struct t506_Tdata *)ptr;
138 CURL *curl;
140 curl = curl_easy_init();
141 if(!curl) {
142 curl_mfprintf(stderr, "curl_easy_init() failed\n");
143 return NULL;
144 }
146 headers = sethost(NULL);
147 curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
148 curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
149 curl_easy_setopt(curl, CURLOPT_URL, tdata->url);
150 curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
151 curl_mprintf("CURLOPT_SHARE\n");
152 curl_easy_setopt(curl, CURLOPT_SHARE, tdata->share);
154 curl_mprintf("PERFORM\n");
155 result = curl_easy_perform(curl);
156 if(result) {
157 int i = 0;
158 curl_mfprintf(stderr, "perform URL '%s' repeat %d failed, curlcode %d\n",
159 tdata->url, i, (int)result);
160 }
162 curl_mprintf("CLEANUP\n");
163 curl_easy_cleanup(curl);
164 curl_slist_free_all(headers);
166 return NULL;
167}
169/* test function */
170static CURLcode test_lib506(const char *URL)
171{
172 CURLcode result;
173 CURLSHcode scode = CURLSHE_OK;
174 CURLcode code = CURLE_OK;
175 char *url = NULL;
176 struct t506_Tdata tdata;
177 CURL *curl;
178 CURLSH *share;
179 struct curl_slist *headers = NULL;
180 struct curl_slist *cookies = NULL;
181 struct curl_slist *next_cookie = NULL;
182 int i;
183 struct t506_userdata user;
185 const char *jar = libtest_arg2;
187 memset(&user, 0, sizeof(user));
188 user.text = "Pigs in space";
190 curl_mprintf("GLOBAL_INIT\n");
191 if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
192 curl_mfprintf(stderr, "curl_global_init() failed\n");
193 return TEST_ERR_MAJOR_BAD;
194 }
196 /* prepare share */
197 curl_mprintf("SHARE_INIT\n");
198 share = curl_share_init();
199 if(!share) {
200 curl_mfprintf(stderr, "curl_share_init() failed\n");
201 curl_global_cleanup();
202 return TEST_ERR_MAJOR_BAD;
203 }
205 if(CURLSHE_OK == scode) {
206 curl_mprintf("CURLSHOPT_LOCKFUNC\n");
207 scode = curl_share_setopt(share, CURLSHOPT_LOCKFUNC, t506_test_lock);
208 }
209 if(CURLSHE_OK == scode) {
210 curl_mprintf("CURLSHOPT_UNLOCKFUNC\n");
211 scode = curl_share_setopt(share, CURLSHOPT_UNLOCKFUNC, t506_test_unlock);
212 }
213 if(CURLSHE_OK == scode) {
214 curl_mprintf("CURLSHOPT_USERDATA\n");
215 scode = curl_share_setopt(share, CURLSHOPT_USERDATA, &user);
216 }
217 if(CURLSHE_OK == scode) {
218 curl_mprintf("CURL_LOCK_DATA_COOKIE\n");
219 scode = curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
220 }
221 if(CURLSHE_OK == scode) {
222 curl_mprintf("CURL_LOCK_DATA_DNS\n");
223 scode = curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
224 }
226 if(CURLSHE_OK != scode) {
227 curl_mfprintf(stderr, "curl_share_setopt() failed\n");
228 curl_share_cleanup(share);
229 curl_global_cleanup();
230 return TEST_ERR_MAJOR_BAD;
231 }
233 /* initial cookie manipulation */
234 curl = curl_easy_init();
235 if(!curl) {
236 curl_mfprintf(stderr, "curl_easy_init() failed\n");
237 curl_share_cleanup(share);
238 curl_global_cleanup();
239 return TEST_ERR_MAJOR_BAD;
240 }
241 curl_mprintf("CURLOPT_SHARE\n");
242 easy_setopt(curl, CURLOPT_SHARE, share);
243 curl_mprintf("CURLOPT_COOKIELIST injected_and_clobbered\n");
244 easy_setopt(curl, CURLOPT_COOKIELIST,
245 "Set-Cookie: injected_and_clobbered=yes; "
246 "domain=host.foo.com; expires=Sat Feb 2 11:56:27 GMT 2030");
247 curl_mprintf("CURLOPT_COOKIELIST ALL\n");
248 easy_setopt(curl, CURLOPT_COOKIELIST, "ALL");
249 curl_mprintf("CURLOPT_COOKIELIST session\n");
250 easy_setopt(curl, CURLOPT_COOKIELIST, "Set-Cookie: session=elephants");
251 curl_mprintf("CURLOPT_COOKIELIST injected\n");
252 easy_setopt(curl, CURLOPT_COOKIELIST,
253 "Set-Cookie: injected=yes; domain=host.foo.com; "
254 "expires=Sat Feb 2 11:56:27 GMT 2030");
255 curl_mprintf("CURLOPT_COOKIELIST SESS\n");
256 easy_setopt(curl, CURLOPT_COOKIELIST, "SESS");
257 curl_mprintf("CLEANUP\n");
258 curl_easy_cleanup(curl);
260 /* start treads */
261 for(i = 1; i <= THREADS; i++) {
263 /* set thread data */
264 tdata.url = tutil_suburl(URL, i); /* must be curl_free()d */
265 tdata.share = share;
267 /* simulate thread, direct call of "thread" function */
268 curl_mprintf("*** run %d\n", i);
269 t506_test_fire(&tdata);
271 curl_free(tdata.url);
272 }
274 /* fetch another one and save cookies */
275 curl_mprintf("*** run %d\n", i);
276 curl = curl_easy_init();
277 if(!curl) {
278 curl_mfprintf(stderr, "curl_easy_init() failed\n");
279 curl_share_cleanup(share);
280 curl_global_cleanup();
281 return TEST_ERR_MAJOR_BAD;
282 }
284 url = tutil_suburl(URL, i);
285 headers = sethost(NULL);
286 easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
287 easy_setopt(curl, CURLOPT_URL, url);
288 curl_mprintf("CURLOPT_SHARE\n");
289 easy_setopt(curl, CURLOPT_SHARE, share);
290 curl_mprintf("CURLOPT_COOKIEJAR\n");
291 easy_setopt(curl, CURLOPT_COOKIEJAR, jar);
292 curl_mprintf("CURLOPT_COOKIELIST FLUSH\n");
293 easy_setopt(curl, CURLOPT_COOKIELIST, "FLUSH");
295 curl_mprintf("PERFORM\n");
296 curl_easy_perform(curl);
298 curl_mprintf("CLEANUP\n");
299 curl_easy_cleanup(curl);
300 curl_free(url);
301 curl_slist_free_all(headers);
303 /* load cookies */
304 curl = curl_easy_init();
305 if(!curl) {
306 curl_mfprintf(stderr, "curl_easy_init() failed\n");
307 curl_share_cleanup(share);
308 curl_global_cleanup();
309 return TEST_ERR_MAJOR_BAD;
310 }
311 url = tutil_suburl(URL, i);
312 headers = sethost(NULL);
313 easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
314 easy_setopt(curl, CURLOPT_URL, url);
315 curl_mprintf("CURLOPT_SHARE\n");
316 easy_setopt(curl, CURLOPT_SHARE, share);
317 curl_mprintf("CURLOPT_COOKIELIST ALL\n");
318 easy_setopt(curl, CURLOPT_COOKIELIST, "ALL");
319 curl_mprintf("CURLOPT_COOKIEJAR\n");
320 easy_setopt(curl, CURLOPT_COOKIEFILE, jar);
321 curl_mprintf("CURLOPT_COOKIELIST RELOAD\n");
322 easy_setopt(curl, CURLOPT_COOKIELIST, "RELOAD");
324 result = CURLE_OK;
326 code = curl_easy_getinfo(curl, CURLINFO_COOKIELIST, &cookies);
327 if(code != CURLE_OK) {
328 curl_mfprintf(stderr, "curl_easy_getinfo() failed\n");
329 result = TEST_ERR_MAJOR_BAD;
330 goto test_cleanup;
331 }
332 curl_mprintf("loaded cookies:\n");
333 if(!cookies) {
334 curl_mfprintf(stderr, " reloading cookies from '%s' failed\n", jar);
335 result = TEST_ERR_MAJOR_BAD;
336 goto test_cleanup;
337 }
338 curl_mprintf("-----------------\n");
339 next_cookie = cookies;
340 while(next_cookie) {
341 curl_mprintf(" %s\n", next_cookie->data);
342 next_cookie = next_cookie->next;
343 }
344 curl_mprintf("-----------------\n");
345 curl_slist_free_all(cookies);
347 /* try to free share, expect to fail because share is in use */
348 curl_mprintf("try SHARE_CLEANUP...\n");
349 scode = curl_share_cleanup(share);
350 if(scode == CURLSHE_OK) {
351 curl_mfprintf(stderr, "curl_share_cleanup succeed but error expected\n");
352 share = NULL;
353 }
354 else {
355 curl_mprintf("SHARE_CLEANUP failed, correct\n");
356 }
358test_cleanup:
360 /* clean up last handle */
361 curl_mprintf("CLEANUP\n");
362 curl_easy_cleanup(curl);
363 curl_slist_free_all(headers);
364 curl_free(url);
366 /* free share */
367 curl_mprintf("SHARE_CLEANUP\n");
368 scode = curl_share_cleanup(share);
369 if(scode != CURLSHE_OK)
370 curl_mfprintf(stderr, "curl_share_cleanup failed, code errno %d\n",
371 (int)scode);
373 curl_mprintf("GLOBAL_CLEANUP\n");
374 curl_global_cleanup();
376 return result;
377}
Diagnostics4 git calls · 148 ms
CallStatusSizeTime0148 ms
discover200152 B2 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=1 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 · hit1 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=145 git.response.bytes=293470 git.response.cache=HIT git.response.duration_ms=1 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 KiB145 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=2861 git.response.cache=MISS git.response.duration_ms=145 git.fetch.wants=8d36c32ec3c408add30d0d242784ab27d09299a7 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=2861 git.pkt.payload.max=2840 git.sideband.band1.bytes=2839 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
- a5e32142aaac5aae
- Request
- f2be92dc…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format