Artifactspublic-v0

curl

master
ply4 git calls437 ms296 KiB2 cachedprotocol v2
1220 lines34 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 "first.h"
26#include <toolx/tool_time.h>
28#ifdef HAVE_FCNTL_H
29#include <fcntl.h>
30#endif
32#ifdef _WIN32
33#include <share.h>
34#endif
36#if defined(CURL_WINDOWS_UWP) && !defined(CURL_DEBUG_NO_WIN32_WND)
37#define CURL_DEBUG_NO_WIN32_WND
38#endif
40void loghex(const unsigned char *buffer, ssize_t len)
42 char data[12000];
43 ssize_t i;
44 const unsigned char *ptr = buffer;
45 char *optr = data;
46 ssize_t width = 0;
47 int left = sizeof(data);
49 for(i = 0; i < len && (left > 2); i++) {
50 snprintf(optr, left, "%02x", ptr[i]);
51 width += 2;
52 optr += 2;
53 left -= 2;
54 }
55 if(width)
56 logmsg("'%s'", data);
59void logmsg(const char *msg, ...)
61 va_list ap;
62 char buffer[2048 + 1];
63 FILE *logfp;
64 struct curltime tv;
65 CURLcode result;
66 time_t sec;
67 struct tm now;
68 char timebuf[50];
69 static time_t epoch_offset;
70 static int known_offset;
72 if(!serverlogfile) {
73 fprintf(stderr, "Error: Server log file not set\n");
74 return;
75 }
77 tv = curlx_now();
78 if(!known_offset) {
79 epoch_offset = time(NULL) - tv.tv_sec;
80 known_offset = 1;
81 }
82 sec = epoch_offset + tv.tv_sec;
83 result = toolx_localtime(sec, &now);
84 if(result)
85 memset(&now, 0, sizeof(now));
87 snprintf(timebuf, sizeof(timebuf), "%02d:%02d:%02d.%06ld",
88 now.tm_hour, now.tm_min, now.tm_sec, (long)tv.tv_usec);
90 va_start(ap, msg);
91/* Suppress for builds where CURL_PRINTF() is not set */
92#ifdef CURL_HAVE_DIAG
93#pragma GCC diagnostic push
94#pragma GCC diagnostic ignored "-Wformat-nonliteral"
95#endif
96 vsnprintf(buffer, sizeof(buffer), msg, ap);
97#ifdef CURL_HAVE_DIAG
98#pragma GCC diagnostic pop
99#endif
100 va_end(ap);
102 do {
103 logfp = curlx_fopen(serverlogfile, "ab");
104 /* !checksrc! disable ERRNOVAR 1 */
105 } while(!logfp && (errno == EINTR));
106 if(logfp) {
107 fprintf(logfp, "%s %s\n", timebuf, buffer);
108 curlx_fclose(logfp);
109 }
110 else {
111 char errbuf[STRERROR_LEN];
112 int error = errno;
113 fprintf(stderr, "fopen() failed with error (%d) %s\n",
114 error, curlx_strerror(error, errbuf, sizeof(errbuf)));
115 fprintf(stderr, "Error opening file '%s'\n", serverlogfile);
116 fprintf(stderr, "Msg not logged: %s %s\n", timebuf, buffer);
117 }
120#ifdef _WIN32
121static void win32_cleanup(void)
123#ifdef USE_WINSOCK
124 WSACleanup();
125#endif
127 _flushall(); /* flush buffers of all streams regardless of their mode */
130int win32_init(void)
132 curlx_now_init();
133#ifdef USE_WINSOCK
134 {
135 WSADATA wsa;
136 if(WSAStartup(MAKEWORD(2, 2), &wsa)) {
137 char buffer[STRERROR_LEN];
138 curlx_strerror(SOCKERRNO, buffer, sizeof(buffer));
139 fprintf(stderr, "Winsock init failed: %s\n", buffer);
140 logmsg("Error initializing Winsock -- aborting");
141 return 1;
142 }
143 }
144#endif
145 atexit(win32_cleanup);
146 return 0;
148#endif /* _WIN32 */
150/* fopens the test case file */
151FILE *test2fopen(long testno, const char *logdir2)
153 FILE *stream;
154 char filename[256];
155 /* first try the alternative, preprocessed, file */
156 snprintf(filename, sizeof(filename), "%s/test%ld", logdir2, testno);
157 stream = curlx_fopen(filename, "rb");
159 return stream;
162#ifdef _WIN32
163#define t_getpid() GetCurrentProcessId()
164#else
165#define t_getpid() getpid()
166#endif
168curl_off_t our_getpid(void)
170 curl_off_t pid = (curl_off_t)t_getpid();
171#ifdef _WIN32
172 /* store pid + MAX_PID to avoid conflict with Cygwin/msys PIDs, see also:
173 * - 2019-01-31: https://cygwin.com/git/?p=newlib-cygwin.git;a=commit;h=b5e1003722cb14235c4f166be72c09acdffc62ea
174 * - 2019-02-02: https://cygwin.com/git/?p=newlib-cygwin.git;a=commit;h=448cf5aa4b429d5a9cebf92a0da4ab4b5b6d23fe
175 * - 2024-12-19: https://cygwin.com/git/?p=newlib-cygwin.git;a=commit;h=363357c023ce01e936bdaedf0f479292a8fa4e0f
176 */
177 pid += 4194304;
178#endif
179 return pid;
182int write_pidfile(const char *filename)
184 FILE *pidfile;
185 curl_off_t pid;
187 pid = our_getpid();
188 pidfile = curlx_fopen(filename, "wb");
189 if(!pidfile) {
190 char errbuf[STRERROR_LEN];
191 logmsg("Could not write pid file: %s (%d) %s", filename,
192 errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
193 return 0; /* fail */
194 }
195 fprintf(pidfile, "%ld\n", (long)pid);
196 curlx_fclose(pidfile);
197 logmsg("Wrote pid %ld to %s", (long)pid, filename);
198 return 1; /* success */
201/* store the used port number in a file */
202int write_portfile(const char *filename, int port)
204 FILE *portfile = curlx_fopen(filename, "wb");
205 if(!portfile) {
206 char errbuf[STRERROR_LEN];
207 logmsg("Could not write port file: %s (%d) %s", filename,
208 errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
209 return 0; /* fail */
210 }
211 fprintf(portfile, "%d\n", port);
212 curlx_fclose(portfile);
213 logmsg("Wrote port %d to %s", port, filename);
214 return 1; /* success */
217void set_advisor_read_lock(const char *filename)
219 FILE *lockfile;
220 int error = 0;
221 char errbuf[STRERROR_LEN];
223 do {
224 lockfile = curlx_fopen(filename, "wb");
225 /* !checksrc! disable ERRNOVAR 1 */
226 } while(!lockfile && ((error = errno) == EINTR));
227 if(!lockfile) {
228 logmsg("Error creating lock file %s error (%d) %s", filename,
229 error, curlx_strerror(error, errbuf, sizeof(errbuf)));
230 return;
231 }
233 if(curlx_fclose(lockfile))
234 logmsg("Error closing lock file %s error (%d) %s", filename,
235 errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
238void clear_advisor_read_lock(const char *filename)
240 int error = 0;
241 int rc;
243 /*
244 * Log all removal failures. Even those due to file not existing.
245 * This allows to detect if unexpectedly the file has already been
246 * removed by a process different than the one that should do this.
247 */
249 do {
250 rc = unlink(filename);
251 /* !checksrc! disable ERRNOVAR 1 */
252 } while(rc && ((error = errno) == EINTR));
253 if(rc) {
254 char errbuf[STRERROR_LEN];
255 logmsg("Error removing lock file %s error (%d) %s", filename,
256 error, curlx_strerror(error, errbuf, sizeof(errbuf)));
257 }
260/* store the entire request in a file */
261void storerequest(const char *reqbuf, size_t totalsize, const char *filename)
263 int error = 0;
264 char errbuf[STRERROR_LEN];
265 size_t written;
266 size_t writeleft;
267 FILE *dump;
268 char dumpfile[256];
270 snprintf(dumpfile, sizeof(dumpfile), "%s/%s", logdir, filename);
272 if(!reqbuf)
273 return;
274 if(totalsize == 0)
275 return;
277 do {
278 dump = curlx_fopen(dumpfile, "ab");
279 /* !checksrc! disable ERRNOVAR 1 */
280 } while(!dump && ((error = errno) == EINTR));
281 if(!dump) {
282 logmsg("storerequest: Error opening file %s error (%d) %s", dumpfile,
283 error, curlx_strerror(error, errbuf, sizeof(errbuf)));
284 return;
285 }
287 writeleft = totalsize;
288 do {
289 written = fwrite(&reqbuf[totalsize - writeleft], 1, writeleft, dump);
290 if(got_exit_signal)
291 goto storerequest_cleanup;
292 if(written > 0)
293 writeleft -= written;
294 error = errno;
295 /* !checksrc! disable ERRNOVAR 1 */
296 } while((writeleft > 0) && (error == EINTR));
298 if(writeleft == 0)
299 logmsg("Wrote request (%lu bytes) input to %s",
300 (unsigned long)totalsize, dumpfile);
301 else if(writeleft > 0) {
302 logmsg("Error writing file %s error (%d) %s", dumpfile,
303 error, curlx_strerror(error, errbuf, sizeof(errbuf)));
304 logmsg("Wrote only (%lu bytes) of (%lu bytes) request input to %s",
305 (unsigned long)(totalsize - writeleft), (unsigned long)totalsize,
306 dumpfile);
307 }
309storerequest_cleanup:
311 if(curlx_fclose(dump))
312 logmsg("Error closing file %s error (%d) %s", dumpfile,
313 errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
316static bool initiate_exit(int signum) /* keep signal-safe */
318 if(got_exit_signal == 0) {
319 got_exit_signal = 1;
320 exit_signal = signum;
321 }
322#ifdef _WIN32
323 if(!exit_event)
324 return FALSE;
325 (void)SetEvent(exit_event);
326#endif
327 return TRUE;
330#ifndef _WIN32
332/* vars used to keep around previous signal handlers */
334typedef void (*SIGHANDLER_T)(int);
336#ifdef SIGHUP
337static SIGHANDLER_T old_sighup_handler = SIG_ERR;
338#endif
339#ifdef SIGPIPE
340static SIGHANDLER_T old_sigpipe_handler = SIG_ERR;
341#endif
342#ifdef SIGALRM
343static SIGHANDLER_T old_sigalrm_handler = SIG_ERR;
344#endif
345#ifdef SIGINT
346static SIGHANDLER_T old_sigint_handler = SIG_ERR;
347#endif
348#ifdef SIGTERM
349static SIGHANDLER_T old_sigterm_handler = SIG_ERR;
350#endif
352/* signal handler that is triggered to indicate that the program
353 * should finish its execution in a controlled manner as soon as possible.
354 * The first time this is called it sets got_exit_signal to 1 and
355 * stores in exit_signal the signal that triggered its execution.
356 *
357 * Only call signal-safe functions from the signal handler, as required by
358 * the POSIX specification:
359 * https://pubs.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html#tag_02_04_03
360 * https://iafisher.com/2026/08/restart
361 * https://iafisher.com/2026/08/safe-signals
362 * https://lwn.net/Articles/414618/
363 */
364static void exit_signal_handler(int signum) /* keep signal-safe */
366 int old_errno = errno;
367 exit_msg = "exit_signal_handler(): triggered";
368 (void)initiate_exit(signum);
369#if !(defined(HAVE_SIGACTION) && defined(SA_RESTART))
370 (void)signal(signum, exit_signal_handler);
371#endif
372 errno = old_errno;
375static SIGHANDLER_T set_signal(int signum, SIGHANDLER_T handler, int norestart)
377#if defined(HAVE_SIGACTION) && defined(SA_RESTART)
378 struct sigaction sa, oldsa;
380 memset(&sa, 0, sizeof(sa));
381 sa.sa_handler = handler;
382 sigemptyset(&sa.sa_mask);
383 sigaddset(&sa.sa_mask, signum);
384 sa.sa_flags = norestart ? 0 : SA_RESTART;
386 if(sigaction(signum, &sa, &oldsa))
387 return SIG_ERR;
389 return oldsa.sa_handler;
390#else
391 SIGHANDLER_T oldhdlr = signal(signum, handler);
393#ifdef HAVE_SIGINTERRUPT
394 if(oldhdlr != SIG_ERR)
395 siginterrupt(signum, norestart);
396#else
397 (void)norestart;
398#endif
400 return oldhdlr;
401#endif
404#else /* _WIN32 */
406/* CTRL event handler for Windows Console applications to handle exit events.
407 *
408 * Background information from MSDN:
409 * When a CTRL+C interrupt occurs, Win32 operating systems generate a new
410 * thread to specifically handle that interrupt. This can cause a single-thread
411 * application, such as one in UNIX, to become multi-threaded and cause
412 * unexpected behavior.
413 */
414static BOOL WINAPI ctrl_event_handler(DWORD dwCtrlType) /* keep signal-safe */
416 static const char msgU[] = "ctrl_event_handler(): unhandled\n";
417 static const char msgH[] = "ctrl_event_handler(): handled\n";
418 static const char msgF[] = "ctrl_event_handler(): failed to handle\n";
419 HANDLE out = GetStdHandle(STD_ERROR_HANDLE);
420 DWORD dwWritten;
421 int signum = 0;
422 switch(dwCtrlType) {
423 case CTRL_C_EVENT:
424 signum = SIGINT;
425 break;
426 case CTRL_CLOSE_EVENT:
427 signum = SIGTERM;
428 break;
429 case CTRL_BREAK_EVENT:
430 signum = SIGBREAK;
431 break;
432 default:
433 WriteFile(out, msgU, CURL_CSTRLEN(msgU), &dwWritten, NULL);
434 exit_msg = msgU;
435 return FALSE;
436 }
437 if(!initiate_exit(signum)) {
438 WriteFile(out, msgF, CURL_CSTRLEN(msgF), &dwWritten, NULL);
439 exit_msg = msgF;
440 return FALSE;
441 }
442 WriteFile(out, msgH, CURL_CSTRLEN(msgH), &dwWritten, NULL);
443 exit_msg = msgH;
444 return TRUE;
447#ifndef CURL_DEBUG_NO_WIN32_WND
448static DWORD thread_main_id = 0;
449static HANDLE thread_main_window = NULL;
450static HWND hidden_main_window = NULL;
452/* Window message handler for Windows applications to add support
453 * for graceful process termination via taskkill (without /f) which
454 * sends WM_CLOSE to all Windows of a process (even hidden ones).
455 *
456 * Therefore we create and run a hidden Window in a separate thread
457 * to receive and handle the WM_CLOSE message as SIGTERM signal.
458 */
459static LRESULT CALLBACK main_window_proc(HWND hwnd, UINT uMsg,
460 WPARAM wParam, LPARAM lParam)
462 if(hwnd == hidden_main_window) {
463 switch(uMsg) {
464 case WM_CLOSE: {
465 static const char msg[] = "main_window_proc(): WM_CLOSE -> SIGTERM\n";
466 DWORD dwWritten;
467 WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, CURL_CSTRLEN(msg),
468 &dwWritten, NULL);
469 exit_msg = msg;
470 initiate_exit(SIGTERM);
471 break;
472 }
473 case WM_DESTROY:
474 PostQuitMessage(0);
475 break;
476 }
477 }
478 return DefWindowProc(hwnd, uMsg, wParam, lParam);
481/* Window message queue loop for hidden main window, details see above. */
482static DWORD WINAPI main_window_loop(void *lpParameter)
484 WNDCLASS wc;
485 BOOL ret;
486 MSG msg;
487 DWORD dwWritten;
489 ZeroMemory(&wc, sizeof(wc));
490 wc.lpfnWndProc = (WNDPROC)main_window_proc;
491 wc.hInstance = (HINSTANCE)lpParameter;
492 wc.lpszClassName = TEXT("MainWClass");
493 if(!RegisterClass(&wc)) {
494 static const char str[] = "RegisterClass() failed\n";
495 WriteFile(GetStdHandle(STD_ERROR_HANDLE), str, CURL_CSTRLEN(str),
496 &dwWritten, NULL);
497 return (DWORD)-1;
498 }
500 hidden_main_window = CreateWindowEx(0, TEXT("MainWClass"),
501 TEXT("Recv WM_CLOSE msg"),
502 WS_OVERLAPPEDWINDOW,
503 CW_USEDEFAULT, CW_USEDEFAULT,
504 CW_USEDEFAULT, CW_USEDEFAULT,
505 (HWND)NULL, (HMENU)NULL,
506 wc.hInstance, NULL);
507 if(!hidden_main_window) {
508 static const char str[] = "CreateWindowEx() failed\n";
509 WriteFile(GetStdHandle(STD_ERROR_HANDLE), str, CURL_CSTRLEN(str),
510 &dwWritten, NULL);
511 return (DWORD)-1;
512 }
514 do {
515 ret = GetMessage(&msg, NULL, 0, 0);
516 if(ret == -1) {
517 static const char str[] = "GetMessage() failed\n";
518 WriteFile(GetStdHandle(STD_ERROR_HANDLE), str, CURL_CSTRLEN(str),
519 &dwWritten, NULL);
520 return (DWORD)-1;
521 }
522 else if(ret) {
523 if(msg.message == WM_APP) {
524 DestroyWindow(hidden_main_window);
525 }
526 else if(msg.hwnd && !TranslateMessage(&msg)) {
527 DispatchMessage(&msg);
528 }
529 }
530 } while(ret);
532 hidden_main_window = NULL;
533 return (DWORD)msg.wParam;
535#endif /* !CURL_DEBUG_NO_WIN32_WND */
536#endif /* !_WIN32 */
538void install_signal_handlers(bool keep_sigalrm)
540 char errbuf[STRERROR_LEN];
541 (void)errbuf;
542 (void)keep_sigalrm;
543#ifndef _WIN32
544#ifdef SIGHUP
545 /* ignore SIGHUP signal */
546 old_sighup_handler = set_signal(SIGHUP, SIG_IGN, 0);
547 if(old_sighup_handler == SIG_ERR)
548 logmsg("cannot install SIGHUP handler: (%d) %s",
549 errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
550#endif
551#ifdef SIGPIPE
552 /* ignore SIGPIPE signal */
553 old_sigpipe_handler = set_signal(SIGPIPE, SIG_IGN, 0);
554 if(old_sigpipe_handler == SIG_ERR)
555 logmsg("cannot install SIGPIPE handler: (%d) %s",
556 errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
557#endif
558#ifdef SIGALRM
559 if(!keep_sigalrm) {
560 /* ignore SIGALRM signal */
561 old_sigalrm_handler = set_signal(SIGALRM, SIG_IGN, 0);
562 if(old_sigalrm_handler == SIG_ERR)
563 logmsg("cannot install SIGALRM handler: (%d) %s",
564 errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
565 }
566#endif
567#ifdef SIGINT
568 /* handle SIGINT signal with our exit_signal_handler */
569 old_sigint_handler = set_signal(SIGINT, exit_signal_handler, 1);
570 if(old_sigint_handler == SIG_ERR)
571 logmsg("cannot install SIGINT handler: (%d) %s",
572 errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
573#endif
574#ifdef SIGTERM
575 /* handle SIGTERM signal with our exit_signal_handler */
576 old_sigterm_handler = set_signal(SIGTERM, exit_signal_handler, 1);
577 if(old_sigterm_handler == SIG_ERR)
578 logmsg("cannot install SIGTERM handler: (%d) %s",
579 errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
580#endif
581#else /* _WIN32 */
582 /* setup Windows exit event before any signal can trigger */
583 exit_event = CreateEvent(NULL, TRUE, FALSE, NULL);
584 if(!exit_event)
585 logmsg("cannot create exit event");
586 if(!SetConsoleCtrlHandler(ctrl_event_handler, TRUE))
587 logmsg("cannot install CTRL event handler");
589#ifndef CURL_DEBUG_NO_WIN32_WND
590 thread_main_window = CreateThread(NULL, 0, &main_window_loop,
591 GetModuleHandle(NULL), 0, &thread_main_id);
592 if(!thread_main_window || !thread_main_id)
593 logmsg("cannot start main window loop");
594#endif
595#endif /* !_WIN32 */
598void restore_signal_handlers(bool keep_sigalrm)
600 (void)keep_sigalrm;
601#ifndef _WIN32
602#ifdef SIGHUP
603 if(old_sighup_handler != SIG_ERR)
604 (void)set_signal(SIGHUP, old_sighup_handler, 0);
605#endif
606#ifdef SIGPIPE
607 if(old_sigpipe_handler != SIG_ERR)
608 (void)set_signal(SIGPIPE, old_sigpipe_handler, 0);
609#endif
610#ifdef SIGALRM
611 if(!keep_sigalrm) {
612 if(old_sigalrm_handler != SIG_ERR)
613 (void)set_signal(SIGALRM, old_sigalrm_handler, 0);
614 }
615#endif
616#ifdef SIGINT
617 if(old_sigint_handler != SIG_ERR)
618 (void)set_signal(SIGINT, old_sigint_handler, 0);
619#endif
620#ifdef SIGTERM
621 if(old_sigterm_handler != SIG_ERR)
622 (void)set_signal(SIGTERM, old_sigterm_handler, 0);
623#endif
624#else /* _WIN32 */
625 (void)SetConsoleCtrlHandler(ctrl_event_handler, FALSE);
626#ifndef CURL_DEBUG_NO_WIN32_WND
627 if(thread_main_window && thread_main_id) {
628 if(PostThreadMessage(thread_main_id, WM_APP, 0, 0)) {
629 if(WaitForSingleObjectEx(thread_main_window, INFINITE, TRUE)) {
630 if(CloseHandle(thread_main_window)) {
631 thread_main_window = NULL;
632 thread_main_id = 0;
633 }
634 }
635 }
636 }
637#endif
638 if(exit_event && CloseHandle(exit_event))
639 exit_event = NULL;
640#endif /* !_WIN32 */
643#ifdef USE_UNIX_SOCKETS
645int bind_unix_socket(curl_socket_t sock, const char *unix_socket,
646 struct sockaddr_un *sau)
648 char errbuf[STRERROR_LEN];
649 int rc;
650 size_t len;
652 if(!unix_socket) {
653 logmsg("Unix socket domain path not specified.");
654 return -1;
655 }
657 len = strlen(unix_socket);
659 memset(sau, 0, sizeof(struct sockaddr_un));
660 sau->sun_family = AF_UNIX;
661 if(len >= sizeof(sau->sun_path) - 1) {
662 logmsg("Too long unix socket domain path (%lu)", (unsigned long)len);
663 return -1;
664 }
665 curlx_strcopy(sau->sun_path, sizeof(sau->sun_path), unix_socket, len);
666 rc = bind(sock, (struct sockaddr *)sau, sizeof(struct sockaddr_un));
667 if(rc && SOCKERRNO == SOCKEADDRINUSE) {
668 int sockerr;
669 /* socket already exists. Perhaps it is stale? */
670 curl_socket_t unixfd = socket(AF_UNIX, SOCK_STREAM, 0);
671 if(unixfd == CURL_SOCKET_BAD) {
672 sockerr = SOCKERRNO;
673 logmsg("Failed to create socket at %s (%d) %s", unix_socket,
674 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
675 return -1;
676 }
677 /* check whether the server is alive */
678 rc = connect(unixfd, (struct sockaddr*)sau, sizeof(struct sockaddr_un));
679 sockerr = SOCKERRNO;
680 sclose(unixfd);
681 if(rc && sockerr != SOCKECONNREFUSED) {
682 logmsg("Failed to connect to %s (%d) %s", unix_socket,
683 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
684 return rc;
685 }
686#if !defined(_WIN32) && defined(S_IFSOCK) /* No lstat(), S_IFSOCK on Windows */
687 /* socket server is not alive, now check if it was actually a socket. */
688 {
689 curlx_struct_stat statbuf;
690 rc = lstat(unix_socket, &statbuf);
691 if(rc && errno != ENOENT) {
692 logmsg("Error binding socket, failed to stat %s (%d) %s", unix_socket,
693 errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
694 return -1;
695 }
696 if(!rc && (statbuf.st_mode & S_IFMT) != S_IFSOCK) {
697 logmsg("Error binding socket, %s is not a socket", unix_socket);
698 return -1;
699 }
700 }
701#endif
702 /* dead socket, cleanup and retry bind */
703 if(unlink(unix_socket) && errno != ENOENT) {
704 logmsg("Error binding socket, failed to unlink %s: %d (%s)", unix_socket,
705 errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
706 return -1;
707 }
708 /* stale socket is gone, retry bind */
709 rc = bind(sock, (struct sockaddr *)sau, sizeof(struct sockaddr_un));
710 }
711 return rc;
713#endif
715curl_socket_t sockdaemon(curl_socket_t sock,
716 uint16_t *listenport,
717 const char *unix_socket,
718 bool bind_only)
720 /* passive daemon style */
721 srvr_sockaddr_union_t listener;
722 int flag;
723 int rc;
724 int totdelay = 0;
725 int maxretr = 10;
726 int delay = 20;
727 int attempt = 0;
728 int sockerr = 0;
729 char errbuf[STRERROR_LEN];
731#ifndef USE_UNIX_SOCKETS
732 (void)unix_socket;
733#endif
735#if defined(_WIN32) && defined(USE_UNIX_SOCKETS)
736 if(socket_domain != AF_UNIX) {
737#endif
738 do {
739 attempt++;
740 flag = 1;
741 rc = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
742 (void *)&flag, sizeof(flag));
743 if(rc) {
744 sockerr = SOCKERRNO;
745 logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
746 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
747 if(maxretr) {
748 if(curlx_wait_ms(delay)) {
749 /* should not happen */
750 sockerr = SOCKERRNO;
751 logmsg("curlx_wait_ms() failed with error (%d) %s",
752 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
753 sclose(sock);
754 return CURL_SOCKET_BAD;
755 }
756 if(got_exit_signal) {
757 logmsg("signalled to die, exiting...");
758 sclose(sock);
759 return CURL_SOCKET_BAD;
760 }
761 totdelay += delay;
762 delay *= 2; /* double the sleep for next attempt */
763 }
764 }
765 } while(rc && maxretr--);
767 if(rc) {
768 logmsg("setsockopt(SO_REUSEADDR) failed %d times in %d ms. "
769 "Error (%d) %s", attempt, totdelay,
770 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
771 logmsg("Continuing anyway...");
772 }
773#if defined(_WIN32) && defined(USE_UNIX_SOCKETS)
774 }
775#endif
777 /* When the specified listener port is zero, it is actually a
778 request to let the system choose a non-zero available port. */
780 switch(socket_domain) {
781 case AF_INET:
782 memset(&listener.sa4, 0, sizeof(listener.sa4));
783 listener.sa4.sin_family = AF_INET;
784 listener.sa4.sin_addr.s_addr = INADDR_ANY;
785 listener.sa4.sin_port = htons(*listenport);
786 rc = bind(sock, &listener.sa, sizeof(listener.sa4));
787 break;
788#ifdef USE_IPV6
789 case AF_INET6:
790 memset(&listener.sa6, 0, sizeof(listener.sa6));
791 listener.sa6.sin6_family = AF_INET6;
792 listener.sa6.sin6_addr = in6addr_any;
793 listener.sa6.sin6_port = htons(*listenport);
794 rc = bind(sock, &listener.sa, sizeof(listener.sa6));
795 break;
796#endif /* USE_IPV6 */
797#ifdef USE_UNIX_SOCKETS
798 case AF_UNIX:
799 rc = bind_unix_socket(sock, unix_socket, &listener.sau);
800 break;
801#endif
802 default:
803 rc = 1;
804 }
806 if(rc) {
807 sockerr = SOCKERRNO;
808#ifdef USE_UNIX_SOCKETS
809 if(socket_domain == AF_UNIX)
810 logmsg("Error binding socket on path %s (%d) %s", unix_socket,
811 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
812 else
813#endif
814 logmsg("Error binding socket on port %hu (%d) %s", *listenport,
815 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
816 sclose(sock);
817 return CURL_SOCKET_BAD;
818 }
820 if(!*listenport
821#ifdef USE_UNIX_SOCKETS
822 && !unix_socket
823#endif
824 ) {
825 /* The system was supposed to choose a port number, figure out which
826 port we actually got and update the listener port value with it. */
827 curl_socklen_t la_size;
828 srvr_sockaddr_union_t localaddr;
829 memset(&localaddr, 0, sizeof(localaddr));
830#ifdef USE_IPV6
831 if(socket_domain == AF_INET6)
832 la_size = sizeof(localaddr.sa6);
833 else
834#endif
835 la_size = sizeof(localaddr.sa4);
836 if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
837 sockerr = SOCKERRNO;
838 logmsg("getsockname() failed with error (%d) %s",
839 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
840 sclose(sock);
841 return CURL_SOCKET_BAD;
842 }
843 switch(localaddr.sa.sa_family) {
844 case AF_INET:
845 *listenport = ntohs(localaddr.sa4.sin_port);
846 break;
847#ifdef USE_IPV6
848 case AF_INET6:
849 *listenport = ntohs(localaddr.sa6.sin6_port);
850 break;
851#endif
852 default:
853 break;
854 }
855 if(!*listenport) {
856 /* Real failure, listener port shall not be zero beyond this point. */
857 logmsg("Apparently getsockname() succeeded, with listener port zero.");
858 logmsg("A valid reason for this failure is a binary built without");
859 logmsg("proper network library linkage. This might not be the only");
860 logmsg("reason, but double check it before anything else.");
861 sclose(sock);
862 return CURL_SOCKET_BAD;
863 }
864 }
866 /* bindonly option forces no listening */
867 if(bind_only) {
868 logmsg("instructed to bind port without listening");
869 return sock;
870 }
872 /* start accepting connections */
873 if(listen(sock, 5)) {
874 sockerr = SOCKERRNO;
875 logmsg("listen(%ld, 5) failed with error (%d) %s", (long)sock,
876 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
877 sclose(sock);
878 return CURL_SOCKET_BAD;
879 }
881 return sock;
884int open_udp_sock(curl_socket_t *psock, uint16_t *pport)
886 srvr_sockaddr_union_t me;
887 curl_socket_t sock = CURL_SOCKET_BAD;
888 uint16_t port = *pport;
889 int sockerr, flag, rc;
890 char errbuf[STRERROR_LEN];
891 int result = 0;
893 sock = socket(socket_domain, SOCK_DGRAM, 0);
895 if(sock == CURL_SOCKET_BAD) {
896 sockerr = SOCKERRNO;
897 logmsg("Error creating socket (%d) %s",
898 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
899 result = 1;
900 goto out;
901 }
903 flag = 1;
904 if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag))) {
905 sockerr = SOCKERRNO;
906 logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
907 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
908 result = 1;
909 goto out;
910 }
912#ifdef USE_IPV6
913 if(socket_domain == AF_INET6) {
914 memset(&me.sa6, 0, sizeof(me.sa6));
915 me.sa6.sin6_family = AF_INET6;
916 me.sa6.sin6_addr = in6addr_any;
917 me.sa6.sin6_port = htons(port);
918 rc = bind(sock, &me.sa, sizeof(me.sa6));
919 }
920 else
921#endif
922 {
923 memset(&me.sa4, 0, sizeof(me.sa4));
924 me.sa4.sin_family = AF_INET;
925 me.sa4.sin_addr.s_addr = INADDR_ANY;
926 me.sa4.sin_port = htons(port);
927 rc = bind(sock, &me.sa, sizeof(me.sa4));
928 }
929 if(rc) {
930 sockerr = SOCKERRNO;
931 logmsg("Error binding socket on port %hu (%d) %s", port,
932 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
933 result = 1;
934 goto out;
935 }
937 if(!port) {
938 /* The system was supposed to choose a port number, figure out which
939 port we actually got and update the listener port value with it. */
940 curl_socklen_t la_size;
941 srvr_sockaddr_union_t localaddr;
942 memset(&localaddr, 0, sizeof(localaddr));
943#ifdef USE_IPV6
944 if(socket_domain == AF_INET6)
945 la_size = sizeof(localaddr.sa6);
946 else
947#endif
948 la_size = sizeof(localaddr.sa4);
949 if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
950 sockerr = SOCKERRNO;
951 logmsg("getsockname() failed with error (%d) %s",
952 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
953 result = 1;
954 goto out;
955 }
956 switch(localaddr.sa.sa_family) {
957 case AF_INET:
958 port = ntohs(localaddr.sa4.sin_port);
959 break;
960#ifdef USE_IPV6
961 case AF_INET6:
962 port = ntohs(localaddr.sa6.sin6_port);
963 break;
964#endif
965 default:
966 break;
967 }
968 if(!port) {
969 /* Real failure, listener port shall not be zero beyond this point. */
970 logmsg("Apparently getsockname() succeeded, with listener port zero.");
971 logmsg("A valid reason for this failure is a binary built without");
972 logmsg("proper network library linkage. This might not be the only");
973 logmsg("reason, but double check it before anything else.");
974 result = 2;
975 goto out;
976 }
977 }
979out:
980 if(result) {
981 if(sock != CURL_SOCKET_BAD)
982 sclose(sock);
983 sock = CURL_SOCKET_BAD;
984 port = 0;
985 }
986 *psock = sock;
987 *pport = port;
988 return result;
991bool socket_domain_is_ip(void)
993 switch(socket_domain) {
994 case AF_INET:
995#ifdef USE_IPV6
996 case AF_INET6:
997#endif
998 return TRUE;
999 default:
1000 /* case AF_UNIX: */
1001 return FALSE;
1005int open_stream_sock(curl_socket_t *psock, uint16_t *pport)
1007 srvr_sockaddr_union_t me;
1008 char errbuf[STRERROR_LEN];
1009 int flag, sockerr, rc = 0;
1010 curl_socket_t sock = CURL_SOCKET_BAD;
1011 uint16_t port = *pport;
1012 int result = 0;
1014 sock = socket(socket_domain, SOCK_STREAM, 0);
1016 if(sock == CURL_SOCKET_BAD) {
1017 sockerr = SOCKERRNO;
1018 logmsg("Error creating socket (%d) %s",
1019 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
1020 result = 1;
1021 goto out;
1024#if defined(_WIN32) && defined(USE_UNIX_SOCKETS)
1025 if(socket_domain != AF_UNIX) {
1026#endif
1027 flag = 1;
1028 if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
1029 (void *)&flag, sizeof(flag))) {
1030 sockerr = SOCKERRNO;
1031 logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
1032 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
1033 result = 1;
1034 goto out;
1036#if defined(_WIN32) && defined(USE_UNIX_SOCKETS)
1038#endif
1039 if(curlx_nonblock(sock, TRUE)) {
1040 sockerr = SOCKERRNO;
1041 logmsg("curlx_nonblock failed with error (%d) %s",
1042 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
1043 result = 1;
1044 goto out;
1047 switch(socket_domain) {
1048 case AF_INET:
1049 memset(&me.sa4, 0, sizeof(me.sa4));
1050 me.sa4.sin_family = AF_INET;
1051 me.sa4.sin_addr.s_addr = INADDR_ANY;
1052 me.sa4.sin_port = htons(port);
1053 rc = bind(sock, &me.sa, sizeof(me.sa4));
1054 break;
1055#ifdef USE_IPV6
1056 case AF_INET6:
1057 memset(&me.sa6, 0, sizeof(me.sa6));
1058 me.sa6.sin6_family = AF_INET6;
1059 me.sa6.sin6_addr = in6addr_any;
1060 me.sa6.sin6_port = htons(port);
1061 rc = bind(sock, &me.sa, sizeof(me.sa6));
1062 break;
1063#endif /* USE_IPV6 */
1064#ifdef USE_UNIX_SOCKETS
1065 case AF_UNIX:
1066 rc = bind_unix_socket(sock, server_unix_socket, &me.sau);
1067#endif /* USE_UNIX_SOCKETS */
1069 if(rc) {
1070 sockerr = SOCKERRNO;
1071#ifdef USE_UNIX_SOCKETS
1072 if(socket_domain == AF_UNIX)
1073 logmsg("Error binding socket on path %s (%d) %s", server_unix_socket,
1074 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
1075 else
1076#endif
1077 logmsg("Error binding socket on port %hu (%d) %s", port,
1078 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
1079 result = 1;
1080 goto out;
1083 if(!port) {
1084 /* The system was supposed to choose a port number, figure out which
1085 port we actually got and update the listener port value with it. */
1086 curl_socklen_t la_size;
1087 srvr_sockaddr_union_t localaddr;
1088 memset(&localaddr, 0, sizeof(localaddr));
1089#ifdef USE_IPV6
1090 if(socket_domain == AF_INET6)
1091 la_size = sizeof(localaddr.sa6);
1092 else
1093#endif
1094 la_size = sizeof(localaddr.sa4);
1095 if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
1096 sockerr = SOCKERRNO;
1097 logmsg("getsockname() failed with error (%d) %s",
1098 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
1099 result = 1;
1100 goto out;
1103 switch(localaddr.sa.sa_family) {
1104 case AF_INET:
1105 port = ntohs(localaddr.sa4.sin_port);
1106 break;
1107#ifdef USE_IPV6
1108 case AF_INET6:
1109 port = ntohs(localaddr.sa6.sin6_port);
1110 break;
1111#endif
1112 default:
1113 break;
1115 if(!port) {
1116 /* Real failure, listener port shall not be zero beyond this point. */
1117 logmsg("Apparently getsockname() succeeded, with listener port zero.");
1118 logmsg("A valid reason for this failure is a binary built without");
1119 logmsg("proper network library linkage. This might not be the only");
1120 logmsg("reason, but double check it before anything else.");
1121 result = 1;
1122 goto out;
1125out:
1126 if(result) {
1127 if(sock != CURL_SOCKET_BAD)
1128 sclose(sock);
1129 sock = CURL_SOCKET_BAD;
1130 port = 0;
1132 *psock = sock;
1133 *pport = port;
1134 return result;
1137/* returns a socket handle, or 0 if there are no more waiting sockets,
1138 or < 0 if there was an error */
1139curl_socket_t accept_connection(curl_socket_t listen_sock)
1141 curl_socket_t msgsock = CURL_SOCKET_BAD;
1142 int sockerr;
1143 char errbuf[STRERROR_LEN];
1144 int flag = 1;
1146 msgsock = accept(listen_sock, NULL, NULL);
1148 if(got_exit_signal) {
1149 if(msgsock != CURL_SOCKET_BAD)
1150 sclose(msgsock);
1151 return CURL_SOCKET_BAD;
1154 if(msgsock == CURL_SOCKET_BAD) {
1155 sockerr = SOCKERRNO;
1156 if(SOCK_EAGAIN(sockerr)) {
1157 /* nothing to accept */
1158 return 0;
1160 logmsg("MAJOR ERROR, accept() failed with error (%d) %s",
1161 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
1162 return CURL_SOCKET_BAD;
1165 if(curlx_nonblock(msgsock, TRUE)) {
1166 sockerr = SOCKERRNO;
1167 logmsg("curlx_nonblock failed with error (%d) %s",
1168 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
1169 sclose(msgsock);
1170 return CURL_SOCKET_BAD;
1173#if defined(_WIN32) && defined(USE_UNIX_SOCKETS)
1174 if(socket_domain != AF_UNIX) {
1175#endif
1176 if(setsockopt(msgsock, SOL_SOCKET, SO_KEEPALIVE,
1177 (void *)&flag, sizeof(flag))) {
1178 sockerr = SOCKERRNO;
1179 logmsg("setsockopt(SO_KEEPALIVE) failed with error (%d) %s",
1180 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
1181 sclose(msgsock);
1182 return CURL_SOCKET_BAD;
1184#if defined(_WIN32) && defined(USE_UNIX_SOCKETS)
1186#endif
1188 /*
1189 * As soon as this server accepts a connection from the test harness it
1190 * must set the server logs advisor read lock to indicate that server
1191 * logs should not be read until this lock is removed by this server.
1192 */
1194 if(!serverlogslocked)
1195 set_advisor_read_lock(loglockfile);
1196 serverlogslocked += 1;
1198 logmsg("====> Client connect");
1200#if defined(TCP_NODELAY) && defined(CURL_TCP_NODELAY_SUPPORTED)
1201 if(socket_domain_is_ip()) {
1202 /*
1203 * Disable the Nagle algorithm to make it easier to send out a large
1204 * response in many small segments to torture the clients more.
1205 */
1206 if(setsockopt(msgsock, IPPROTO_TCP, TCP_NODELAY,
1207 (void *)&flag, sizeof(flag)))
1208 logmsg("====> TCP_NODELAY failed");
1210#endif
1212 return msgsock;
1215bool curlx_str_case_equal(const struct Curl_str *s1,
1216 const struct Curl_str *s2)
1218 return ((s1->len == s2->len) &&
1219 !CURL_STRNICMP(s1->str, s2->str, s1->len));
Diagnostics4 git calls · 437 ms
CallStatusSizeTime0437 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 · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
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=86
Open pack map
fetch2009.5 KiB431 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=431
git.response.bytes=9693
git.response.cache=MISS
git.response.duration_ms=431
git.fetch.wants=6175d2a5a16222e3e5481810b7da40da09aac6da
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=9693
git.pkt.payload.max=9672
git.sideband.band1.bytes=9671
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
a5e2b2ff8b0e994c
Request
af619f36…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format