update.
[chise/xemacs-chise.git.1] / src / process-nt.c
1 /* Asynchronous subprocess implementation for Win32
2    Copyright (C) 1985, 1986, 1987, 1988, 1992, 1993, 1994, 1995
3    Free Software Foundation, Inc.
4    Copyright (C) 1995 Sun Microsystems, Inc.
5    Copyright (C) 1995, 1996, 2000 Ben Wing.
6
7 This file is part of XEmacs.
8
9 XEmacs is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
12 later version.
13
14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17 for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with XEmacs; see the file COPYING.  If not, write to
21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA.  */
23
24 /* Written by Kirill M. Katsnelson <kkm@kis.ru>, April 1998 */
25
26 #include <config.h>
27 #include "lisp.h"
28
29 #include "buffer.h"
30 #include "console-msw.h"
31 #include "hash.h"
32 #include "lstream.h"
33 #include "nt.h"
34 #include "process.h"
35 #include "procimpl.h"
36 #include "sysdep.h"
37
38 #include <shellapi.h>
39 #include <errno.h>
40 #include <signal.h>
41 #ifdef HAVE_SOCKETS
42 #include <winsock.h>
43 #endif
44
45 /* Bound by win32-native.el */
46 Lisp_Object Qmswindows_construct_process_command_line;
47
48 /* Arbitrary size limit for code fragments passed to run_in_other_process */
49 #define FRAGMENT_CODE_SIZE 32
50
51 /* Implementation-specific data. Pointed to by Lisp_Process->process_data */
52 struct nt_process_data
53 {
54   HANDLE h_process;
55   DWORD dwProcessId;
56   HWND hwnd; /* console window */
57 };
58
59 /* Control whether create_child causes the process to inherit Emacs'
60    console window, or be given a new one of its own.  The default is
61    nil, to allow multiple DOS programs to run on Win95.  Having separate
62    consoles also allows Emacs to cleanly terminate process groups.  */
63 Lisp_Object Vmswindows_start_process_share_console;
64
65 /* Control whether create_child cause the process to inherit Emacs'
66    error mode setting.  The default is t, to minimize the possibility of
67    subprocesses blocking when accessing unmounted drives.  */
68 Lisp_Object Vmswindows_start_process_inherit_error_mode;
69
70 #define NT_DATA(p) ((struct nt_process_data*)((p)->process_data))
71 \f
72 /*-----------------------------------------------------------------------*/
73 /* Process helpers                                                       */
74 /*-----------------------------------------------------------------------*/
75
76 /* This one breaks process abstraction. Prototype is in console-msw.h,
77    used by select_process method in event-msw.c */
78 HANDLE
79 get_nt_process_handle (Lisp_Process *p)
80 {
81   return (NT_DATA (p)->h_process);
82 }
83
84 static struct Lisp_Process *
85 find_process_from_pid (DWORD pid)
86 {
87   Lisp_Object tail, proc;
88
89   for (tail = Vprocess_list; CONSP (tail); tail = XCDR (tail))
90     {
91       proc = XCAR (tail);
92       if (NT_DATA (XPROCESS (proc))->dwProcessId == pid)
93         return XPROCESS (proc);
94     }
95   return 0;
96 }
97
98 \f
99 /*-----------------------------------------------------------------------*/
100 /* Running remote threads. See Microsoft Systems Journal 1994 Number 5   */
101 /* Jeffrey Richter, Load Your 32-bit DLL into Another Process's Address..*/
102 /*-----------------------------------------------------------------------*/
103
104 typedef struct
105 {
106   HANDLE h_process;
107   HANDLE h_thread;
108   LPVOID address;
109 } process_memory;
110
111 /*
112  * Allocate SIZE bytes in H_PROCESS address space. Fill in PMC used
113  * further by other routines. Return nonzero if successful.
114  *
115  * The memory in other process is allocated by creating a suspended
116  * thread. Initial stack of that thread is used as the memory
117  * block. The thread entry point is the routine ExitThread in
118  * kernel32.dll, so the allocated memory is freed just by resuming the 
119  * thread, which immediately terminates after that.
120  */
121
122 static int 
123 alloc_process_memory (HANDLE h_process, size_t size,
124                       process_memory* pmc)
125 {
126   LPTHREAD_START_ROUTINE adr_ExitThread =
127     (LPTHREAD_START_ROUTINE)
128     GetProcAddress (GetModuleHandle ("kernel32"), "ExitThread");
129   DWORD dw_unused;
130   CONTEXT context;
131   MEMORY_BASIC_INFORMATION mbi;
132
133   pmc->h_process = h_process;
134   pmc->h_thread = CreateRemoteThread (h_process, NULL, size,
135                                      adr_ExitThread, NULL,
136                                      CREATE_SUSPENDED, &dw_unused);
137   if (pmc->h_thread == NULL)
138     return 0;
139
140   /* Get context, for thread's stack pointer */
141   context.ContextFlags = CONTEXT_CONTROL;
142   if (!GetThreadContext (pmc->h_thread, &context))
143     goto failure;
144
145   /* Determine base address of the committed range */
146   if (sizeof(mbi) != VirtualQueryEx (h_process,
147 #if defined (_X86_)
148                                      (LPDWORD)context.Esp - 1,
149 #elif defined (_ALPHA_)
150                                      (LPDWORD)context.IntSp - 1,
151 #else
152 #error Unknown processor architecture
153 #endif
154                                      &mbi, sizeof(mbi)))
155     goto failure;
156
157   /* Change the page protection of the allocated memory to executable,
158      read, and write. */
159   if (!VirtualProtectEx (h_process, mbi.BaseAddress, size,
160                          PAGE_EXECUTE_READWRITE, &dw_unused))
161     goto failure;
162
163   pmc->address = mbi.BaseAddress;
164   return 1;
165
166  failure:
167   ResumeThread (pmc->h_thread);
168   pmc->address = 0;
169   return 0;
170 }
171
172 static void
173 free_process_memory (process_memory* pmc)
174 {
175   ResumeThread (pmc->h_thread);
176 }
177
178 /*
179  * Run ROUTINE in the context of process determined by H_PROCESS. The
180  * routine is passed the address of DATA as parameter. The ROUTINE must
181  * not be longer than ROUTINE_CODE_SIZE bytes. DATA_SIZE is the size of
182  * DATA structure.
183  *
184  * Note that the code must be positionally independent, and compiled
185  * without stack checks (they cause implicit calls into CRT so will
186  * fail). DATA should not refer any data in calling process, as both
187  * routine and its data are copied into remote process. Size of data
188  * and code together should not exceed one page (4K on x86 systems).
189  *
190  * Return the value returned by ROUTINE, or (DWORD)-1 if call failed.
191  */
192 static DWORD
193 run_in_other_process (HANDLE h_process,
194                       LPTHREAD_START_ROUTINE routine,
195                       LPVOID data, size_t data_size)
196 {
197   process_memory pm;
198   const size_t code_size = FRAGMENT_CODE_SIZE;
199   /* Need at most 3 extra bytes of memory, for data alignment */
200   size_t total_size = code_size + data_size + 3;
201   LPVOID remote_data;
202   HANDLE h_thread;
203   DWORD dw_unused;
204
205   /* Allocate memory */
206   if (!alloc_process_memory (h_process, total_size, &pm))
207     return (DWORD)-1;
208
209   /* Copy code */
210   if (!WriteProcessMemory (h_process, pm.address, (LPVOID)routine,
211                            code_size, NULL))
212     goto failure;
213
214   /* Copy data */
215   if (data_size)
216     {
217       remote_data = (LPBYTE)pm.address + ((code_size + 4) & ~3);
218       if (!WriteProcessMemory (h_process, remote_data, data, data_size, NULL))
219         goto failure;
220     }
221   else
222     remote_data = NULL;
223
224   /* Execute the remote copy of code, passing it remote data */
225   h_thread = CreateRemoteThread (h_process, NULL, 0,
226                                  (LPTHREAD_START_ROUTINE) pm.address,
227                                  remote_data, 0, &dw_unused);
228   if (h_thread == NULL)
229     goto failure;
230
231   /* Wait till thread finishes */
232   WaitForSingleObject (h_thread, INFINITE);
233
234   /* Free remote memory */
235   free_process_memory (&pm);
236
237   /* Return thread's exit code */
238   {
239     DWORD exit_code;
240     GetExitCodeThread (h_thread, &exit_code);
241     CloseHandle (h_thread);
242     return exit_code;
243   }
244
245  failure:
246   free_process_memory (&pm);
247   return (DWORD)-1;
248 }
249 \f
250 /*-----------------------------------------------------------------------*/
251 /* Sending signals                                                       */
252 /*-----------------------------------------------------------------------*/
253
254 /* ---------------------------- the NT way ------------------------------- */
255
256 /*
257  * We handle the following signals:
258  *
259  * SIGKILL, SIGTERM, SIGQUIT, SIGHUP - These four translate to ExitProcess
260  *    executed by the remote process
261  * SIGINT - The remote process is sent CTRL_BREAK_EVENT
262  *
263  * The MSVC5.0 compiler feels free to re-order functions within a
264  * compilation unit, so we have no way of finding out the size of the
265  * following functions. Therefore these functions must not be larger than
266  * FRAGMENT_CODE_SIZE.
267  */
268
269 /*
270  * Sending SIGKILL
271  */
272 typedef struct
273 {
274   void (WINAPI *adr_ExitProcess) (UINT);
275 } sigkill_data;
276
277 static DWORD WINAPI
278 sigkill_proc (sigkill_data* data)
279 {
280   (*data->adr_ExitProcess)(255);
281   return 1;
282 }
283
284 /*
285  * Sending break or control c
286  */
287 typedef struct
288 {
289   BOOL (WINAPI *adr_GenerateConsoleCtrlEvent) (DWORD, DWORD);
290   DWORD event;
291 } sigint_data;
292
293 static DWORD WINAPI
294 sigint_proc (sigint_data* data)
295 {
296   return (*data->adr_GenerateConsoleCtrlEvent) (data->event, 0);
297 }
298
299 /*
300  * Enabling signals
301  */
302 typedef struct
303 {
304   BOOL (WINAPI *adr_SetConsoleCtrlHandler) (LPVOID, BOOL);
305 } sig_enable_data;
306
307 static DWORD WINAPI
308 sig_enable_proc (sig_enable_data* data)
309 {
310   (*data->adr_SetConsoleCtrlHandler) (NULL, FALSE);
311   return 1;
312 }
313
314 /*
315  * Send signal SIGNO to process H_PROCESS.
316  * Return nonzero if successful.
317  */
318
319 static int
320 send_signal_the_nt_way (struct nt_process_data *cp, int pid, int signo)
321 {
322   HANDLE h_process;
323   HMODULE h_kernel = GetModuleHandle ("kernel32");
324   int close_process = 0;
325   DWORD retval;
326   
327   assert (h_kernel != NULL);
328   
329   if (cp)
330     {
331       pid = cp->dwProcessId;
332       h_process = cp->h_process;
333     }
334   else
335     {
336       close_process = 1;
337       /* Try to open the process with required privileges */
338       h_process = OpenProcess (PROCESS_CREATE_THREAD
339                                | PROCESS_QUERY_INFORMATION 
340                                | PROCESS_VM_OPERATION
341                                | PROCESS_VM_WRITE,
342                                FALSE, pid);
343       if (!h_process)
344         return 0;
345     }
346
347   switch (signo)
348     {
349     case SIGKILL:
350     case SIGTERM:
351     case SIGQUIT:
352     case SIGHUP:
353       {
354         sigkill_data d;
355
356         d.adr_ExitProcess =
357           (void (WINAPI *) (UINT)) GetProcAddress (h_kernel, "ExitProcess");
358         assert (d.adr_ExitProcess);
359         retval = run_in_other_process (h_process, 
360                                        (LPTHREAD_START_ROUTINE)sigkill_proc,
361                                        &d, sizeof (d));
362         break;
363       }
364     case SIGINT:
365       {
366         sigint_data d;
367         d.adr_GenerateConsoleCtrlEvent =
368           (BOOL (WINAPI *) (DWORD, DWORD))
369           GetProcAddress (h_kernel, "GenerateConsoleCtrlEvent");
370         assert (d.adr_GenerateConsoleCtrlEvent);
371         d.event = CTRL_C_EVENT;
372         retval = run_in_other_process (h_process, 
373                                        (LPTHREAD_START_ROUTINE)sigint_proc,
374                                        &d, sizeof (d));
375         break;
376       }
377     default:
378       assert (0);
379     }
380
381   if (close_process)
382     CloseHandle (h_process);
383   return (int)retval > 0 ? 1 : 0;
384 }
385
386 /*
387  * Enable CTRL_C_EVENT handling in a new child process
388  */
389 static void
390 enable_child_signals (HANDLE h_process)
391 {
392   HMODULE h_kernel = GetModuleHandle ("kernel32");
393   sig_enable_data d;
394   
395   assert (h_kernel != NULL);
396   d.adr_SetConsoleCtrlHandler =
397     (BOOL (WINAPI *) (LPVOID, BOOL))
398     GetProcAddress (h_kernel, "SetConsoleCtrlHandler");
399   assert (d.adr_SetConsoleCtrlHandler);
400   run_in_other_process (h_process, (LPTHREAD_START_ROUTINE)sig_enable_proc,
401                         &d, sizeof (d));
402 }
403   
404 #pragma warning (default : 4113)
405
406 /* ---------------------------- the 95 way ------------------------------- */
407
408 static BOOL CALLBACK
409 find_child_console (HWND hwnd, long putada)
410 {
411   DWORD thread_id;
412   DWORD process_id;
413   struct nt_process_data *cp = (struct nt_process_data *) putada;
414
415   thread_id = GetWindowThreadProcessId (hwnd, &process_id);
416   if (process_id == cp->dwProcessId)
417     {
418       char window_class[32];
419
420       GetClassName (hwnd, window_class, sizeof (window_class));
421       if (strcmp (window_class,
422                   mswindows_windows9x_p ()
423                   ? "tty"
424                   : "ConsoleWindowClass") == 0)
425         {
426           cp->hwnd = hwnd;
427           return FALSE;
428         }
429     }
430   /* keep looking */
431   return TRUE;
432 }
433
434 static int
435 send_signal_the_95_way (struct nt_process_data *cp, int pid, int signo)
436 {
437   HANDLE h_process;
438   int close_process = 0;
439   int rc = 1;
440   
441   if (cp)
442     {
443       pid = cp->dwProcessId;
444       h_process = cp->h_process;
445
446       /* Try to locate console window for process. */
447       EnumWindows (find_child_console, (LPARAM) cp);
448     }
449   else
450     {
451       close_process = 1;
452       /* Try to open the process with required privileges */
453       h_process = OpenProcess (PROCESS_TERMINATE, FALSE, pid);
454       if (!h_process)
455         return 0;
456     }
457     
458   if (signo == SIGINT)
459     {
460       if (NILP (Vmswindows_start_process_share_console) && cp && cp->hwnd)
461         {
462           BYTE control_scan_code = (BYTE) MapVirtualKey (VK_CONTROL, 0);
463           BYTE vk_break_code = VK_CANCEL;
464           BYTE break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
465           HWND foreground_window;
466
467           if (break_scan_code == 0)
468             {
469               /* Fake Ctrl-C if we can't manage Ctrl-Break. */
470               vk_break_code = 'C';
471               break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
472             }
473
474           foreground_window = GetForegroundWindow ();
475           if (foreground_window)
476             {
477               /* NT 5.0, and apparently also Windows 98, will not allow
478                  a Window to be set to foreground directly without the
479                  user's involvement. The workaround is to attach
480                  ourselves to the thread that owns the foreground
481                  window, since that is the only thread that can set the
482                  foreground window.  */
483               DWORD foreground_thread, child_thread;
484               foreground_thread =
485                 GetWindowThreadProcessId (foreground_window, NULL);
486               if (foreground_thread == GetCurrentThreadId ()
487                   || !AttachThreadInput (GetCurrentThreadId (),
488                                          foreground_thread, TRUE))
489                 foreground_thread = 0;
490
491               child_thread = GetWindowThreadProcessId (cp->hwnd, NULL);
492               if (child_thread == GetCurrentThreadId ()
493                   || !AttachThreadInput (GetCurrentThreadId (),
494                                          child_thread, TRUE))
495                 child_thread = 0;
496
497               /* Set the foreground window to the child.  */
498               if (SetForegroundWindow (cp->hwnd))
499                 {
500                   /* Generate keystrokes as if user had typed Ctrl-Break or
501                      Ctrl-C.  */
502                   keybd_event (VK_CONTROL, control_scan_code, 0, 0);
503                   keybd_event (vk_break_code, break_scan_code,
504                     (vk_break_code == 'C' ? 0 : KEYEVENTF_EXTENDEDKEY), 0);
505                   keybd_event (vk_break_code, break_scan_code,
506                     (vk_break_code == 'C' ? 0 : KEYEVENTF_EXTENDEDKEY)
507                     | KEYEVENTF_KEYUP, 0);
508                   keybd_event (VK_CONTROL, control_scan_code,
509                                KEYEVENTF_KEYUP, 0);
510
511                   /* Sleep for a bit to give time for Emacs frame to respond
512                      to focus change events (if Emacs was active app).  */
513                   Sleep (100);
514
515                   SetForegroundWindow (foreground_window);
516                 }
517               /* Detach from the foreground and child threads now that
518                  the foreground switching is over.  */
519               if (foreground_thread)
520                 AttachThreadInput (GetCurrentThreadId (),
521                                    foreground_thread, FALSE);
522               if (child_thread)
523                 AttachThreadInput (GetCurrentThreadId (),
524                                    child_thread, FALSE);
525             }
526         }
527       /* Ctrl-Break is NT equivalent of SIGINT.  */
528       else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, pid))
529         {
530 #if 0 /* FSF Emacs */
531           DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
532                      "for pid %lu\n", GetLastError (), pid));
533           errno = EINVAL;
534 #endif
535           rc = 0;
536         }
537     }
538   else
539     {
540       if (NILP (Vmswindows_start_process_share_console) && cp && cp->hwnd)
541         {
542 #if 1
543           if (mswindows_windows9x_p ())
544             {
545 /*
546    Another possibility is to try terminating the VDM out-right by
547    calling the Shell VxD (id 0x17) V86 interface, function #4
548    "SHELL_Destroy_VM", ie.
549
550      mov edx,4
551      mov ebx,vm_handle
552      call shellapi
553
554    First need to determine the current VM handle, and then arrange for
555    the shellapi call to be made from the system vm (by using
556    Switch_VM_and_callback).
557
558    Could try to invoke DestroyVM through CallVxD.
559
560 */
561 #if 0
562               /* On Win95, posting WM_QUIT causes the 16-bit subsystem
563                  to hang when cmdproxy is used in conjunction with
564                  command.com for an interactive shell.  Posting
565                  WM_CLOSE pops up a dialog that, when Yes is selected,
566                  does the same thing.  TerminateProcess is also less
567                  than ideal in that subprocesses tend to stick around
568                  until the machine is shutdown, but at least it
569                  doesn't freeze the 16-bit subsystem.  */
570               PostMessage (cp->hwnd, WM_QUIT, 0xff, 0);
571 #endif
572               if (!TerminateProcess (h_process, 0xff))
573                 {
574 #if 0 /* FSF Emacs */
575                   DebPrint (("sys_kill.TerminateProcess returned %d "
576                              "for pid %lu\n", GetLastError (), pid));
577                   errno = EINVAL;
578 #endif
579                   rc = 0;
580                 }
581             }
582           else
583 #endif
584             PostMessage (cp->hwnd, WM_CLOSE, 0, 0);
585         }
586       /* Kill the process.  On W32 this doesn't kill child processes
587          so it doesn't work very well for shells which is why it's not
588          used in every case.  */
589       else if (!TerminateProcess (h_process, 0xff))
590         {
591 #if 0 /* FSF Emacs */
592           DebPrint (("sys_kill.TerminateProcess returned %d "
593                      "for pid %lu\n", GetLastError (), pid));
594           errno = EINVAL;
595 #endif
596           rc = 0;
597         }
598     }
599
600   if (close_process)
601     CloseHandle (h_process);
602
603   return rc;
604 }
605
606 /* -------------------------- all-OS functions ---------------------------- */
607
608 static int
609 send_signal (struct nt_process_data *cp, int pid, int signo)
610 {
611   return (!mswindows_windows9x_p () && send_signal_the_nt_way (cp, pid, signo))
612     || send_signal_the_95_way (cp, pid, signo);
613 }
614
615 /*
616  * Signal error if SIGNO is not supported
617  */
618 static void
619 validate_signal_number (int signo)
620 {
621   if (signo != SIGKILL && signo != SIGTERM
622       && signo != SIGQUIT && signo != SIGINT
623       && signo != SIGHUP)
624     invalid_argument ("Signal number not supported", make_int (signo));
625 }
626 \f  
627 /*-----------------------------------------------------------------------*/
628 /* Process methods                                                       */
629 /*-----------------------------------------------------------------------*/
630
631 /*
632  * Allocate and initialize Lisp_Process->process_data
633  */
634
635 static void
636 nt_alloc_process_data (Lisp_Process *p)
637 {
638   p->process_data = xnew_and_zero (struct nt_process_data);
639 }
640
641 static void
642 nt_finalize_process_data (Lisp_Process *p, int for_disksave)
643 {
644   assert (!for_disksave);
645   /* If it's still in the list of processes we are waiting on delete
646      it.  */
647   mswindows_unwait_process (p);
648   if (NT_DATA (p)->h_process)
649     CloseHandle (NT_DATA (p)->h_process);
650 }
651
652 /*
653  * Initialize XEmacs process implementation once
654  */
655 static void
656 nt_init_process (void)
657 {
658   /* Initialize winsock */
659   WSADATA wsa_data;
660   /* Request Winsock v1.1 Note the order: (minor=1, major=1) */
661   WSAStartup (MAKEWORD (1,1), &wsa_data);
662 }
663
664 /*
665  * Fork off a subprocess. P is a pointer to newly created subprocess
666  * object. If this function signals, the caller is responsible for
667  * deleting (and finalizing) the process object.
668  *
669  * The method must return PID of the new process, a (positive??? ####) number
670  * which fits into Lisp_Int. No return value indicates an error, the method
671  * must signal an error instead.
672  */
673
674 static void
675 signal_cannot_launch (Lisp_Object image_file, DWORD err)
676 {
677   mswindows_set_errno (err);
678   report_file_error ("Error starting", image_file);
679 }
680
681 static void
682 ensure_console_window_exists (void)
683 {
684   if (mswindows_windows9x_p ())
685     mswindows_hide_console ();
686 }
687
688 int
689 compare_env (const void *strp1, const void *strp2)
690 {
691   const char *str1 = *(const char**)strp1, *str2 = *(const char**)strp2;
692
693   while (*str1 && *str2 && *str1 != '=' && *str2 != '=')
694     {
695       if ((*str1) > (*str2))
696         return 1;
697       else if ((*str1) < (*str2))
698         return -1;
699       str1++, str2++;
700     }
701
702   if (*str1 == '=' && *str2 == '=')
703     return 0;
704   else if (*str1 == '=')
705     return -1;
706   else
707     return 1;
708 }
709
710 static int
711 nt_create_process (Lisp_Process *p,
712                    Lisp_Object *argv, int nargv,
713                    Lisp_Object program, Lisp_Object cur_dir)
714 {
715   /* Synched up with sys_spawnve in FSF 20.6.  Significantly different
716      but still synchable. */
717   HANDLE hmyshove, hmyslurp, hprocin, hprocout, hprocerr;
718   Extbyte *command_line;
719   BOOL do_io, windowed;
720   char *proc_env;
721
722   /* No need to DOS-ize the filename; expand-file-name (called prior)
723      already does this. */
724
725   /* Find out whether the application is windowed or not */
726   if (xSHGetFileInfoA)
727     {
728       /* SHGetFileInfo tends to return ERROR_FILE_NOT_FOUND on most
729          errors. This leads to bogus error message. */
730       DWORD image_type;
731       char *p = strrchr ((char *)XSTRING_DATA (program), '.');
732       if (p != NULL &&
733           (stricmp (p, ".exe") == 0 ||
734            stricmp (p, ".com") == 0 ||
735            stricmp (p, ".bat") == 0 ||
736            stricmp (p, ".cmd") == 0))
737         {
738           image_type = xSHGetFileInfoA ((char *)XSTRING_DATA (program), 0,NULL,
739                                         0, SHGFI_EXETYPE);
740         }
741       else
742         {
743           char progname[MAX_PATH];
744           sprintf (progname, "%s.exe", (char *)XSTRING_DATA (program));
745           image_type = xSHGetFileInfoA (progname, 0, NULL, 0, SHGFI_EXETYPE);
746         }
747       if (image_type == 0)
748         signal_cannot_launch (program, (GetLastError () == ERROR_FILE_NOT_FOUND
749                                         ? ERROR_BAD_FORMAT : GetLastError ()));
750       windowed = HIWORD (image_type) != 0;
751     }
752   else /* NT 3.5; we have no idea so just guess. */
753     windowed = 0;
754
755   /* Decide whether to do I/O on process handles, or just mark the
756      process exited immediately upon successful launching. We do I/O if the
757      process is a console one, or if it is windowed but windowed_process_io
758      is non-zero */
759   do_io = !windowed || windowed_process_io ;
760   
761   if (do_io)
762     {
763       /* Create two unidirectional named pipes */
764       HANDLE htmp;
765       SECURITY_ATTRIBUTES sa;
766
767       sa.nLength = sizeof(sa);
768       sa.bInheritHandle = TRUE;
769       sa.lpSecurityDescriptor = NULL;
770
771       CreatePipe (&hprocin, &hmyshove, &sa, 0);
772       CreatePipe (&hmyslurp, &hprocout, &sa, 0);
773
774       /* Duplicate the stdout handle for use as stderr */
775       DuplicateHandle(GetCurrentProcess(), hprocout, GetCurrentProcess(),
776                       &hprocerr, 0, TRUE, DUPLICATE_SAME_ACCESS);
777
778       /* Stupid Win32 allows to create a pipe with *both* ends either
779          inheritable or not. We need process ends inheritable, and local
780          ends not inheritable. */
781       DuplicateHandle (GetCurrentProcess(), hmyshove, GetCurrentProcess(),
782                        &htmp, 0, FALSE,
783                        DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
784       hmyshove = htmp;
785       DuplicateHandle (GetCurrentProcess(), hmyslurp, GetCurrentProcess(),
786                        &htmp, 0, FALSE,
787                        DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
788       hmyslurp = htmp;
789     }
790
791   /* Convert an argv vector into Win32 style command line by a call to
792      lisp function `mswindows-construct-process-command-line'
793      (in win32-native.el) */
794   {
795     int i;
796     Lisp_Object args_or_ret = Qnil;
797     struct gcpro gcpro1;
798
799     GCPRO1 (args_or_ret);
800
801     for (i = 0; i < nargv; ++i)
802       args_or_ret = Fcons (*argv++, args_or_ret);
803     args_or_ret = Fnreverse (args_or_ret);
804     args_or_ret = Fcons (program, args_or_ret);
805
806     args_or_ret = call1 (Qmswindows_construct_process_command_line,
807                          args_or_ret);
808
809     if (!STRINGP (args_or_ret))
810       /* Luser wrote his/her own clever version */
811       invalid_argument
812         ("Bogus return value from `mswindows-construct-process-command-line'",
813          args_or_ret);
814
815     LISP_STRING_TO_EXTERNAL (args_or_ret, command_line, Qmswindows_tstr);
816
817     UNGCPRO; /* args_or_ret */
818   }
819
820   /* Set `proc_env' to a nul-separated array of the strings in
821      Vprocess_environment terminated by 2 nuls.  */
822  
823   {
824     char **env;
825     REGISTER Lisp_Object tem;
826     REGISTER char **new_env;
827     REGISTER int new_length = 0, i, new_space;
828     char *penv;
829     
830     for (tem = Vprocess_environment;
831          (CONSP (tem)
832           && STRINGP (XCAR (tem)));
833          tem = XCDR (tem))
834       new_length++;
835
836     /* FSF adds an extra env var to hold the current process ID of the
837        Emacs process.  Apparently this is used only by emacsserver.c,
838        which we have superseded to gnuserv.c. (#### Does it work under
839        MS Windows?)
840
841        sprintf (ppid_env_var_buffer, "EM_PARENT_PROCESS_ID=%d", 
842          GetCurrentProcessId ());
843        arglen += strlen (ppid_env_var_buffer) + 1;
844        numenv++;
845     */
846     
847     /* new_length + 1 to include terminating 0.  */
848     env = new_env = alloca_array (char *, new_length + 1);
849  
850     /* Copy the Vprocess_environment strings into new_env.  */
851     for (tem = Vprocess_environment;
852          (CONSP (tem)
853           && STRINGP (XCAR (tem)));
854          tem = XCDR (tem))
855       {
856         char **ep = env;
857         char *string = (char *) XSTRING_DATA (XCAR (tem));
858         /* See if this string duplicates any string already in the env.
859            If so, don't put it in.
860            When an env var has multiple definitions,
861            we keep the definition that comes first in process-environment.  */
862         for (; ep != new_env; ep++)
863           {
864             char *p = *ep, *q = string;
865             while (1)
866               {
867                 if (*q == 0)
868                   /* The string is malformed; might as well drop it.  */
869                   goto duplicate;
870                 if (*q != *p)
871                   break;
872                 if (*q == '=')
873                   goto duplicate;
874                 p++, q++;
875               }
876           }
877         *new_env++ = string;
878       duplicate: ;
879       }
880     *new_env = 0;
881     
882     /* Sort the environment variables */
883     new_length = new_env - env;
884     qsort (env, new_length, sizeof (char *), compare_env);
885     
886     /* Work out how much space to allocate */
887     new_space = 0;
888     for (i = 0; i < new_length; i++)
889       {
890         new_space += strlen(env[i]) + 1;
891       }
892     new_space++;
893     
894     /* Allocate space and copy variables into it */
895     penv = proc_env = (char*) alloca(new_space);
896     for (i = 0; i < new_length; i++)
897       {
898         strcpy(penv, env[i]);
899         penv += strlen(env[i]) + 1;
900       }
901     *penv = 0;
902   }
903
904 #if 0
905     /* #### we need to port this. */
906     /* On Windows 95, if cmdname is a DOS app, we invoke a helper
907        application to start it by specifying the helper app as cmdname,
908        while leaving the real app name as argv[0].  */
909     if (is_dos_app)
910       {
911         cmdname = (char*) alloca (MAXPATHLEN);
912         if (egetenv ("CMDPROXY"))
913           strcpy ((char*)cmdname, egetenv ("CMDPROXY"));
914         else
915           {
916             strcpy ((char*)cmdname, XSTRING_DATA (Vinvocation_directory));
917             strcat ((char*)cmdname, "cmdproxy.exe");
918           }
919       }
920 #endif
921   
922   /* Create process */
923   {
924     STARTUPINFO si;
925     PROCESS_INFORMATION pi;
926     DWORD err;
927     DWORD flags;
928
929     xzero (si);
930     si.dwFlags = STARTF_USESHOWWINDOW;
931     si.wShowWindow = windowed ? SW_SHOWNORMAL : SW_HIDE;
932     if (do_io)
933       {
934         si.hStdInput = hprocin;
935         si.hStdOutput = hprocout;
936         si.hStdError = hprocerr;
937         si.dwFlags |= STARTF_USESTDHANDLES;
938       }
939
940     flags = CREATE_SUSPENDED;
941     if (mswindows_windows9x_p ())
942       flags |= (!NILP (Vmswindows_start_process_share_console)
943                 ? CREATE_NEW_PROCESS_GROUP
944                 : CREATE_NEW_CONSOLE);
945     else
946       flags |= CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP;
947     if (NILP (Vmswindows_start_process_inherit_error_mode))
948       flags |= CREATE_DEFAULT_ERROR_MODE;
949
950     ensure_console_window_exists ();
951
952     err = (CreateProcess (NULL, command_line, NULL, NULL, TRUE, flags,
953                           proc_env, (char *) XSTRING_DATA (cur_dir), &si, &pi)
954            ? 0 : GetLastError ());
955
956     if (do_io)
957       {
958         /* These just have been inherited; we do not need a copy */
959         CloseHandle (hprocin);
960         CloseHandle (hprocout);
961         CloseHandle (hprocerr);
962       }
963     
964     /* Handle process creation failure */
965     if (err)
966       {
967         if (do_io)
968           {
969             CloseHandle (hmyshove);
970             CloseHandle (hmyslurp);
971           }
972         signal_cannot_launch (program, GetLastError ());
973       }
974
975     /* The process started successfully */
976     if (do_io)
977       {
978         NT_DATA(p)->h_process = pi.hProcess;
979         NT_DATA(p)->dwProcessId = pi.dwProcessId;
980         init_process_io_handles (p, (void*)hmyslurp, (void*)hmyshove, 0);
981       }
982     else
983       {
984         /* Indicate as if the process has exited immediately. */
985         p->status_symbol = Qexit;
986         CloseHandle (pi.hProcess);
987       }
988
989     if (!windowed)
990       enable_child_signals (pi.hProcess);
991
992     ResumeThread (pi.hThread);
993     CloseHandle (pi.hThread);
994
995     return ((int)pi.dwProcessId);
996   }
997 }
998
999 /* 
1000  * This method is called to update status fields of the process
1001  * structure. If the process has not existed, this method is expected
1002  * to do nothing.
1003  *
1004  * The method is called only for real child processes.  
1005  */
1006
1007 static void
1008 nt_update_status_if_terminated (Lisp_Process* p)
1009 {
1010   DWORD exit_code;
1011   if (GetExitCodeProcess (NT_DATA(p)->h_process, &exit_code)
1012       && exit_code != STILL_ACTIVE)
1013     {
1014       p->tick++;
1015       p->core_dumped = 0;
1016       /* The exit code can be a code returned by process, or an
1017          NTSTATUS value. We cannot accurately handle the latter since
1018          it is a full 32 bit integer */
1019       if (exit_code & 0xC0000000)
1020         {
1021           p->status_symbol = Qsignal;
1022           p->exit_code = exit_code & 0x1FFFFFFF;
1023         }
1024       else
1025         {
1026           p->status_symbol = Qexit;
1027           p->exit_code = exit_code;
1028         }
1029     }
1030 }
1031
1032 /*
1033  * Stuff the entire contents of LSTREAM to the process output pipe
1034  */
1035
1036 /* #### If only this function could be somehow merged with
1037    unix_send_process... */
1038
1039 static void
1040 nt_send_process (Lisp_Object proc, struct lstream* lstream)
1041 {
1042   volatile Lisp_Object vol_proc = proc;
1043   Lisp_Process *volatile p = XPROCESS (proc);
1044
1045   /* use a reasonable-sized buffer (somewhere around the size of the
1046      stream buffer) so as to avoid inundating the stream with blocked
1047      data. */
1048   Bufbyte chunkbuf[512];
1049   Bytecount chunklen;
1050
1051   while (1)
1052     {
1053       Lstream_data_count writeret;
1054
1055       chunklen = Lstream_read (lstream, chunkbuf, 512);
1056       if (chunklen <= 0)
1057         break; /* perhaps should ABORT() if < 0?
1058                   This should never happen. */
1059
1060       /* Lstream_write() will never successfully write less than the
1061          amount sent in.  In the worst case, it just buffers the
1062          unwritten data. */
1063       writeret = Lstream_write (XLSTREAM (DATA_OUTSTREAM(p)), chunkbuf,
1064                                 chunklen);
1065       Lstream_flush (XLSTREAM (DATA_OUTSTREAM(p)));
1066       if (writeret < 0)
1067         {
1068           p->status_symbol = Qexit;
1069           p->exit_code = ERROR_BROKEN_PIPE;
1070           p->core_dumped = 0;
1071           p->tick++;
1072           process_tick++;
1073           deactivate_process (*((Lisp_Object *) (&vol_proc)));
1074           invalid_operation ("Broken pipe error sending to process; closed it",
1075                              p->name);
1076         }
1077
1078       {
1079         int wait_ms = 25;
1080         while (Lstream_was_blocked_p (XLSTREAM (p->pipe_outstream)))
1081           {
1082             /* Buffer is full.  Wait, accepting input; that may allow
1083                the program to finish doing output and read more.  */
1084             Faccept_process_output (Qnil, Qzero, make_int (wait_ms));
1085             Lstream_flush (XLSTREAM (p->pipe_outstream));
1086             wait_ms = min (1000, 2 * wait_ms);
1087           }
1088       }
1089     }
1090 }
1091
1092 /*
1093  * Send a signal number SIGNO to PROCESS.
1094  * CURRENT_GROUP means send to the process group that currently owns
1095  * the terminal being used to communicate with PROCESS.
1096  * This is used for various commands in shell mode.
1097  * If NOMSG is zero, insert signal-announcements into process's buffers
1098  * right away.
1099  *
1100  * If we can, we try to signal PROCESS by sending control characters
1101  * down the pty.  This allows us to signal inferiors who have changed
1102  * their uid, for which killpg would return an EPERM error.
1103  *
1104  * The method signals an error if the given SIGNO is not valid
1105  */
1106
1107 static void
1108 nt_kill_child_process (Lisp_Object proc, int signo,
1109                        int current_group, int nomsg)
1110 {
1111   Lisp_Process *p = XPROCESS (proc);
1112
1113   /* Signal error if SIGNO cannot be sent */
1114   validate_signal_number (signo);
1115
1116   /* Send signal */
1117   if (!send_signal (NT_DATA (p), 0, signo))
1118     invalid_operation ("Cannot send signal to process", proc);
1119 }
1120
1121 /*
1122  * Kill any process in the system given its PID
1123  *
1124  * Returns zero if a signal successfully sent, or
1125  * negative number upon failure
1126  */
1127 static int
1128 nt_kill_process_by_pid (int pid, int signo)
1129 {
1130   struct Lisp_Process *p;
1131
1132   /* Signal error if SIGNO cannot be sent */
1133   validate_signal_number (signo);
1134
1135   p = find_process_from_pid (pid);
1136   return send_signal (p ? NT_DATA (p) : 0, pid, signo) ? 0 : -1;
1137 }
1138 \f
1139 /*-----------------------------------------------------------------------*/
1140 /* Sockets connections                                                   */
1141 /*-----------------------------------------------------------------------*/
1142 #ifdef HAVE_SOCKETS
1143
1144 /* #### Hey MS, how long Winsock 2 for '95 will be in beta? */
1145
1146 #define SOCK_TIMER_ID 666
1147 #define XM_SOCKREPLY (WM_USER + 666)
1148
1149 static int
1150 get_internet_address (Lisp_Object host, struct sockaddr_in *address,
1151                       Error_behavior errb)
1152 {
1153   char buf [MAXGETHOSTSTRUCT];
1154   HWND hwnd;
1155   HANDLE hasync;
1156   int success = 0;
1157
1158   address->sin_family = AF_INET;
1159
1160   /* First check if HOST is already a numeric address */
1161   {
1162     unsigned long inaddr = inet_addr (XSTRING_DATA (host));
1163     if (inaddr != INADDR_NONE)
1164       {
1165         address->sin_addr.s_addr = inaddr;
1166         return 1;
1167       }
1168   }
1169
1170   /* Create a window which will receive completion messages */
1171   hwnd = CreateWindow ("STATIC", NULL, WS_OVERLAPPED, 0, 0, 1, 1,
1172                        NULL, NULL, NULL, NULL);
1173   assert (hwnd);
1174
1175   /* Post name resolution request */
1176   hasync = WSAAsyncGetHostByName (hwnd, XM_SOCKREPLY, XSTRING_DATA (host),
1177                                   buf, sizeof (buf));
1178   if (hasync == NULL)
1179     goto done;
1180
1181   /* Set a timer to poll for quit every 250 ms */
1182   SetTimer (hwnd, SOCK_TIMER_ID, 250, NULL);
1183
1184   while (1)
1185     {
1186       MSG msg;
1187       GetMessage (&msg, hwnd, 0, 0);
1188       if (msg.message == XM_SOCKREPLY)
1189         {
1190           /* Ok, got an answer */
1191           if (WSAGETASYNCERROR(msg.lParam) == NO_ERROR)
1192             success = 1;
1193           else
1194             {
1195               warn_when_safe(Qstream, Qwarning,
1196                              "cannot get IP address for host \"%s\"",
1197                              XSTRING_DATA (host));
1198             }
1199           goto done;
1200         }
1201       else if (msg.message == WM_TIMER && msg.wParam == SOCK_TIMER_ID)
1202         {
1203           if (QUITP)
1204             {
1205               WSACancelAsyncRequest (hasync);
1206               KillTimer (hwnd, SOCK_TIMER_ID);
1207               DestroyWindow (hwnd);
1208               REALLY_QUIT;
1209             }
1210         }
1211       DispatchMessage (&msg);
1212     }
1213
1214  done:
1215   KillTimer (hwnd, SOCK_TIMER_ID);
1216   DestroyWindow (hwnd);
1217   if (success)
1218     {
1219       /* BUF starts with struct hostent */
1220       struct hostent* he = (struct hostent*) buf;
1221       address->sin_addr.s_addr = *(unsigned long*)he->h_addr_list[0];
1222     }
1223   return success;
1224 }
1225
1226 static Lisp_Object
1227 nt_canonicalize_host_name (Lisp_Object host)
1228 {
1229   struct sockaddr_in address;
1230
1231   if (!get_internet_address (host, &address, ERROR_ME_NOT))
1232     return host;
1233
1234   if (address.sin_family == AF_INET)
1235     return build_string (inet_ntoa (address.sin_addr));
1236   else
1237     return host;
1238 }
1239
1240 /* open a TCP network connection to a given HOST/SERVICE.  Treated
1241    exactly like a normal process when reading and writing.  Only
1242    differences are in status display and process deletion.  A network
1243    connection has no PID; you cannot signal it.  All you can do is
1244    deactivate and close it via delete-process */
1245
1246 static void
1247 nt_open_network_stream (Lisp_Object name, Lisp_Object host,
1248                         Lisp_Object service,
1249                         Lisp_Object protocol, void** vinfd, void** voutfd)
1250 {
1251   /* !!#### not Mule-ized */
1252   struct sockaddr_in address;
1253   SOCKET s;
1254   int port;
1255   int retval;
1256
1257   CHECK_STRING (host);
1258
1259   if (!EQ (protocol, Qtcp))
1260     invalid_argument ("Unsupported protocol", protocol);
1261
1262   if (INTP (service))
1263     port = htons ((unsigned short) XINT (service));
1264   else
1265     {
1266       struct servent *svc_info;
1267       CHECK_STRING (service);
1268       svc_info = getservbyname ((char *) XSTRING_DATA (service), "tcp");
1269       if (svc_info == 0)
1270         invalid_argument ("Unknown service", service);
1271       port = svc_info->s_port;
1272     }
1273
1274   get_internet_address (host, &address, ERROR_ME);
1275   address.sin_port = port;
1276
1277   s = socket (address.sin_family, SOCK_STREAM, 0);
1278   if (s < 0)
1279     report_file_error ("error creating socket", list1 (name));
1280
1281   /* We don't want to be blocked on connect */
1282   {
1283     unsigned long nonblock = 1;
1284     ioctlsocket (s, FIONBIO, &nonblock);
1285   }
1286   
1287   retval = connect (s, (struct sockaddr *) &address, sizeof (address));
1288   if (retval != NO_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
1289     goto connect_failed;
1290   /* Wait while connection is established */
1291   while (1)
1292     {
1293       fd_set fdset;
1294       struct timeval tv;
1295       int nsel;
1296
1297       if (QUITP)
1298         {
1299           closesocket (s);
1300           REALLY_QUIT;
1301         }
1302
1303       /* Poll for quit every 250 ms */
1304       tv.tv_sec = 0;
1305       tv.tv_usec = 250 * 1000;
1306
1307       FD_ZERO (&fdset);
1308       FD_SET (s, &fdset);
1309       nsel = select (0, NULL, &fdset, &fdset, &tv);
1310
1311       if (nsel > 0)
1312         {
1313           /* Check: was connection successful or not? */
1314           tv.tv_usec = 0;
1315           nsel = select (0, NULL, NULL, &fdset, &tv);
1316           if (nsel > 0)
1317             goto connect_failed;
1318           else
1319             break;
1320         }
1321     }
1322
1323   /* We are connected at this point */
1324   *vinfd = (void*)s;
1325   DuplicateHandle (GetCurrentProcess(), (HANDLE)s,
1326                    GetCurrentProcess(), (LPHANDLE)voutfd,
1327                    0, FALSE, DUPLICATE_SAME_ACCESS);
1328   return;
1329
1330  connect_failed:  
1331   closesocket (s);
1332   if (INTP (service))
1333     {
1334       warn_when_safe (Qstream, Qwarning,
1335                       "failure to open network stream to host \"%s\" for service \"%d\"",
1336                       XSTRING_DATA (host),
1337                       (unsigned short) XINT (service));
1338     }
1339   else
1340     {
1341       warn_when_safe (Qstream, Qwarning,
1342                       "failure to open network stream to host \"%s\" for service \"%s\"",
1343                       XSTRING_DATA (host),
1344                       XSTRING_DATA (service));
1345     }
1346   report_file_error ("connection failed", list2 (host, name));
1347 }
1348
1349 #endif
1350 \f
1351 /*-----------------------------------------------------------------------*/
1352 /* Initialization                                                        */
1353 /*-----------------------------------------------------------------------*/
1354
1355 void
1356 process_type_create_nt (void)
1357 {
1358   PROCESS_HAS_METHOD (nt, alloc_process_data);
1359   PROCESS_HAS_METHOD (nt, finalize_process_data);
1360   PROCESS_HAS_METHOD (nt, init_process);
1361   PROCESS_HAS_METHOD (nt, create_process);
1362   PROCESS_HAS_METHOD (nt, update_status_if_terminated);
1363   PROCESS_HAS_METHOD (nt, send_process);
1364   PROCESS_HAS_METHOD (nt, kill_child_process);
1365   PROCESS_HAS_METHOD (nt, kill_process_by_pid);
1366 #ifdef HAVE_SOCKETS
1367   PROCESS_HAS_METHOD (nt, canonicalize_host_name);
1368   PROCESS_HAS_METHOD (nt, open_network_stream);
1369 #ifdef HAVE_MULTICAST
1370 #error I won't do this until '95 has winsock2
1371   PROCESS_HAS_METHOD (nt, open_multicast_group);
1372 #endif
1373 #endif
1374 }
1375
1376 void
1377 syms_of_process_nt (void)
1378 {
1379   DEFSYMBOL (Qmswindows_construct_process_command_line);
1380 }
1381
1382 void
1383 vars_of_process_nt (void)
1384 {
1385   DEFVAR_LISP ("mswindows-start-process-share-console",
1386                &Vmswindows_start_process_share_console /*
1387 When nil, new child processes are given a new console.
1388 When non-nil, they share the Emacs console; this has the limitation of
1389 allowing only one DOS subprocess to run at a time (whether started directly
1390 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
1391 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
1392 otherwise respond to interrupts from Emacs.
1393 */ );
1394   Vmswindows_start_process_share_console = Qnil;
1395
1396   DEFVAR_LISP ("mswindows-start-process-inherit-error-mode",
1397                &Vmswindows_start_process_inherit_error_mode /*
1398     "When nil, new child processes revert to the default error mode.
1399 When non-nil, they inherit their error mode setting from Emacs, which stops
1400 them blocking when trying to access unmounted drives etc.
1401 */ );
1402   Vmswindows_start_process_inherit_error_mode = Qt;
1403 }