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