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.
7 This file is part of XEmacs.
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
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
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. */
24 /* Written by Kirill M. Katsnelson <kkm@kis.ru>, April 1998 */
30 #include "console-msw.h"
45 /* Arbitrary size limit for code fragments passed to run_in_other_process */
46 #define FRAGMENT_CODE_SIZE 32
48 /* Implementation-specific data. Pointed to by Lisp_Process->process_data */
49 struct nt_process_data
53 HWND hwnd; /* console window */
56 /* Control how args are quoted to ensure correct parsing by child
58 Lisp_Object Vmswindows_quote_process_args;
60 /* Control whether create_child causes the process to inherit Emacs'
61 console window, or be given a new one of its own. The default is
62 nil, to allow multiple DOS programs to run on Win95. Having separate
63 consoles also allows Emacs to cleanly terminate process groups. */
64 Lisp_Object Vmswindows_start_process_share_console;
66 /* Control whether create_child cause the process to inherit Emacs'
67 error mode setting. The default is t, to minimize the possibility of
68 subprocesses blocking when accessing unmounted drives. */
69 Lisp_Object Vmswindows_start_process_inherit_error_mode;
71 #define NT_DATA(p) ((struct nt_process_data*)((p)->process_data))
73 /*-----------------------------------------------------------------------*/
75 /*-----------------------------------------------------------------------*/
77 /* This one breaks process abstraction. Prototype is in console-msw.h,
78 used by select_process method in event-msw.c */
80 get_nt_process_handle (Lisp_Process *p)
82 return (NT_DATA (p)->h_process);
85 static struct Lisp_Process *
86 find_process_from_pid (DWORD pid)
88 Lisp_Object tail, proc;
90 for (tail = Vprocess_list; CONSP (tail); tail = XCDR (tail))
93 if (NT_DATA (XPROCESS (proc))->dwProcessId == pid)
94 return XPROCESS (proc);
100 /*-----------------------------------------------------------------------*/
101 /* Running remote threads. See Microsoft Systems Journal 1994 Number 5 */
102 /* Jeffrey Richter, Load Your 32-bit DLL into Another Process's Address..*/
103 /*-----------------------------------------------------------------------*/
113 * Allocate SIZE bytes in H_PROCESS address space. Fill in PMC used
114 * further by other routines. Return nonzero if successful.
116 * The memory in other process is allocated by creating a suspended
117 * thread. Initial stack of that thread is used as the memory
118 * block. The thread entry point is the routine ExitThread in
119 * kernel32.dll, so the allocated memory is freed just by resuming the
120 * thread, which immediately terminates after that.
124 alloc_process_memory (HANDLE h_process, size_t size,
127 LPTHREAD_START_ROUTINE adr_ExitThread =
128 (LPTHREAD_START_ROUTINE)
129 GetProcAddress (GetModuleHandle ("kernel32"), "ExitThread");
132 MEMORY_BASIC_INFORMATION mbi;
134 pmc->h_process = h_process;
135 pmc->h_thread = CreateRemoteThread (h_process, NULL, size,
136 adr_ExitThread, NULL,
137 CREATE_SUSPENDED, &dw_unused);
138 if (pmc->h_thread == NULL)
141 /* Get context, for thread's stack pointer */
142 context.ContextFlags = CONTEXT_CONTROL;
143 if (!GetThreadContext (pmc->h_thread, &context))
146 /* Determine base address of the committed range */
147 if (sizeof(mbi) != VirtualQueryEx (h_process,
149 (LPDWORD)context.Esp - 1,
150 #elif defined (_ALPHA_)
151 (LPDWORD)context.IntSp - 1,
153 #error Unknown processor architecture
158 /* Change the page protection of the allocated memory to executable,
160 if (!VirtualProtectEx (h_process, mbi.BaseAddress, size,
161 PAGE_EXECUTE_READWRITE, &dw_unused))
164 pmc->address = mbi.BaseAddress;
168 ResumeThread (pmc->h_thread);
174 free_process_memory (process_memory* pmc)
176 ResumeThread (pmc->h_thread);
180 * Run ROUTINE in the context of process determined by H_PROCESS. The
181 * routine is passed the address of DATA as parameter. The ROUTINE must
182 * not be longer than ROUTINE_CODE_SIZE bytes. DATA_SIZE is the size of
185 * Note that the code must be positionally independent, and compiled
186 * without stack checks (they cause implicit calls into CRT so will
187 * fail). DATA should not refer any data in calling process, as both
188 * routine and its data are copied into remote process. Size of data
189 * and code together should not exceed one page (4K on x86 systems).
191 * Return the value returned by ROUTINE, or (DWORD)-1 if call failed.
194 run_in_other_process (HANDLE h_process,
195 LPTHREAD_START_ROUTINE routine,
196 LPVOID data, size_t data_size)
199 const size_t code_size = FRAGMENT_CODE_SIZE;
200 /* Need at most 3 extra bytes of memory, for data alignment */
201 size_t total_size = code_size + data_size + 3;
206 /* Allocate memory */
207 if (!alloc_process_memory (h_process, total_size, &pm))
211 if (!WriteProcessMemory (h_process, pm.address, (LPVOID)routine,
218 remote_data = (LPBYTE)pm.address + ((code_size + 4) & ~3);
219 if (!WriteProcessMemory (h_process, remote_data, data, data_size, NULL))
225 /* Execute the remote copy of code, passing it remote data */
226 h_thread = CreateRemoteThread (h_process, NULL, 0,
227 (LPTHREAD_START_ROUTINE) pm.address,
228 remote_data, 0, &dw_unused);
229 if (h_thread == NULL)
232 /* Wait till thread finishes */
233 WaitForSingleObject (h_thread, INFINITE);
235 /* Free remote memory */
236 free_process_memory (&pm);
238 /* Return thread's exit code */
241 GetExitCodeThread (h_thread, &exit_code);
242 CloseHandle (h_thread);
247 free_process_memory (&pm);
251 /*-----------------------------------------------------------------------*/
252 /* Sending signals */
253 /*-----------------------------------------------------------------------*/
255 /* ---------------------------- the NT way ------------------------------- */
258 * We handle the following signals:
260 * SIGKILL, SIGTERM, SIGQUIT, SIGHUP - These four translate to ExitProcess
261 * executed by the remote process
262 * SIGINT - The remote process is sent CTRL_BREAK_EVENT
264 * The MSVC5.0 compiler feels free to re-order functions within a
265 * compilation unit, so we have no way of finding out the size of the
266 * following functions. Therefore these functions must not be larger than
267 * FRAGMENT_CODE_SIZE.
275 void (WINAPI *adr_ExitProcess) (UINT);
279 sigkill_proc (sigkill_data* data)
281 (*data->adr_ExitProcess)(255);
286 * Sending break or control c
290 BOOL (WINAPI *adr_GenerateConsoleCtrlEvent) (DWORD, DWORD);
295 sigint_proc (sigint_data* data)
297 return (*data->adr_GenerateConsoleCtrlEvent) (data->event, 0);
305 BOOL (WINAPI *adr_SetConsoleCtrlHandler) (LPVOID, BOOL);
309 sig_enable_proc (sig_enable_data* data)
311 (*data->adr_SetConsoleCtrlHandler) (NULL, FALSE);
316 * Send signal SIGNO to process H_PROCESS.
317 * Return nonzero if successful.
321 send_signal_the_nt_way (struct nt_process_data *cp, int pid, int signo)
324 HMODULE h_kernel = GetModuleHandle ("kernel32");
325 int close_process = 0;
328 assert (h_kernel != NULL);
332 pid = cp->dwProcessId;
333 h_process = cp->h_process;
338 /* Try to open the process with required privileges */
339 h_process = OpenProcess (PROCESS_CREATE_THREAD
340 | PROCESS_QUERY_INFORMATION
341 | PROCESS_VM_OPERATION
358 (void (WINAPI *) (UINT)) GetProcAddress (h_kernel, "ExitProcess");
359 assert (d.adr_ExitProcess);
360 retval = run_in_other_process (h_process,
361 (LPTHREAD_START_ROUTINE)sigkill_proc,
368 d.adr_GenerateConsoleCtrlEvent =
369 (BOOL (WINAPI *) (DWORD, DWORD))
370 GetProcAddress (h_kernel, "GenerateConsoleCtrlEvent");
371 assert (d.adr_GenerateConsoleCtrlEvent);
372 d.event = CTRL_C_EVENT;
373 retval = run_in_other_process (h_process,
374 (LPTHREAD_START_ROUTINE)sigint_proc,
383 CloseHandle (h_process);
384 return (int)retval > 0 ? 1 : 0;
388 * Enable CTRL_C_EVENT handling in a new child process
391 enable_child_signals (HANDLE h_process)
393 HMODULE h_kernel = GetModuleHandle ("kernel32");
396 assert (h_kernel != NULL);
397 d.adr_SetConsoleCtrlHandler =
398 (BOOL (WINAPI *) (LPVOID, BOOL))
399 GetProcAddress (h_kernel, "SetConsoleCtrlHandler");
400 assert (d.adr_SetConsoleCtrlHandler);
401 run_in_other_process (h_process, (LPTHREAD_START_ROUTINE)sig_enable_proc,
405 #pragma warning (default : 4113)
407 /* ---------------------------- the 95 way ------------------------------- */
410 find_child_console (HWND hwnd, struct nt_process_data *cp)
415 thread_id = GetWindowThreadProcessId (hwnd, &process_id);
416 if (process_id == cp->dwProcessId)
418 char window_class[32];
420 GetClassName (hwnd, window_class, sizeof (window_class));
421 if (strcmp (window_class,
422 mswindows_windows9x_p ()
424 : "ConsoleWindowClass") == 0)
435 send_signal_the_95_way (struct nt_process_data *cp, int pid, int signo)
438 int close_process = 0;
443 pid = cp->dwProcessId;
444 h_process = cp->h_process;
446 /* Try to locate console window for process. */
447 EnumWindows (find_child_console, (LPARAM) cp);
452 /* Try to open the process with required privileges */
453 h_process = OpenProcess (PROCESS_TERMINATE, FALSE, pid);
460 if (NILP (Vmswindows_start_process_share_console) && cp && cp->hwnd)
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;
467 if (break_scan_code == 0)
469 /* Fake Ctrl-C if we can't manage Ctrl-Break. */
471 break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
474 foreground_window = GetForegroundWindow ();
475 if (foreground_window)
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;
485 GetWindowThreadProcessId (foreground_window, NULL);
486 if (foreground_thread == GetCurrentThreadId ()
487 || !AttachThreadInput (GetCurrentThreadId (),
488 foreground_thread, TRUE))
489 foreground_thread = 0;
491 child_thread = GetWindowThreadProcessId (cp->hwnd, NULL);
492 if (child_thread == GetCurrentThreadId ()
493 || !AttachThreadInput (GetCurrentThreadId (),
497 /* Set the foreground window to the child. */
498 if (SetForegroundWindow (cp->hwnd))
500 /* Generate keystrokes as if user had typed Ctrl-Break or
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,
511 /* Sleep for a bit to give time for Emacs frame to respond
512 to focus change events (if Emacs was active app). */
515 SetForegroundWindow (foreground_window);
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);
523 AttachThreadInput (GetCurrentThreadId (),
524 child_thread, FALSE);
527 /* Ctrl-Break is NT equivalent of SIGINT. */
528 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, pid))
530 #if 0 /* FSF Emacs */
531 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
532 "for pid %lu\n", GetLastError (), pid));
540 if (NILP (Vmswindows_start_process_share_console) && cp && cp->hwnd)
543 if (mswindows_windows9x_p ())
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.
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).
558 Could try to invoke DestroyVM through CallVxD.
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);
572 if (!TerminateProcess (h_process, 0xff))
574 #if 0 /* FSF Emacs */
575 DebPrint (("sys_kill.TerminateProcess returned %d "
576 "for pid %lu\n", GetLastError (), pid));
584 PostMessage (cp->hwnd, WM_CLOSE, 0, 0);
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))
591 #if 0 /* FSF Emacs */
592 DebPrint (("sys_kill.TerminateProcess returned %d "
593 "for pid %lu\n", GetLastError (), pid));
601 CloseHandle (h_process);
606 /* -------------------------- all-OS functions ---------------------------- */
609 send_signal (struct nt_process_data *cp, int pid, int signo)
611 return send_signal_the_nt_way (cp, pid, signo)
612 || send_signal_the_95_way (cp, pid, signo);
616 * Signal error if SIGNO is not supported
619 validate_signal_number (int signo)
621 if (signo != SIGKILL && signo != SIGTERM
622 && signo != SIGQUIT && signo != SIGINT
624 signal_simple_error ("Signal number not supported", make_int (signo));
627 /*-----------------------------------------------------------------------*/
628 /* Process methods */
629 /*-----------------------------------------------------------------------*/
632 * Allocate and initialize Lisp_Process->process_data
636 nt_alloc_process_data (Lisp_Process *p)
638 p->process_data = xnew_and_zero (struct nt_process_data);
642 nt_finalize_process_data (Lisp_Process *p, int for_disksave)
644 assert (!for_disksave);
645 if (NT_DATA (p)->h_process)
646 CloseHandle (NT_DATA (p)->h_process);
650 * Initialize XEmacs process implementation once
653 nt_init_process (void)
655 /* Initialize winsock */
657 /* Request Winsock v1.1 Note the order: (minor=1, major=1) */
658 WSAStartup (MAKEWORD (1,1), &wsa_data);
662 * Fork off a subprocess. P is a pointer to newly created subprocess
663 * object. If this function signals, the caller is responsible for
664 * deleting (and finalizing) the process object.
666 * The method must return PID of the new process, a (positive??? ####) number
667 * which fits into Lisp_Int. No return value indicates an error, the method
668 * must signal an error instead.
672 signal_cannot_launch (Lisp_Object image_file, DWORD err)
674 mswindows_set_errno (err);
675 signal_simple_error_2 ("Error starting", image_file, lisp_strerror (errno));
679 ensure_console_window_exists (void)
681 if (mswindows_windows9x_p ())
682 mswindows_hide_console ();
686 compare_env (const void *strp1, const void *strp2)
688 const char *str1 = *(const char**)strp1, *str2 = *(const char**)strp2;
690 while (*str1 && *str2 && *str1 != '=' && *str2 != '=')
692 if ((*str1) > (*str2))
694 else if ((*str1) < (*str2))
699 if (*str1 == '=' && *str2 == '=')
701 else if (*str1 == '=')
708 nt_create_process (Lisp_Process *p,
709 Lisp_Object *argv, int nargv,
710 Lisp_Object program, Lisp_Object cur_dir)
712 /* Synched up with sys_spawnve in FSF 20.6. Significantly different
713 but still synchable. */
714 HANDLE hmyshove, hmyslurp, hprocin, hprocout, hprocerr;
715 Extbyte *command_line;
716 BOOL do_io, windowed;
719 /* No need to DOS-ize the filename; expand-file-name (called prior)
720 already does this. */
722 /* Find out whether the application is windowed or not */
724 /* SHGetFileInfo tends to return ERROR_FILE_NOT_FOUND on most
725 errors. This leads to bogus error message. */
727 char *p = strrchr ((char *)XSTRING_DATA (program), '.');
729 (stricmp (p, ".exe") == 0 ||
730 stricmp (p, ".com") == 0 ||
731 stricmp (p, ".bat") == 0 ||
732 stricmp (p, ".cmd") == 0))
734 image_type = SHGetFileInfo ((char *)XSTRING_DATA (program), 0,NULL,
739 char progname[MAX_PATH];
740 sprintf (progname, "%s.exe", (char *)XSTRING_DATA (program));
741 image_type = SHGetFileInfo (progname, 0, NULL, 0, SHGFI_EXETYPE);
744 signal_cannot_launch (program, (GetLastError () == ERROR_FILE_NOT_FOUND
745 ? ERROR_BAD_FORMAT : GetLastError ()));
746 windowed = HIWORD (image_type) != 0;
749 /* Decide whether to do I/O on process handles, or just mark the
750 process exited immediately upon successful launching. We do I/O if the
751 process is a console one, or if it is windowed but windowed_process_io
753 do_io = !windowed || windowed_process_io ;
757 /* Create two unidirectional named pipes */
759 SECURITY_ATTRIBUTES sa;
761 sa.nLength = sizeof(sa);
762 sa.bInheritHandle = TRUE;
763 sa.lpSecurityDescriptor = NULL;
765 CreatePipe (&hprocin, &hmyshove, &sa, 0);
766 CreatePipe (&hmyslurp, &hprocout, &sa, 0);
768 /* Duplicate the stdout handle for use as stderr */
769 DuplicateHandle(GetCurrentProcess(), hprocout, GetCurrentProcess(),
770 &hprocerr, 0, TRUE, DUPLICATE_SAME_ACCESS);
772 /* Stupid Win32 allows to create a pipe with *both* ends either
773 inheritable or not. We need process ends inheritable, and local
774 ends not inheritable. */
775 DuplicateHandle (GetCurrentProcess(), hmyshove, GetCurrentProcess(),
777 DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
779 DuplicateHandle (GetCurrentProcess(), hmyslurp, GetCurrentProcess(),
781 DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
785 /* Convert an argv vector into Win32 style command line. */
788 Bufbyte **quoted_args;
789 int is_dos_app, is_cygnus_app;
790 int is_command_shell;
792 char escape_char = 0;
794 nargv++; /* include program; we access argv offset by 1 below */
795 quoted_args = alloca_array (Bufbyte *, nargv);
797 /* Determine whether program is a 16-bit DOS executable, or a Win32
798 executable that is implicitly linked to the Cygnus dll (implying it
799 was compiled with the Cygnus GNU toolchain and hence relies on
800 cygwin.dll to parse the command line - we use this to decide how to
801 escape quote chars in command line args that must be quoted). */
802 mswindows_executable_type (XSTRING_DATA (program),
803 &is_dos_app, &is_cygnus_app);
806 /* #### Bleeeeeeeeeeeeeeeeech!!!! The command shells appear to
807 use '^' as a quote character, at least under NT. #### I haven't
808 tested 95. If it allows no quoting conventions at all, set
809 escape_char to 0 and the code below will work. (e.g. NT tolerates
810 no quoting -- this command
812 cmd /c "ls "/Program Files""
816 struct gcpro gcpro1, gcpro2;
817 Lisp_Object progname = Qnil;
819 GCPRO2 (program, progname);
820 progname = Ffile_name_nondirectory (program);
821 progname = Fdowncase (progname, Qnil);
824 internal_equal (progname, build_string ("command.com"), 0)
825 || internal_equal (progname, build_string ("cmd.exe"), 0);
830 /* #### we need to port this. */
831 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
832 application to start it by specifying the helper app as cmdname,
833 while leaving the real app name as argv[0]. */
836 cmdname = (char*) alloca (MAXPATHLEN);
837 if (egetenv ("CMDPROXY"))
838 strcpy ((char*)cmdname, egetenv ("CMDPROXY"));
841 strcpy ((char*)cmdname, XSTRING_DATA (Vinvocation_directory));
842 strcat ((char*)cmdname, "cmdproxy.exe");
847 /* we have to do some conjuring here to put argv and envp into the
848 form CreateProcess wants... argv needs to be a space separated/null
849 terminated list of parameters, and envp is a null
850 separated/double-null terminated list of parameters.
852 Additionally, zero-length args and args containing whitespace or
853 quote chars need to be wrapped in double quotes - for this to work,
854 embedded quotes need to be escaped as well. The aim is to ensure
855 the child process reconstructs the argv array we start with
856 exactly, so we treat quotes at the beginning and end of arguments
859 The Win32 GNU-based library from Cygnus doubles quotes to escape
860 them, while MSVC uses backslash for escaping. (Actually the MSVC
861 startup code does attempt to recognize doubled quotes and accept
862 them, but gets it wrong and ends up requiring three quotes to get a
863 single embedded quote!) So by default we decide whether to use
864 quote or backslash as the escape character based on whether the
865 binary is apparently a Cygnus compiled app.
867 Note that using backslash to escape embedded quotes requires
868 additional special handling if an embedded quote is already
869 preceded by backslash, or if an arg requiring quoting ends with
870 backslash. In such cases, the run of escape characters needs to be
871 doubled. For consistency, we apply this special handling as long
872 as the escape character is not quote.
874 Since we have no idea how large argv and envp are likely to be we
875 figure out list lengths on the fly and allocate them. */
877 if (!NILP (Vmswindows_quote_process_args))
880 /* Override escape char by binding mswindows-quote-process-args to
881 desired character, or use t for auto-selection. */
882 if (INTP (Vmswindows_quote_process_args))
883 escape_char = (char) XINT (Vmswindows_quote_process_args);
885 escape_char = is_command_shell ? '^' : is_cygnus_app ? '"' : '\\';
889 for (i = 0; i < nargv; ++i)
891 Bufbyte *targ = XSTRING_DATA (i == 0 ? program : argv[i - 1]);
894 int escape_char_run = 0;
903 /* allow for embedded quotes to be escaped */
907 /* handle the case where the embedded quote is already escaped */
908 if (escape_char_run > 0)
910 /* To preserve the arg exactly, we need to double the
911 preceding escape characters (plus adding one to
912 escape the quote character itself). */
913 arglen += escape_char_run;
916 else if (*p == ' ' || *p == '\t')
921 if (escape_char && *p == escape_char && escape_char != '"')
929 /* handle the case where the arg ends with an escape char - we
930 must not let the enclosing quote be escaped. */
931 if (escape_char_run > 0)
932 arglen += escape_char_run;
934 arglen += strlen (targ) + 1;
936 quoted_args[i] = alloca_array (Bufbyte, arglen);
939 for (i = 0; i < nargv; ++i)
941 Bufbyte *targ = XSTRING_DATA (i == 0 ? program : argv[i - 1]);
944 Bufbyte *parg = quoted_args[i];
952 if (*p == ' ' || *p == '\t' || *p == '"')
957 int escape_char_run = 0;
963 last = p + strlen (p) - 1;
966 /* This version does not escape quotes if they occur at the
967 beginning or end of the arg - this could lead to incorrect
968 behavior when the arg itself represents a command line
969 containing quoted args. I believe this was originally done
970 as a hack to make some things work, before
971 `mswindows-quote-process-args' was added. */
974 if (*p == '"' && p > first && p < last)
975 *parg++ = escape_char; /* escape embedded quotes */
981 if (escape_char && *p == '"')
983 /* double preceding escape chars if any */
984 while (escape_char_run > 0)
986 *parg++ = escape_char;
989 /* escape all quote chars, even at beginning or end */
990 *parg++ = escape_char;
994 if (escape_char && *p == escape_char && escape_char != '"')
999 /* double escape chars before enclosing quote */
1000 while (escape_char_run > 0)
1002 *parg++ = escape_char;
1010 strcpy (parg, targ);
1011 parg += strlen (targ);
1017 int total_cmdline_len = 0;
1018 Extcount *extargcount = (Extcount *) alloca_array (Extcount, nargv);
1019 Extbyte **extarg = (Extbyte **) alloca_array (Extbyte *, nargv);
1020 Extbyte *command_ptr;
1022 for (i = 0; i < nargv; ++i)
1024 TO_EXTERNAL_FORMAT (C_STRING, quoted_args[i], ALLOCA,
1025 (extarg[i], extargcount[i]), Qmswindows_tstr);
1026 /* account for space and terminating null */
1027 total_cmdline_len += extargcount[i] + EITCHAR_SIZE;
1030 command_line = alloca_array (char, total_cmdline_len);
1031 command_ptr = command_line;
1032 for (i = 0; i < nargv; ++i)
1034 memcpy (command_ptr, extarg[i], extargcount[i]);
1035 command_ptr += extargcount[i];
1036 EICOPY_TCHAR (command_ptr, ' ');
1037 command_ptr += EITCHAR_SIZE;
1039 EICOPY_TCHAR (command_ptr, '\0');
1040 command_ptr += EITCHAR_SIZE;
1043 /* Set `proc_env' to a nul-separated array of the strings in
1044 Vprocess_environment terminated by 2 nuls. */
1048 REGISTER Lisp_Object tem;
1049 REGISTER char **new_env;
1050 REGISTER int new_length = 0, i, new_space;
1053 for (tem = Vprocess_environment;
1055 && STRINGP (XCAR (tem)));
1059 /* FSF adds an extra env var to hold the current process ID of the
1060 Emacs process. Apparently this is used only by emacsserver.c,
1061 which we have superseded to gnuserv.c. (#### Does it work under
1064 sprintf (ppid_env_var_buffer, "EM_PARENT_PROCESS_ID=%d",
1065 GetCurrentProcessId ());
1066 arglen += strlen (ppid_env_var_buffer) + 1;
1070 /* new_length + 1 to include terminating 0. */
1071 env = new_env = alloca_array (char *, new_length + 1);
1073 /* Copy the Vprocess_environment strings into new_env. */
1074 for (tem = Vprocess_environment;
1076 && STRINGP (XCAR (tem)));
1080 char *string = (char *) XSTRING_DATA (XCAR (tem));
1081 /* See if this string duplicates any string already in the env.
1082 If so, don't put it in.
1083 When an env var has multiple definitions,
1084 we keep the definition that comes first in process-environment. */
1085 for (; ep != new_env; ep++)
1087 char *p = *ep, *q = string;
1091 /* The string is malformed; might as well drop it. */
1100 *new_env++ = string;
1105 /* Sort the environment variables */
1106 new_length = new_env - env;
1107 qsort (env, new_length, sizeof (char *), compare_env);
1109 /* Work out how much space to allocate */
1111 for (i = 0; i < new_length; i++)
1113 new_space += strlen(env[i]) + 1;
1117 /* Allocate space and copy variables into it */
1118 penv = proc_env = (char*) alloca(new_space);
1119 for (i = 0; i < new_length; i++)
1121 strcpy(penv, env[i]);
1122 penv += strlen(env[i]) + 1;
1127 /* Create process */
1130 PROCESS_INFORMATION pi;
1135 si.dwFlags = STARTF_USESHOWWINDOW;
1136 si.wShowWindow = windowed ? SW_SHOWNORMAL : SW_HIDE;
1139 si.hStdInput = hprocin;
1140 si.hStdOutput = hprocout;
1141 si.hStdError = hprocerr;
1142 si.dwFlags |= STARTF_USESTDHANDLES;
1145 flags = CREATE_SUSPENDED;
1146 if (mswindows_windows9x_p ())
1147 flags |= (!NILP (Vmswindows_start_process_share_console)
1148 ? CREATE_NEW_PROCESS_GROUP
1149 : CREATE_NEW_CONSOLE);
1151 flags |= CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP;
1152 if (NILP (Vmswindows_start_process_inherit_error_mode))
1153 flags |= CREATE_DEFAULT_ERROR_MODE;
1155 ensure_console_window_exists ();
1157 err = (CreateProcess (NULL, command_line, NULL, NULL, TRUE, flags,
1158 proc_env, (char *) XSTRING_DATA (cur_dir), &si, &pi)
1159 ? 0 : GetLastError ());
1163 /* These just have been inherited; we do not need a copy */
1164 CloseHandle (hprocin);
1165 CloseHandle (hprocout);
1166 CloseHandle (hprocerr);
1169 /* Handle process creation failure */
1174 CloseHandle (hmyshove);
1175 CloseHandle (hmyslurp);
1177 signal_cannot_launch (program, GetLastError ());
1180 /* The process started successfully */
1183 NT_DATA(p)->h_process = pi.hProcess;
1184 NT_DATA(p)->dwProcessId = pi.dwProcessId;
1185 init_process_io_handles (p, (void*)hmyslurp, (void*)hmyshove, 0);
1189 /* Indicate as if the process has exited immediately. */
1190 p->status_symbol = Qexit;
1191 CloseHandle (pi.hProcess);
1195 enable_child_signals (pi.hProcess);
1197 ResumeThread (pi.hThread);
1198 CloseHandle (pi.hThread);
1200 return ((int)pi.dwProcessId);
1205 * This method is called to update status fields of the process
1206 * structure. If the process has not existed, this method is expected
1209 * The method is called only for real child processes.
1213 nt_update_status_if_terminated (Lisp_Process* p)
1216 if (GetExitCodeProcess (NT_DATA(p)->h_process, &exit_code)
1217 && exit_code != STILL_ACTIVE)
1221 /* The exit code can be a code returned by process, or an
1222 NTSTATUS value. We cannot accurately handle the latter since
1223 it is a full 32 bit integer */
1224 if (exit_code & 0xC0000000)
1226 p->status_symbol = Qsignal;
1227 p->exit_code = exit_code & 0x1FFFFFFF;
1231 p->status_symbol = Qexit;
1232 p->exit_code = exit_code;
1238 * Stuff the entire contents of LSTREAM to the process output pipe
1241 /* #### If only this function could be somehow merged with
1242 unix_send_process... */
1245 nt_send_process (Lisp_Object proc, struct lstream* lstream)
1247 volatile Lisp_Object vol_proc = proc;
1248 Lisp_Process *volatile p = XPROCESS (proc);
1250 /* use a reasonable-sized buffer (somewhere around the size of the
1251 stream buffer) so as to avoid inundating the stream with blocked
1253 Bufbyte chunkbuf[512];
1260 chunklen = Lstream_read (lstream, chunkbuf, 512);
1262 break; /* perhaps should abort() if < 0?
1263 This should never happen. */
1265 /* Lstream_write() will never successfully write less than the
1266 amount sent in. In the worst case, it just buffers the
1268 writeret = Lstream_write (XLSTREAM (DATA_OUTSTREAM(p)), chunkbuf,
1270 Lstream_flush (XLSTREAM (DATA_OUTSTREAM(p)));
1273 p->status_symbol = Qexit;
1274 p->exit_code = ERROR_BROKEN_PIPE;
1278 deactivate_process (*((Lisp_Object *) (&vol_proc)));
1279 error ("Broken pipe error sending to process %s; closed it",
1280 XSTRING_DATA (p->name));
1285 while (Lstream_was_blocked_p (XLSTREAM (p->pipe_outstream)))
1287 /* Buffer is full. Wait, accepting input; that may allow
1288 the program to finish doing output and read more. */
1289 Faccept_process_output (Qnil, Qzero, make_int (wait_ms));
1290 Lstream_flush (XLSTREAM (p->pipe_outstream));
1291 wait_ms = min (1000, 2 * wait_ms);
1298 * Send a signal number SIGNO to PROCESS.
1299 * CURRENT_GROUP means send to the process group that currently owns
1300 * the terminal being used to communicate with PROCESS.
1301 * This is used for various commands in shell mode.
1302 * If NOMSG is zero, insert signal-announcements into process's buffers
1305 * If we can, we try to signal PROCESS by sending control characters
1306 * down the pty. This allows us to signal inferiors who have changed
1307 * their uid, for which killpg would return an EPERM error.
1309 * The method signals an error if the given SIGNO is not valid
1313 nt_kill_child_process (Lisp_Object proc, int signo,
1314 int current_group, int nomsg)
1316 Lisp_Process *p = XPROCESS (proc);
1318 /* Signal error if SIGNO cannot be sent */
1319 validate_signal_number (signo);
1322 if (!send_signal (NT_DATA (p), 0, signo))
1323 signal_simple_error ("Cannot send signal to process", proc);
1327 * Kill any process in the system given its PID
1329 * Returns zero if a signal successfully sent, or
1330 * negative number upon failure
1333 nt_kill_process_by_pid (int pid, int signo)
1335 struct Lisp_Process *p;
1337 /* Signal error if SIGNO cannot be sent */
1338 validate_signal_number (signo);
1340 p = find_process_from_pid (pid);
1341 return send_signal (p ? NT_DATA (p) : 0, pid, signo) ? 0 : -1;
1344 /*-----------------------------------------------------------------------*/
1345 /* Sockets connections */
1346 /*-----------------------------------------------------------------------*/
1349 /* #### Hey MS, how long Winsock 2 for '95 will be in beta? */
1351 #define SOCK_TIMER_ID 666
1352 #define XM_SOCKREPLY (WM_USER + 666)
1355 get_internet_address (Lisp_Object host, struct sockaddr_in *address,
1356 Error_behavior errb)
1358 char buf [MAXGETHOSTSTRUCT];
1363 address->sin_family = AF_INET;
1365 /* First check if HOST is already a numeric address */
1367 unsigned long inaddr = inet_addr (XSTRING_DATA (host));
1368 if (inaddr != INADDR_NONE)
1370 address->sin_addr.s_addr = inaddr;
1375 /* Create a window which will receive completion messages */
1376 hwnd = CreateWindow ("STATIC", NULL, WS_OVERLAPPED, 0, 0, 1, 1,
1377 NULL, NULL, NULL, NULL);
1380 /* Post name resolution request */
1381 hasync = WSAAsyncGetHostByName (hwnd, XM_SOCKREPLY, XSTRING_DATA (host),
1386 /* Set a timer to poll for quit every 250 ms */
1387 SetTimer (hwnd, SOCK_TIMER_ID, 250, NULL);
1392 GetMessage (&msg, hwnd, 0, 0);
1393 if (msg.message == XM_SOCKREPLY)
1395 /* Ok, got an answer */
1396 if (WSAGETASYNCERROR(msg.lParam) == NO_ERROR)
1400 warn_when_safe(Qstream, Qwarning,
1401 "cannot get IP address for host \"%s\"",
1402 XSTRING_DATA (host));
1406 else if (msg.message == WM_TIMER && msg.wParam == SOCK_TIMER_ID)
1410 WSACancelAsyncRequest (hasync);
1411 KillTimer (hwnd, SOCK_TIMER_ID);
1412 DestroyWindow (hwnd);
1416 DispatchMessage (&msg);
1420 KillTimer (hwnd, SOCK_TIMER_ID);
1421 DestroyWindow (hwnd);
1424 /* BUF starts with struct hostent */
1425 struct hostent* he = (struct hostent*) buf;
1426 address->sin_addr.s_addr = *(unsigned long*)he->h_addr_list[0];
1432 nt_canonicalize_host_name (Lisp_Object host)
1434 struct sockaddr_in address;
1436 if (!get_internet_address (host, &address, ERROR_ME_NOT))
1439 if (address.sin_family == AF_INET)
1440 return build_string (inet_ntoa (address.sin_addr));
1445 /* open a TCP network connection to a given HOST/SERVICE. Treated
1446 exactly like a normal process when reading and writing. Only
1447 differences are in status display and process deletion. A network
1448 connection has no PID; you cannot signal it. All you can do is
1449 deactivate and close it via delete-process */
1452 nt_open_network_stream (Lisp_Object name, Lisp_Object host,
1453 Lisp_Object service,
1454 Lisp_Object protocol, void** vinfd, void** voutfd)
1456 /* !!#### not Mule-ized */
1457 struct sockaddr_in address;
1462 CHECK_STRING (host);
1464 if (!EQ (protocol, Qtcp))
1465 signal_simple_error ("Unsupported protocol", protocol);
1468 port = htons ((unsigned short) XINT (service));
1471 struct servent *svc_info;
1472 CHECK_STRING (service);
1473 svc_info = getservbyname ((char *) XSTRING_DATA (service), "tcp");
1475 signal_simple_error ("Unknown service", service);
1476 port = svc_info->s_port;
1479 get_internet_address (host, &address, ERROR_ME);
1480 address.sin_port = port;
1482 s = socket (address.sin_family, SOCK_STREAM, 0);
1484 report_file_error ("error creating socket", list1 (name));
1486 /* We don't want to be blocked on connect */
1488 unsigned long nonblock = 1;
1489 ioctlsocket (s, FIONBIO, &nonblock);
1492 retval = connect (s, (struct sockaddr *) &address, sizeof (address));
1493 if (retval != NO_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
1494 goto connect_failed;
1495 /* Wait while connection is established */
1508 /* Poll for quit every 250 ms */
1510 tv.tv_usec = 250 * 1000;
1514 nsel = select (0, NULL, &fdset, &fdset, &tv);
1518 /* Check: was connection successful or not? */
1520 nsel = select (0, NULL, NULL, &fdset, &tv);
1522 goto connect_failed;
1528 /* We are connected at this point */
1530 DuplicateHandle (GetCurrentProcess(), (HANDLE)s,
1531 GetCurrentProcess(), (LPHANDLE)voutfd,
1532 0, FALSE, DUPLICATE_SAME_ACCESS);
1539 warn_when_safe (Qstream, Qwarning,
1540 "failure to open network stream to host \"%s\" for service \"%d\"",
1541 XSTRING_DATA (host),
1542 (unsigned short) XINT (service));
1546 warn_when_safe (Qstream, Qwarning,
1547 "failure to open network stream to host \"%s\" for service \"%s\"",
1548 XSTRING_DATA (host),
1549 XSTRING_DATA (service));
1551 report_file_error ("connection failed", list2 (host, name));
1556 /*-----------------------------------------------------------------------*/
1557 /* Initialization */
1558 /*-----------------------------------------------------------------------*/
1561 process_type_create_nt (void)
1563 PROCESS_HAS_METHOD (nt, alloc_process_data);
1564 PROCESS_HAS_METHOD (nt, finalize_process_data);
1565 PROCESS_HAS_METHOD (nt, init_process);
1566 PROCESS_HAS_METHOD (nt, create_process);
1567 PROCESS_HAS_METHOD (nt, update_status_if_terminated);
1568 PROCESS_HAS_METHOD (nt, send_process);
1569 PROCESS_HAS_METHOD (nt, kill_child_process);
1570 PROCESS_HAS_METHOD (nt, kill_process_by_pid);
1572 PROCESS_HAS_METHOD (nt, canonicalize_host_name);
1573 PROCESS_HAS_METHOD (nt, open_network_stream);
1574 #ifdef HAVE_MULTICAST
1575 #error I won't do this until '95 has winsock2
1576 PROCESS_HAS_METHOD (nt, open_multicast_group);
1582 syms_of_process_nt (void)
1587 vars_of_process_nt (void)
1589 DEFVAR_LISP ("mswindows-quote-process-args",
1590 &Vmswindows_quote_process_args /*
1591 Non-nil enables quoting of process arguments to ensure correct parsing.
1592 Because Windows does not directly pass argv arrays to child processes,
1593 programs have to reconstruct the argv array by parsing the command
1594 line string. For an argument to contain a space, it must be enclosed
1595 in double quotes or it will be parsed as multiple arguments.
1597 If the value is a character, that character will be used to escape any
1598 quote characters that appear, otherwise a suitable escape character
1599 will be chosen based on the type of the program (normal or Cygwin).
1601 Vmswindows_quote_process_args = Qt;
1603 DEFVAR_LISP ("mswindows-start-process-share-console",
1604 &Vmswindows_start_process_share_console /*
1605 When nil, new child processes are given a new console.
1606 When non-nil, they share the Emacs console; this has the limitation of
1607 allowing only only DOS subprocess to run at a time (whether started directly
1608 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
1609 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
1610 otherwise respond to interrupts from Emacs.
1612 Vmswindows_start_process_share_console = Qnil;
1614 DEFVAR_LISP ("mswindows-start-process-inherit-error-mode",
1615 &Vmswindows_start_process_inherit_error_mode /*
1616 "When nil, new child processes revert to the default error mode.
1617 When non-nil, they inherit their error mode setting from Emacs, which stops
1618 them blocking when trying to access unmounted drives etc.
1620 Vmswindows_start_process_inherit_error_mode = Qt;