![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to daemon_win32.cpp CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / smartmontools / os_win32|
Return to daemon_win32.cpp CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / smartmontools / os_win32 |
1.1 misho 1: /*
2: * os_win32/daemon_win32.cpp
3: *
4: * Home page of code is: http://smartmontools.sourceforge.net
5: *
6: * Copyright (C) 2004-11 Christian Franke <smartmontools-support@lists.sourceforge.net>
7: *
8: * This program is free software; you can redistribute it and/or modify
9: * it under the terms of the GNU General Public License as published by
10: * the Free Software Foundation; either version 2, or (at your option)
11: * any later version.
12: *
13: * You should have received a copy of the GNU General Public License
14: * (for example COPYING); if not, write to the Free
15: * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
16: *
17: */
18:
19: // Need MB_SERVICE_NOTIFICATION (NT4/2000/XP), IsDebuggerPresent() (Win98/ME/NT4/2000/XP)
20: #define WINVER 0x0400
21: #define _WIN32_WINNT WINVER
22:
23: #include <stdio.h>
24: #include <stdlib.h>
25: #include <signal.h>
26: #include <io.h>
27:
28: #define WIN32_LEAN_AND_MEAN
29: #include <windows.h>
30: #ifdef _DEBUG
31: #include <crtdbg.h>
32: #endif
33:
34: #include "daemon_win32.h"
35:
36: const char * daemon_win32_cpp_cvsid = "$Id: daemon_win32.cpp 3426 2011-10-06 18:23:15Z chrfranke $"
37: DAEMON_WIN32_H_CVSID;
38:
39:
40: /////////////////////////////////////////////////////////////////////////////
41:
42: #define ARGUSED(x) ((void)(x))
43:
44: // Prevent spawning of child process if debugging
45: #ifdef _DEBUG
46: #define debugging() IsDebuggerPresent()
47: #else
48: #define debugging() FALSE
49: #endif
50:
51:
52: #define EVT_NAME_LEN 260
53:
54: // Internal events (must be > SIGUSRn)
55: #define EVT_RUNNING 100 // Exists when running, signaled on creation
56: #define EVT_DETACHED 101 // Signaled when child detaches from console
57: #define EVT_RESTART 102 // Signaled when child should restart
58:
59: static void make_name(char * name, int sig)
60: {
61: int i;
62: if (!GetModuleFileNameA(NULL, name, EVT_NAME_LEN-10))
63: strcpy(name, "DaemonEvent");
64: for (i = 0; name[i]; i++) {
65: char c = name[i];
66: if (!( ('0' <= c && c <= '9')
67: || ('A' <= c && c <= 'Z')
68: || ('a' <= c && c <= 'z')))
69: name[i] = '_';
70: }
71: sprintf(name+strlen(name), "-%d", sig);
72: }
73:
74:
75: static HANDLE create_event(int sig, BOOL initial, BOOL errmsg, BOOL * exists)
76: {
77: char name[EVT_NAME_LEN];
78: HANDLE h;
79: if (sig >= 0)
80: make_name(name, sig);
81: else
82: name[0] = 0;
83: if (exists)
84: *exists = FALSE;
85: if (!(h = CreateEventA(NULL, FALSE, initial, (name[0] ? name : NULL)))) {
86: if (errmsg)
87: fprintf(stderr, "CreateEvent(.,\"%s\"): Error=%ld\n", name, GetLastError());
88: return 0;
89: }
90:
91: if (GetLastError() == ERROR_ALREADY_EXISTS) {
92: if (!exists) {
93: if (errmsg)
94: fprintf(stderr, "CreateEvent(.,\"%s\"): Exists\n", name);
95: CloseHandle(h);
96: return 0;
97: }
98: *exists = TRUE;
99: }
100: return h;
101: }
102:
103:
104: static HANDLE open_event(int sig)
105: {
106: char name[EVT_NAME_LEN];
107: make_name(name, sig);
108: return OpenEventA(EVENT_MODIFY_STATE, FALSE, name);
109: }
110:
111:
112: static int event_exists(int sig)
113: {
114: char name[EVT_NAME_LEN];
115: HANDLE h;
116: make_name(name, sig);
117: if (!(h = OpenEventA(EVENT_MODIFY_STATE, FALSE, name)))
118: return 0;
119: CloseHandle(h);
120: return 1;
121: }
122:
123:
124: static int sig_event(int sig)
125: {
126: char name[EVT_NAME_LEN];
127: HANDLE h;
128: make_name(name, sig);
129: if (!(h = OpenEventA(EVENT_MODIFY_STATE, FALSE, name))) {
130: make_name(name, EVT_RUNNING);
131: if (!(h = OpenEvent(EVENT_MODIFY_STATE, FALSE, name)))
132: return -1;
133: CloseHandle(h);
134: return 0;
135: }
136: SetEvent(h);
137: CloseHandle(h);
138: return 1;
139: }
140:
141:
142: static void daemon_help(FILE * f, const char * ident, const char * message)
143: {
144: fprintf(f,
145: "%s: %s.\n"
146: "Use \"%s status|stop|reload|restart|sigusr1|sigusr2\" to control daemon.\n",
147: ident, message, ident);
148: fflush(f);
149: }
150:
151:
152: /////////////////////////////////////////////////////////////////////////////
153: // Parent Process
154:
155:
156: static BOOL WINAPI parent_console_handler(DWORD event)
157: {
158: switch (event) {
159: case CTRL_C_EVENT:
160: case CTRL_BREAK_EVENT:
161: return TRUE; // Ignore
162: }
163: return FALSE; // continue with next handler ...
164: }
165:
166:
167: static int parent_main(HANDLE rev)
168: {
169: HANDLE dev;
170: HANDLE ht[2];
171: char * cmdline;
172: STARTUPINFO si;
173: PROCESS_INFORMATION pi;
174: DWORD rc, exitcode;
175:
176: // Ignore ^C, ^BREAK in parent
177: SetConsoleCtrlHandler(parent_console_handler, TRUE/*add*/);
178:
179: // Create event used by child to signal daemon_detach()
180: if (!(dev = create_event(EVT_DETACHED, FALSE/*not signaled*/, TRUE, NULL/*must not exist*/))) {
181: CloseHandle(rev);
182: return 101;
183: }
184:
185: // Restart process with same args
186: cmdline = GetCommandLineA();
187: memset(&si, 0, sizeof(si)); si.cb = sizeof(si);
188:
189: if (!CreateProcessA(
190: NULL, cmdline,
191: NULL, NULL, TRUE/*inherit*/,
192: 0, NULL, NULL, &si, &pi)) {
193: fprintf(stderr, "CreateProcess(.,\"%s\",.) failed, Error=%ld\n", cmdline, GetLastError());
194: CloseHandle(rev); CloseHandle(dev);
195: return 101;
196: }
197: CloseHandle(pi.hThread);
198:
199: // Wait for daemon_detach() or exit()
200: ht[0] = dev; ht[1] = pi.hProcess;
201: rc = WaitForMultipleObjects(2, ht, FALSE/*or*/, INFINITE);
202: if (!(/*WAIT_OBJECT_0(0) <= rc && */ rc < WAIT_OBJECT_0+2)) {
203: fprintf(stderr, "WaitForMultipleObjects returns %lX\n", rc);
204: TerminateProcess(pi.hProcess, 200);
205: }
206: CloseHandle(rev); CloseHandle(dev);
207:
208: // Get exit code
209: if (!GetExitCodeProcess(pi.hProcess, &exitcode))
210: exitcode = 201;
211: else if (exitcode == STILL_ACTIVE) // detach()ed, assume OK
212: exitcode = 0;
213:
214: CloseHandle(pi.hProcess);
215: return exitcode;
216: }
217:
218:
219: /////////////////////////////////////////////////////////////////////////////
220: // Child Process
221:
222:
223: static int svc_mode; // Running as service?
224: static int svc_paused; // Service paused?
225:
226: static void service_report_status(int state, int waithint);
227:
228:
229: // Tables of signal handler and corresponding events
230: typedef void (*sigfunc_t)(int);
231:
232: #define MAX_SIG_HANDLERS 8
233:
234: static int num_sig_handlers = 0;
235: static sigfunc_t sig_handlers[MAX_SIG_HANDLERS];
236: static int sig_numbers[MAX_SIG_HANDLERS];
237: static HANDLE sig_events[MAX_SIG_HANDLERS];
238:
239: static HANDLE sighup_handle, sigint_handle, sigbreak_handle;
240: static HANDLE sigterm_handle, sigusr1_handle;
241:
242: static HANDLE running_event;
243:
244: static int reopen_stdin, reopen_stdout, reopen_stderr;
245:
246:
247: // Handler for windows console events
248:
249: static BOOL WINAPI child_console_handler(DWORD event)
250: {
251: // Caution: runs in a new thread
252: // TODO: Guard with a mutex
253: HANDLE h = 0;
254: switch (event) {
255: case CTRL_C_EVENT: // <CONTROL-C> (SIGINT)
256: h = sigint_handle; break;
257: case CTRL_BREAK_EVENT: // <CONTROL-Break> (SIGBREAK/SIGQUIT)
258: case CTRL_CLOSE_EVENT: // User closed console or abort via task manager
259: h = sigbreak_handle; break;
260: case CTRL_LOGOFF_EVENT: // Logout/Shutdown (SIGTERM)
261: case CTRL_SHUTDOWN_EVENT:
262: h = sigterm_handle; break;
263: }
264: if (!h)
265: return FALSE; // continue with next handler
266: // Signal event
267: if (!SetEvent(h))
268: return FALSE;
269: return TRUE;
270: }
271:
272:
273: static void child_exit(void)
274: {
275: int i;
276: char * cmdline;
277: HANDLE rst;
278: STARTUPINFO si;
279: PROCESS_INFORMATION pi;
280:
281: for (i = 0; i < num_sig_handlers; i++)
282: CloseHandle(sig_events[i]);
283: num_sig_handlers = 0;
284: CloseHandle(running_event); running_event = 0;
285:
286: // Restart?
287: if (!(rst = open_event(EVT_RESTART)))
288: return; // No => normal exit
289:
290: // Yes => Signal exit and restart process
291: Sleep(500);
292: SetEvent(rst);
293: CloseHandle(rst);
294: Sleep(500);
295:
296: cmdline = GetCommandLineA();
297: memset(&si, 0, sizeof(si)); si.cb = sizeof(si);
298: si.dwFlags = STARTF_USESHOWWINDOW; si.wShowWindow = SW_HIDE;
299:
300: if (!CreateProcessA(
301: NULL, cmdline,
302: NULL, NULL, TRUE/*inherit*/,
303: 0, NULL, NULL, &si, &pi)) {
304: fprintf(stderr, "CreateProcess(.,\"%s\",.) failed, Error=%ld\n", cmdline, GetLastError());
305: }
306: CloseHandle(pi.hThread); CloseHandle(pi.hProcess);
307: }
308:
309: static int child_main(HANDLE hev,int (*main_func)(int, char **), int argc, char **argv)
310: {
311: // Keep EVT_RUNNING open until exit
312: running_event = hev;
313:
314: // Install console handler
315: SetConsoleCtrlHandler(child_console_handler, TRUE/*add*/);
316:
317: // Install restart handler
318: atexit(child_exit);
319:
320: // Continue in main_func() to do the real work
321: return main_func(argc, argv);
322: }
323:
324:
325: // Simulate signal()
326:
327: sigfunc_t daemon_signal(int sig, sigfunc_t func)
328: {
329: int i;
330: HANDLE h;
331: if (func == SIG_DFL || func == SIG_IGN)
332: return func; // TODO
333: for (i = 0; i < num_sig_handlers; i++) {
334: if (sig_numbers[i] == sig) {
335: sigfunc_t old = sig_handlers[i];
336: sig_handlers[i] = func;
337: return old;
338: }
339: }
340: if (num_sig_handlers >= MAX_SIG_HANDLERS)
341: return SIG_ERR;
342: if (!(h = create_event((!svc_mode ? sig : -1), FALSE, TRUE, NULL)))
343: return SIG_ERR;
344: sig_events[num_sig_handlers] = h;
345: sig_numbers[num_sig_handlers] = sig;
346: sig_handlers[num_sig_handlers] = func;
347: switch (sig) {
348: case SIGHUP: sighup_handle = h; break;
349: case SIGINT: sigint_handle = h; break;
350: case SIGTERM: sigterm_handle = h; break;
351: case SIGBREAK: sigbreak_handle = h; break;
352: case SIGUSR1: sigusr1_handle = h; break;
353: }
354: num_sig_handlers++;
355: return SIG_DFL;
356: }
357:
358:
359: // strsignal()
360:
361: const char * daemon_strsignal(int sig)
362: {
363: switch (sig) {
364: case SIGHUP: return "SIGHUP";
365: case SIGINT: return "SIGINT";
366: case SIGTERM: return "SIGTERM";
367: case SIGBREAK:return "SIGBREAK";
368: case SIGUSR1: return "SIGUSR1";
369: case SIGUSR2: return "SIGUSR2";
370: default: return "*UNKNOWN*";
371: }
372: }
373:
374:
375: // Simulate sleep()
376:
377: void daemon_sleep(int seconds)
378: {
379: do {
380: if (num_sig_handlers <= 0) {
381: Sleep(seconds*1000L);
382: }
383: else {
384: // Wait for any signal or timeout
385: DWORD rc = WaitForMultipleObjects(num_sig_handlers, sig_events,
386: FALSE/*OR*/, seconds*1000L);
387: if (rc != WAIT_TIMEOUT) {
388: if (!(/*WAIT_OBJECT_0(0) <= rc && */ rc < WAIT_OBJECT_0+(unsigned)num_sig_handlers)) {
389: fprintf(stderr,"WaitForMultipleObjects returns %lu\n", rc);
390: Sleep(seconds*1000L);
391: return;
392: }
393: // Call Handler
394: sig_handlers[rc-WAIT_OBJECT_0](sig_numbers[rc-WAIT_OBJECT_0]);
395: break;
396: }
397: }
398: } while (svc_paused);
399: }
400:
401:
402: // Disable/Enable console
403:
404: void daemon_disable_console()
405: {
406: SetConsoleCtrlHandler(child_console_handler, FALSE/*remove*/);
407: reopen_stdin = reopen_stdout = reopen_stderr = 0;
408: if (isatty(fileno(stdin))) {
409: fclose(stdin); reopen_stdin = 1;
410: }
411: if (isatty(fileno(stdout))) {
412: fclose(stdout); reopen_stdout = 1;
413: }
414: if (isatty(fileno(stderr))) {
415: fclose(stderr); reopen_stderr = 1;
416: }
417: FreeConsole();
418: SetConsoleCtrlHandler(child_console_handler, TRUE/*add*/);
419: }
420:
421: int daemon_enable_console(const char * title)
422: {
423: BOOL ok;
424: SetConsoleCtrlHandler(child_console_handler, FALSE/*remove*/);
425: ok = AllocConsole();
426: SetConsoleCtrlHandler(child_console_handler, TRUE/*add*/);
427: if (!ok)
428: return -1;
429: if (title)
430: SetConsoleTitleA(title);
431: if (reopen_stdin)
432: freopen("conin$", "r", stdin);
433: if (reopen_stdout)
434: freopen("conout$", "w", stdout);
435: if (reopen_stderr)
436: freopen("conout$", "w", stderr);
437: reopen_stdin = reopen_stdout = reopen_stderr = 0;
438: return 0;
439: }
440:
441:
442: // Detach daemon from console & parent
443:
444: int daemon_detach(const char * ident)
445: {
446: if (!svc_mode) {
447: if (ident) {
448: // Print help
449: FILE * f = ( isatty(fileno(stdout)) ? stdout
450: : isatty(fileno(stderr)) ? stderr : NULL);
451: if (f)
452: daemon_help(f, ident, "now detaches from console into background mode");
453: }
454: // Signal detach to parent
455: if (sig_event(EVT_DETACHED) != 1) {
456: if (!debugging())
457: return -1;
458: }
459: daemon_disable_console();
460: }
461: else {
462: // Signal end of initialization to service control manager
463: service_report_status(SERVICE_RUNNING, 0);
464: reopen_stdin = reopen_stdout = reopen_stderr = 1;
465: }
466:
467: return 0;
468: }
469:
470:
471: /////////////////////////////////////////////////////////////////////////////
472: // MessageBox
473:
474: #ifndef _MT
475: //MT runtime not necessary, because mbox_thread uses no unsafe lib functions
476: //#error Program must be linked with multithreaded runtime library
477: #endif
478:
479: static LONG mbox_count; // # mbox_thread()s
480: static HANDLE mbox_mutex; // Show 1 box at a time (not necessary for service)
481:
482: typedef struct mbox_args_s {
483: HANDLE taken; const char * title, * text; int mode;
484: } mbox_args;
485:
486:
487: // Thread to display one message box
488:
489: static ULONG WINAPI mbox_thread(LPVOID arg)
490: {
491: // Take args
492: mbox_args * mb = (mbox_args *)arg;
493: char title[100]; char text[1000]; int mode;
494: strncpy(title, mb->title, sizeof(title)-1); title[sizeof(title)-1] = 0;
495: strncpy(text , mb->text , sizeof(text )-1); text [sizeof(text )-1] = 0;
496: mode = mb->mode;
497: SetEvent(mb->taken);
498:
499: // Show only one box at a time
500: WaitForSingleObject(mbox_mutex, INFINITE);
501: MessageBoxA(NULL, text, title, mode);
502: ReleaseMutex(mbox_mutex);
503:
504: InterlockedDecrement(&mbox_count);
505: return 0;
506: }
507:
508:
509: // Display a message box
510: int daemon_messagebox(int system, const char * title, const char * text)
511: {
512: mbox_args mb;
513: HANDLE ht; DWORD tid;
514:
515: // Create mutex during first call
516: if (!mbox_mutex)
517: mbox_mutex = CreateMutex(NULL/*!inherit*/, FALSE/*!owned*/, NULL/*unnamed*/);
518:
519: // Allow at most 10 threads
520: if (InterlockedIncrement(&mbox_count) > 10) {
521: InterlockedDecrement(&mbox_count);
522: return -1;
523: }
524:
525: // Create thread
526: mb.taken = CreateEvent(NULL/*!inherit*/, FALSE, FALSE/*!signaled*/, NULL/*unnamed*/);
527: mb.mode = MB_OK|MB_ICONWARNING
528: |(svc_mode?MB_SERVICE_NOTIFICATION:0)
529: |(system?MB_SYSTEMMODAL:MB_APPLMODAL);
530: mb.title = title;
531: mb.text = text;
532: if (!(ht = CreateThread(NULL, 0, mbox_thread, &mb, 0, &tid)))
533: return -1;
534:
535: // Wait for args taken
536: if (WaitForSingleObject(mb.taken, 10000) != WAIT_OBJECT_0)
537: TerminateThread(ht, 0);
538: CloseHandle(mb.taken);
539: CloseHandle(ht);
540: return 0;
541: }
542:
543:
544: /////////////////////////////////////////////////////////////////////////////
545:
546: // Spawn a command and redirect <inpbuf >outbuf
547: // return command's exitcode or -1 on error
548:
549: int daemon_spawn(const char * cmd,
550: const char * inpbuf, int inpsize,
551: char * outbuf, int outsize )
552: {
553: HANDLE pipe_inp_r, pipe_inp_w, pipe_out_r, pipe_out_w, pipe_err_w, h;
554: char temp_path[MAX_PATH];
555: DWORD flags, num_io, exitcode;
556: int use_file, state, i;
557: SECURITY_ATTRIBUTES sa;
558: STARTUPINFO si; PROCESS_INFORMATION pi;
559: HANDLE self = GetCurrentProcess();
560:
561: if (GetVersion() & 0x80000000L) {
562: // Win9x/ME: A calling process never receives EOF if output of COMMAND.COM or
563: // any other DOS program is redirected via a pipe. Using a temp file instead.
564: use_file = 1; flags = DETACHED_PROCESS;
565: }
566: else {
567: // NT4/2000/XP: If DETACHED_PROCESS is used, CMD.EXE opens a new console window
568: // for each external command in a redirected .BAT file.
569: // Even (DETACHED_PROCESS|CREATE_NO_WINDOW) does not work.
570: use_file = 0; flags = CREATE_NO_WINDOW;
571: }
572:
573: // Create stdin pipe with inheritable read side
574: memset(&sa, 0, sizeof(sa)); sa.nLength = sizeof(sa);
575: sa.bInheritHandle = TRUE;
576: if (!CreatePipe(&pipe_inp_r, &h, &sa/*inherit*/, inpsize*2+13))
577: return -1;
578: if (!DuplicateHandle(self, h, self, &pipe_inp_w,
579: 0, FALSE/*!inherit*/, DUPLICATE_SAME_ACCESS|DUPLICATE_CLOSE_SOURCE)) {
580: CloseHandle(pipe_inp_r);
581: return -1;
582: }
583:
584: memset(&sa, 0, sizeof(sa)); sa.nLength = sizeof(sa);
585: sa.bInheritHandle = TRUE;
586: if (!use_file) {
587: // Create stdout pipe with inheritable write side
588: if (!CreatePipe(&h, &pipe_out_w, &sa/*inherit*/, outsize)) {
589: CloseHandle(pipe_inp_r); CloseHandle(pipe_inp_w);
590: return -1;
591: }
592: }
593: else {
594: // Create temp file with inheritable write handle
595: char temp_dir[MAX_PATH];
596: if (!GetTempPathA(sizeof(temp_dir), temp_dir))
597: strcpy(temp_dir, ".");
598: if (!GetTempFileNameA(temp_dir, "out"/*prefix*/, 0/*create unique*/, temp_path)) {
599: CloseHandle(pipe_inp_r); CloseHandle(pipe_inp_w);
600: return -1;
601: }
602: if ((h = CreateFileA(temp_path, GENERIC_READ|GENERIC_WRITE,
603: 0/*no sharing*/, &sa/*inherit*/, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE) {
604: CloseHandle(pipe_inp_r); CloseHandle(pipe_inp_w);
605: return -1;
606: }
607: if (!DuplicateHandle(self, h, self, &pipe_out_w,
608: GENERIC_WRITE, TRUE/*inherit*/, 0)) {
609: CloseHandle(h); CloseHandle(pipe_inp_r); CloseHandle(pipe_inp_w);
610: return -1;
611: }
612: }
613:
614: if (!DuplicateHandle(self, h, self, &pipe_out_r,
615: GENERIC_READ, FALSE/*!inherit*/, DUPLICATE_CLOSE_SOURCE)) {
616: CloseHandle(pipe_out_w); CloseHandle(pipe_inp_r); CloseHandle(pipe_inp_w);
617: return -1;
618: }
619:
620: // Create stderr handle as dup of stdout write side
621: if (!DuplicateHandle(self, pipe_out_w, self, &pipe_err_w,
622: 0, TRUE/*inherit*/, DUPLICATE_SAME_ACCESS)) {
623: CloseHandle(pipe_out_r); CloseHandle(pipe_out_w);
624: CloseHandle(pipe_inp_r); CloseHandle(pipe_inp_w);
625: return -1;
626: }
627:
628: // Create process with pipes/file as stdio
629: memset(&si, 0, sizeof(si)); si.cb = sizeof(si);
630: si.hStdInput = pipe_inp_r;
631: si.hStdOutput = pipe_out_w;
632: si.hStdError = pipe_err_w;
633: si.dwFlags = STARTF_USESTDHANDLES;
634: if (!CreateProcessA(
635: NULL, (char*)cmd,
636: NULL, NULL, TRUE/*inherit*/,
637: flags/*DETACHED_PROCESS or CREATE_NO_WINDOW*/,
638: NULL, NULL, &si, &pi)) {
639: CloseHandle(pipe_err_w);
640: CloseHandle(pipe_out_r); CloseHandle(pipe_out_w);
641: CloseHandle(pipe_inp_r); CloseHandle(pipe_inp_w);
642: return -1;
643: }
644: CloseHandle(pi.hThread);
645: // Close inherited handles
646: CloseHandle(pipe_inp_r);
647: CloseHandle(pipe_out_w);
648: CloseHandle(pipe_err_w);
649:
650: // Copy inpbuf to stdin
651: // convert \n => \r\n
652: for (i = 0; i < inpsize; ) {
653: int len = 0;
654: while (i+len < inpsize && inpbuf[i+len] != '\n')
655: len++;
656: if (len > 0)
657: WriteFile(pipe_inp_w, inpbuf+i, len, &num_io, NULL);
658: i += len;
659: if (i < inpsize) {
660: WriteFile(pipe_inp_w, "\r\n", 2, &num_io, NULL);
661: i++;
662: }
663: }
664: CloseHandle(pipe_inp_w);
665:
666: exitcode = 42;
667: for (state = 0; state < 2; state++) {
668: // stdout pipe: read pipe first
669: // stdout file: wait for process first
670: if (state == use_file) {
671: // Copy stdout to output buffer until full, rest to /dev/null
672: // convert \r\n => \n
673: if (use_file)
674: SetFilePointer(pipe_out_r, 0, NULL, FILE_BEGIN);
675: for (i = 0; ; ) {
676: char buf[256];
677: int j;
678: if (!ReadFile(pipe_out_r, buf, sizeof(buf), &num_io, NULL) || num_io == 0)
679: break;
680: for (j = 0; i < outsize-1 && j < (int)num_io; j++) {
681: if (buf[j] != '\r')
682: outbuf[i++] = buf[j];
683: }
684: }
685: outbuf[i] = 0;
686: CloseHandle(pipe_out_r);
687: if (use_file)
688: DeleteFileA(temp_path);
689: }
690: else {
691: // Wait for process exitcode
692: WaitForSingleObject(pi.hProcess, INFINITE);
693: GetExitCodeProcess(pi.hProcess, &exitcode);
694: CloseHandle(pi.hProcess);
695: }
696: }
697: return exitcode;
698: }
699:
700:
701: /////////////////////////////////////////////////////////////////////////////
702: // Initd Functions
703:
704: static int wait_signaled(HANDLE h, int seconds)
705: {
706: int i;
707: for (i = 0; ; ) {
708: if (WaitForSingleObject(h, 1000L) == WAIT_OBJECT_0)
709: return 0;
710: if (++i >= seconds)
711: return -1;
712: fputchar('.'); fflush(stdout);
713: }
714: }
715:
716:
717: static int wait_evt_running(int seconds, int exists)
718: {
719: int i;
720: if (event_exists(EVT_RUNNING) == exists)
721: return 0;
722: for (i = 0; ; ) {
723: Sleep(1000);
724: if (event_exists(EVT_RUNNING) == exists)
725: return 0;
726: if (++i >= seconds)
727: return -1;
728: fputchar('.'); fflush(stdout);
729: }
730: }
731:
732:
733: static int is_initd_command(char * s)
734: {
735: if (!strcmp(s, "status"))
736: return EVT_RUNNING;
737: if (!strcmp(s, "stop"))
738: return SIGTERM;
739: if (!strcmp(s, "reload"))
740: return SIGHUP;
741: if (!strcmp(s, "sigusr1"))
742: return SIGUSR1;
743: if (!strcmp(s, "sigusr2"))
744: return SIGUSR2;
745: if (!strcmp(s, "restart"))
746: return EVT_RESTART;
747: return -1;
748: }
749:
750:
751: static int initd_main(const char * ident, int argc, char **argv)
752: {
753: int rc;
754: if (argc < 2)
755: return -1;
756: if ((rc = is_initd_command(argv[1])) < 0)
757: return -1;
758: if (argc != 2) {
759: printf("%s: no arguments allowed for command %s\n", ident, argv[1]);
760: return 1;
761: }
762:
763: switch (rc) {
764: default:
765: case EVT_RUNNING:
766: printf("Checking for %s:", ident); fflush(stdout);
767: rc = event_exists(EVT_RUNNING);
768: puts(rc ? " running" : " not running");
769: return (rc ? 0 : 1);
770:
771: case SIGTERM:
772: printf("Stopping %s:", ident); fflush(stdout);
773: rc = sig_event(SIGTERM);
774: if (rc <= 0) {
775: puts(rc < 0 ? " not running" : " error");
776: return (rc < 0 ? 0 : 1);
777: }
778: rc = wait_evt_running(10, 0);
779: puts(!rc ? " done" : " timeout");
780: return (!rc ? 0 : 1);
781:
782: case SIGHUP:
783: printf("Reloading %s:", ident); fflush(stdout);
784: rc = sig_event(SIGHUP);
785: puts(rc > 0 ? " done" : rc == 0 ? " error" : " not running");
786: return (rc > 0 ? 0 : 1);
787:
788: case SIGUSR1:
789: case SIGUSR2:
790: printf("Sending SIGUSR%d to %s:", (rc-SIGUSR1+1), ident); fflush(stdout);
791: rc = sig_event(rc);
792: puts(rc > 0 ? " done" : rc == 0 ? " error" : " not running");
793: return (rc > 0 ? 0 : 1);
794:
795: case EVT_RESTART:
796: {
797: HANDLE rst;
798: printf("Stopping %s:", ident); fflush(stdout);
799: if (event_exists(EVT_DETACHED)) {
800: puts(" not detached, cannot restart");
801: return 1;
802: }
803: if (!(rst = create_event(EVT_RESTART, FALSE, FALSE, NULL))) {
804: puts(" error");
805: return 1;
806: }
807: rc = sig_event(SIGTERM);
808: if (rc <= 0) {
809: puts(rc < 0 ? " not running" : " error");
810: CloseHandle(rst);
811: return 1;
812: }
813: rc = wait_signaled(rst, 10);
814: CloseHandle(rst);
815: if (rc) {
816: puts(" timeout");
817: return 1;
818: }
819: puts(" done");
820: Sleep(100);
821:
822: printf("Starting %s:", ident); fflush(stdout);
823: rc = wait_evt_running(10, 1);
824: puts(!rc ? " done" : " error");
825: return (!rc ? 0 : 1);
826: }
827: }
828: }
829:
830:
831: /////////////////////////////////////////////////////////////////////////////
832: // Windows Service Functions
833:
834: int daemon_winsvc_exitcode; // Set by app to exit(code)
835:
836: static SERVICE_STATUS_HANDLE svc_handle;
837: static SERVICE_STATUS svc_status;
838:
839:
840: // Report status to SCM
841:
842: static void service_report_status(int state, int seconds)
843: {
844: // TODO: Avoid race
845: static DWORD checkpoint = 1;
846: static DWORD accept_more = SERVICE_ACCEPT_PARAMCHANGE; // Win2000/XP
847: svc_status.dwCurrentState = state;
848: svc_status.dwWaitHint = seconds*1000;
849: switch (state) {
850: default:
851: svc_status.dwCheckPoint = checkpoint++;
852: break;
853: case SERVICE_RUNNING:
854: case SERVICE_STOPPED:
855: svc_status.dwCheckPoint = 0;
856: }
857: switch (state) {
858: case SERVICE_START_PENDING:
859: case SERVICE_STOP_PENDING:
860: svc_status.dwControlsAccepted = 0;
861: break;
862: default:
863: svc_status.dwControlsAccepted =
864: SERVICE_ACCEPT_STOP|SERVICE_ACCEPT_SHUTDOWN|
865: SERVICE_ACCEPT_PAUSE_CONTINUE|accept_more;
866: break;
867: }
868: if (!SetServiceStatus(svc_handle, &svc_status)) {
869: if (svc_status.dwControlsAccepted & accept_more) {
870: // Retry without SERVICE_ACCEPT_PARAMCHANGE (WinNT4)
871: svc_status.dwControlsAccepted &= ~accept_more;
872: accept_more = 0;
873: SetServiceStatus(svc_handle, &svc_status);
874: }
875: }
876: }
877:
878:
879: // Control the service, called by SCM
880:
881: static void WINAPI service_control(DWORD ctrlcode)
882: {
883: switch (ctrlcode) {
884: case SERVICE_CONTROL_STOP:
885: case SERVICE_CONTROL_SHUTDOWN:
886: service_report_status(SERVICE_STOP_PENDING, 30);
887: svc_paused = 0;
888: SetEvent(sigterm_handle);
889: break;
890: case SERVICE_CONTROL_PARAMCHANGE: // Win2000/XP
891: service_report_status(svc_status.dwCurrentState, 0);
892: svc_paused = 0;
893: SetEvent(sighup_handle); // reload
894: break;
895: case SERVICE_CONTROL_PAUSE:
896: service_report_status(SERVICE_PAUSED, 0);
897: svc_paused = 1;
898: break;
899: case SERVICE_CONTROL_CONTINUE:
900: service_report_status(SERVICE_RUNNING, 0);
901: {
902: int was_paused = svc_paused;
903: svc_paused = 0;
904: SetEvent(was_paused ? sighup_handle : sigusr1_handle); // reload:recheck
905: }
906: break;
907: case SERVICE_CONTROL_INTERROGATE:
908: default: // unknown
909: service_report_status(svc_status.dwCurrentState, 0);
910: break;
911: }
912: }
913:
914:
915: // Exit handler for service
916:
917: static void service_exit(void)
918: {
919: // Close signal events
920: int i;
921: for (i = 0; i < num_sig_handlers; i++)
922: CloseHandle(sig_events[i]);
923: num_sig_handlers = 0;
924:
925: // Set exitcode
926: if (daemon_winsvc_exitcode) {
927: svc_status.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
928: svc_status.dwServiceSpecificExitCode = daemon_winsvc_exitcode;
929: }
930: // Report stopped
931: service_report_status(SERVICE_STOPPED, 0);
932: }
933:
934:
935: // Variables for passing main(argc, argv) from daemon_main to service_main()
936: static int (*svc_main_func)(int, char **);
937: static int svc_main_argc;
938: static char ** svc_main_argv;
939:
940: // Main function for service, called by service dispatcher
941:
942: static void WINAPI service_main(DWORD argc, LPSTR * argv)
943: {
944: char path[MAX_PATH], *p;
945: ARGUSED(argc);
946:
947: // Register control handler
948: svc_handle = RegisterServiceCtrlHandler(argv[0], service_control);
949:
950: // Init service status
951: svc_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS|SERVICE_INTERACTIVE_PROCESS;
952: service_report_status(SERVICE_START_PENDING, 10);
953:
954: // Service started in \windows\system32, change to .exe directory
955: if (GetModuleFileNameA(NULL, path, sizeof(path)) && (p = strrchr(path, '\\'))) {
956: *p = 0; SetCurrentDirectoryA(path);
957: }
958:
959: // Install exit handler
960: atexit(service_exit);
961:
962: // Do the real work, service status later updated by daemon_detach()
963: daemon_winsvc_exitcode = svc_main_func(svc_main_argc, svc_main_argv);
964:
965: exit(daemon_winsvc_exitcode);
966: // ... continued in service_exit()
967: }
968:
969:
970: /////////////////////////////////////////////////////////////////////////////
971: // Windows Service Admin Functions
972:
973: // Set Service description (Win2000/XP)
974:
975: static int svcadm_setdesc(SC_HANDLE hs, const char * desc)
976: {
977: HINSTANCE hdll;
978: BOOL (WINAPI * ChangeServiceConfig2A_p)(SC_HANDLE, DWORD, LPVOID);
979: BOOL ret;
980: if (!(hdll = LoadLibraryA("ADVAPI32.DLL")))
981: return FALSE;
982: if (!((ChangeServiceConfig2A_p = (BOOL (WINAPI *)(SC_HANDLE, DWORD, LPVOID))GetProcAddress(hdll, "ChangeServiceConfig2A"))))
983: ret = FALSE;
984: else {
985: SERVICE_DESCRIPTIONA sd = { (char *)desc };
986: ret = ChangeServiceConfig2A_p(hs, SERVICE_CONFIG_DESCRIPTION, &sd);
987: }
988: FreeLibrary(hdll);
989: return ret;
990: }
991:
992:
993: // Service install/remove commands
994:
995: static int svcadm_main(const char * ident, const daemon_winsvc_options * svc_opts,
996: int argc, char **argv )
997: {
998: int remove; long err;
999: SC_HANDLE hm, hs;
1000:
1001: if (argc < 2)
1002: return -1;
1003: if (!strcmp(argv[1], "install"))
1004: remove = 0;
1005: else if (!strcmp(argv[1], "remove")) {
1006: if (argc != 2) {
1007: printf("%s: no arguments allowed for command remove\n", ident);
1008: return 1;
1009: }
1010: remove = 1;
1011: }
1012: else
1013: return -1;
1014:
1015: printf("%s service %s:", (!remove?"Installing":"Removing"), ident); fflush(stdout);
1016:
1017: // Open SCM
1018: if (!(hm = OpenSCManager(NULL/*local*/, NULL/*default*/, SC_MANAGER_ALL_ACCESS))) {
1019: if ((err = GetLastError()) == ERROR_ACCESS_DENIED)
1020: puts(" access to SCManager denied");
1021: else if (err == ERROR_CALL_NOT_IMPLEMENTED)
1022: puts(" services not implemented on this version of Windows");
1023: else
1024: printf(" cannot open SCManager, Error=%ld\n", err);
1025: return 1;
1026: }
1027:
1028: if (!remove) {
1029: char path[MAX_PATH+100];
1030: int i;
1031: // Get program path
1032: if (!GetModuleFileNameA(NULL, path, MAX_PATH)) {
1033: printf(" unknown program path, Error=%ld\n", GetLastError());
1034: CloseServiceHandle(hm);
1035: return 1;
1036: }
1037: // Add quotes if necessary
1038: if (strchr(path, ' ')) {
1039: i = strlen(path);
1040: path[i+1] = '"'; path[i+2] = 0;
1041: while (--i >= 0)
1042: path[i+1] = path[i];
1043: path[0] = '"';
1044: }
1045: // Append options
1046: strcat(path, " "); strcat(path, svc_opts->cmd_opt);
1047: for (i = 2; i < argc; i++) {
1048: const char * s = argv[i];
1049: if (strlen(path)+1+1+strlen(s)+1 >= sizeof(path))
1050: break;
1051: // Add quotes if necessary
1052: if (strchr(s, ' ') && !strchr(s, '"')) {
1053: strcat(path, " \""); strcat(path, s); strcat(path, "\"");
1054: }
1055: else {
1056: strcat(path, " "); strcat(path, s);
1057: }
1058: }
1059: // Create
1060: if (!(hs = CreateService(hm,
1061: svc_opts->svcname, svc_opts->dispname,
1062: SERVICE_ALL_ACCESS,
1063: SERVICE_WIN32_OWN_PROCESS|SERVICE_INTERACTIVE_PROCESS,
1064: SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, path,
1065: NULL/*no load ordering*/, NULL/*no tag id*/,
1066: ""/*no depedencies*/, NULL/*local system account*/, NULL/*no pw*/))) {
1067: if ((err = GetLastError()) == ERROR_SERVICE_EXISTS)
1068: puts(" the service is already installed");
1069: else if (err == ERROR_SERVICE_MARKED_FOR_DELETE)
1070: puts(" service is still running and marked for deletion\n"
1071: "Stop the service and retry install");
1072: else
1073: printf(" failed, Error=%ld\n", err);
1074: CloseServiceHandle(hm);
1075: return 1;
1076: }
1077: // Set optional description
1078: if (svc_opts->descript)
1079: svcadm_setdesc(hs, svc_opts->descript);
1080: }
1081: else {
1082: // Open
1083: if (!(hs = OpenService(hm, svc_opts->svcname, SERVICE_ALL_ACCESS))) {
1084: puts(" not found");
1085: CloseServiceHandle(hm);
1086: return 1;
1087: }
1088: // TODO: Stop service if running
1089: // Remove
1090: if (!DeleteService(hs)) {
1091: if ((err = GetLastError()) == ERROR_SERVICE_MARKED_FOR_DELETE)
1092: puts(" service is still running and marked for deletion\n"
1093: "Stop the service to remove it");
1094: else
1095: printf(" failed, Error=%ld\n", err);
1096: CloseServiceHandle(hs); CloseServiceHandle(hm);
1097: return 1;
1098: }
1099: }
1100: puts(" done");
1101: CloseServiceHandle(hs); CloseServiceHandle(hm);
1102: return 0;
1103: }
1104:
1105:
1106: /////////////////////////////////////////////////////////////////////////////
1107: // Main Function
1108:
1109: // This function must be called from main()
1110: // main_func is the function doing the real work
1111:
1112: int daemon_main(const char * ident, const daemon_winsvc_options * svc_opts,
1113: int (*main_func)(int, char **), int argc, char **argv )
1114: {
1115: int rc;
1116: #ifdef _DEBUG
1117: // Enable Debug heap checks
1118: _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG)
1119: |_CRTDBG_ALLOC_MEM_DF|_CRTDBG_CHECK_ALWAYS_DF|_CRTDBG_LEAK_CHECK_DF);
1120: #endif
1121:
1122: // Check for [status|stop|reload|restart|sigusr1|sigusr2] parameters
1123: if ((rc = initd_main(ident, argc, argv)) >= 0)
1124: return rc;
1125: // Check for [install|remove] parameters
1126: if (svc_opts && (rc = svcadm_main(ident, svc_opts, argc, argv)) >= 0)
1127: return rc;
1128:
1129: // Run as service if svc_opts.cmd_opt is given as first(!) argument
1130: svc_mode = (svc_opts && argc >= 2 && !strcmp(argv[1], svc_opts->cmd_opt));
1131:
1132: if (!svc_mode) {
1133: // Daemon: Try to simulate a Unix-like daemon
1134: HANDLE rev;
1135: BOOL exists;
1136:
1137: // Create main event to detect process type:
1138: // 1. new: parent process => start child and wait for detach() or exit() of child.
1139: // 2. exists && signaled: child process => do the real work, signal detach() to parent
1140: // 3. exists && !signaled: already running => exit()
1141: if (!(rev = create_event(EVT_RUNNING, TRUE/*signaled*/, TRUE, &exists)))
1142: return 100;
1143:
1144: if (!exists && !debugging()) {
1145: // Event new => parent process
1146: return parent_main(rev);
1147: }
1148:
1149: if (WaitForSingleObject(rev, 0) == WAIT_OBJECT_0) {
1150: // Event was signaled => In child process
1151: return child_main(rev, main_func, argc, argv);
1152: }
1153:
1154: // Event no longer signaled => Already running!
1155: daemon_help(stdout, ident, "already running");
1156: CloseHandle(rev);
1157: return 1;
1158: }
1159: else {
1160: // Service: Start service_main() via SCM
1161: SERVICE_TABLE_ENTRY service_table[] = {
1162: { (char*)svc_opts->svcname, service_main }, { NULL, NULL }
1163: };
1164:
1165: svc_main_func = main_func;
1166: svc_main_argc = argc;
1167: svc_main_argv = argv;
1168: if (!StartServiceCtrlDispatcher(service_table)) {
1169: printf("%s: cannot dispatch service, Error=%ld\n"
1170: "Option \"%s\" cannot be used to start %s as a service from console.\n"
1171: "Use \"%s install ...\" to install the service\n"
1172: "and \"net start %s\" to start it.\n",
1173: ident, GetLastError(), svc_opts->cmd_opt, ident, ident, ident);
1174:
1175: #ifdef _DEBUG
1176: if (debugging())
1177: service_main(argc, argv);
1178: #endif
1179: return 100;
1180: }
1181: Sleep(1000);
1182: ExitThread(0); // Do not redo exit() processing
1183: /*NOTREACHED*/
1184: return 0;
1185: }
1186: }
1187:
1188:
1189: /////////////////////////////////////////////////////////////////////////////
1190: // Test Program
1191:
1192: #ifdef TEST
1193:
1194: static volatile sig_atomic_t caughtsig = 0;
1195:
1196: static void sig_handler(int sig)
1197: {
1198: caughtsig = sig;
1199: }
1200:
1201: static void test_exit(void)
1202: {
1203: printf("Main exit\n");
1204: }
1205:
1206: int test_main(int argc, char **argv)
1207: {
1208: int i;
1209: int debug = 0;
1210: char * cmd = 0;
1211:
1212: printf("PID=%ld\n", GetCurrentProcessId());
1213: for (i = 0; i < argc; i++) {
1214: printf("%d: \"%s\"\n", i, argv[i]);
1215: if (!strcmp(argv[i],"-d"))
1216: debug = 1;
1217: }
1218: if (argc > 1 && argv[argc-1][0] != '-')
1219: cmd = argv[argc-1];
1220:
1221: daemon_signal(SIGINT, sig_handler);
1222: daemon_signal(SIGBREAK, sig_handler);
1223: daemon_signal(SIGTERM, sig_handler);
1224: daemon_signal(SIGHUP, sig_handler);
1225: daemon_signal(SIGUSR1, sig_handler);
1226: daemon_signal(SIGUSR2, sig_handler);
1227:
1228: atexit(test_exit);
1229:
1230: if (!debug) {
1231: printf("Preparing to detach...\n");
1232: Sleep(2000);
1233: daemon_detach("test");
1234: printf("Detached!\n");
1235: }
1236:
1237: for (;;) {
1238: daemon_sleep(1);
1239: printf("."); fflush(stdout);
1240: if (caughtsig) {
1241: if (caughtsig == SIGUSR2) {
1242: debug ^= 1;
1243: if (debug)
1244: daemon_enable_console("Daemon[Debug]");
1245: else
1246: daemon_disable_console();
1247: }
1248: else if (caughtsig == SIGUSR1 && cmd) {
1249: char inpbuf[200], outbuf[1000]; int rc;
1250: strcpy(inpbuf, "Hello\nWorld!\n");
1251: rc = daemon_spawn(cmd, inpbuf, strlen(inpbuf), outbuf, sizeof(outbuf));
1252: if (!debug)
1253: daemon_enable_console("Command output");
1254: printf("\"%s\" returns %d\n", cmd, rc);
1255: if (rc >= 0)
1256: printf("output:\n%s.\n", outbuf);
1257: fflush(stdout);
1258: if (!debug) {
1259: Sleep(10000); daemon_disable_console();
1260: }
1261: }
1262: printf("[PID=%ld: Signal=%d]", GetCurrentProcessId(), caughtsig); fflush(stdout);
1263: if (caughtsig == SIGTERM || caughtsig == SIGBREAK)
1264: break;
1265: caughtsig = 0;
1266: }
1267: }
1268: printf("\nExiting on signal %d\n", caughtsig);
1269: return 0;
1270: }
1271:
1272:
1273: int main(int argc, char **argv)
1274: {
1275: static const daemon_winsvc_options svc_opts = {
1276: "-s", "test", "Test Service", "Service to test daemon_win32.c Module"
1277: };
1278:
1279: return daemon_main("testd", &svc_opts, test_main, argc, argv);
1280: }
1281:
1282: #endif