Annotation of embedaddon/curl/tests/server/util.c, revision 1.1.1.1
1.1 misho 1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2020, 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.haxx.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: ***************************************************************************/
22: #include "server_setup.h"
23:
24: #ifdef HAVE_SIGNAL_H
25: #include <signal.h>
26: #endif
27: #ifdef HAVE_NETINET_IN_H
28: #include <netinet/in.h>
29: #endif
30: #ifdef _XOPEN_SOURCE_EXTENDED
31: /* This define is "almost" required to build on HPUX 11 */
32: #include <arpa/inet.h>
33: #endif
34: #ifdef HAVE_NETDB_H
35: #include <netdb.h>
36: #endif
37: #ifdef HAVE_POLL_H
38: #include <poll.h>
39: #elif defined(HAVE_SYS_POLL_H)
40: #include <sys/poll.h>
41: #endif
42: #ifdef __MINGW32__
43: #include <w32api.h>
44: #endif
45:
46: #define ENABLE_CURLX_PRINTF
47: /* make the curlx header define all printf() functions to use the curlx_*
48: versions instead */
49: #include "curlx.h" /* from the private lib dir */
50: #include "getpart.h"
51: #include "util.h"
52: #include "timeval.h"
53:
54: #ifdef USE_WINSOCK
55: #undef EINTR
56: #define EINTR 4 /* errno.h value */
57: #undef EINVAL
58: #define EINVAL 22 /* errno.h value */
59: #endif
60:
61: /* MinGW with w32api version < 3.6 declared in6addr_any as extern,
62: but lacked the definition */
63: #if defined(ENABLE_IPV6) && defined(__MINGW32__)
64: #if (__W32API_MAJOR_VERSION < 3) || \
65: ((__W32API_MAJOR_VERSION == 3) && (__W32API_MINOR_VERSION < 6))
66: const struct in6_addr in6addr_any = {{ IN6ADDR_ANY_INIT }};
67: #endif /* w32api < 3.6 */
68: #endif /* ENABLE_IPV6 && __MINGW32__*/
69:
70: static struct timeval tvnow(void);
71:
72: /* This function returns a pointer to STATIC memory. It converts the given
73: * binary lump to a hex formatted string usable for output in logs or
74: * whatever.
75: */
76: char *data_to_hex(char *data, size_t len)
77: {
78: static char buf[256*3];
79: size_t i;
80: char *optr = buf;
81: char *iptr = data;
82:
83: if(len > 255)
84: len = 255;
85:
86: for(i = 0; i < len; i++) {
87: if((data[i] >= 0x20) && (data[i] < 0x7f))
88: *optr++ = *iptr++;
89: else {
90: msnprintf(optr, 4, "%%%02x", *iptr++);
91: optr += 3;
92: }
93: }
94: *optr = 0; /* in case no sprintf was used */
95:
96: return buf;
97: }
98:
99: void logmsg(const char *msg, ...)
100: {
101: va_list ap;
102: char buffer[2048 + 1];
103: FILE *logfp;
104: struct timeval tv;
105: time_t sec;
106: struct tm *now;
107: char timebuf[20];
108: static time_t epoch_offset;
109: static int known_offset;
110:
111: if(!serverlogfile) {
112: fprintf(stderr, "Error: serverlogfile not set\n");
113: return;
114: }
115:
116: tv = tvnow();
117: if(!known_offset) {
118: epoch_offset = time(NULL) - tv.tv_sec;
119: known_offset = 1;
120: }
121: sec = epoch_offset + tv.tv_sec;
122: now = localtime(&sec); /* not thread safe but we don't care */
123:
124: msnprintf(timebuf, sizeof(timebuf), "%02d:%02d:%02d.%06ld",
125: (int)now->tm_hour, (int)now->tm_min, (int)now->tm_sec,
126: (long)tv.tv_usec);
127:
128: va_start(ap, msg);
129: mvsnprintf(buffer, sizeof(buffer), msg, ap);
130: va_end(ap);
131:
132: logfp = fopen(serverlogfile, "ab");
133: if(logfp) {
134: fprintf(logfp, "%s %s\n", timebuf, buffer);
135: fclose(logfp);
136: }
137: else {
138: int error = errno;
139: fprintf(stderr, "fopen() failed with error: %d %s\n",
140: error, strerror(error));
141: fprintf(stderr, "Error opening file: %s\n", serverlogfile);
142: fprintf(stderr, "Msg not logged: %s %s\n", timebuf, buffer);
143: }
144: }
145:
146: #ifdef WIN32
147: /* use instead of perror() on generic windows */
148: void win32_perror(const char *msg)
149: {
150: char buf[512];
151: DWORD err = SOCKERRNO;
152:
153: if(!FormatMessageA((FORMAT_MESSAGE_FROM_SYSTEM |
154: FORMAT_MESSAGE_IGNORE_INSERTS), NULL, err,
155: LANG_NEUTRAL, buf, sizeof(buf), NULL))
156: msnprintf(buf, sizeof(buf), "Unknown error %lu (%#lx)", err, err);
157: if(msg)
158: fprintf(stderr, "%s: ", msg);
159: fprintf(stderr, "%s\n", buf);
160: }
161: #endif /* WIN32 */
162:
163: #ifdef USE_WINSOCK
164: void win32_init(void)
165: {
166: WORD wVersionRequested;
167: WSADATA wsaData;
168: int err;
169: wVersionRequested = MAKEWORD(USE_WINSOCK, USE_WINSOCK);
170:
171: err = WSAStartup(wVersionRequested, &wsaData);
172:
173: if(err != 0) {
174: perror("Winsock init failed");
175: logmsg("Error initialising winsock -- aborting");
176: exit(1);
177: }
178:
179: if(LOBYTE(wsaData.wVersion) != USE_WINSOCK ||
180: HIBYTE(wsaData.wVersion) != USE_WINSOCK) {
181: WSACleanup();
182: perror("Winsock init failed");
183: logmsg("No suitable winsock.dll found -- aborting");
184: exit(1);
185: }
186: }
187:
188: void win32_cleanup(void)
189: {
190: WSACleanup();
191: }
192: #endif /* USE_WINSOCK */
193:
194: /* set by the main code to point to where the test dir is */
195: const char *path = ".";
196:
197: FILE *test2fopen(long testno)
198: {
199: FILE *stream;
200: char filename[256];
201: /* first try the alternative, preprocessed, file */
202: msnprintf(filename, sizeof(filename), ALTTEST_DATA_PATH, path, testno);
203: stream = fopen(filename, "rb");
204: if(stream)
205: return stream;
206:
207: /* then try the source version */
208: msnprintf(filename, sizeof(filename), TEST_DATA_PATH, path, testno);
209: stream = fopen(filename, "rb");
210:
211: return stream;
212: }
213:
214: /*
215: * Portable function used for waiting a specific amount of ms.
216: * Waiting indefinitely with this function is not allowed, a
217: * zero or negative timeout value will return immediately.
218: *
219: * Return values:
220: * -1 = system call error, or invalid timeout value
221: * 0 = specified timeout has elapsed
222: */
223: int wait_ms(int timeout_ms)
224: {
225: #if !defined(MSDOS) && !defined(USE_WINSOCK)
226: #ifndef HAVE_POLL_FINE
227: struct timeval pending_tv;
228: #endif
229: struct timeval initial_tv;
230: int pending_ms;
231: #endif
232: int r = 0;
233:
234: if(!timeout_ms)
235: return 0;
236: if(timeout_ms < 0) {
237: errno = EINVAL;
238: return -1;
239: }
240: #if defined(MSDOS)
241: delay(timeout_ms);
242: #elif defined(USE_WINSOCK)
243: Sleep(timeout_ms);
244: #else
245: pending_ms = timeout_ms;
246: initial_tv = tvnow();
247: do {
248: int error;
249: #if defined(HAVE_POLL_FINE)
250: r = poll(NULL, 0, pending_ms);
251: #else
252: pending_tv.tv_sec = pending_ms / 1000;
253: pending_tv.tv_usec = (pending_ms % 1000) * 1000;
254: r = select(0, NULL, NULL, NULL, &pending_tv);
255: #endif /* HAVE_POLL_FINE */
256: if(r != -1)
257: break;
258: error = errno;
259: if(error && (error != EINTR))
260: break;
261: pending_ms = timeout_ms - (int)timediff(tvnow(), initial_tv);
262: if(pending_ms <= 0)
263: break;
264: } while(r == -1);
265: #endif /* USE_WINSOCK */
266: if(r)
267: r = -1;
268: return r;
269: }
270:
271: int write_pidfile(const char *filename)
272: {
273: FILE *pidfile;
274: curl_off_t pid;
275:
276: pid = (curl_off_t)getpid();
277: pidfile = fopen(filename, "wb");
278: if(!pidfile) {
279: logmsg("Couldn't write pid file: %s %s", filename, strerror(errno));
280: return 0; /* fail */
281: }
282: #if defined(WIN32) || defined(_WIN32)
283: /* store pid + 65536 to avoid conflict with Cygwin/msys PIDs, see also:
284: * - https://cygwin.com/git/?p=newlib-cygwin.git;a=commit; ↵
285: * h=b5e1003722cb14235c4f166be72c09acdffc62ea
286: * - https://cygwin.com/git/?p=newlib-cygwin.git;a=commit; ↵
287: * h=448cf5aa4b429d5a9cebf92a0da4ab4b5b6d23fe
288: */
289: pid += 65536;
290: #endif
291: fprintf(pidfile, "%" CURL_FORMAT_CURL_OFF_T "\n", pid);
292: fclose(pidfile);
293: logmsg("Wrote pid %ld to %s", pid, filename);
294: return 1; /* success */
295: }
296:
297: /* store the used port number in a file */
298: int write_portfile(const char *filename, int port)
299: {
300: FILE *portfile = fopen(filename, "wb");
301: if(!portfile) {
302: logmsg("Couldn't write port file: %s %s", filename, strerror(errno));
303: return 0; /* fail */
304: }
305: fprintf(portfile, "%d\n", port);
306: fclose(portfile);
307: logmsg("Wrote port %d to %s", port, filename);
308: return 1; /* success */
309: }
310:
311: void set_advisor_read_lock(const char *filename)
312: {
313: FILE *lockfile;
314: int error = 0;
315: int res;
316:
317: do {
318: lockfile = fopen(filename, "wb");
319: } while((lockfile == NULL) && ((error = errno) == EINTR));
320: if(lockfile == NULL) {
321: logmsg("Error creating lock file %s error: %d %s",
322: filename, error, strerror(error));
323: return;
324: }
325:
326: do {
327: res = fclose(lockfile);
328: } while(res && ((error = errno) == EINTR));
329: if(res)
330: logmsg("Error closing lock file %s error: %d %s",
331: filename, error, strerror(error));
332: }
333:
334: void clear_advisor_read_lock(const char *filename)
335: {
336: int error = 0;
337: int res;
338:
339: /*
340: ** Log all removal failures. Even those due to file not existing.
341: ** This allows to detect if unexpectedly the file has already been
342: ** removed by a process different than the one that should do this.
343: */
344:
345: do {
346: res = unlink(filename);
347: } while(res && ((error = errno) == EINTR));
348: if(res)
349: logmsg("Error removing lock file %s error: %d %s",
350: filename, error, strerror(error));
351: }
352:
353:
354: /* Portable, consistent toupper (remember EBCDIC). Do not use toupper() because
355: its behavior is altered by the current locale. */
356: static char raw_toupper(char in)
357: {
358: #if !defined(CURL_DOES_CONVERSIONS)
359: if(in >= 'a' && in <= 'z')
360: return (char)('A' + in - 'a');
361: #else
362: switch(in) {
363: case 'a':
364: return 'A';
365: case 'b':
366: return 'B';
367: case 'c':
368: return 'C';
369: case 'd':
370: return 'D';
371: case 'e':
372: return 'E';
373: case 'f':
374: return 'F';
375: case 'g':
376: return 'G';
377: case 'h':
378: return 'H';
379: case 'i':
380: return 'I';
381: case 'j':
382: return 'J';
383: case 'k':
384: return 'K';
385: case 'l':
386: return 'L';
387: case 'm':
388: return 'M';
389: case 'n':
390: return 'N';
391: case 'o':
392: return 'O';
393: case 'p':
394: return 'P';
395: case 'q':
396: return 'Q';
397: case 'r':
398: return 'R';
399: case 's':
400: return 'S';
401: case 't':
402: return 'T';
403: case 'u':
404: return 'U';
405: case 'v':
406: return 'V';
407: case 'w':
408: return 'W';
409: case 'x':
410: return 'X';
411: case 'y':
412: return 'Y';
413: case 'z':
414: return 'Z';
415: }
416: #endif
417:
418: return in;
419: }
420:
421: int strncasecompare(const char *first, const char *second, size_t max)
422: {
423: while(*first && *second && max) {
424: if(raw_toupper(*first) != raw_toupper(*second)) {
425: break;
426: }
427: max--;
428: first++;
429: second++;
430: }
431: if(0 == max)
432: return 1; /* they are equal this far */
433:
434: return raw_toupper(*first) == raw_toupper(*second);
435: }
436:
437: #if defined(WIN32) && !defined(MSDOS)
438:
439: static struct timeval tvnow(void)
440: {
441: /*
442: ** GetTickCount() is available on _all_ Windows versions from W95 up
443: ** to nowadays. Returns milliseconds elapsed since last system boot,
444: ** increases monotonically and wraps once 49.7 days have elapsed.
445: **
446: ** GetTickCount64() is available on Windows version from Windows Vista
447: ** and Windows Server 2008 up to nowadays. The resolution of the
448: ** function is limited to the resolution of the system timer, which
449: ** is typically in the range of 10 milliseconds to 16 milliseconds.
450: */
451: struct timeval now;
452: #if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600) && \
453: (!defined(__MINGW32__) || defined(__MINGW64_VERSION_MAJOR))
454: ULONGLONG milliseconds = GetTickCount64();
455: #else
456: DWORD milliseconds = GetTickCount();
457: #endif
458: now.tv_sec = (long)(milliseconds / 1000);
459: now.tv_usec = (long)((milliseconds % 1000) * 1000);
460: return now;
461: }
462:
463: #elif defined(HAVE_CLOCK_GETTIME_MONOTONIC)
464:
465: static struct timeval tvnow(void)
466: {
467: /*
468: ** clock_gettime() is granted to be increased monotonically when the
469: ** monotonic clock is queried. Time starting point is unspecified, it
470: ** could be the system start-up time, the Epoch, or something else,
471: ** in any case the time starting point does not change once that the
472: ** system has started up.
473: */
474: struct timeval now;
475: struct timespec tsnow;
476: if(0 == clock_gettime(CLOCK_MONOTONIC, &tsnow)) {
477: now.tv_sec = tsnow.tv_sec;
478: now.tv_usec = tsnow.tv_nsec / 1000;
479: }
480: /*
481: ** Even when the configure process has truly detected monotonic clock
482: ** availability, it might happen that it is not actually available at
483: ** run-time. When this occurs simply fallback to other time source.
484: */
485: #ifdef HAVE_GETTIMEOFDAY
486: else
487: (void)gettimeofday(&now, NULL);
488: #else
489: else {
490: now.tv_sec = (long)time(NULL);
491: now.tv_usec = 0;
492: }
493: #endif
494: return now;
495: }
496:
497: #elif defined(HAVE_GETTIMEOFDAY)
498:
499: static struct timeval tvnow(void)
500: {
501: /*
502: ** gettimeofday() is not granted to be increased monotonically, due to
503: ** clock drifting and external source time synchronization it can jump
504: ** forward or backward in time.
505: */
506: struct timeval now;
507: (void)gettimeofday(&now, NULL);
508: return now;
509: }
510:
511: #else
512:
513: static struct timeval tvnow(void)
514: {
515: /*
516: ** time() returns the value of time in seconds since the Epoch.
517: */
518: struct timeval now;
519: now.tv_sec = (long)time(NULL);
520: now.tv_usec = 0;
521: return now;
522: }
523:
524: #endif
525:
526: long timediff(struct timeval newer, struct timeval older)
527: {
528: timediff_t diff = newer.tv_sec-older.tv_sec;
529: if(diff >= (LONG_MAX/1000))
530: return LONG_MAX;
531: else if(diff <= (LONG_MIN/1000))
532: return LONG_MIN;
533: return (long)(newer.tv_sec-older.tv_sec)*1000+
534: (long)(newer.tv_usec-older.tv_usec)/1000;
535: }
536:
537: /* do-nothing macro replacement for systems which lack siginterrupt() */
538:
539: #ifndef HAVE_SIGINTERRUPT
540: #define siginterrupt(x,y) do {} while(0)
541: #endif
542:
543: /* vars used to keep around previous signal handlers */
544:
545: typedef RETSIGTYPE (*SIGHANDLER_T)(int);
546:
547: #ifdef SIGHUP
548: static SIGHANDLER_T old_sighup_handler = SIG_ERR;
549: #endif
550:
551: #ifdef SIGPIPE
552: static SIGHANDLER_T old_sigpipe_handler = SIG_ERR;
553: #endif
554:
555: #ifdef SIGALRM
556: static SIGHANDLER_T old_sigalrm_handler = SIG_ERR;
557: #endif
558:
559: #ifdef SIGINT
560: static SIGHANDLER_T old_sigint_handler = SIG_ERR;
561: #endif
562:
563: #ifdef SIGTERM
564: static SIGHANDLER_T old_sigterm_handler = SIG_ERR;
565: #endif
566:
567: #if defined(SIGBREAK) && defined(WIN32)
568: static SIGHANDLER_T old_sigbreak_handler = SIG_ERR;
569: #endif
570:
571: #ifdef WIN32
572: static DWORD thread_main_id = 0;
573: static HANDLE thread_main_window = NULL;
574: static HWND hidden_main_window = NULL;
575: #endif
576:
577: /* var which if set indicates that the program should finish execution */
578: volatile int got_exit_signal = 0;
579:
580: /* if next is set indicates the first signal handled in exit_signal_handler */
581: volatile int exit_signal = 0;
582:
583: /* signal handler that will be triggered to indicate that the program
584: * should finish its execution in a controlled manner as soon as possible.
585: * The first time this is called it will set got_exit_signal to one and
586: * store in exit_signal the signal that triggered its execution.
587: */
588: static RETSIGTYPE exit_signal_handler(int signum)
589: {
590: int old_errno = errno;
591: logmsg("exit_signal_handler: %d", signum);
592: if(got_exit_signal == 0) {
593: got_exit_signal = 1;
594: exit_signal = signum;
595: }
596: (void)signal(signum, exit_signal_handler);
597: errno = old_errno;
598: }
599:
600: #ifdef WIN32
601: /* CTRL event handler for Windows Console applications to simulate
602: * SIGINT, SIGTERM and SIGBREAK on CTRL events and trigger signal handler.
603: *
604: * Background information from MSDN:
605: * SIGINT is not supported for any Win32 application. When a CTRL+C
606: * interrupt occurs, Win32 operating systems generate a new thread
607: * to specifically handle that interrupt. This can cause a single-thread
608: * application, such as one in UNIX, to become multithreaded and cause
609: * unexpected behavior.
610: * [...]
611: * The SIGILL and SIGTERM signals are not generated under Windows.
612: * They are included for ANSI compatibility. Therefore, you can set
613: * signal handlers for these signals by using signal, and you can also
614: * explicitly generate these signals by calling raise. Source:
615: * https://docs.microsoft.com/de-de/cpp/c-runtime-library/reference/signal
616: */
617: static BOOL WINAPI ctrl_event_handler(DWORD dwCtrlType)
618: {
619: int signum = 0;
620: logmsg("ctrl_event_handler: %d", dwCtrlType);
621: switch(dwCtrlType) {
622: #ifdef SIGINT
623: case CTRL_C_EVENT: signum = SIGINT; break;
624: #endif
625: #ifdef SIGTERM
626: case CTRL_CLOSE_EVENT: signum = SIGTERM; break;
627: #endif
628: #ifdef SIGBREAK
629: case CTRL_BREAK_EVENT: signum = SIGBREAK; break;
630: #endif
631: default: return FALSE;
632: }
633: if(signum) {
634: logmsg("ctrl_event_handler: %d -> %d", dwCtrlType, signum);
635: exit_signal_handler(signum);
636: }
637: return TRUE;
638: }
639: /* Window message handler for Windows applications to add support
640: * for graceful process termination via taskkill (without /f) which
641: * sends WM_CLOSE to all Windows of a process (even hidden ones).
642: *
643: * Therefore we create and run a hidden Window in a separate thread
644: * to receive and handle the WM_CLOSE message as SIGTERM signal.
645: */
646: static LRESULT CALLBACK main_window_proc(HWND hwnd, UINT uMsg,
647: WPARAM wParam, LPARAM lParam)
648: {
649: int signum = 0;
650: if(hwnd == hidden_main_window) {
651: switch(uMsg) {
652: #ifdef SIGTERM
653: case WM_CLOSE: signum = SIGTERM; break;
654: #endif
655: case WM_DESTROY: PostQuitMessage(0); break;
656: }
657: if(signum) {
658: logmsg("main_window_proc: %d -> %d", uMsg, signum);
659: exit_signal_handler(signum);
660: }
661: }
662: return DefWindowProc(hwnd, uMsg, wParam, lParam);
663: }
664: /* Window message queue loop for hidden main window, details see above.
665: */
666: static DWORD WINAPI main_window_loop(LPVOID lpParameter)
667: {
668: WNDCLASS wc;
669: BOOL ret;
670: MSG msg;
671:
672: ZeroMemory(&wc, sizeof(wc));
673: wc.lpfnWndProc = (WNDPROC)main_window_proc;
674: wc.hInstance = (HINSTANCE)lpParameter;
675: wc.lpszClassName = "MainWClass";
676: if(!RegisterClass(&wc)) {
677: perror("RegisterClass failed");
678: return (DWORD)-1;
679: }
680:
681: hidden_main_window = CreateWindowEx(0, "MainWClass", "Recv WM_CLOSE msg",
682: WS_OVERLAPPEDWINDOW,
683: CW_USEDEFAULT, CW_USEDEFAULT,
684: CW_USEDEFAULT, CW_USEDEFAULT,
685: (HWND)NULL, (HMENU)NULL,
686: wc.hInstance, (LPVOID)NULL);
687: if(!hidden_main_window) {
688: perror("CreateWindowEx failed");
689: return (DWORD)-1;
690: }
691:
692: do {
693: ret = GetMessage(&msg, NULL, 0, 0);
694: if(ret == -1) {
695: perror("GetMessage failed");
696: return (DWORD)-1;
697: }
698: else if(ret) {
699: if(msg.message == WM_APP) {
700: DestroyWindow(hidden_main_window);
701: }
702: else if(msg.hwnd && !TranslateMessage(&msg)) {
703: DispatchMessage(&msg);
704: }
705: }
706: } while(ret);
707:
708: hidden_main_window = NULL;
709: return (DWORD)msg.wParam;
710: }
711: #endif
712:
713: void install_signal_handlers(bool keep_sigalrm)
714: {
715: #ifdef SIGHUP
716: /* ignore SIGHUP signal */
717: old_sighup_handler = signal(SIGHUP, SIG_IGN);
718: if(old_sighup_handler == SIG_ERR)
719: logmsg("cannot install SIGHUP handler: %s", strerror(errno));
720: #endif
721: #ifdef SIGPIPE
722: /* ignore SIGPIPE signal */
723: old_sigpipe_handler = signal(SIGPIPE, SIG_IGN);
724: if(old_sigpipe_handler == SIG_ERR)
725: logmsg("cannot install SIGPIPE handler: %s", strerror(errno));
726: #endif
727: #ifdef SIGALRM
728: if(!keep_sigalrm) {
729: /* ignore SIGALRM signal */
730: old_sigalrm_handler = signal(SIGALRM, SIG_IGN);
731: if(old_sigalrm_handler == SIG_ERR)
732: logmsg("cannot install SIGALRM handler: %s", strerror(errno));
733: }
734: #else
735: (void)keep_sigalrm;
736: #endif
737: #ifdef SIGINT
738: /* handle SIGINT signal with our exit_signal_handler */
739: old_sigint_handler = signal(SIGINT, exit_signal_handler);
740: if(old_sigint_handler == SIG_ERR)
741: logmsg("cannot install SIGINT handler: %s", strerror(errno));
742: else
743: siginterrupt(SIGINT, 1);
744: #endif
745: #ifdef SIGTERM
746: /* handle SIGTERM signal with our exit_signal_handler */
747: old_sigterm_handler = signal(SIGTERM, exit_signal_handler);
748: if(old_sigterm_handler == SIG_ERR)
749: logmsg("cannot install SIGTERM handler: %s", strerror(errno));
750: else
751: siginterrupt(SIGTERM, 1);
752: #endif
753: #if defined(SIGBREAK) && defined(WIN32)
754: /* handle SIGBREAK signal with our exit_signal_handler */
755: old_sigbreak_handler = signal(SIGBREAK, exit_signal_handler);
756: if(old_sigbreak_handler == SIG_ERR)
757: logmsg("cannot install SIGBREAK handler: %s", strerror(errno));
758: else
759: siginterrupt(SIGBREAK, 1);
760: #endif
761: #ifdef WIN32
762: if(!SetConsoleCtrlHandler(ctrl_event_handler, TRUE))
763: logmsg("cannot install CTRL event handler");
764: thread_main_window = CreateThread(NULL, 0,
765: &main_window_loop,
766: (LPVOID)GetModuleHandle(NULL),
767: 0, &thread_main_id);
768: if(!thread_main_window || !thread_main_id)
769: logmsg("cannot start main window loop");
770: #endif
771: }
772:
773: void restore_signal_handlers(bool keep_sigalrm)
774: {
775: #ifdef SIGHUP
776: if(SIG_ERR != old_sighup_handler)
777: (void)signal(SIGHUP, old_sighup_handler);
778: #endif
779: #ifdef SIGPIPE
780: if(SIG_ERR != old_sigpipe_handler)
781: (void)signal(SIGPIPE, old_sigpipe_handler);
782: #endif
783: #ifdef SIGALRM
784: if(!keep_sigalrm) {
785: if(SIG_ERR != old_sigalrm_handler)
786: (void)signal(SIGALRM, old_sigalrm_handler);
787: }
788: #else
789: (void)keep_sigalrm;
790: #endif
791: #ifdef SIGINT
792: if(SIG_ERR != old_sigint_handler)
793: (void)signal(SIGINT, old_sigint_handler);
794: #endif
795: #ifdef SIGTERM
796: if(SIG_ERR != old_sigterm_handler)
797: (void)signal(SIGTERM, old_sigterm_handler);
798: #endif
799: #if defined(SIGBREAK) && defined(WIN32)
800: if(SIG_ERR != old_sigbreak_handler)
801: (void)signal(SIGBREAK, old_sigbreak_handler);
802: #endif
803: #ifdef WIN32
804: (void)SetConsoleCtrlHandler(ctrl_event_handler, FALSE);
805: if(thread_main_window && thread_main_id) {
806: if(PostThreadMessage(thread_main_id, WM_APP, 0, 0))
807: (void)WaitForSingleObjectEx(thread_main_window, INFINITE, TRUE);
808: }
809: #endif
810: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to util.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / tests / server