1 /* Process support for Windows NT port of XEMACS.
2 Copyright (C) 1992, 1995 Free Software Foundation, Inc.
4 This file is part of XEmacs.
6 XEmacs is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with XEmacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 Drew Bliss Oct 14, 1993
22 Adapted from alarm.c by Tim Fleehart */
24 /* Adapted for XEmacs by David Hobley <david@spook-le0.cia.com.au> */
25 /* Synced with FSF Emacs 19.34.6 by Marc Paquette <marcpa@cam.org> */
34 /* must include CRT headers *before* config.h */
35 /* ### I don't believe it - martin */
44 #include <sys/socket.h>
51 #include "ntheap.h" /* From 19.34.6 */
53 #include "syssignal.h"
58 /*#include "w32term.h"*/ /* From 19.34.6: sync in ? --marcpa */
60 /* #### I'm not going to play with shit. */
61 #pragma warning (disable:4013 4024 4090)
63 /* Control whether spawnve quotes arguments as necessary to ensure
64 correct parsing by child process. Because not all uses of spawnve
65 are careful about constructing argv arrays, we make this behavior
66 conditional (off by default). */
67 Lisp_Object Vwin32_quote_process_args;
69 /* Control whether create_child causes the process' window to be
70 hidden. The default is nil. */
71 Lisp_Object Vwin32_start_process_show_window;
73 /* Control whether create_child causes the process to inherit Emacs'
74 console window, or be given a new one of its own. The default is
75 nil, to allow multiple DOS programs to run on Win95. Having separate
76 consoles also allows Emacs to cleanly terminate process groups. */
77 Lisp_Object Vwin32_start_process_share_console;
79 /* Time to sleep before reading from a subprocess output pipe - this
80 avoids the inefficiency of frequently reading small amounts of data.
81 This is primarily necessary for handling DOS processes on Windows 95,
82 but is useful for Win32 processes on both Win95 and NT as well. */
83 Lisp_Object Vwin32_pipe_read_delay;
85 /* Control whether stat() attempts to generate fake but hopefully
86 "accurate" inode values, by hashing the absolute truenames of files.
87 This should detect aliasing between long and short names, but still
88 allows the possibility of hash collisions. */
89 Lisp_Object Vwin32_generate_fake_inodes;
91 Lisp_Object Qhigh, Qlow;
93 extern Lisp_Object Vlisp_EXEC_SUFFIXES;
98 void _DebPrint (const char *fmt, ...)
104 va_start (args, fmt);
105 vsprintf (buf, fmt, args);
107 OutputDebugString (buf);
111 /* sys_signal moved to nt.c. It's now called msw_signal... */
113 /* Defined in <process.h> which conflicts with the local copy */
116 /* Child process management list. */
117 int child_proc_count = 0;
118 child_process child_procs[ MAX_CHILDREN ];
119 child_process *dead_child = NULL;
121 DWORD WINAPI reader_thread (void *arg);
123 /* Find an unused process slot. */
130 for (cp = child_procs+(child_proc_count-1); cp >= child_procs; cp--)
131 if (!CHILD_ACTIVE (cp))
133 if (child_proc_count == MAX_CHILDREN)
135 cp = &child_procs[child_proc_count++];
141 if (cp->procinfo.hProcess)
142 CloseHandle(cp->procinfo.hProcess);
143 cp->procinfo.hProcess = NULL;
144 cp->status = STATUS_READ_ERROR;
146 /* use manual reset event so that select() will function properly */
147 cp->char_avail = CreateEvent (NULL, TRUE, FALSE, NULL);
150 cp->char_consumed = CreateEvent (NULL, FALSE, FALSE, NULL);
151 if (cp->char_consumed)
153 cp->thrd = CreateThread (NULL, 1024, reader_thread, cp, 0, &id);
163 delete_child (child_process *cp)
167 /* Should not be deleting a child that is still needed. */
168 for (i = 0; i < MAXDESC; i++)
169 if (fd_info[i].cp == cp)
172 if (!CHILD_ACTIVE (cp))
175 /* reap thread if necessary */
180 if (GetExitCodeThread (cp->thrd, &rc) && rc == STILL_ACTIVE)
182 /* let the thread exit cleanly if possible */
183 cp->status = STATUS_READ_ERROR;
184 SetEvent (cp->char_consumed);
185 if (WaitForSingleObject (cp->thrd, 1000) != WAIT_OBJECT_0)
187 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
188 "with %lu for fd %ld\n", GetLastError (), cp->fd));
189 TerminateThread (cp->thrd, 0);
192 CloseHandle (cp->thrd);
197 CloseHandle (cp->char_avail);
198 cp->char_avail = NULL;
200 if (cp->char_consumed)
202 CloseHandle (cp->char_consumed);
203 cp->char_consumed = NULL;
206 /* update child_proc_count (highest numbered slot in use plus one) */
207 if (cp == child_procs + child_proc_count - 1)
209 for (i = child_proc_count-1; i >= 0; i--)
210 if (CHILD_ACTIVE (&child_procs[i]))
212 child_proc_count = i + 1;
217 child_proc_count = 0;
220 /* Find a child by pid. */
221 static child_process *
222 find_child_pid (DWORD pid)
226 for (cp = child_procs+(child_proc_count-1); cp >= child_procs; cp--)
227 if (CHILD_ACTIVE (cp) && pid == cp->pid)
232 /* Function to do blocking read of one byte, needed to implement
233 select. It is only allowed on sockets and pipes. */
235 _sys_read_ahead (int fd)
240 if (fd < 0 || fd >= MAXDESC)
241 return STATUS_READ_ERROR;
245 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
246 return STATUS_READ_ERROR;
248 if ((fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET)) == 0
249 || (fd_info[fd].flags & FILE_READ) == 0)
251 /* fd is not a pipe or socket */
255 cp->status = STATUS_READ_IN_PROGRESS;
257 if (fd_info[fd].flags & FILE_PIPE)
259 rc = _read (fd, &cp->chr, sizeof (char));
261 /* Give subprocess time to buffer some more output for us before
262 reporting that input is available; we need this because Win95
263 connects DOS programs to pipes by making the pipe appear to be
264 the normal console stdout - as a result most DOS programs will
265 write to stdout without buffering, ie. one character at a
266 time. Even some Win32 programs do this - "dir" in a command
267 shell on NT is very slow if we don't do this. */
270 int wait = XINT (Vwin32_pipe_read_delay);
276 /* Yield remainder of our time slice, effectively giving a
277 temporary priority boost to the child process. */
282 if (rc == sizeof (char))
283 cp->status = STATUS_READ_SUCCEEDED;
285 cp->status = STATUS_READ_FAILED;
290 /* Thread proc for child process and socket reader threads. Each thread
291 is normally blocked until woken by select() to check for input by
292 reading one char. When the read completes, char_avail is signalled
293 to wake up the select emulator and the thread blocks itself again. */
295 reader_thread (void *arg)
300 cp = (child_process *)arg;
302 /* <matts@tibco.com> - I think the test below is wrong - we don't
303 want to wait for someone to signal char_consumed, as we haven't
304 read anything for them to consume yet! */
308 WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0)
320 rc = _sys_read_ahead (cp->fd);
322 /* The name char_avail is a misnomer - it really just means the
323 read-ahead has completed, whether successfully or not. */
324 if (!SetEvent (cp->char_avail))
326 DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
327 GetLastError (), cp->fd));
331 if (rc == STATUS_READ_ERROR)
333 /* We are finished, so clean up handles and set to NULL so
334 that CHILD_ACTIVE will see what is going on */
335 if (cp->char_avail) {
336 CloseHandle (cp->char_avail);
337 cp->char_avail = NULL;
340 CloseHandle (cp->thrd);
343 if (cp->char_consumed) {
344 CloseHandle(cp->char_consumed);
345 cp->char_consumed = NULL;
347 if (cp->procinfo.hProcess)
349 CloseHandle (cp->procinfo.hProcess);
350 cp->procinfo.hProcess=NULL;
355 /* If the read died, the child has died so let the thread die */
356 if (rc == STATUS_READ_FAILED)
359 /* Wait until our input is acknowledged before reading again */
360 if (WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0)
362 DebPrint (("reader_thread.WaitForSingleObject failed with "
363 "%lu for fd %ld\n", GetLastError (), cp->fd));
367 /* We are finished, so clean up handles and set to NULL so that
368 CHILD_ACTIVE will see what is going on */
369 if (cp->char_avail) {
370 CloseHandle (cp->char_avail);
371 cp->char_avail = NULL;
374 CloseHandle (cp->thrd);
377 if (cp->char_consumed) {
378 CloseHandle(cp->char_consumed);
379 cp->char_consumed = NULL;
381 if (cp->procinfo.hProcess)
383 CloseHandle (cp->procinfo.hProcess);
384 cp->procinfo.hProcess=NULL;
390 /* To avoid Emacs changing directory, we just record here the directory
391 the new process should start in. This is set just before calling
392 sys_spawnve, and is not generally valid at any other time. */
393 static const char * process_dir;
396 create_child (CONST char *exe, char *cmdline, char *env,
397 int * pPid, child_process *cp)
400 SECURITY_ATTRIBUTES sec_attrs;
401 SECURITY_DESCRIPTOR sec_desc;
402 char dir[ MAXPATHLEN ];
404 if (cp == NULL) abort ();
407 start.cb = sizeof (start);
410 if (NILP (Vwin32_start_process_show_window))
411 start.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
413 start.dwFlags = STARTF_USESTDHANDLES;
414 start.wShowWindow = SW_HIDE;
416 start.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
417 start.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
418 start.hStdError = GetStdHandle (STD_ERROR_HANDLE);
419 #endif /* HAVE_NTGUI */
421 /* Explicitly specify no security */
422 if (!InitializeSecurityDescriptor (&sec_desc, SECURITY_DESCRIPTOR_REVISION))
424 if (!SetSecurityDescriptorDacl (&sec_desc, TRUE, NULL, FALSE))
426 sec_attrs.nLength = sizeof (sec_attrs);
427 sec_attrs.lpSecurityDescriptor = &sec_desc;
428 sec_attrs.bInheritHandle = FALSE;
430 strcpy (dir, process_dir);
431 unixtodos_filename (dir);
433 if (!CreateProcess (exe, cmdline, &sec_attrs, NULL, TRUE,
434 (!NILP (Vwin32_start_process_share_console)
435 ? CREATE_NEW_PROCESS_GROUP
436 : CREATE_NEW_CONSOLE),
438 &start, &cp->procinfo))
441 cp->pid = (int) cp->procinfo.dwProcessId;
443 CloseHandle (cp->procinfo.hThread);
444 CloseHandle (cp->procinfo.hProcess);
445 cp->procinfo.hThread=NULL;
446 cp->procinfo.hProcess=NULL;
448 /* pid must fit in a Lisp_Int */
456 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError()););
461 /* Return pointer to section header for section containing the given
462 relative virtual address. */
463 static IMAGE_SECTION_HEADER *
464 rva_to_section (DWORD rva, IMAGE_NT_HEADERS * nt_header)
466 PIMAGE_SECTION_HEADER section;
469 section = IMAGE_FIRST_SECTION (nt_header);
471 for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
473 if (rva >= section->VirtualAddress
474 && rva < section->VirtualAddress + section->SizeOfRawData)
483 win32_executable_type (CONST char * filename, int * is_dos_app, int * is_cygnus_app)
485 file_data executable;
488 /* Default values in case we can't tell for sure. */
490 *is_cygnus_app = FALSE;
492 if (!open_input_file (&executable, filename))
495 p = strrchr (filename, '.');
497 /* We can only identify DOS .com programs from the extension. */
498 if (p && stricmp (p, ".com") == 0)
500 else if (p && (stricmp (p, ".bat") == 0 ||
501 stricmp (p, ".cmd") == 0))
503 /* A DOS shell script - it appears that CreateProcess is happy to
504 accept this (somewhat surprisingly); presumably it looks at
505 COMSPEC to determine what executable to actually invoke.
506 Therefore, we have to do the same here as well. */
507 /* Actually, I think it uses the program association for that
508 extension, which is defined in the registry. */
509 p = egetenv ("COMSPEC");
511 win32_executable_type (p, is_dos_app, is_cygnus_app);
515 /* Look for DOS .exe signature - if found, we must also check that
516 it isn't really a 16- or 32-bit Windows exe, since both formats
517 start with a DOS program stub. Note that 16-bit Windows
518 executables use the OS/2 1.x format. */
521 /* mingw32 doesn't have enough headers to detect cygwin
522 apps, just do what we can. */
525 exe_header = (FILHDR*) executable.file_base;
526 if (exe_header->e_magic != DOSMAGIC)
529 if ((char *) exe_header->e_lfanew > (char *) executable.size)
531 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
534 else if (exe_header->nt_signature != NT_SIGNATURE)
539 IMAGE_DOS_HEADER * dos_header;
540 IMAGE_NT_HEADERS * nt_header;
542 dos_header = (PIMAGE_DOS_HEADER) executable.file_base;
543 if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
546 nt_header = (PIMAGE_NT_HEADERS) ((char *) dos_header + dos_header->e_lfanew);
548 if ((char *) nt_header > (char *) dos_header + executable.size)
550 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
553 else if (nt_header->Signature != IMAGE_NT_SIGNATURE &&
554 LOWORD (nt_header->Signature) != IMAGE_OS2_SIGNATURE)
558 else if (nt_header->Signature == IMAGE_NT_SIGNATURE)
560 /* Look for cygwin.dll in DLL import list. */
561 IMAGE_DATA_DIRECTORY import_dir =
562 nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
563 IMAGE_IMPORT_DESCRIPTOR * imports;
564 IMAGE_SECTION_HEADER * section;
566 section = rva_to_section (import_dir.VirtualAddress, nt_header);
567 imports = RVA_TO_PTR (import_dir.VirtualAddress, section, executable);
569 for ( ; imports->Name; imports++)
571 char * dllname = RVA_TO_PTR (imports->Name, section, executable);
573 if (strcmp (dllname, "cygwin.dll") == 0)
575 *is_cygnus_app = TRUE;
584 close_file_data (&executable);
588 compare_env (const void *strp1, const void *strp2)
590 const char *str1 = *(const char**)strp1, *str2 = *(const char**)strp2;
592 while (*str1 && *str2 && *str1 != '=' && *str2 != '=')
594 if ((*str1) > (*str2))
596 else if ((*str1) < (*str2))
601 if (*str1 == '=' && *str2 == '=')
603 else if (*str1 == '=')
610 merge_and_sort_env (char **envp1, char **envp2, char **new_envp)
626 qsort (new_envp, num, sizeof (char *), compare_env);
631 /* When a new child process is created we need to register it in our list,
632 so intercept spawn requests. */
634 sys_spawnve (int mode, CONST char *cmdname,
635 CONST char * CONST *argv, CONST char *CONST *envp)
637 Lisp_Object program, full;
638 char *cmdline, *env, *parg, **targ;
642 int is_dos_app, is_cygnus_app;
644 char escape_char = 0;
645 /* We pass our process ID to our children by setting up an environment
646 variable in their environment. */
647 char ppid_env_var_buffer[64];
648 char *extra_env[] = {ppid_env_var_buffer, NULL};
651 /* We don't care about the other modes */
652 if (mode != _P_NOWAIT)
658 /* Handle executable names without an executable suffix. */
659 program = make_string (cmdname, strlen (cmdname));
661 if (NILP (Ffile_executable_p (program)))
664 locate_file (Vexec_path, program, Vlisp_EXEC_SUFFIXES, &full, 1);
671 GET_C_STRING_FILENAME_DATA_ALLOCA (full, cmdname);
675 (char*)cmdname = alloca (strlen (argv[0]) + 1);
676 strcpy ((char*)cmdname, argv[0]);
680 /* make sure argv[0] and cmdname are both in DOS format */
681 unixtodos_filename ((char*)cmdname);
683 ((CONST char**)argv)[0] = cmdname;
685 /* Determine whether program is a 16-bit DOS executable, or a Win32
686 executable that is implicitly linked to the Cygnus dll (implying it
687 was compiled with the Cygnus GNU toolchain and hence relies on
688 cygwin.dll to parse the command line - we use this to decide how to
689 escape quote chars in command line args that must be quoted). */
690 win32_executable_type (cmdname, &is_dos_app, &is_cygnus_app);
692 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
693 application to start it by specifying the helper app as cmdname,
694 while leaving the real app name as argv[0]. */
697 cmdname = alloca (MAXPATHLEN);
698 if (egetenv ("CMDPROXY"))
699 strcpy ((char*)cmdname, egetenv ("CMDPROXY"));
702 strcpy ((char*)cmdname, XSTRING_DATA (Vinvocation_directory));
703 strcat ((char*)cmdname, "cmdproxy.exe");
705 unixtodos_filename ((char*)cmdname);
708 /* we have to do some conjuring here to put argv and envp into the
709 form CreateProcess wants... argv needs to be a space separated/null
710 terminated list of parameters, and envp is a null
711 separated/double-null terminated list of parameters.
713 Additionally, zero-length args and args containing whitespace or
714 quote chars need to be wrapped in double quotes - for this to work,
715 embedded quotes need to be escaped as well. The aim is to ensure
716 the child process reconstructs the argv array we start with
717 exactly, so we treat quotes at the beginning and end of arguments
720 The Win32 GNU-based library from Cygnus doubles quotes to escape
721 them, while MSVC uses backslash for escaping. (Actually the MSVC
722 startup code does attempt to recognize doubled quotes and accept
723 them, but gets it wrong and ends up requiring three quotes to get a
724 single embedded quote!) So by default we decide whether to use
725 quote or backslash as the escape character based on whether the
726 binary is apparently a Cygnus compiled app.
728 Note that using backslash to escape embedded quotes requires
729 additional special handling if an embedded quote is already
730 preceded by backslash, or if an arg requiring quoting ends with
731 backslash. In such cases, the run of escape characters needs to be
732 doubled. For consistency, we apply this special handling as long
733 as the escape character is not quote.
735 Since we have no idea how large argv and envp are likely to be we
736 figure out list lengths on the fly and allocate them. */
738 if (!NILP (Vwin32_quote_process_args))
741 /* Override escape char by binding win32-quote-process-args to
742 desired character, or use t for auto-selection. */
743 if (INTP (Vwin32_quote_process_args))
744 escape_char = XINT (Vwin32_quote_process_args);
746 escape_char = is_cygnus_app ? '"' : '\\';
756 int escape_char_run = 0;
764 /* allow for embedded quotes to be escaped */
767 /* handle the case where the embedded quote is already escaped */
768 if (escape_char_run > 0)
770 /* To preserve the arg exactly, we need to double the
771 preceding escape characters (plus adding one to
772 escape the quote character itself). */
773 arglen += escape_char_run;
776 else if (*p == ' ' || *p == '\t')
781 if (*p == escape_char && escape_char != '"')
789 /* handle the case where the arg ends with an escape char - we
790 must not let the enclosing quote be escaped. */
791 if (escape_char_run > 0)
792 arglen += escape_char_run;
794 arglen += strlen (*targ++) + 1;
796 cmdline = alloca (arglen);
810 if (*p == ' ' || *p == '\t' || *p == '"')
815 int escape_char_run = 0;
821 last = p + strlen (p) - 1;
824 /* This version does not escape quotes if they occur at the
825 beginning or end of the arg - this could lead to incorrect
826 behavior when the arg itself represents a command line
827 containing quoted args. I believe this was originally done
828 as a hack to make some things work, before
829 `win32-quote-process-args' was added. */
832 if (*p == '"' && p > first && p < last)
833 *parg++ = escape_char; /* escape embedded quotes */
841 /* double preceding escape chars if any */
842 while (escape_char_run > 0)
844 *parg++ = escape_char;
847 /* escape all quote chars, even at beginning or end */
848 *parg++ = escape_char;
852 if (*p == escape_char && escape_char != '"')
857 /* double escape chars before enclosing quote */
858 while (escape_char_run > 0)
860 *parg++ = escape_char;
868 strcpy (parg, *targ);
869 parg += strlen (*targ);
879 numenv = 1; /* for end null */
882 arglen += strlen (*targ++) + 1;
885 /* extra env vars... */
886 sprintf (ppid_env_var_buffer, "__PARENT_PROCESS_ID=%d",
887 GetCurrentProcessId ());
888 arglen += strlen (ppid_env_var_buffer) + 1;
891 /* merge env passed in and extra env into one, and sort it. */
892 targ = (char **) alloca (numenv * sizeof (char *));
893 merge_and_sort_env ((char**)envp, extra_env, targ);
895 /* concatenate env entries. */
896 env = alloca (arglen);
900 strcpy (parg, *targ);
901 parg += strlen (*targ++);
914 /* Now create the process. */
915 if (!create_child (cmdname, cmdline, env, &pid, cp))
925 /* Substitute for certain kill () operations */
928 find_child_console (HWND hwnd, child_process * cp)
933 thread_id = GetWindowThreadProcessId (hwnd, &process_id);
934 if (process_id == cp->procinfo.dwProcessId)
936 char window_class[32];
938 GetClassName (hwnd, window_class, sizeof (window_class));
939 if (strcmp (window_class,
940 (os_subtype == OS_WIN95)
942 : "ConsoleWindowClass") == 0)
953 sys_kill (int pid, int sig)
957 int need_to_free = 0;
960 /* Only handle signals that will result in the process dying */
961 if (sig != SIGINT && sig != SIGKILL && sig != SIGQUIT && sig != SIGHUP)
967 cp = find_child_pid (pid);
970 proc_hand = OpenProcess (PROCESS_TERMINATE, 0, pid);
971 if (proc_hand == NULL)
980 proc_hand = cp->procinfo.hProcess;
981 pid = cp->procinfo.dwProcessId;
983 /* Try to locate console window for process. */
984 EnumWindows ((WNDENUMPROC)find_child_console, (LPARAM) cp);
989 if (NILP (Vwin32_start_process_share_console) && cp && cp->hwnd)
991 BYTE control_scan_code = (BYTE) MapVirtualKey (VK_CONTROL, 0);
992 BYTE vk_break_code = VK_CANCEL;
993 BYTE break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
994 HWND foreground_window;
996 if (break_scan_code == 0)
998 /* Fake Ctrl-C if we can't manage Ctrl-Break. */
1000 break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
1003 foreground_window = GetForegroundWindow ();
1004 if (foreground_window && SetForegroundWindow (cp->hwnd))
1006 /* Generate keystrokes as if user had typed Ctrl-Break or Ctrl-C. */
1007 keybd_event (VK_CONTROL, control_scan_code, 0, 0);
1008 keybd_event (vk_break_code, break_scan_code, 0, 0);
1009 keybd_event (vk_break_code, break_scan_code, KEYEVENTF_KEYUP, 0);
1010 keybd_event (VK_CONTROL, control_scan_code, KEYEVENTF_KEYUP, 0);
1012 /* Sleep for a bit to give time for Emacs frame to respond
1013 to focus change events (if Emacs was active app). */
1016 SetForegroundWindow (foreground_window);
1019 /* Ctrl-Break is NT equivalent of SIGINT. */
1020 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, pid))
1022 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
1023 "for pid %lu\n", GetLastError (), pid));
1030 if (NILP (Vwin32_start_process_share_console) && cp && cp->hwnd)
1033 if (os_subtype == OS_WIN95)
1036 Another possibility is to try terminating the VDM out-right by
1037 calling the Shell VxD (id 0x17) V86 interface, function #4
1038 "SHELL_Destroy_VM", ie.
1044 First need to determine the current VM handle, and then arrange for
1045 the shellapi call to be made from the system vm (by using
1046 Switch_VM_and_callback).
1048 Could try to invoke DestroyVM through CallVxD.
1052 /* On Win95, posting WM_QUIT causes the 16-bit subsystem
1053 to hang when cmdproxy is used in conjunction with
1054 command.com for an interactive shell. Posting
1055 WM_CLOSE pops up a dialog that, when Yes is selected,
1056 does the same thing. TerminateProcess is also less
1057 than ideal in that subprocesses tend to stick around
1058 until the machine is shutdown, but at least it
1059 doesn't freeze the 16-bit subsystem. */
1060 PostMessage (cp->hwnd, WM_QUIT, 0xff, 0);
1062 if (!TerminateProcess (proc_hand, 0xff))
1064 DebPrint (("sys_kill.TerminateProcess returned %d "
1065 "for pid %lu\n", GetLastError (), pid));
1072 PostMessage (cp->hwnd, WM_CLOSE, 0, 0);
1074 /* Kill the process. On Win32 this doesn't kill child processes
1075 so it doesn't work very well for shells which is why it's not
1076 used in every case. */
1077 else if (!TerminateProcess (proc_hand, 0xff))
1079 DebPrint (("sys_kill.TerminateProcess returned %d "
1080 "for pid %lu\n", GetLastError (), pid));
1087 CloseHandle (proc_hand);
1093 /* Sync with FSF Emacs 19.34.6 note: ifdef'ed out in XEmacs */
1094 extern int report_file_error (CONST char *, Lisp_Object);
1096 /* The following two routines are used to manipulate stdin, stdout, and
1097 stderr of our child processes.
1099 Assuming that in, out, and err are *not* inheritable, we make them
1100 stdin, stdout, and stderr of the child as follows:
1102 - Save the parent's current standard handles.
1103 - Set the std handles to inheritable duplicates of the ones being passed in.
1104 (Note that _get_osfhandle() is an io.h procedure that retrieves the
1105 NT file handle for a crt file descriptor.)
1106 - Spawn the child, which inherits in, out, and err as stdin,
1107 stdout, and stderr. (see Spawnve)
1108 - Close the std handles passed to the child.
1109 - Reset the parent's standard handles to the saved handles.
1110 (see reset_standard_handles)
1111 We assume that the caller closes in, out, and err after calling us. */
1114 prepare_standard_handles (int in, int out, int err, HANDLE handles[3])
1117 HANDLE newstdin, newstdout, newstderr;
1119 parent = GetCurrentProcess ();
1121 handles[0] = GetStdHandle (STD_INPUT_HANDLE);
1122 handles[1] = GetStdHandle (STD_OUTPUT_HANDLE);
1123 handles[2] = GetStdHandle (STD_ERROR_HANDLE);
1125 /* make inheritable copies of the new handles */
1126 if (!DuplicateHandle (parent,
1127 (HANDLE) _get_osfhandle (in),
1132 DUPLICATE_SAME_ACCESS))
1133 report_file_error ("Duplicating input handle for child", Qnil);
1135 if (!DuplicateHandle (parent,
1136 (HANDLE) _get_osfhandle (out),
1141 DUPLICATE_SAME_ACCESS))
1142 report_file_error ("Duplicating output handle for child", Qnil);
1144 if (!DuplicateHandle (parent,
1145 (HANDLE) _get_osfhandle (err),
1150 DUPLICATE_SAME_ACCESS))
1151 report_file_error ("Duplicating error handle for child", Qnil);
1153 /* and store them as our std handles */
1154 if (!SetStdHandle (STD_INPUT_HANDLE, newstdin))
1155 report_file_error ("Changing stdin handle", Qnil);
1157 if (!SetStdHandle (STD_OUTPUT_HANDLE, newstdout))
1158 report_file_error ("Changing stdout handle", Qnil);
1160 if (!SetStdHandle (STD_ERROR_HANDLE, newstderr))
1161 report_file_error ("Changing stderr handle", Qnil);
1165 reset_standard_handles (int in, int out, int err, HANDLE handles[3])
1167 /* close the duplicated handles passed to the child */
1168 CloseHandle (GetStdHandle (STD_INPUT_HANDLE));
1169 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE));
1170 CloseHandle (GetStdHandle (STD_ERROR_HANDLE));
1172 /* now restore parent's saved std handles */
1173 SetStdHandle (STD_INPUT_HANDLE, handles[0]);
1174 SetStdHandle (STD_OUTPUT_HANDLE, handles[1]);
1175 SetStdHandle (STD_ERROR_HANDLE, handles[2]);
1179 set_process_dir (const char * dir)
1184 /* Some miscellaneous functions that are Windows specific, but not GUI
1185 specific (ie. are applicable in terminal or batch mode as well). */
1187 /* lifted from fileio.c */
1188 #define CORRECT_DIR_SEPS(s) \
1189 do { if ('/' == DIRECTORY_SEP) dostounix_filename (s); \
1190 else unixtodos_filename (s); \
1193 DEFUN ("win32-short-file-name", Fwin32_short_file_name, 1, 1, "", /*
1194 Return the short file name version (8.3) of the full path of FILENAME.
1195 If FILENAME does not exist, return nil.
1196 All path elements in FILENAME are converted to their short names.
1200 char shortname[MAX_PATH];
1202 CHECK_STRING (filename);
1204 /* first expand it. */
1205 filename = Fexpand_file_name (filename, Qnil);
1207 /* luckily, this returns the short version of each element in the path. */
1208 if (GetShortPathName (XSTRING_DATA (filename), shortname, MAX_PATH) == 0)
1211 CORRECT_DIR_SEPS (shortname);
1213 return build_string (shortname);
1217 DEFUN ("win32-long-file-name", Fwin32_long_file_name, 1, 1, "", /*
1218 Return the long file name version of the full path of FILENAME.
1219 If FILENAME does not exist, return nil.
1220 All path elements in FILENAME are converted to their long names.
1224 char longname[ MAX_PATH ];
1226 CHECK_STRING (filename);
1228 /* first expand it. */
1229 filename = Fexpand_file_name (filename, Qnil);
1231 if (!win32_get_long_filename (XSTRING_DATA (filename), longname, MAX_PATH))
1234 CORRECT_DIR_SEPS (longname);
1236 return build_string (longname);
1239 DEFUN ("win32-set-process-priority", Fwin32_set_process_priority, 2, 2, "", /*
1240 Set the priority of PROCESS to PRIORITY.
1241 If PROCESS is nil, the priority of Emacs is changed, otherwise the
1242 priority of the process whose pid is PROCESS is changed.
1243 PRIORITY should be one of the symbols high, normal, or low;
1244 any other symbol will be interpreted as normal.
1246 If successful, the return value is t, otherwise nil.
1248 (process, priority))
1250 HANDLE proc_handle = GetCurrentProcess ();
1251 DWORD priority_class = NORMAL_PRIORITY_CLASS;
1252 Lisp_Object result = Qnil;
1254 CHECK_SYMBOL (priority);
1256 if (!NILP (process))
1261 CHECK_INT (process);
1263 /* Allow pid to be an internally generated one, or one obtained
1264 externally. This is necessary because real pids on Win95 are
1267 pid = XINT (process);
1268 cp = find_child_pid (pid);
1270 pid = cp->procinfo.dwProcessId;
1272 proc_handle = OpenProcess (PROCESS_SET_INFORMATION, FALSE, pid);
1275 if (EQ (priority, Qhigh))
1276 priority_class = HIGH_PRIORITY_CLASS;
1277 else if (EQ (priority, Qlow))
1278 priority_class = IDLE_PRIORITY_CLASS;
1280 if (proc_handle != NULL)
1282 if (SetPriorityClass (proc_handle, priority_class))
1284 if (!NILP (process))
1285 CloseHandle (proc_handle);
1292 DEFUN ("win32-get-locale-info", Fwin32_get_locale_info, 1, 2, "", /*
1293 "Return information about the Windows locale LCID.
1294 By default, return a three letter locale code which encodes the default
1295 language as the first two characters, and the country or regional variant
1296 as the third letter. For example, ENU refers to `English (United States)',
1297 while ENC means `English (Canadian)'.
1299 If the optional argument LONGFORM is non-nil, the long form of the locale
1300 name is returned, e.g. `English (United States)' instead.
1302 If LCID (a 16-bit number) is not a valid locale, the result is nil.
1308 char abbrev_name[32] = { 0 };
1309 char full_name[256] = { 0 };
1313 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
1316 if (NILP (longform))
1318 got_abbrev = GetLocaleInfo (XINT (lcid),
1319 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
1320 abbrev_name, sizeof (abbrev_name));
1322 return build_string (abbrev_name);
1326 got_full = GetLocaleInfo (XINT (lcid),
1327 LOCALE_SLANGUAGE | LOCALE_USE_CP_ACP,
1328 full_name, sizeof (full_name));
1330 return build_string (full_name);
1337 DEFUN ("win32-get-current-locale-id", Fwin32_get_current_locale_id, 0, 0, "", /*
1338 "Return Windows locale id for current locale setting.
1339 This is a numerical value; use `win32-get-locale-info' to convert to a
1340 human-readable form.
1344 return make_int (GetThreadLocale ());
1348 DEFUN ("win32-get-default-locale-id", Fwin32_get_default_locale_id, 0, 1, "", /*
1349 "Return Windows locale id for default locale setting.
1350 By default, the system default locale setting is returned; if the optional
1351 parameter USERP is non-nil, the user default locale setting is returned.
1352 This is a numerical value; use `win32-get-locale-info' to convert to a
1353 human-readable form.
1358 return make_int (GetSystemDefaultLCID ());
1359 return make_int (GetUserDefaultLCID ());
1362 DWORD int_from_hex (char * s)
1365 static char hex[] = "0123456789abcdefABCDEF";
1368 while (*s && (p = strchr(hex, *s)) != NULL)
1370 unsigned digit = p - hex;
1373 val = val * 16 + digit;
1379 /* We need to build a global list, since the EnumSystemLocale callback
1380 function isn't given a context pointer. */
1381 Lisp_Object Vwin32_valid_locale_ids;
1383 BOOL CALLBACK enum_locale_fn (LPTSTR localeNum)
1385 DWORD id = int_from_hex (localeNum);
1386 Vwin32_valid_locale_ids = Fcons (make_int (id), Vwin32_valid_locale_ids);
1390 DEFUN ("win32-get-valid-locale-ids", Fwin32_get_valid_locale_ids, 0, 0, "", /*
1391 Return list of all valid Windows locale ids.
1392 Each id is a numerical value; use `win32-get-locale-info' to convert to a
1393 human-readable form.
1397 Vwin32_valid_locale_ids = Qnil;
1399 EnumSystemLocales (enum_locale_fn, LCID_SUPPORTED);
1401 Vwin32_valid_locale_ids = Fnreverse (Vwin32_valid_locale_ids);
1402 return Vwin32_valid_locale_ids;
1406 DEFUN ("win32-set-current-locale", Fwin32_set_current_locale, 1, 1, "", /*
1407 Make Windows locale LCID be the current locale setting for Emacs.
1408 If successful, the new locale id is returned, otherwise nil.
1414 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
1417 if (!SetThreadLocale (XINT (lcid)))
1420 /* Sync with FSF Emacs 19.34.6 note: dwWinThreadId declared in
1421 w32term.h and defined in w32fns.c, both of which are not in current
1422 XEmacs. ### Check what we lose by ifdef'ing out these. --marcpa */
1424 /* Need to set input thread locale if present. */
1426 /* Reply is not needed. */
1427 PostThreadMessage (dwWinThreadId, WM_EMACS_SETLOCALE, XINT (lcid), 0);
1430 return make_int (GetThreadLocale ());
1437 DEFSUBR (Fwin32_short_file_name);
1438 DEFSUBR (Fwin32_long_file_name);
1439 DEFSUBR (Fwin32_set_process_priority);
1440 DEFSUBR (Fwin32_get_locale_info);
1441 DEFSUBR (Fwin32_get_current_locale_id);
1442 DEFSUBR (Fwin32_get_default_locale_id);
1443 DEFSUBR (Fwin32_get_valid_locale_ids);
1444 DEFSUBR (Fwin32_set_current_locale);
1449 vars_of_ntproc (void)
1451 defsymbol (&Qhigh, "high");
1452 defsymbol (&Qlow, "low");
1454 DEFVAR_LISP ("win32-quote-process-args", &Vwin32_quote_process_args /*
1455 Non-nil enables quoting of process arguments to ensure correct parsing.
1456 Because Windows does not directly pass argv arrays to child processes,
1457 programs have to reconstruct the argv array by parsing the command
1458 line string. For an argument to contain a space, it must be enclosed
1459 in double quotes or it will be parsed as multiple arguments.
1461 If the value is a character, that character will be used to escape any
1462 quote characters that appear, otherwise a suitable escape character
1463 will be chosen based on the type of the program.
1465 Vwin32_quote_process_args = Qt;
1467 DEFVAR_LISP ("win32-start-process-show-window",
1468 &Vwin32_start_process_show_window /*
1469 When nil, processes started via start-process hide their windows.
1470 When non-nil, they show their window in the method of their choice.
1472 Vwin32_start_process_show_window = Qnil;
1474 DEFVAR_LISP ("win32-start-process-share-console",
1475 &Vwin32_start_process_share_console /*
1476 When nil, processes started via start-process are given a new console.
1477 When non-nil, they share the Emacs console; this has the limitation of
1478 allowing only only DOS subprocess to run at a time (whether started directly
1479 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
1480 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
1481 otherwise respond to interrupts from Emacs.
1483 Vwin32_start_process_share_console = Qt;
1485 DEFVAR_LISP ("win32-pipe-read-delay", &Vwin32_pipe_read_delay /*
1486 Forced delay before reading subprocess output.
1487 This is done to improve the buffering of subprocess output, by
1488 avoiding the inefficiency of frequently reading small amounts of data.
1490 If positive, the value is the number of milliseconds to sleep before
1491 reading the subprocess output. If negative, the magnitude is the number
1492 of time slices to wait (effectively boosting the priority of the child
1493 process temporarily). A value of zero disables waiting entirely.
1495 Vwin32_pipe_read_delay = make_int (50);
1498 DEFVAR_LISP ("win32-generate-fake-inodes", &Vwin32_generate_fake_inodes /*
1499 "Non-nil means attempt to fake realistic inode values.
1500 This works by hashing the truename of files, and should detect
1501 aliasing between long and short (8.3 DOS) names, but can have
1502 false positives because of hash collisions. Note that determining
1503 the truename of a file can be slow.
1505 Vwin32_generate_fake_inodes = Qnil;
1509 /* end of ntproc.c */