Don't cast returns from malloc()
[openafs.git] / src / procmgmt / procmgmt_nt.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12 #include <afs/stds.h>
13
14 #include "procmgmt.h" /* Must be before roken */
15
16 #include <roken.h>
17
18 #include <windows.h>
19 #include <pthread.h>
20 #include <afs/errmap_nt.h>
21 #include <afs/secutil_nt.h>
22
23 #include "pmgtprivate.h"
24
25 /* Signal disposition table and associated definitions and locks */
26
27 typedef struct {
28     struct sigaction action;    /* signal action information */
29 } sigtable_entry_t;
30
31 static sigtable_entry_t signalTable[NSIG];      /* signal table; slot 0 unused */
32 static pthread_mutex_t signalTableLock; /* lock protects signalTable */
33
34 /* Global signal block lock; all signal handlers are serialized for now */
35 static pthread_mutex_t signalBlockLock;
36
37 /* Named pipe prefix for sending signals */
38 #define PMGT_SIGNAL_PIPE_PREFIX  "\\\\.\\pipe\\TransarcAfsSignalPipe"
39
40 /* Macro to test process exit status for an uncaught exception */
41 #define PMGT_IS_EXPSTATUS(status)   (((status) & 0xF0000000) == 0xC0000000)
42
43
44
45 /* Child process table and associated definitions and locks */
46
47 typedef struct {
48     HANDLE p_handle;            /* process handle (NULL if table entry not valid) */
49     BOOL p_reserved;            /* table entry is reserved for spawn */
50     DWORD p_id;                 /* process id */
51     BOOL p_terminated;          /* process terminated; status available/valid */
52     DWORD p_status;             /* status of terminated process */
53 } proctable_entry_t;
54
55 /* Max number of active child processes supported */
56 #define PMGT_CHILD_MAX  100
57
58 static proctable_entry_t procTable[PMGT_CHILD_MAX];     /* child process table */
59 static int procEntryCount;      /* count of valid entries in procTable */
60 static int procTermCount;       /* count of terminated entries in procTable */
61
62 /* lock protects procTable, procEntryCount, and procTermCount */
63 static pthread_mutex_t procTableLock;
64
65 /* Named shared memory prefix for passing a data buffer to a child process */
66 #define PMGT_DATA_MEM_PREFIX  "TransarcAfsSpawnDataMemory"
67
68 /* Named event prefix for indicating that a data buffer has been read */
69 #define PMGT_DATA_EVENT_PREFIX  "TransarcAfsSpawnDataEvent"
70
71 /* event signals termination of a child process */
72 static pthread_cond_t childTermEvent;
73
74
75 /* Exported data values */
76
77 void *pmgt_spawnData = NULL;
78 size_t pmgt_spawnDataLen = 0;
79
80
81 /* General definitions */
82
83 #define DWORD_OF_ONES   ((DWORD)0xFFFFFFFF)     /* a common Win32 failure code */
84
85
86
87
88
89
90 /* -----------------  Signals  ---------------- */
91
92
93 /*
94  * SignalIsDefined() -- Determine if an integer value corresponds to a
95  *     signal value defined for this platform.
96  */
97 static int
98 SignalIsDefined(int signo)
99 {
100     int isDefined = 0;
101
102     if (signo >= 1 && signo <= (NSIG - 1)) {
103         /* value is in valid range; check specifics */
104         switch (signo) {
105         case SIGHUP:
106         case SIGINT:
107         case SIGQUIT:
108         case SIGILL:
109         case SIGABRT:
110         case SIGFPE:
111         case SIGKILL:
112         case SIGSEGV:
113         case SIGTERM:
114         case SIGUSR1:
115         case SIGUSR2:
116         case SIGCHLD:
117         case SIGTSTP:
118             isDefined = 1;
119             break;
120         }
121     }
122     return isDefined;
123 }
124
125
126 /*
127  * DefaultActionHandler() -- Execute the default action for the given signal.
128  */
129 static void __cdecl
130 DefaultActionHandler(int signo)
131 {
132     switch (signo) {
133     case SIGHUP:
134     case SIGINT:
135     case SIGKILL:
136     case SIGQUIT:
137     case SIGTERM:
138         /* default action is "exit" */
139         ExitProcess(PMGT_SIGSTATUS_ENCODE(signo));
140         break;
141     case SIGILL:
142     case SIGABRT:
143     case SIGFPE:
144     case SIGSEGV:
145         /* default action is "core" */
146         /* Best we can do is to raise an exception that can be caught by
147          * Dr. Watson, which can in turn generate a crash dump file.
148          * The default exception handler will call ExitProcess() with
149          * our application-specific exception code.
150          */
151         RaiseException((DWORD) PMGT_SIGSTATUS_ENCODE(signo),
152                        EXCEPTION_NONCONTINUABLE, 0, NULL);
153         break;
154     case SIGUSR1:
155     case SIGUSR2:
156     case SIGCHLD:
157         /* default action is "ignore" */
158         break;
159     case SIGTSTP:
160         /* default action is "stop" */
161         /* No good way to implement this from inside a process so ignore */
162         break;
163     default:
164         /* no default action for specified signal value; just ignore */
165         break;
166     }
167 }
168
169
170 /*
171  * ProcessSignal() -- Execute the specified or default handler for the given
172  *     signal; reset the signal's disposition to SIG_DFL if necessary.
173  *     If the signal's disposition is SIG_IGN then no processing takes place.
174  *
175  * ASSUMPTIONS: signo is valid (i.e., SignalIsDefined(signo) is TRUE).
176  */
177 static void
178 ProcessSignal(int signo)
179 {
180     struct sigaction sigEntry;
181
182     if (signo != SIGKILL) {
183         /* serialize signals, but never block processing of SIGKILL */
184         (void)pthread_mutex_lock(&signalBlockLock);
185     }
186
187     /* fetch disposition of signo, updating it if necessary */
188
189     (void)pthread_mutex_lock(&signalTableLock);
190     sigEntry = signalTable[signo].action;
191
192     if ((sigEntry.sa_handler != SIG_IGN) && (sigEntry.sa_flags & SA_RESETHAND)
193         && (signo != SIGILL)) {
194         signalTable[signo].action.sa_handler = SIG_DFL;
195     }
196     (void)pthread_mutex_unlock(&signalTableLock);
197
198     /* execute handler */
199
200     if (sigEntry.sa_handler != SIG_IGN) {
201         if (sigEntry.sa_handler == SIG_DFL) {
202             sigEntry.sa_handler = DefaultActionHandler;
203         }
204         (*sigEntry.sa_handler) (signo);
205     }
206
207     if (signo != SIGKILL) {
208         (void)pthread_mutex_unlock(&signalBlockLock);
209     }
210 }
211
212
213 /*
214  * RemoteSignalThread() -- Thread spawned to process remote signal.
215  *
216  *     Param must be the signal number.
217  */
218 static DWORD WINAPI
219 RemoteSignalThread(LPVOID param)
220 {
221     int signo = (int)(intptr_t)param;
222     DWORD rc = 0;
223
224     if (SignalIsDefined(signo)) {
225         /* process signal */
226         ProcessSignal(signo);
227     } else if (signo != 0) {
228         /* invalid signal value */
229         rc = -1;
230     }
231     return rc;
232 }
233
234
235 /*
236  * RemoteSignalListenerThread() -- Thread spawned to receive and process
237  *     remotely generated signals; never returns.
238  *
239  *     Param must be a handle for a duplex server message pipe in blocking
240  *     mode.
241  */
242 static DWORD WINAPI
243 RemoteSignalListenerThread(LPVOID param)
244 {
245     HANDLE sigPipeHandle = (HANDLE) param;
246     HMODULE hLib = LoadLibrary("AFSPROCMGMT.DLL");
247
248     while (1) {
249         /* wait for pipe client to connect */
250
251         if ((ConnectNamedPipe(sigPipeHandle, NULL))
252             || (GetLastError() == ERROR_PIPE_CONNECTED)) {
253             /* client connected; read signal value */
254             int signo;
255             DWORD bytesXfered;
256
257             if ((ReadFile
258                  (sigPipeHandle, &signo, sizeof(signo), &bytesXfered, NULL))
259                 && (bytesXfered == sizeof(signo))) {
260                 HANDLE sigThreadHandle;
261                 DWORD sigThreadId;
262
263                 /* ACK signal to release sender */
264                 (void)WriteFile(sigPipeHandle, &signo, sizeof(signo),
265                                 &bytesXfered, NULL);
266
267                 /* spawn thread to process signal; we do this so that
268                  * we can always process a SIGKILL even if a signal handler
269                  * invoked earlier fails to return (blocked/spinning).
270                  */
271                 sigThreadHandle = CreateThread(NULL,    /* default security attr. */
272                                                0,       /* default stack size */
273                                                RemoteSignalThread, (LPVOID) (intptr_t)signo,    /* thread argument */
274                                                0,       /* creation flags */
275                                                &sigThreadId);   /* thread id */
276
277                 if (sigThreadHandle != NULL) {
278                     (void)CloseHandle(sigThreadHandle);
279                 }
280             }
281             /* nothing to do if ReadFile, WriteFile or CreateThread fails. */
282
283         } else {
284             /* connect failed; this should never happen */
285             Sleep(2000);        /* sleep 2 seconds to avoid tight loop */
286         }
287
288         (void)DisconnectNamedPipe(sigPipeHandle);
289     }
290
291     /* never reached */
292     FreeLibrary(hLib);
293     return (0);
294 }
295
296
297
298
299
300 /*
301  * pmgt_SigactionSet() -- Examine and/or specify the action for a given
302  *     signal (Unix sigaction() semantics).
303  */
304 int
305 pmgt_SigactionSet(int signo, const struct sigaction *actionP,
306                   struct sigaction *old_actionP)
307 {
308     /* validate arguments */
309
310     if (!SignalIsDefined(signo) || signo == SIGKILL) {
311         /* invalid signal value or signal can't be caught/ignored */
312         errno = EINVAL;
313         return -1;
314     }
315
316     if (actionP && actionP->sa_handler == SIG_ERR) {
317         /* invalid signal disposition */
318         errno = EINVAL;
319         return -1;
320     }
321
322     /* fetch and/or set disposition of signo */
323
324     (void)pthread_mutex_lock(&signalTableLock);
325
326     if (old_actionP) {
327         *old_actionP = signalTable[signo].action;
328     }
329
330     if (actionP) {
331         signalTable[signo].action = *actionP;
332     }
333
334     (void)pthread_mutex_unlock(&signalTableLock);
335
336     return 0;
337 }
338
339
340 /*
341  * pmgt_SignalSet() -- Specify the disposition for a given signal
342  *     value (Unix signal() semantics).
343  */
344 void (__cdecl * pmgt_SignalSet(int signo, void (__cdecl * dispP) (int))) (int) {
345     struct sigaction newAction, oldAction;
346
347     /* construct action to request Unix signal() semantics */
348
349     newAction.sa_handler = dispP;
350     sigemptyset(&newAction.sa_mask);
351     newAction.sa_flags = SA_RESETHAND;
352
353     if (!pmgt_SigactionSet(signo, &newAction, &oldAction)) {
354         /* successfully set new signal action */
355         return oldAction.sa_handler;
356     } else {
357         /* failed to set signal action; errno will have been set */
358         return SIG_ERR;
359     }
360 }
361
362
363 /*
364  * pmgt_SignalRaiseLocal() -- Raise a signal in this process (C raise()
365  *     semantics).
366  */
367 int
368 pmgt_SignalRaiseLocal(int signo)
369 {
370     int rc = 0;
371
372     /* Process signal directly in the context of the calling thread.
373      * This is the same as if the signal had been raised in this process
374      * and this thread chosen to execute the handler.
375      */
376
377     if (SignalIsDefined(signo)) {
378         /* process signal */
379         ProcessSignal(signo);
380     } else if (signo != 0) {
381         /* invalid signal value */
382         errno = EINVAL;
383         rc = -1;
384     }
385     return rc;
386 }
387
388
389 /*
390  * pmgt_SignalRaiseLocalByName() -- Raise a signal in this process where
391  *     the signal is specified by name (C raise() semantics).
392  *
393  *     Upon successful completion, *libSigno is set to the process management
394  *     library's constant value for signame.
395  *
396  *     Note: exists to implement the native-signal redirector (redirect_nt.c),
397  *           which can't include procmgmt.h and hence can't get the SIG* decls.
398  */
399 int
400 pmgt_SignalRaiseLocalByName(const char *signame, int *libSigno)
401 {
402     int rc = 0;
403     int signo;
404
405     if (!strcmp(signame, "SIGHUP")) {
406         signo = SIGHUP;
407     } else if (!strcmp(signame, "SIGINT")) {
408         signo = SIGINT;
409     } else if (!strcmp(signame, "SIGQUIT")) {
410         signo = SIGQUIT;
411     } else if (!strcmp(signame, "SIGILL")) {
412         signo = SIGILL;
413     } else if (!strcmp(signame, "SIGABRT")) {
414         signo = SIGABRT;
415     } else if (!strcmp(signame, "SIGFPE")) {
416         signo = SIGFPE;
417     } else if (!strcmp(signame, "SIGKILL")) {
418         signo = SIGKILL;
419     } else if (!strcmp(signame, "SIGSEGV")) {
420         signo = SIGSEGV;
421     } else if (!strcmp(signame, "SIGTERM")) {
422         signo = SIGTERM;
423     } else if (!strcmp(signame, "SIGUSR1")) {
424         signo = SIGUSR1;
425     } else if (!strcmp(signame, "SIGUSR2")) {
426         signo = SIGUSR2;
427     } else if (!strcmp(signame, "SIGCLD")) {
428         signo = SIGCLD;
429     } else if (!strcmp(signame, "SIGCHLD")) {
430         signo = SIGCHLD;
431     } else if (!strcmp(signame, "SIGTSTP")) {
432         signo = SIGTSTP;
433     } else {
434         /* unknown signal name */
435         errno = EINVAL;
436         rc = -1;
437     }
438
439     if (rc == 0) {
440         *libSigno = signo;
441         rc = pmgt_SignalRaiseLocal(signo);
442     }
443     return rc;
444 }
445
446
447 /*
448  * pmgt_SignalRaiseRemote() -- Raise a signal in the specified process (Unix
449  *     kill() semantics).
450  *
451  *     Note: only supports sending signal to a specific (single) process.
452  */
453 int
454 pmgt_SignalRaiseRemote(pid_t pid, int signo)
455 {
456     BOOL fsuccess;
457     char sigPipeName[sizeof(PMGT_SIGNAL_PIPE_PREFIX) + 20];
458     DWORD ackBytesRead;
459     int signoACK;
460     int status = 0;
461
462     /* validate arguments */
463
464     if ((pid <= (pid_t) 0) || (!SignalIsDefined(signo) && signo != 0)) {
465         /* invalid pid or signo */
466         errno = EINVAL;
467         return -1;
468     }
469
470     /* optimize for the "this process" case */
471
472     if (pid == (pid_t) GetCurrentProcessId()) {
473         return pmgt_SignalRaiseLocal(signo);
474     }
475
476     /* send signal to process via named pipe */
477
478     sprintf(sigPipeName, "%s%d", PMGT_SIGNAL_PIPE_PREFIX, (int)pid);
479
480     fsuccess = CallNamedPipe(sigPipeName,       /* process pid's signal pipe */
481                              &signo,    /* data written to pipe */
482                              sizeof(signo),     /* size of data to write */
483                              &signoACK, /* data read from pipe */
484                              sizeof(signoACK),  /* size of data read buffer */
485                              &ackBytesRead,     /* number of bytes actually read */
486                              5 * 1000); /* 5 second timeout */
487
488     if (!fsuccess) {
489         /* failed to send signal via named pipe */
490         status = -1;
491
492         if (signo == SIGKILL) {
493             /* could be a non-AFS process, which might still be kill-able */
494             HANDLE procHandle;
495
496             if (procHandle =
497                 OpenProcess(PROCESS_TERMINATE, FALSE, (DWORD) pid)) {
498                 if (TerminateProcess
499                     (procHandle, PMGT_SIGSTATUS_ENCODE(SIGKILL))) {
500                     /* successfully killed process */
501                     status = 0;
502                 } else {
503                     errno = nterr_nt2unix(GetLastError(), EPERM);
504                 }
505                 (void)CloseHandle(procHandle);
506             } else {
507                 if (GetLastError() == ERROR_INVALID_PARAMETER) {
508                     errno = ESRCH;
509                 } else if (GetLastError() == ERROR_ACCESS_DENIED) {
510                     errno = EPERM;
511                 } else {
512                     errno = nterr_nt2unix(GetLastError(), EPERM);
513                 }
514             }
515         } else {
516             /* couldn't open pipe so can't send (non-SIGKILL) signal */
517             errno = nterr_nt2unix(GetLastError(), EPERM);
518         }
519     }
520
521     return status;
522 }
523
524
525
526
527 /* -----------------  Processes  ---------------- */
528
529
530 /*
531  * StringArrayToString() -- convert a null-terminated array of strings,
532  *     such as argv, into a single string of space-separated elements
533  *     with each element quoted (in case it contains space characters
534  *     or is of zero length).
535  */
536 static char *
537 StringArrayToString(char *strArray[])
538 {
539     int strCount = 0;
540     int byteCount = 0;
541     char *buffer = NULL;
542
543     for (strCount = 0; strArray[strCount] != NULL; strCount++) {
544         /* sum all string lengths */
545         byteCount += (int)strlen(strArray[strCount]);
546     }
547
548     /* put all strings into buffer; guarantee buffer is at least one char */
549     buffer = malloc(byteCount + (strCount * 3) /* quotes+space */ +1);
550     if (buffer != NULL) {
551         int i;
552
553         buffer[0] = '\0';
554
555         for (i = 0; i < strCount; i++) {
556             char *bufp = buffer + strlen(buffer);
557
558             if (i == strCount - 1) {
559                 /* last string; no trailing space */
560                 sprintf(bufp, "\"%s\"", strArray[i]);
561             } else {
562                 sprintf(bufp, "\"%s\" ", strArray[i]);
563             }
564         }
565     }
566
567     return (buffer);
568 }
569
570
571 /*
572  * StringArrayToMultiString() -- convert a null-terminated array of strings,
573  *     such as envp, into a multistring.
574  */
575 static char *
576 StringArrayToMultiString(char *strArray[])
577 {
578     int strCount = 0;
579     int byteCount = 0;
580     char *buffer = NULL;
581
582     for (strCount = 0; strArray[strCount] != NULL; strCount++) {
583         /* sum all string lengths */
584         byteCount += strlen(strArray[strCount]);
585     }
586
587     /* put all strings into buffer; guarantee buffer is at least two chars */
588     buffer = malloc(byteCount + strCount + 2);
589     if (buffer != NULL) {
590         if (byteCount == 0) {
591             buffer[0] = '\0';
592             buffer[1] = '\0';
593         } else {
594             int i;
595             char *bufp = buffer;
596
597             for (i = 0; i < strCount; i++) {
598                 int strLen = strlen(strArray[i]);
599
600                 if (strLen > 0) {
601                     /* can not embed zero length string in a multistring */
602                     strcpy(bufp, strArray[i]);
603                     bufp += strLen + 1;
604                 }
605             }
606             *bufp = '\0';       /* terminate multistring */
607         }
608     }
609
610     return (buffer);
611 }
612
613
614
615 /*
616  * ComputeWaitStatus() -- Compute an appropriate wait status value from
617  *     a given process termination (exit) code.
618  */
619 static int
620 ComputeWaitStatus(DWORD exitStatus)
621 {
622     int waitStatus;
623
624     if (PMGT_IS_SIGSTATUS(exitStatus)) {
625         /* child terminated due to an unhandled signal */
626         int signo = PMGT_SIGSTATUS_DECODE(exitStatus);
627         waitStatus = WSIGNALED_ENCODE(signo);
628     } else if (PMGT_IS_EXPSTATUS(exitStatus)) {
629         /* child terminated due to an uncaught exception */
630         int signo;
631
632         switch (exitStatus) {
633         case EXCEPTION_FLT_DENORMAL_OPERAND:
634         case EXCEPTION_FLT_DIVIDE_BY_ZERO:
635         case EXCEPTION_FLT_INEXACT_RESULT:
636         case EXCEPTION_FLT_INVALID_OPERATION:
637         case EXCEPTION_FLT_OVERFLOW:
638         case EXCEPTION_FLT_STACK_CHECK:
639         case EXCEPTION_FLT_UNDERFLOW:
640         case EXCEPTION_INT_DIVIDE_BY_ZERO:
641         case EXCEPTION_INT_OVERFLOW:
642             signo = SIGFPE;
643             break;
644         case EXCEPTION_PRIV_INSTRUCTION:
645         case EXCEPTION_ILLEGAL_INSTRUCTION:
646             signo = SIGILL;
647             break;
648         case CONTROL_C_EXIT:
649             signo = SIGINT;
650             break;
651         default:
652             signo = SIGSEGV;
653             break;
654         }
655         waitStatus = WSIGNALED_ENCODE(signo);
656     } else {
657         /* child terminated normally */
658         waitStatus = WEXITED_ENCODE(exitStatus);
659     }
660
661     return waitStatus;
662 }
663
664
665
666 /*
667  * CreateChildDataBuffer() -- Create and fill a named data buffer to pass to
668  *     a child process, along with a corresponding buffer read event.
669  *
670  * ASSUMPTIONS: child process is linked with this process management library;
671  *     otherwise no data transfer will take place.
672  */
673 static BOOL
674 CreateChildDataBuffer(DWORD pid,        /* child pid */
675                       void *datap,      /* data to place in buffer */
676                       size_t dataLen,   /* size of data in bytes */
677                       HANDLE * bufMemHandlep,   /* buffer memory handle */
678                       HANDLE * bufEventHandlep)
679 {                               /* buffer read event handle */
680     BOOL fsuccess = FALSE;
681     DWORD bufMemSize = dataLen + (DWORD)sizeof(size_t);
682     char bufMemName[sizeof(PMGT_DATA_MEM_PREFIX) + 20];
683     char bufEventName[sizeof(PMGT_DATA_EVENT_PREFIX) + 20];
684
685     sprintf(bufMemName, "%s%d", PMGT_DATA_MEM_PREFIX, (int)pid);
686     sprintf(bufEventName, "%s%d", PMGT_DATA_EVENT_PREFIX, (int)pid);
687
688     /* Create and initialize named shared memory and named event */
689
690     *bufMemHandlep = CreateFileMapping(INVALID_HANDLE_VALUE,    /* page-file backed */
691                                        NULL, PAGE_READWRITE, 0, bufMemSize,
692                                        bufMemName);
693
694     if (*bufMemHandlep != NULL) {
695         void *bufMemp;
696
697         bufMemp =
698             MapViewOfFile(*bufMemHandlep, FILE_MAP_WRITE, 0, 0, bufMemSize);
699
700         if (bufMemp != NULL) {
701             /* copy data into shared memory, prefixed with data size */
702             size_t *memp = (size_t *) bufMemp;
703
704             *memp++ = dataLen;
705             memcpy((void *)memp, datap, dataLen);
706
707             if (UnmapViewOfFile(bufMemp)) {
708                 /* create buffer read event */
709                 *bufEventHandlep =
710                     CreateEvent(NULL, FALSE /* manual reset */ ,
711                                 FALSE /* initial state */ ,
712                                 bufEventName);
713                 if (*bufEventHandlep != NULL) {
714                     fsuccess = TRUE;
715                 }
716             }
717         }
718
719         if (!fsuccess) {
720             (void)CloseHandle(*bufMemHandlep);
721         }
722     }
723
724     if (!fsuccess) {
725         *bufMemHandlep = *bufEventHandlep = NULL;
726     }
727     return fsuccess;
728 }
729
730
731
732 /*
733  * ReadChildDataBuffer() -- Read data buffer passed to child from parent,
734  *     if any, and place in allocated storage.
735  */
736 static BOOL
737 ReadChildDataBuffer(void **datap,       /* allocated data buffer */
738                     size_t * dataLen)
739 {                               /* size of data buffer returned */
740     BOOL fsuccess = FALSE;
741     char bufMemName[sizeof(PMGT_DATA_MEM_PREFIX) + 20];
742     char bufEventName[sizeof(PMGT_DATA_EVENT_PREFIX) + 20];
743     HANDLE bufMemHandle, bufEventHandle;
744
745     sprintf(bufMemName, "%s%d", PMGT_DATA_MEM_PREFIX,
746             (int)GetCurrentProcessId());
747     sprintf(bufEventName, "%s%d", PMGT_DATA_EVENT_PREFIX,
748             (int)GetCurrentProcessId());
749
750     /* Attempt to open named event and named shared memory */
751
752     bufEventHandle = OpenEvent(EVENT_MODIFY_STATE, FALSE, bufEventName);
753
754     if (bufEventHandle != NULL) {
755         bufMemHandle = OpenFileMapping(FILE_MAP_READ, FALSE, bufMemName);
756
757         if (bufMemHandle != NULL) {
758             void *bufMemp;
759
760             bufMemp = MapViewOfFile(bufMemHandle, FILE_MAP_READ, 0, 0, 0);
761
762             if (bufMemp != NULL) {
763                 /* read data size and data from shared memory */
764                 size_t *memp = (size_t *) bufMemp;
765
766                 *dataLen = *memp++;
767                 *datap = malloc(*dataLen);
768
769                 if (*datap != NULL) {
770                     memcpy(*datap, (void *)memp, *dataLen);
771                     fsuccess = TRUE;
772                 }
773                 (void)UnmapViewOfFile(bufMemp);
774             }
775
776             (void)CloseHandle(bufMemHandle);
777         }
778
779         (void)SetEvent(bufEventHandle);
780         (void)CloseHandle(bufEventHandle);
781     }
782
783     if (!fsuccess) {
784         *datap = NULL;
785         *dataLen = 0;
786     }
787     return fsuccess;
788 }
789
790
791
792 /*
793  * ChildMonitorThread() -- Thread spawned to monitor status of child process.
794  *
795  *     Param must be index into child process table.
796  */
797 static DWORD WINAPI
798 ChildMonitorThread(LPVOID param)
799 {
800     int tidx = (int)(intptr_t)param;
801     HANDLE childProcHandle;
802     BOOL fsuccess;
803     DWORD rc = -1;
804
805     /* retrieve handle for child process from process table and duplicate */
806
807     (void)pthread_mutex_lock(&procTableLock);
808
809     fsuccess = DuplicateHandle(GetCurrentProcess(),     /* source process handle */
810                                procTable[tidx].p_handle,        /* source handle to dup */
811                                GetCurrentProcess(),     /* target process handle */
812                                &childProcHandle,        /* target handle (duplicate) */
813                                0,       /* access (ignored here) */
814                                FALSE,   /* not inheritable */
815                                DUPLICATE_SAME_ACCESS);
816
817     (void)pthread_mutex_unlock(&procTableLock);
818
819     if (fsuccess) {
820         /* wait for child process to terminate */
821
822         if (WaitForSingleObject(childProcHandle, INFINITE) == WAIT_OBJECT_0) {
823             /* child process terminated; mark in table and signal event */
824             (void)pthread_mutex_lock(&procTableLock);
825
826             procTable[tidx].p_terminated = TRUE;
827             (void)GetExitCodeProcess(childProcHandle,
828                                      &procTable[tidx].p_status);
829             procTermCount++;
830
831             (void)pthread_mutex_unlock(&procTableLock);
832
833             (void)pthread_cond_broadcast(&childTermEvent);
834
835             /* process/raise SIGCHLD; do last in case handler never returns */
836             ProcessSignal(SIGCHLD);
837             rc = 0;
838         }
839
840         (void)CloseHandle(childProcHandle);
841     }
842
843     /* note: nothing can be done if DuplicateHandle() or WaitForSingleObject()
844      *       fail; however, this should never happen.
845      */
846     return rc;
847 }
848
849
850
851 /*
852  * pmgt_ProcessSpawnVEB() -- Spawn a process (Unix fork()/execve() semantics)
853  *
854  *     Returns pid of the child process ((pid_t)-1 on failure with errno set).
855  *
856  *     Notes: A senvp value of NULL results in Unix fork()/execv() semantics.
857  *            Open files are not inherited; child's stdin, stdout, and stderr
858  *                are set to parent's console.
859  *            If spath does not specify a filename extension ".exe" is used.
860  *            If sdatap is not NULL, and sdatalen > 0, data is passed to child.
861  *            The spath and sargv[] strings must not contain quote chars (").
862  *
863  * ASSUMPTIONS: sargv[0] is the same as spath (or its last component).
864  */
865 pid_t
866 pmgt_ProcessSpawnVEB(const char *spath, char *sargv[], char *senvp[],
867                      void *sdatap, size_t sdatalen)
868 {
869     int tidx;
870     char *pathbuf, *argbuf, *envbuf;
871     char pathext[_MAX_EXT];
872     STARTUPINFO startInfo;
873     PROCESS_INFORMATION procInfo;
874     HANDLE monitorHandle = NULL;
875     HANDLE bufMemHandle, bufEventHandle;
876     DWORD monitorId, createFlags;
877     BOOL passingBuffer = (sdatap != NULL && sdatalen > 0);
878     BOOL fsuccess;
879     int lasterror;
880
881     /* verify arguments */
882     if (!spath || !sargv) {
883         errno = EFAULT;
884         return (pid_t) - 1;
885     } else if (*spath == '\0') {
886         errno = ENOENT;
887         return (pid_t) - 1;
888     }
889
890     /* create path with .exe extension if no filename extension supplied */
891     if (!(pathbuf = malloc(strlen(spath) + 5 /* .exe */ ))) {
892         errno = ENOMEM;
893         return ((pid_t) - 1);
894     }
895     strcpy(pathbuf, spath);
896
897     _splitpath(pathbuf, NULL, NULL, NULL, pathext);
898     if (*pathext == '\0') {
899         /* no filename extension supplied for spath; .exe is assumed */
900         strcat(pathbuf, ".exe");
901     }
902
903     /* create command line argument string */
904     argbuf = StringArrayToString(sargv);
905
906     if (!argbuf) {
907         free(pathbuf);
908         errno = ENOMEM;
909         return ((pid_t) - 1);
910     }
911
912     /* create environment variable block (multistring) */
913     if (senvp) {
914         /* use environment variables provided */
915         envbuf = StringArrayToMultiString(senvp);
916
917         if (!envbuf) {
918             free(pathbuf);
919             free(argbuf);
920             errno = ENOMEM;
921             return ((pid_t) - 1);
922         }
923     } else {
924         /* use default environment variables */
925         envbuf = NULL;
926     }
927
928     /* set process creation flags */
929     createFlags = CREATE_SUSPENDED | NORMAL_PRIORITY_CLASS;
930
931     if (getenv(PMGT_SPAWN_DETACHED_ENV_NAME) != NULL) {
932         createFlags |= DETACHED_PROCESS;
933     }
934
935     /* clear start-up info; use defaults */
936     memset((void *)&startInfo, 0, sizeof(startInfo));
937     startInfo.cb = sizeof(startInfo);
938
939     /* perform the following as a logically atomic unit:
940      *     1) allocate a process table entry
941      *     2) spawn child process (suspended)
942      *     3) create data buffer to pass (optional)
943      *     4) initialize process table entry
944      *     5) start child watcher thread
945      *     6) resume spawned child process
946      */
947
948     (void)pthread_mutex_lock(&procTableLock);
949
950     for (tidx = 0; tidx < PMGT_CHILD_MAX; tidx++) {
951         if (procTable[tidx].p_handle == NULL
952             && procTable[tidx].p_reserved == FALSE) {
953             procTable[tidx].p_reserved = TRUE;
954             break;
955         }
956     }
957     (void)pthread_mutex_unlock(&procTableLock);
958
959     if (tidx >= PMGT_CHILD_MAX) {
960         /* no space left in process table */
961         free(pathbuf);
962         free(argbuf);
963         free(envbuf);
964
965         errno = EAGAIN;
966         return (pid_t) - 1;
967     }
968
969     fsuccess = CreateProcess(pathbuf,   /* executable path */
970                              argbuf,    /* command line argument string */
971                              NULL,      /* default process security attr */
972                              NULL,      /* default thread security attr */
973                              FALSE,     /* do NOT inherit handles */
974                              createFlags,       /* creation control flags */
975                              envbuf,    /* environment variable block */
976                              NULL,      /* current directory is that of parent */
977                              &startInfo,        /* startup info block */
978                              &procInfo);
979
980     lasterror = GetLastError();
981     free(pathbuf);
982     free(argbuf);
983     free(envbuf);
984
985     if (!fsuccess) {
986         /* failed to spawn process */
987         errno = nterr_nt2unix(lasterror, ENOENT);
988
989         (void)pthread_mutex_lock(&procTableLock);
990         procTable[tidx].p_reserved = FALSE;     /* mark entry as not reserved */
991         (void)pthread_mutex_unlock(&procTableLock);
992
993         return (pid_t) - 1;
994     }
995
996     if (passingBuffer) {
997         /* create named data buffer and read event for child */
998         fsuccess =
999             CreateChildDataBuffer(procInfo.dwProcessId, sdatap, sdatalen,
1000                                   &bufMemHandle, &bufEventHandle);
1001         if (!fsuccess) {
1002             (void)pthread_mutex_lock(&procTableLock);
1003             procTable[tidx].p_reserved = FALSE; /* mark entry not reserved */
1004             (void)pthread_mutex_unlock(&procTableLock);
1005
1006             (void)TerminateProcess(procInfo.hProcess,
1007                                    PMGT_SIGSTATUS_ENCODE(SIGKILL));
1008             (void)CloseHandle(procInfo.hThread);
1009             (void)CloseHandle(procInfo.hProcess);
1010
1011             errno = EAGAIN;
1012             return (pid_t) - 1;
1013         }
1014     }
1015
1016     (void)pthread_mutex_lock(&procTableLock);
1017
1018     procTable[tidx].p_handle = procInfo.hProcess;
1019     procTable[tidx].p_id = procInfo.dwProcessId;
1020     procTable[tidx].p_terminated = FALSE;
1021
1022     procEntryCount++;
1023
1024     /* Note: must hold procTableLock during monitor thread creation so
1025      * that if creation fails we can clean up process table before another
1026      * thread has a chance to see this procTable entry.  Continue to hold
1027      * procTableLock while resuming child process, since the procTable
1028      * entry contains a copy of the child process handle which we might use.
1029      */
1030     monitorHandle = CreateThread(NULL,  /* default security attr. */
1031                                  0,     /* default stack size */
1032                                  ChildMonitorThread, (LPVOID)(intptr_t) tidx,   /* thread argument */
1033                                  0,     /* creation flags */
1034                                  &monitorId);   /* thread id */
1035
1036     if (monitorHandle == NULL) {
1037         /* failed to start child monitor thread */
1038         procTable[tidx].p_handle = NULL;        /* invalidate table entry */
1039         procTable[tidx].p_reserved = FALSE;     /* mark entry as not reserved */
1040         procEntryCount--;
1041
1042         (void)pthread_mutex_unlock(&procTableLock);
1043
1044         (void)TerminateProcess(procInfo.hProcess,
1045                                PMGT_SIGSTATUS_ENCODE(SIGKILL));
1046         (void)CloseHandle(procInfo.hThread);
1047         (void)CloseHandle(procInfo.hProcess);
1048
1049         if (passingBuffer) {
1050             (void)CloseHandle(bufMemHandle);
1051             (void)CloseHandle(bufEventHandle);
1052         }
1053
1054         errno = EAGAIN;
1055         return (pid_t) - 1;
1056     }
1057
1058     /* Resume child process, which was created suspended to implement spawn
1059      * atomically.  If resumption fails, which it never should, terminate
1060      * the child process with a status of SIGKILL.  Spawn still succeeds and
1061      * the net result is the same as if the child process received a spurious
1062      * SIGKILL signal; the child monitor thread will then handle this.
1063      */
1064     if (ResumeThread(procInfo.hThread) == DWORD_OF_ONES) {
1065         (void)TerminateProcess(procInfo.hProcess,
1066                                PMGT_SIGSTATUS_ENCODE(SIGKILL));
1067
1068         if (passingBuffer) {
1069             /* child will never read data buffer */
1070             (void)SetEvent(bufEventHandle);
1071         }
1072     }
1073
1074     (void)pthread_mutex_unlock(&procTableLock);
1075
1076     (void)CloseHandle(procInfo.hThread);
1077     (void)CloseHandle(monitorHandle);
1078
1079     /* After spawn returns, signals can not be sent to the new child process
1080      * until that child initializes its signal-receiving mechanism (assuming
1081      * the child is linked with this library).  Shorten (but sadly don't
1082      * eliminate) this window of opportunity for failure by yielding this
1083      * thread's time slice.
1084      */
1085     (void)SwitchToThread();
1086
1087     /* If passing a data buffer to child, wait until child reads buffer
1088      * before closing handles and thus freeing resources; if don't wait
1089      * then parent can not safely exit immediately after returning from
1090      * this call (hence why wait is not done in a background thread).
1091      */
1092     if (passingBuffer) {
1093         WaitForSingleObject(bufEventHandle, 10000);
1094         /* note: if wait times out, child may not get to read buffer */
1095         (void)CloseHandle(bufMemHandle);
1096         (void)CloseHandle(bufEventHandle);
1097     }
1098
1099     return (pid_t) procInfo.dwProcessId;
1100 }
1101
1102
1103
1104 /*
1105  * pmgt_ProcessWaitPid() -- Wait for child process status; i.e., wait
1106  *     for child to terminate (Unix waitpid() semantics).
1107  *
1108  *     Note: does not support waiting for process in group (i.e., pid
1109  *           equals (pid_t)0 or pid is less than (pid_t)-1.
1110  */
1111 pid_t
1112 pmgt_ProcessWaitPid(pid_t pid, int *statusP, int options)
1113 {
1114     pid_t rc;
1115     int tidx;
1116     BOOL statusFound = FALSE;
1117     DWORD waitTime;
1118
1119     /* validate arguments */
1120     if (pid < (pid_t) - 1 || pid == (pid_t) 0) {
1121         errno = EINVAL;
1122         return (pid_t) - 1;
1123     }
1124
1125     /* determine how long caller is willing to wait for child */
1126
1127     waitTime = (options & WNOHANG) ? 0 : INFINITE;
1128
1129     /* get child status */
1130
1131     (void)pthread_mutex_lock(&procTableLock);
1132
1133     while (1) {
1134         BOOL waitForChild = FALSE;
1135
1136         if (procEntryCount == 0) {
1137             /* no child processes */
1138             errno = ECHILD;
1139             rc = (pid_t) - 1;
1140         } else {
1141             /* determine if status is available for specified child id */
1142
1143             if (pid == (pid_t) - 1) {
1144                 /* CASE 1: pid matches any child id */
1145
1146                 if (procTermCount == 0) {
1147                     /* status not available for any child ... */
1148                     if (waitTime == 0) {
1149                         /* ... and caller is not willing to wait */
1150                         rc = (pid_t) 0;
1151                     } else {
1152                         /* ... but caller is willing to wait */
1153                         waitForChild = TRUE;
1154                     }
1155                 } else {
1156                     /* status available for some child; locate table entry */
1157                     for (tidx = 0; tidx < PMGT_CHILD_MAX; tidx++) {
1158                         if (procTable[tidx].p_handle != NULL
1159                             && procTable[tidx].p_terminated == TRUE) {
1160                             statusFound = TRUE;
1161                             break;
1162                         }
1163                     }
1164
1165                     if (!statusFound) {
1166                         /* should never happen; indicates a bug */
1167                         errno = EINTR;  /* plausible lie for failure */
1168                         rc = (pid_t) - 1;
1169                     }
1170                 }
1171
1172             } else {
1173                 /* CASE 2: pid must match a specific child id */
1174
1175                 /* locate table entry */
1176                 for (tidx = 0; tidx < PMGT_CHILD_MAX; tidx++) {
1177                     if (procTable[tidx].p_handle != NULL
1178                         && procTable[tidx].p_id == (DWORD) pid) {
1179                         break;
1180                     }
1181                 }
1182
1183                 if (tidx >= PMGT_CHILD_MAX) {
1184                     /* pid does not match any child id */
1185                     errno = ECHILD;
1186                     rc = (pid_t) - 1;
1187                 } else if (procTable[tidx].p_terminated == FALSE) {
1188                     /* status not available for specified child ... */
1189                     if (waitTime == 0) {
1190                         /* ... and caller is not willing to wait */
1191                         rc = (pid_t) 0;
1192                     } else {
1193                         /* ... but caller is willing to wait */
1194                         waitForChild = TRUE;
1195                     }
1196                 } else {
1197                     /* status is available for specified child */
1198                     statusFound = TRUE;
1199                 }
1200             }
1201         }
1202
1203         if (waitForChild) {
1204             (void)pthread_cond_wait(&childTermEvent, &procTableLock);
1205         } else {
1206             break;
1207         }
1208     }                           /* while() */
1209
1210     if (statusFound) {
1211         /* child status available */
1212         if (statusP) {
1213             *statusP = ComputeWaitStatus(procTable[tidx].p_status);
1214         }
1215         rc = (pid_t) procTable[tidx].p_id;
1216
1217         /* clean up process table */
1218         (void)CloseHandle(procTable[tidx].p_handle);
1219         procTable[tidx].p_handle = NULL;
1220         procTable[tidx].p_reserved = FALSE;
1221
1222         procEntryCount--;
1223         procTermCount--;
1224     }
1225
1226     (void)pthread_mutex_unlock(&procTableLock);
1227     return rc;
1228 }
1229
1230
1231
1232
1233
1234
1235 /* -----------------  General  ---------------- */
1236
1237
1238
1239 /*
1240  * PmgtLibraryInitialize() -- Initialize process management library.
1241  */
1242 static int
1243 PmgtLibraryInitialize(void)
1244 {
1245     int rc, i;
1246     HANDLE sigPipeHandle;
1247     char sigPipeName[sizeof(PMGT_SIGNAL_PIPE_PREFIX) + 20];
1248     HANDLE sigListenerHandle;
1249     DWORD sigListenerId;
1250
1251     /* initialize mutex locks and condition variables */
1252
1253     if ((rc = pthread_mutex_init(&signalTableLock, NULL))
1254         || (rc = pthread_mutex_init(&signalBlockLock, NULL))
1255         || (rc = pthread_mutex_init(&procTableLock, NULL))
1256         || (rc = pthread_cond_init(&childTermEvent, NULL))) {
1257         errno = rc;
1258         return -1;
1259     }
1260
1261     /* initialize signal disposition table */
1262
1263     for (i = 0; i < NSIG; i++) {
1264         if (SignalIsDefined(i)) {
1265             /* initialize to default action for defined signals */
1266             signalTable[i].action.sa_handler = SIG_DFL;
1267             sigemptyset(&signalTable[i].action.sa_mask);
1268             signalTable[i].action.sa_flags = 0;
1269         } else {
1270             /* initialize to ignore for undefined signals */
1271             signalTable[i].action.sa_handler = SIG_IGN;
1272         }
1273     }
1274
1275     /* initialize child process table */
1276
1277     for (i = 0; i < PMGT_CHILD_MAX; i++) {
1278         procTable[i].p_handle = NULL;
1279         procTable[i].p_reserved = FALSE;
1280     }
1281     procEntryCount = 0;
1282     procTermCount = 0;
1283
1284     /* retrieve data buffer passed from parent in spawn, if any */
1285
1286     if (!ReadChildDataBuffer(&pmgt_spawnData, &pmgt_spawnDataLen)) {
1287         pmgt_spawnData = NULL;
1288         pmgt_spawnDataLen = 0;
1289     }
1290
1291     /* create named pipe for delivering signals to this process */
1292
1293     sprintf(sigPipeName, "%s%d", PMGT_SIGNAL_PIPE_PREFIX,
1294             (int)GetCurrentProcessId());
1295
1296     sigPipeHandle = CreateNamedPipe(sigPipeName,        /* pipe for this process */
1297                                     PIPE_ACCESS_DUPLEX |        /* full duplex pipe */
1298                                     WRITE_DAC,  /* DACL write access */
1299                                     PIPE_TYPE_MESSAGE | /* message type pipe */
1300                                     PIPE_READMODE_MESSAGE |     /* message read-mode */
1301                                     PIPE_WAIT,  /* blocking mode */
1302                                     1,  /* max of 1 pipe instance */
1303                                     64, /* output buffer size (advisory) */
1304                                     64, /* input buffer size (advisory) */
1305                                     1000,       /* 1 sec default client timeout */
1306                                     NULL);      /* default security attr. */
1307
1308     if (sigPipeHandle == INVALID_HANDLE_VALUE) {
1309         /* failed to create signal pipe */
1310         errno = nterr_nt2unix(GetLastError(), EIO);
1311         return -1;
1312     }
1313
1314     /* add entry to signal pipe ACL granting local Administrators R/W access */
1315
1316     (void)ObjectDaclEntryAdd(sigPipeHandle, SE_KERNEL_OBJECT,
1317                              LocalAdministratorsGroup,
1318                              GENERIC_READ | GENERIC_WRITE, GRANT_ACCESS,
1319                              NO_INHERITANCE);
1320
1321     /* start signal pipe listener thread */
1322
1323     sigListenerHandle = CreateThread(NULL,      /* default security attr. */
1324                                      0, /* default stack size */
1325                                      RemoteSignalListenerThread, (LPVOID) sigPipeHandle,        /* thread argument */
1326                                      0, /* creation flags */
1327                                      &sigListenerId);   /* thread id */
1328
1329     if (sigListenerHandle != NULL) {
1330         /* listener thread started; bump priority */
1331         (void)SetThreadPriority(sigListenerHandle, THREAD_PRIORITY_HIGHEST);
1332         (void)CloseHandle(sigListenerHandle);
1333     } else {
1334         /* failed to start listener thread */
1335         errno = EAGAIN;
1336         (void)CloseHandle(sigPipeHandle);
1337         return -1;
1338     }
1339
1340     /* redirect native NT signals into this process management library */
1341
1342     if (pmgt_RedirectNativeSignals()) {
1343         /* errno set by called function */
1344         return -1;
1345     }
1346
1347     return 0;
1348 }
1349
1350
1351 /*
1352  * DllMain() -- Entry-point function called by the DllMainCRTStartup()
1353  *     function in the MSVC runtime DLL (msvcrt.dll).
1354  *
1355  *     Note: the system serializes calls to this function.
1356  */
1357 BOOL WINAPI
1358 DllMain(HINSTANCE dllInstHandle,        /* instance handle for this DLL module */
1359         DWORD reason,           /* reason function is being called */
1360         LPVOID reserved)
1361 {                               /* reserved for future use */
1362     switch (reason) {
1363     case DLL_PROCESS_ATTACH:
1364         /* library is being attached to a process */
1365         if (PmgtLibraryInitialize()) {
1366             /* failed to initialize library */
1367             return FALSE;
1368         }
1369
1370         /* disable thread attach/detach notifications */
1371         (void)DisableThreadLibraryCalls(dllInstHandle);
1372         return TRUE;
1373     case DLL_PROCESS_DETACH:
1374         pmgt_RestoreNativeSignals();
1375         return TRUE;
1376     default:
1377         return FALSE;
1378     }
1379 }