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"
59 #include "console-msw.h"
61 /*#include "w32term.h"*/ /* From 19.34.6: sync in ? --marcpa */
63 /* #### I'm not going to play with shit. */
64 #pragma warning (disable:4013 4024 4090)
66 /* Control whether spawnve quotes arguments as necessary to ensure
67 correct parsing by child process. Because not all uses of spawnve
68 are careful about constructing argv arrays, we make this behavior
69 conditional (off by default). */
70 Lisp_Object Vwin32_quote_process_args;
72 /* Control whether create_child causes the process' window to be
73 hidden. The default is nil. */
74 Lisp_Object Vwin32_start_process_show_window;
76 /* Control whether create_child causes the process to inherit Emacs'
77 console window, or be given a new one of its own. The default is
78 nil, to allow multiple DOS programs to run on Win95. Having separate
79 consoles also allows Emacs to cleanly terminate process groups. */
80 Lisp_Object Vwin32_start_process_share_console;
82 /* Time to sleep before reading from a subprocess output pipe - this
83 avoids the inefficiency of frequently reading small amounts of data.
84 This is primarily necessary for handling DOS processes on Windows 95,
85 but is useful for Win32 processes on both Win95 and NT as well. */
86 Lisp_Object Vwin32_pipe_read_delay;
88 /* Control whether stat() attempts to generate fake but hopefully
89 "accurate" inode values, by hashing the absolute truenames of files.
90 This should detect aliasing between long and short names, but still
91 allows the possibility of hash collisions. */
92 Lisp_Object Vwin32_generate_fake_inodes;
94 Lisp_Object Qhigh, Qlow;
96 extern Lisp_Object Vlisp_EXEC_SUFFIXES;
101 void _DebPrint (const char *fmt, ...)
107 va_start (args, fmt);
108 vsprintf (buf, fmt, args);
110 OutputDebugString (buf);
114 /* sys_signal moved to nt.c. It's now called msw_signal... */
116 /* Defined in <process.h> which conflicts with the local copy */
119 /* Child process management list. */
120 int child_proc_count = 0;
121 child_process child_procs[ MAX_CHILDREN ];
122 child_process *dead_child = NULL;
124 DWORD WINAPI reader_thread (void *arg);
126 /* Find an unused process slot. */
133 for (cp = child_procs+(child_proc_count-1); cp >= child_procs; cp--)
134 if (!CHILD_ACTIVE (cp))
136 if (child_proc_count == MAX_CHILDREN)
138 cp = &child_procs[child_proc_count++];
144 if (cp->procinfo.hProcess)
145 CloseHandle(cp->procinfo.hProcess);
146 cp->procinfo.hProcess = NULL;
147 cp->status = STATUS_READ_ERROR;
149 /* use manual reset event so that select() will function properly */
150 cp->char_avail = CreateEvent (NULL, TRUE, FALSE, NULL);
153 cp->char_consumed = CreateEvent (NULL, FALSE, FALSE, NULL);
154 if (cp->char_consumed)
156 cp->thrd = CreateThread (NULL, 1024, reader_thread, cp, 0, &id);
166 delete_child (child_process *cp)
170 /* Should not be deleting a child that is still needed. */
171 for (i = 0; i < MAXDESC; i++)
172 if (fd_info[i].cp == cp)
175 if (!CHILD_ACTIVE (cp))
178 /* reap thread if necessary */
183 if (GetExitCodeThread (cp->thrd, &rc) && rc == STILL_ACTIVE)
185 /* let the thread exit cleanly if possible */
186 cp->status = STATUS_READ_ERROR;
187 SetEvent (cp->char_consumed);
188 if (WaitForSingleObject (cp->thrd, 1000) != WAIT_OBJECT_0)
190 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
191 "with %lu for fd %ld\n", GetLastError (), cp->fd));
192 TerminateThread (cp->thrd, 0);
195 CloseHandle (cp->thrd);
200 CloseHandle (cp->char_avail);
201 cp->char_avail = NULL;
203 if (cp->char_consumed)
205 CloseHandle (cp->char_consumed);
206 cp->char_consumed = NULL;
209 /* update child_proc_count (highest numbered slot in use plus one) */
210 if (cp == child_procs + child_proc_count - 1)
212 for (i = child_proc_count-1; i >= 0; i--)
213 if (CHILD_ACTIVE (&child_procs[i]))
215 child_proc_count = i + 1;
220 child_proc_count = 0;
223 /* Find a child by pid. */
224 static child_process *
225 find_child_pid (DWORD pid)
229 for (cp = child_procs+(child_proc_count-1); cp >= child_procs; cp--)
230 if (CHILD_ACTIVE (cp) && pid == cp->pid)
235 /* Function to do blocking read of one byte, needed to implement
236 select. It is only allowed on sockets and pipes. */
238 _sys_read_ahead (int fd)
243 if (fd < 0 || fd >= MAXDESC)
244 return STATUS_READ_ERROR;
248 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
249 return STATUS_READ_ERROR;
251 if ((fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET)) == 0
252 || (fd_info[fd].flags & FILE_READ) == 0)
254 /* fd is not a pipe or socket */
258 cp->status = STATUS_READ_IN_PROGRESS;
260 if (fd_info[fd].flags & FILE_PIPE)
262 rc = _read (fd, &cp->chr, sizeof (char));
264 /* Give subprocess time to buffer some more output for us before
265 reporting that input is available; we need this because Win95
266 connects DOS programs to pipes by making the pipe appear to be
267 the normal console stdout - as a result most DOS programs will
268 write to stdout without buffering, ie. one character at a
269 time. Even some Win32 programs do this - "dir" in a command
270 shell on NT is very slow if we don't do this. */
273 int wait = XINT (Vwin32_pipe_read_delay);
279 /* Yield remainder of our time slice, effectively giving a
280 temporary priority boost to the child process. */
285 if (rc == sizeof (char))
286 cp->status = STATUS_READ_SUCCEEDED;
288 cp->status = STATUS_READ_FAILED;
293 /* Thread proc for child process and socket reader threads. Each thread
294 is normally blocked until woken by select() to check for input by
295 reading one char. When the read completes, char_avail is signalled
296 to wake up the select emulator and the thread blocks itself again. */
298 reader_thread (void *arg)
303 cp = (child_process *)arg;
305 /* <matts@tibco.com> - I think the test below is wrong - we don't
306 want to wait for someone to signal char_consumed, as we haven't
307 read anything for them to consume yet! */
311 WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0)
323 rc = _sys_read_ahead (cp->fd);
325 /* The name char_avail is a misnomer - it really just means the
326 read-ahead has completed, whether successfully or not. */
327 if (!SetEvent (cp->char_avail))
329 DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
330 GetLastError (), cp->fd));
334 if (rc == STATUS_READ_ERROR)
336 /* We are finished, so clean up handles and set to NULL so
337 that CHILD_ACTIVE will see what is going on */
338 if (cp->char_avail) {
339 CloseHandle (cp->char_avail);
340 cp->char_avail = NULL;
343 CloseHandle (cp->thrd);
346 if (cp->char_consumed) {
347 CloseHandle(cp->char_consumed);
348 cp->char_consumed = NULL;
350 if (cp->procinfo.hProcess)
352 CloseHandle (cp->procinfo.hProcess);
353 cp->procinfo.hProcess=NULL;
358 /* If the read died, the child has died so let the thread die */
359 if (rc == STATUS_READ_FAILED)
362 /* Wait until our input is acknowledged before reading again */
363 if (WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0)
365 DebPrint (("reader_thread.WaitForSingleObject failed with "
366 "%lu for fd %ld\n", GetLastError (), cp->fd));
370 /* We are finished, so clean up handles and set to NULL so that
371 CHILD_ACTIVE will see what is going on */
372 if (cp->char_avail) {
373 CloseHandle (cp->char_avail);
374 cp->char_avail = NULL;
377 CloseHandle (cp->thrd);
380 if (cp->char_consumed) {
381 CloseHandle(cp->char_consumed);
382 cp->char_consumed = NULL;
384 if (cp->procinfo.hProcess)
386 CloseHandle (cp->procinfo.hProcess);
387 cp->procinfo.hProcess=NULL;
393 /* To avoid Emacs changing directory, we just record here the directory
394 the new process should start in. This is set just before calling
395 sys_spawnve, and is not generally valid at any other time. */
396 static const char * process_dir;
399 create_child (const char *exe, char *cmdline, char *env,
400 int * pPid, child_process *cp)
403 SECURITY_ATTRIBUTES sec_attrs;
404 SECURITY_DESCRIPTOR sec_desc;
405 char dir[ MAXPATHLEN ];
407 if (cp == NULL) abort ();
410 start.cb = sizeof (start);
413 if (NILP (Vwin32_start_process_show_window))
414 start.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
416 start.dwFlags = STARTF_USESTDHANDLES;
417 start.wShowWindow = SW_HIDE;
419 start.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
420 start.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
421 start.hStdError = GetStdHandle (STD_ERROR_HANDLE);
422 #endif /* HAVE_NTGUI */
424 /* Explicitly specify no security */
425 if (!InitializeSecurityDescriptor (&sec_desc, SECURITY_DESCRIPTOR_REVISION))
427 if (!SetSecurityDescriptorDacl (&sec_desc, TRUE, NULL, FALSE))
429 sec_attrs.nLength = sizeof (sec_attrs);
430 sec_attrs.lpSecurityDescriptor = &sec_desc;
431 sec_attrs.bInheritHandle = FALSE;
433 strcpy (dir, process_dir);
434 unixtodos_filename (dir);
436 if (!CreateProcess (exe, cmdline, &sec_attrs, NULL, TRUE,
437 (!NILP (Vwin32_start_process_share_console)
438 ? CREATE_NEW_PROCESS_GROUP
439 : CREATE_NEW_CONSOLE),
441 &start, &cp->procinfo))
444 cp->pid = (int) cp->procinfo.dwProcessId;
446 CloseHandle (cp->procinfo.hThread);
447 CloseHandle (cp->procinfo.hProcess);
448 cp->procinfo.hThread=NULL;
449 cp->procinfo.hProcess=NULL;
451 /* pid must fit in a Lisp_Int */
459 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError()););
464 /* Return pointer to section header for section containing the given
465 relative virtual address. */
466 static IMAGE_SECTION_HEADER *
467 rva_to_section (DWORD rva, IMAGE_NT_HEADERS * nt_header)
469 PIMAGE_SECTION_HEADER section;
472 section = IMAGE_FIRST_SECTION (nt_header);
474 for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
476 if (rva >= section->VirtualAddress
477 && rva < section->VirtualAddress + section->SizeOfRawData)
486 win32_executable_type (const char * filename, int * is_dos_app, int * is_cygnus_app)
488 file_data executable;
491 /* Default values in case we can't tell for sure. */
493 *is_cygnus_app = FALSE;
495 if (!open_input_file (&executable, filename))
498 p = strrchr (filename, '.');
500 /* We can only identify DOS .com programs from the extension. */
501 if (p && stricmp (p, ".com") == 0)
503 else if (p && (stricmp (p, ".bat") == 0 ||
504 stricmp (p, ".cmd") == 0))
506 /* A DOS shell script - it appears that CreateProcess is happy to
507 accept this (somewhat surprisingly); presumably it looks at
508 COMSPEC to determine what executable to actually invoke.
509 Therefore, we have to do the same here as well. */
510 /* Actually, I think it uses the program association for that
511 extension, which is defined in the registry. */
512 p = egetenv ("COMSPEC");
514 win32_executable_type (p, is_dos_app, is_cygnus_app);
518 /* Look for DOS .exe signature - if found, we must also check that
519 it isn't really a 16- or 32-bit Windows exe, since both formats
520 start with a DOS program stub. Note that 16-bit Windows
521 executables use the OS/2 1.x format. */
524 /* mingw32 doesn't have enough headers to detect cygwin
525 apps, just do what we can. */
528 exe_header = (FILHDR*) executable.file_base;
529 if (exe_header->e_magic != DOSMAGIC)
532 if ((char*) exe_header->e_lfanew > (char*) executable.size)
534 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
537 else if (exe_header->nt_signature != NT_SIGNATURE)
542 IMAGE_DOS_HEADER * dos_header;
543 IMAGE_NT_HEADERS * nt_header;
545 dos_header = (PIMAGE_DOS_HEADER) executable.file_base;
546 if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
549 nt_header = (PIMAGE_NT_HEADERS) ((char*) dos_header + dos_header->e_lfanew);
551 if ((char*) nt_header > (char*) dos_header + executable.size)
553 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
556 else if (nt_header->Signature != IMAGE_NT_SIGNATURE &&
557 LOWORD (nt_header->Signature) != IMAGE_OS2_SIGNATURE)
561 else if (nt_header->Signature == IMAGE_NT_SIGNATURE)
563 /* Look for cygwin.dll in DLL import list. */
564 IMAGE_DATA_DIRECTORY import_dir =
565 nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
566 IMAGE_IMPORT_DESCRIPTOR * imports;
567 IMAGE_SECTION_HEADER * section;
569 section = rva_to_section (import_dir.VirtualAddress, nt_header);
570 imports = (IMAGE_IMPORT_DESCRIPTOR *) RVA_TO_PTR (import_dir.VirtualAddress,
571 section, executable);
573 for ( ; imports->Name; imports++)
575 char *dllname = (char*) RVA_TO_PTR (imports->Name, section, executable);
577 if (strcmp (dllname, "cygwin.dll") == 0)
579 *is_cygnus_app = TRUE;
588 close_file_data (&executable);
592 compare_env (const void *strp1, const void *strp2)
594 const char *str1 = *(const char**)strp1, *str2 = *(const char**)strp2;
596 while (*str1 && *str2 && *str1 != '=' && *str2 != '=')
598 if ((*str1) > (*str2))
600 else if ((*str1) < (*str2))
605 if (*str1 == '=' && *str2 == '=')
607 else if (*str1 == '=')
614 merge_and_sort_env (char **envp1, char **envp2, char **new_envp)
630 qsort (new_envp, num, sizeof (char*), compare_env);
635 /* When a new child process is created we need to register it in our list,
636 so intercept spawn requests. */
638 sys_spawnve (int mode, const char *cmdname,
639 const char * const *argv, const char *const *envp)
641 Lisp_Object program, full;
642 char *cmdline, *env, *parg, **targ;
646 int is_dos_app, is_cygnus_app;
648 char escape_char = 0;
649 /* We pass our process ID to our children by setting up an environment
650 variable in their environment. */
651 char ppid_env_var_buffer[64];
652 char *extra_env[] = {ppid_env_var_buffer, NULL};
655 /* We don't care about the other modes */
656 if (mode != _P_NOWAIT)
662 /* Handle executable names without an executable suffix. */
663 program = make_string (cmdname, strlen (cmdname));
665 if (NILP (Ffile_executable_p (program)))
668 locate_file (Vexec_path, program, Vlisp_EXEC_SUFFIXES, &full, 1);
675 TO_EXTERNAL_FORMAT (LISP_STRING, full,
676 C_STRING_ALLOCA, cmdname,
681 cmdname = (char*)alloca (strlen (argv[0]) + 1);
682 strcpy ((char*)cmdname, argv[0]);
686 /* make sure argv[0] and cmdname are both in DOS format */
687 unixtodos_filename ((char*)cmdname);
689 ((const char**)argv)[0] = cmdname;
691 /* Determine whether program is a 16-bit DOS executable, or a Win32
692 executable that is implicitly linked to the Cygnus dll (implying it
693 was compiled with the Cygnus GNU toolchain and hence relies on
694 cygwin.dll to parse the command line - we use this to decide how to
695 escape quote chars in command line args that must be quoted). */
696 win32_executable_type (cmdname, &is_dos_app, &is_cygnus_app);
698 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
699 application to start it by specifying the helper app as cmdname,
700 while leaving the real app name as argv[0]. */
703 cmdname = (char*) alloca (MAXPATHLEN);
704 if (egetenv ("CMDPROXY"))
705 strcpy ((char*)cmdname, egetenv ("CMDPROXY"));
708 strcpy ((char*)cmdname, XSTRING_DATA (Vinvocation_directory));
709 strcat ((char*)cmdname, "cmdproxy.exe");
711 unixtodos_filename ((char*)cmdname);
714 /* we have to do some conjuring here to put argv and envp into the
715 form CreateProcess wants... argv needs to be a space separated/null
716 terminated list of parameters, and envp is a null
717 separated/double-null terminated list of parameters.
719 Additionally, zero-length args and args containing whitespace or
720 quote chars need to be wrapped in double quotes - for this to work,
721 embedded quotes need to be escaped as well. The aim is to ensure
722 the child process reconstructs the argv array we start with
723 exactly, so we treat quotes at the beginning and end of arguments
726 The Win32 GNU-based library from Cygnus doubles quotes to escape
727 them, while MSVC uses backslash for escaping. (Actually the MSVC
728 startup code does attempt to recognize doubled quotes and accept
729 them, but gets it wrong and ends up requiring three quotes to get a
730 single embedded quote!) So by default we decide whether to use
731 quote or backslash as the escape character based on whether the
732 binary is apparently a Cygnus compiled app.
734 Note that using backslash to escape embedded quotes requires
735 additional special handling if an embedded quote is already
736 preceded by backslash, or if an arg requiring quoting ends with
737 backslash. In such cases, the run of escape characters needs to be
738 doubled. For consistency, we apply this special handling as long
739 as the escape character is not quote.
741 Since we have no idea how large argv and envp are likely to be we
742 figure out list lengths on the fly and allocate them. */
744 if (!NILP (Vwin32_quote_process_args))
747 /* Override escape char by binding win32-quote-process-args to
748 desired character, or use t for auto-selection. */
749 if (INTP (Vwin32_quote_process_args))
750 escape_char = (char) XINT (Vwin32_quote_process_args);
752 escape_char = is_cygnus_app ? '"' : '\\';
762 int escape_char_run = 0;
770 /* allow for embedded quotes to be escaped */
773 /* handle the case where the embedded quote is already escaped */
774 if (escape_char_run > 0)
776 /* To preserve the arg exactly, we need to double the
777 preceding escape characters (plus adding one to
778 escape the quote character itself). */
779 arglen += escape_char_run;
782 else if (*p == ' ' || *p == '\t')
787 if (*p == escape_char && escape_char != '"')
795 /* handle the case where the arg ends with an escape char - we
796 must not let the enclosing quote be escaped. */
797 if (escape_char_run > 0)
798 arglen += escape_char_run;
800 arglen += strlen (*targ++) + 1;
802 cmdline = (char*) alloca (arglen);
816 if (*p == ' ' || *p == '\t' || *p == '"')
821 int escape_char_run = 0;
827 last = p + strlen (p) - 1;
830 /* This version does not escape quotes if they occur at the
831 beginning or end of the arg - this could lead to incorrect
832 behavior when the arg itself represents a command line
833 containing quoted args. I believe this was originally done
834 as a hack to make some things work, before
835 `win32-quote-process-args' was added. */
838 if (*p == '"' && p > first && p < last)
839 *parg++ = escape_char; /* escape embedded quotes */
847 /* double preceding escape chars if any */
848 while (escape_char_run > 0)
850 *parg++ = escape_char;
853 /* escape all quote chars, even at beginning or end */
854 *parg++ = escape_char;
858 if (*p == escape_char && escape_char != '"')
863 /* double escape chars before enclosing quote */
864 while (escape_char_run > 0)
866 *parg++ = escape_char;
874 strcpy (parg, *targ);
875 parg += strlen (*targ);
884 targ = (char**) envp;
885 numenv = 1; /* for end null */
888 arglen += strlen (*targ++) + 1;
891 /* extra env vars... */
892 sprintf (ppid_env_var_buffer, "__PARENT_PROCESS_ID=%d",
893 GetCurrentProcessId ());
894 arglen += strlen (ppid_env_var_buffer) + 1;
897 /* merge env passed in and extra env into one, and sort it. */
898 targ = (char **) alloca (numenv * sizeof (char*));
899 merge_and_sort_env ((char**) envp, extra_env, targ);
901 /* concatenate env entries. */
902 env = (char*) alloca (arglen);
906 strcpy (parg, *targ);
907 parg += strlen (*targ++);
920 /* Now create the process. */
921 if (!create_child (cmdname, cmdline, env, &pid, cp))
931 /* Substitute for certain kill () operations */
934 find_child_console (HWND hwnd, child_process * cp)
939 thread_id = GetWindowThreadProcessId (hwnd, &process_id);
940 if (process_id == cp->procinfo.dwProcessId)
942 char window_class[32];
944 GetClassName (hwnd, window_class, sizeof (window_class));
945 if (strcmp (window_class,
948 : "ConsoleWindowClass") == 0)
959 sys_kill (int pid, int sig)
963 int need_to_free = 0;
966 /* Only handle signals that will result in the process dying */
967 if (sig != SIGINT && sig != SIGKILL && sig != SIGQUIT && sig != SIGHUP)
973 cp = find_child_pid (pid);
976 proc_hand = OpenProcess (PROCESS_TERMINATE, 0, pid);
977 if (proc_hand == NULL)
986 proc_hand = cp->procinfo.hProcess;
987 pid = cp->procinfo.dwProcessId;
989 /* Try to locate console window for process. */
990 EnumWindows ((WNDENUMPROC)find_child_console, (LPARAM) cp);
995 if (NILP (Vwin32_start_process_share_console) && cp && cp->hwnd)
997 BYTE control_scan_code = (BYTE) MapVirtualKey (VK_CONTROL, 0);
998 BYTE vk_break_code = VK_CANCEL;
999 BYTE break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
1000 HWND foreground_window;
1002 if (break_scan_code == 0)
1004 /* Fake Ctrl-C if we can't manage Ctrl-Break. */
1005 vk_break_code = 'C';
1006 break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
1009 foreground_window = GetForegroundWindow ();
1010 if (foreground_window && SetForegroundWindow (cp->hwnd))
1012 /* Generate keystrokes as if user had typed Ctrl-Break or Ctrl-C. */
1013 keybd_event (VK_CONTROL, control_scan_code, 0, 0);
1014 keybd_event (vk_break_code, break_scan_code, 0, 0);
1015 keybd_event (vk_break_code, break_scan_code, KEYEVENTF_KEYUP, 0);
1016 keybd_event (VK_CONTROL, control_scan_code, KEYEVENTF_KEYUP, 0);
1018 /* Sleep for a bit to give time for Emacs frame to respond
1019 to focus change events (if Emacs was active app). */
1022 SetForegroundWindow (foreground_window);
1025 /* Ctrl-Break is NT equivalent of SIGINT. */
1026 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, pid))
1028 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
1029 "for pid %lu\n", GetLastError (), pid));
1036 if (NILP (Vwin32_start_process_share_console) && cp && cp->hwnd)
1039 if (msw_windows9x_p())
1042 Another possibility is to try terminating the VDM out-right by
1043 calling the Shell VxD (id 0x17) V86 interface, function #4
1044 "SHELL_Destroy_VM", ie.
1050 First need to determine the current VM handle, and then arrange for
1051 the shellapi call to be made from the system vm (by using
1052 Switch_VM_and_callback).
1054 Could try to invoke DestroyVM through CallVxD.
1058 /* On Win95, posting WM_QUIT causes the 16-bit subsystem
1059 to hang when cmdproxy is used in conjunction with
1060 command.com for an interactive shell. Posting
1061 WM_CLOSE pops up a dialog that, when Yes is selected,
1062 does the same thing. TerminateProcess is also less
1063 than ideal in that subprocesses tend to stick around
1064 until the machine is shutdown, but at least it
1065 doesn't freeze the 16-bit subsystem. */
1066 PostMessage (cp->hwnd, WM_QUIT, 0xff, 0);
1068 if (!TerminateProcess (proc_hand, 0xff))
1070 DebPrint (("sys_kill.TerminateProcess returned %d "
1071 "for pid %lu\n", GetLastError (), pid));
1078 PostMessage (cp->hwnd, WM_CLOSE, 0, 0);
1080 /* Kill the process. On Win32 this doesn't kill child processes
1081 so it doesn't work very well for shells which is why it's not
1082 used in every case. */
1083 else if (!TerminateProcess (proc_hand, 0xff))
1085 DebPrint (("sys_kill.TerminateProcess returned %d "
1086 "for pid %lu\n", GetLastError (), pid));
1093 CloseHandle (proc_hand);
1099 /* Sync with FSF Emacs 19.34.6 note: ifdef'ed out in XEmacs */
1100 extern int report_file_error (const char *, Lisp_Object);
1102 /* The following two routines are used to manipulate stdin, stdout, and
1103 stderr of our child processes.
1105 Assuming that in, out, and err are *not* inheritable, we make them
1106 stdin, stdout, and stderr of the child as follows:
1108 - Save the parent's current standard handles.
1109 - Set the std handles to inheritable duplicates of the ones being passed in.
1110 (Note that _get_osfhandle() is an io.h procedure that retrieves the
1111 NT file handle for a crt file descriptor.)
1112 - Spawn the child, which inherits in, out, and err as stdin,
1113 stdout, and stderr. (see Spawnve)
1114 - Close the std handles passed to the child.
1115 - Reset the parent's standard handles to the saved handles.
1116 (see reset_standard_handles)
1117 We assume that the caller closes in, out, and err after calling us. */
1120 prepare_standard_handles (int in, int out, int err, HANDLE handles[3])
1123 HANDLE newstdin, newstdout, newstderr;
1125 parent = GetCurrentProcess ();
1127 handles[0] = GetStdHandle (STD_INPUT_HANDLE);
1128 handles[1] = GetStdHandle (STD_OUTPUT_HANDLE);
1129 handles[2] = GetStdHandle (STD_ERROR_HANDLE);
1131 /* make inheritable copies of the new handles */
1132 if (!DuplicateHandle (parent,
1133 (HANDLE) _get_osfhandle (in),
1138 DUPLICATE_SAME_ACCESS))
1139 report_file_error ("Duplicating input handle for child", Qnil);
1141 if (!DuplicateHandle (parent,
1142 (HANDLE) _get_osfhandle (out),
1147 DUPLICATE_SAME_ACCESS))
1148 report_file_error ("Duplicating output handle for child", Qnil);
1150 if (!DuplicateHandle (parent,
1151 (HANDLE) _get_osfhandle (err),
1156 DUPLICATE_SAME_ACCESS))
1157 report_file_error ("Duplicating error handle for child", Qnil);
1159 /* and store them as our std handles */
1160 if (!SetStdHandle (STD_INPUT_HANDLE, newstdin))
1161 report_file_error ("Changing stdin handle", Qnil);
1163 if (!SetStdHandle (STD_OUTPUT_HANDLE, newstdout))
1164 report_file_error ("Changing stdout handle", Qnil);
1166 if (!SetStdHandle (STD_ERROR_HANDLE, newstderr))
1167 report_file_error ("Changing stderr handle", Qnil);
1171 reset_standard_handles (int in, int out, int err, HANDLE handles[3])
1173 /* close the duplicated handles passed to the child */
1174 CloseHandle (GetStdHandle (STD_INPUT_HANDLE));
1175 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE));
1176 CloseHandle (GetStdHandle (STD_ERROR_HANDLE));
1178 /* now restore parent's saved std handles */
1179 SetStdHandle (STD_INPUT_HANDLE, handles[0]);
1180 SetStdHandle (STD_OUTPUT_HANDLE, handles[1]);
1181 SetStdHandle (STD_ERROR_HANDLE, handles[2]);
1185 set_process_dir (const char * dir)
1190 /* Some miscellaneous functions that are Windows specific, but not GUI
1191 specific (ie. are applicable in terminal or batch mode as well). */
1193 /* lifted from fileio.c */
1194 #define CORRECT_DIR_SEPS(s) \
1195 do { if ('/' == DIRECTORY_SEP) dostounix_filename (s); \
1196 else unixtodos_filename (s); \
1199 DEFUN ("win32-short-file-name", Fwin32_short_file_name, 1, 1, "", /*
1200 Return the short file name version (8.3) of the full path of FILENAME.
1201 If FILENAME does not exist, return nil.
1202 All path elements in FILENAME are converted to their short names.
1206 char shortname[MAX_PATH];
1208 CHECK_STRING (filename);
1210 /* first expand it. */
1211 filename = Fexpand_file_name (filename, Qnil);
1213 /* luckily, this returns the short version of each element in the path. */
1214 if (GetShortPathName (XSTRING_DATA (filename), shortname, MAX_PATH) == 0)
1217 CORRECT_DIR_SEPS (shortname);
1219 return build_string (shortname);
1223 DEFUN ("win32-long-file-name", Fwin32_long_file_name, 1, 1, "", /*
1224 Return the long file name version of the full path of FILENAME.
1225 If FILENAME does not exist, return nil.
1226 All path elements in FILENAME are converted to their long names.
1230 char longname[ MAX_PATH ];
1232 CHECK_STRING (filename);
1234 /* first expand it. */
1235 filename = Fexpand_file_name (filename, Qnil);
1237 if (!win32_get_long_filename (XSTRING_DATA (filename), longname, MAX_PATH))
1240 CORRECT_DIR_SEPS (longname);
1242 return build_string (longname);
1245 DEFUN ("win32-set-process-priority", Fwin32_set_process_priority, 2, 2, "", /*
1246 Set the priority of PROCESS to PRIORITY.
1247 If PROCESS is nil, the priority of Emacs is changed, otherwise the
1248 priority of the process whose pid is PROCESS is changed.
1249 PRIORITY should be one of the symbols high, normal, or low;
1250 any other symbol will be interpreted as normal.
1252 If successful, the return value is t, otherwise nil.
1254 (process, priority))
1256 HANDLE proc_handle = GetCurrentProcess ();
1257 DWORD priority_class = NORMAL_PRIORITY_CLASS;
1258 Lisp_Object result = Qnil;
1260 CHECK_SYMBOL (priority);
1262 if (!NILP (process))
1267 CHECK_INT (process);
1269 /* Allow pid to be an internally generated one, or one obtained
1270 externally. This is necessary because real pids on Win95 are
1273 pid = XINT (process);
1274 cp = find_child_pid (pid);
1276 pid = cp->procinfo.dwProcessId;
1278 proc_handle = OpenProcess (PROCESS_SET_INFORMATION, FALSE, pid);
1281 if (EQ (priority, Qhigh))
1282 priority_class = HIGH_PRIORITY_CLASS;
1283 else if (EQ (priority, Qlow))
1284 priority_class = IDLE_PRIORITY_CLASS;
1286 if (proc_handle != NULL)
1288 if (SetPriorityClass (proc_handle, priority_class))
1290 if (!NILP (process))
1291 CloseHandle (proc_handle);
1298 DEFUN ("win32-get-locale-info", Fwin32_get_locale_info, 1, 2, "", /*
1299 "Return information about the Windows locale LCID.
1300 By default, return a three letter locale code which encodes the default
1301 language as the first two characters, and the country or regional variant
1302 as the third letter. For example, ENU refers to `English (United States)',
1303 while ENC means `English (Canadian)'.
1305 If the optional argument LONGFORM is non-nil, the long form of the locale
1306 name is returned, e.g. `English (United States)' instead.
1308 If LCID (a 16-bit number) is not a valid locale, the result is nil.
1314 char abbrev_name[32] = { 0 };
1315 char full_name[256] = { 0 };
1319 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
1322 if (NILP (longform))
1324 got_abbrev = GetLocaleInfo (XINT (lcid),
1325 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
1326 abbrev_name, sizeof (abbrev_name));
1328 return build_string (abbrev_name);
1332 got_full = GetLocaleInfo (XINT (lcid),
1333 LOCALE_SLANGUAGE | LOCALE_USE_CP_ACP,
1334 full_name, sizeof (full_name));
1336 return build_string (full_name);
1343 DEFUN ("win32-get-current-locale-id", Fwin32_get_current_locale_id, 0, 0, "", /*
1344 "Return Windows locale id for current locale setting.
1345 This is a numerical value; use `win32-get-locale-info' to convert to a
1346 human-readable form.
1350 return make_int (GetThreadLocale ());
1354 DEFUN ("win32-get-default-locale-id", Fwin32_get_default_locale_id, 0, 1, "", /*
1355 "Return Windows locale id for default locale setting.
1356 By default, the system default locale setting is returned; if the optional
1357 parameter USERP is non-nil, the user default locale setting is returned.
1358 This is a numerical value; use `win32-get-locale-info' to convert to a
1359 human-readable form.
1364 return make_int (GetSystemDefaultLCID ());
1365 return make_int (GetUserDefaultLCID ());
1368 DWORD int_from_hex (char * s)
1371 static char hex[] = "0123456789abcdefABCDEF";
1374 while (*s && (p = strchr(hex, *s)) != NULL)
1376 unsigned digit = p - hex;
1379 val = val * 16 + digit;
1385 /* We need to build a global list, since the EnumSystemLocale callback
1386 function isn't given a context pointer. */
1387 Lisp_Object Vwin32_valid_locale_ids;
1389 BOOL CALLBACK enum_locale_fn (LPTSTR localeNum)
1391 DWORD id = int_from_hex (localeNum);
1392 Vwin32_valid_locale_ids = Fcons (make_int (id), Vwin32_valid_locale_ids);
1396 DEFUN ("win32-get-valid-locale-ids", Fwin32_get_valid_locale_ids, 0, 0, "", /*
1397 Return list of all valid Windows locale ids.
1398 Each id is a numerical value; use `win32-get-locale-info' to convert to a
1399 human-readable form.
1403 Vwin32_valid_locale_ids = Qnil;
1405 EnumSystemLocales (enum_locale_fn, LCID_SUPPORTED);
1407 Vwin32_valid_locale_ids = Fnreverse (Vwin32_valid_locale_ids);
1408 return Vwin32_valid_locale_ids;
1412 DEFUN ("win32-set-current-locale", Fwin32_set_current_locale, 1, 1, "", /*
1413 Make Windows locale LCID be the current locale setting for Emacs.
1414 If successful, the new locale id is returned, otherwise nil.
1420 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
1423 if (!SetThreadLocale (XINT (lcid)))
1426 /* Sync with FSF Emacs 19.34.6 note: dwWinThreadId declared in
1427 w32term.h and defined in w32fns.c, both of which are not in current
1428 XEmacs. #### Check what we lose by ifdef'ing out these. --marcpa */
1430 /* Need to set input thread locale if present. */
1432 /* Reply is not needed. */
1433 PostThreadMessage (dwWinThreadId, WM_EMACS_SETLOCALE, XINT (lcid), 0);
1436 return make_int (GetThreadLocale ());
1441 syms_of_ntproc (void)
1443 DEFSUBR (Fwin32_short_file_name);
1444 DEFSUBR (Fwin32_long_file_name);
1445 DEFSUBR (Fwin32_set_process_priority);
1446 DEFSUBR (Fwin32_get_locale_info);
1447 DEFSUBR (Fwin32_get_current_locale_id);
1448 DEFSUBR (Fwin32_get_default_locale_id);
1449 DEFSUBR (Fwin32_get_valid_locale_ids);
1450 DEFSUBR (Fwin32_set_current_locale);
1455 vars_of_ntproc (void)
1457 defsymbol (&Qhigh, "high");
1458 defsymbol (&Qlow, "low");
1460 DEFVAR_LISP ("win32-quote-process-args", &Vwin32_quote_process_args /*
1461 Non-nil enables quoting of process arguments to ensure correct parsing.
1462 Because Windows does not directly pass argv arrays to child processes,
1463 programs have to reconstruct the argv array by parsing the command
1464 line string. For an argument to contain a space, it must be enclosed
1465 in double quotes or it will be parsed as multiple arguments.
1467 If the value is a character, that character will be used to escape any
1468 quote characters that appear, otherwise a suitable escape character
1469 will be chosen based on the type of the program.
1471 Vwin32_quote_process_args = Qt;
1473 DEFVAR_LISP ("win32-start-process-show-window",
1474 &Vwin32_start_process_show_window /*
1475 When nil, processes started via start-process hide their windows.
1476 When non-nil, they show their window in the method of their choice.
1478 Vwin32_start_process_show_window = Qnil;
1480 DEFVAR_LISP ("win32-start-process-share-console",
1481 &Vwin32_start_process_share_console /*
1482 When nil, processes started via start-process are given a new console.
1483 When non-nil, they share the Emacs console; this has the limitation of
1484 allowing only only DOS subprocess to run at a time (whether started directly
1485 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
1486 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
1487 otherwise respond to interrupts from Emacs.
1489 Vwin32_start_process_share_console = Qt;
1491 DEFVAR_LISP ("win32-pipe-read-delay", &Vwin32_pipe_read_delay /*
1492 Forced delay before reading subprocess output.
1493 This is done to improve the buffering of subprocess output, by
1494 avoiding the inefficiency of frequently reading small amounts of data.
1496 If positive, the value is the number of milliseconds to sleep before
1497 reading the subprocess output. If negative, the magnitude is the number
1498 of time slices to wait (effectively boosting the priority of the child
1499 process temporarily). A value of zero disables waiting entirely.
1501 Vwin32_pipe_read_delay = make_int (50);
1504 DEFVAR_LISP ("win32-generate-fake-inodes", &Vwin32_generate_fake_inodes /*
1505 "Non-nil means attempt to fake realistic inode values.
1506 This works by hashing the truename of files, and should detect
1507 aliasing between long and short (8.3 DOS) names, but can have
1508 false positives because of hash collisions. Note that determining
1509 the truename of a file can be slow.
1511 Vwin32_generate_fake_inodes = Qnil;
1515 /* end of ntproc.c */