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>
49 #include "ntheap.h" /* From 19.34.6 */
51 #include "syssignal.h"
54 /*#include "w32term.h"*/ /* From 19.34.6: sync in ? --marcpa */
56 /* #### I'm not going to play with shit. */
57 #pragma warning (disable:4013 4024 4090)
59 /* Control whether spawnve quotes arguments as necessary to ensure
60 correct parsing by child process. Because not all uses of spawnve
61 are careful about constructing argv arrays, we make this behaviour
62 conditional (off by default). */
63 Lisp_Object Vwin32_quote_process_args;
65 /* Control whether create_child causes the process' window to be
66 hidden. The default is nil. */
67 Lisp_Object Vwin32_start_process_show_window;
69 /* Control whether create_child causes the process to inherit Emacs'
70 console window, or be given a new one of its own. The default is
71 nil, to allow multiple DOS programs to run on Win95. Having separate
72 consoles also allows Emacs to cleanly terminate process groups. */
73 Lisp_Object Vwin32_start_process_share_console;
75 /* Time to sleep before reading from a subprocess output pipe - this
76 avoids the inefficiency of frequently reading small amounts of data.
77 This is primarily necessary for handling DOS processes on Windows 95,
78 but is useful for Win32 processes on both Win95 and NT as well. */
79 Lisp_Object Vwin32_pipe_read_delay;
81 /* Control whether stat() attempts to generate fake but hopefully
82 "accurate" inode values, by hashing the absolute truenames of files.
83 This should detect aliasing between long and short names, but still
84 allows the possibility of hash collisions. */
85 Lisp_Object Vwin32_generate_fake_inodes;
87 Lisp_Object Qhigh, Qlow;
92 void _DebPrint (const char *fmt, ...)
99 vsprintf (buf, fmt, args);
101 OutputDebugString (buf);
105 /* sys_signal moved to nt.c. It's now called msw_signal... */
107 /* Defined in <process.h> which conflicts with the local copy */
110 /* Child process management list. */
111 int child_proc_count = 0;
112 child_process child_procs[ MAX_CHILDREN ];
113 child_process *dead_child = NULL;
115 DWORD WINAPI reader_thread (void *arg);
117 /* Find an unused process slot. */
124 for (cp = child_procs+(child_proc_count-1); cp >= child_procs; cp--)
125 if (!CHILD_ACTIVE (cp))
127 if (child_proc_count == MAX_CHILDREN)
129 cp = &child_procs[child_proc_count++];
135 if (cp->procinfo.hProcess)
136 CloseHandle(cp->procinfo.hProcess);
137 cp->procinfo.hProcess = NULL;
138 cp->status = STATUS_READ_ERROR;
140 /* use manual reset event so that select() will function properly */
141 cp->char_avail = CreateEvent (NULL, TRUE, FALSE, NULL);
144 cp->char_consumed = CreateEvent (NULL, FALSE, FALSE, NULL);
145 if (cp->char_consumed)
147 cp->thrd = CreateThread (NULL, 1024, reader_thread, cp, 0, &id);
157 delete_child (child_process *cp)
161 /* Should not be deleting a child that is still needed. */
162 for (i = 0; i < MAXDESC; i++)
163 if (fd_info[i].cp == cp)
166 if (!CHILD_ACTIVE (cp))
169 /* reap thread if necessary */
174 if (GetExitCodeThread (cp->thrd, &rc) && rc == STILL_ACTIVE)
176 /* let the thread exit cleanly if possible */
177 cp->status = STATUS_READ_ERROR;
178 SetEvent (cp->char_consumed);
179 if (WaitForSingleObject (cp->thrd, 1000) != WAIT_OBJECT_0)
181 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
182 "with %lu for fd %ld\n", GetLastError (), cp->fd));
183 TerminateThread (cp->thrd, 0);
186 CloseHandle (cp->thrd);
191 CloseHandle (cp->char_avail);
192 cp->char_avail = NULL;
194 if (cp->char_consumed)
196 CloseHandle (cp->char_consumed);
197 cp->char_consumed = NULL;
200 /* update child_proc_count (highest numbered slot in use plus one) */
201 if (cp == child_procs + child_proc_count - 1)
203 for (i = child_proc_count-1; i >= 0; i--)
204 if (CHILD_ACTIVE (&child_procs[i]))
206 child_proc_count = i + 1;
211 child_proc_count = 0;
214 /* Find a child by pid. */
215 static child_process *
216 find_child_pid (DWORD pid)
220 for (cp = child_procs+(child_proc_count-1); cp >= child_procs; cp--)
221 if (CHILD_ACTIVE (cp) && pid == cp->pid)
227 /* Thread proc for child process and socket reader threads. Each thread
228 is normally blocked until woken by select() to check for input by
229 reading one char. When the read completes, char_avail is signalled
230 to wake up the select emulator and the thread blocks itself again. */
232 reader_thread (void *arg)
237 cp = (child_process *)arg;
239 /* <matts@tibco.com> - I think the test below is wrong - we don't
240 want to wait for someone to signal char_consumed, as we haven't
241 read anything for them to consume yet! */
245 WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0)
257 rc = _sys_read_ahead (cp->fd);
259 /* The name char_avail is a misnomer - it really just means the
260 read-ahead has completed, whether successfully or not. */
261 if (!SetEvent (cp->char_avail))
263 DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
264 GetLastError (), cp->fd));
268 if (rc == STATUS_READ_ERROR)
270 /* We are finished, so clean up handles and set to NULL so
271 that CHILD_ACTIVE will see what is going on */
272 if (cp->char_avail) {
273 CloseHandle (cp->char_avail);
274 cp->char_avail = NULL;
277 CloseHandle (cp->thrd);
280 if (cp->char_consumed) {
281 CloseHandle(cp->char_consumed);
282 cp->char_consumed = NULL;
284 if (cp->procinfo.hProcess)
286 CloseHandle (cp->procinfo.hProcess);
287 cp->procinfo.hProcess=NULL;
292 /* If the read died, the child has died so let the thread die */
293 if (rc == STATUS_READ_FAILED)
296 /* Wait until our input is acknowledged before reading again */
297 if (WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0)
299 DebPrint (("reader_thread.WaitForSingleObject failed with "
300 "%lu for fd %ld\n", GetLastError (), cp->fd));
304 /* We are finished, so clean up handles and set to NULL so that
305 CHILD_ACTIVE will see what is going on */
306 if (cp->char_avail) {
307 CloseHandle (cp->char_avail);
308 cp->char_avail = NULL;
311 CloseHandle (cp->thrd);
314 if (cp->char_consumed) {
315 CloseHandle(cp->char_consumed);
316 cp->char_consumed = NULL;
318 if (cp->procinfo.hProcess)
320 CloseHandle (cp->procinfo.hProcess);
321 cp->procinfo.hProcess=NULL;
327 /* To avoid Emacs changing directory, we just record here the directory
328 the new process should start in. This is set just before calling
329 sys_spawnve, and is not generally valid at any other time. */
330 static const char * process_dir;
333 create_child (char *exe, char *cmdline, char *env,
334 int * pPid, child_process *cp)
337 SECURITY_ATTRIBUTES sec_attrs;
338 SECURITY_DESCRIPTOR sec_desc;
339 char dir[ MAXPATHLEN ];
341 if (cp == NULL) abort ();
344 start.cb = sizeof (start);
347 if (NILP (Vwin32_start_process_show_window))
348 start.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
350 start.dwFlags = STARTF_USESTDHANDLES;
351 start.wShowWindow = SW_HIDE;
353 start.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
354 start.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
355 start.hStdError = GetStdHandle (STD_ERROR_HANDLE);
356 #endif /* HAVE_NTGUI */
358 /* Explicitly specify no security */
359 if (!InitializeSecurityDescriptor (&sec_desc, SECURITY_DESCRIPTOR_REVISION))
361 if (!SetSecurityDescriptorDacl (&sec_desc, TRUE, NULL, FALSE))
363 sec_attrs.nLength = sizeof (sec_attrs);
364 sec_attrs.lpSecurityDescriptor = &sec_desc;
365 sec_attrs.bInheritHandle = FALSE;
367 strcpy (dir, process_dir);
368 unixtodos_filename (dir);
370 if (!CreateProcess (exe, cmdline, &sec_attrs, NULL, TRUE,
371 (!NILP (Vwin32_start_process_share_console)
372 ? CREATE_NEW_PROCESS_GROUP
373 : CREATE_NEW_CONSOLE),
375 &start, &cp->procinfo))
378 cp->pid = (int) cp->procinfo.dwProcessId;
380 CloseHandle (cp->procinfo.hThread);
381 CloseHandle (cp->procinfo.hProcess);
382 cp->procinfo.hThread=NULL;
383 cp->procinfo.hProcess=NULL;
385 /* Hack for Windows 95, which assigns large (ie negative) pids */
389 /* pid must fit in a Lisp_Int */
390 #ifdef USE_UNION_TYPE
391 cp->pid = (cp->pid & ((1U << VALBITS) - 1));
393 cp->pid = (cp->pid & VALMASK);
401 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError()););
406 win32_executable_type (char * filename, int * is_dos_app, int * is_cygnus_app)
408 file_data executable;
411 /* Default values in case we can't tell for sure. */
413 *is_cygnus_app = FALSE;
415 if (!open_input_file (&executable, filename))
418 p = strrchr (filename, '.');
420 /* We can only identify DOS .com programs from the extension. */
421 if (p && stricmp (p, ".com") == 0)
423 else if (p && (stricmp (p, ".bat") == 0 ||
424 stricmp (p, ".cmd") == 0))
426 /* A DOS shell script - it appears that CreateProcess is happy to
427 accept this (somewhat surprisingly); presumably it looks at
428 COMSPEC to determine what executable to actually invoke.
429 Therefore, we have to do the same here as well. */
430 /* Actually, I think it uses the program association for that
431 extension, which is defined in the registry. */
432 p = egetenv ("COMSPEC");
434 win32_executable_type (p, is_dos_app, is_cygnus_app);
438 /* Look for DOS .exe signature - if found, we must also check that
439 it isn't really a 16- or 32-bit Windows exe, since both formats
440 start with a DOS program stub. Note that 16-bit Windows
441 executables use the OS/2 1.x format. */
443 IMAGE_DOS_HEADER * dos_header;
444 IMAGE_NT_HEADERS * nt_header;
446 dos_header = (PIMAGE_DOS_HEADER) executable.file_base;
447 if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
450 nt_header = (PIMAGE_NT_HEADERS) ((char *) dos_header + dos_header->e_lfanew);
452 if ((char *) nt_header > (char *) dos_header + executable.size)
454 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
457 else if (nt_header->Signature != IMAGE_NT_SIGNATURE &&
458 LOWORD (nt_header->Signature) != IMAGE_OS2_SIGNATURE)
462 else if (nt_header->Signature == IMAGE_NT_SIGNATURE)
464 /* Look for cygwin.dll in DLL import list. */
465 IMAGE_DATA_DIRECTORY import_dir =
466 nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
467 IMAGE_IMPORT_DESCRIPTOR * imports;
468 IMAGE_SECTION_HEADER * section;
470 section = rva_to_section (import_dir.VirtualAddress, nt_header);
471 imports = RVA_TO_PTR (import_dir.VirtualAddress, section, executable);
473 for ( ; imports->Name; imports++)
475 char * dllname = RVA_TO_PTR (imports->Name, section, executable);
477 if (strcmp (dllname, "cygwin.dll") == 0)
479 *is_cygnus_app = TRUE;
487 close_file_data (&executable);
491 compare_env (const char **strp1, const char **strp2)
493 const char *str1 = *strp1, *str2 = *strp2;
495 while (*str1 && *str2 && *str1 != '=' && *str2 != '=')
497 if ((*str1) > (*str2))
499 else if ((*str1) < (*str2))
504 if (*str1 == '=' && *str2 == '=')
506 else if (*str1 == '=')
513 merge_and_sort_env (char **envp1, char **envp2, char **new_envp)
529 qsort (new_envp, num, sizeof (char *), compare_env);
534 /* When a new child process is created we need to register it in our list,
535 so intercept spawn requests. */
537 sys_spawnve (int mode, CONST char *cmdname,
538 CONST char * CONST *argv, CONST char *CONST *envp)
540 Lisp_Object program, full;
541 char *cmdline, *env, *parg, **targ;
545 int is_dos_app, is_cygnus_app;
548 /* We pass our process ID to our children by setting up an environment
549 variable in their environment. */
550 char ppid_env_var_buffer[64];
551 char *extra_env[] = {ppid_env_var_buffer, NULL};
554 /* We don't care about the other modes */
555 if (mode != _P_NOWAIT)
561 /* Handle executable names without an executable suffix. */
562 program = make_string (cmdname, strlen (cmdname));
564 if (NILP (Ffile_executable_p (program)))
567 locate_file (Vexec_path, program, EXEC_SUFFIXES, &full, 1);
574 cmdname = XSTRING_DATA (full);
576 *(char**)(argv[0]) = cmdname;
580 /* make sure argv[0] and cmdname are both in DOS format */
581 strcpy (cmdname = alloca (strlen (cmdname) + 1), argv[0]);
582 unixtodos_filename (cmdname);
584 *(char**)(argv[0]) = cmdname;
586 /* Determine whether program is a 16-bit DOS executable, or a Win32
587 executable that is implicitly linked to the Cygnus dll (implying it
588 was compiled with the Cygnus GNU toolchain and hence relies on
589 cygwin.dll to parse the command line - we use this to decide how to
590 escape quote chars in command line args that must be quoted). */
591 win32_executable_type (cmdname, &is_dos_app, &is_cygnus_app);
593 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
594 application to start it by specifying the helper app as cmdname,
595 while leaving the real app name as argv[0]. */
598 cmdname = alloca (MAXPATHLEN);
599 if (egetenv ("CMDPROXY"))
600 strcpy (cmdname, egetenv ("CMDPROXY"));
603 strcpy (cmdname, XSTRING_DATA (Vinvocation_directory));
604 strcat (cmdname, "cmdproxy.exe");
606 unixtodos_filename (cmdname);
609 /* we have to do some conjuring here to put argv and envp into the
610 form CreateProcess wants... argv needs to be a space separated/null
611 terminated list of parameters, and envp is a null
612 separated/double-null terminated list of parameters.
614 Additionally, zero-length args and args containing whitespace or
615 quote chars need to be wrapped in double quotes - for this to work,
616 embedded quotes need to be escaped as well. The aim is to ensure
617 the child process reconstructs the argv array we start with
618 exactly, so we treat quotes at the beginning and end of arguments
621 The Win32 GNU-based library from Cygnus doubles quotes to escape
622 them, while MSVC uses backslash for escaping. (Actually the MSVC
623 startup code does attempt to recognise doubled quotes and accept
624 them, but gets it wrong and ends up requiring three quotes to get a
625 single embedded quote!) So by default we decide whether to use
626 quote or backslash as the escape character based on whether the
627 binary is apparently a Cygnus compiled app.
629 Note that using backslash to escape embedded quotes requires
630 additional special handling if an embedded quote is already
631 preceeded by backslash, or if an arg requiring quoting ends with
632 backslash. In such cases, the run of escape characters needs to be
633 doubled. For consistency, we apply this special handling as long
634 as the escape character is not quote.
636 Since we have no idea how large argv and envp are likely to be we
637 figure out list lengths on the fly and allocate them. */
639 if (!NILP (Vwin32_quote_process_args))
642 /* Override escape char by binding win32-quote-process-args to
643 desired character, or use t for auto-selection. */
644 if (INTP (Vwin32_quote_process_args))
645 escape_char = XINT (Vwin32_quote_process_args);
647 escape_char = is_cygnus_app ? '"' : '\\';
657 int escape_char_run = 0;
665 /* allow for embedded quotes to be escaped */
668 /* handle the case where the embedded quote is already escaped */
669 if (escape_char_run > 0)
671 /* To preserve the arg exactly, we need to double the
672 preceding escape characters (plus adding one to
673 escape the quote character itself). */
674 arglen += escape_char_run;
677 else if (*p == ' ' || *p == '\t')
682 if (*p == escape_char && escape_char != '"')
690 /* handle the case where the arg ends with an escape char - we
691 must not let the enclosing quote be escaped. */
692 if (escape_char_run > 0)
693 arglen += escape_char_run;
695 arglen += strlen (*targ++) + 1;
697 cmdline = alloca (arglen);
711 if (*p == ' ' || *p == '\t' || *p == '"')
716 int escape_char_run = 0;
722 last = p + strlen (p) - 1;
725 /* This version does not escape quotes if they occur at the
726 beginning or end of the arg - this could lead to incorrect
727 behaviour when the arg itself represents a command line
728 containing quoted args. I believe this was originally done
729 as a hack to make some things work, before
730 `win32-quote-process-args' was added. */
733 if (*p == '"' && p > first && p < last)
734 *parg++ = escape_char; /* escape embedded quotes */
742 /* double preceding escape chars if any */
743 while (escape_char_run > 0)
745 *parg++ = escape_char;
748 /* escape all quote chars, even at beginning or end */
749 *parg++ = escape_char;
753 if (*p == escape_char && escape_char != '"')
758 /* double escape chars before enclosing quote */
759 while (escape_char_run > 0)
761 *parg++ = escape_char;
769 strcpy (parg, *targ);
770 parg += strlen (*targ);
780 numenv = 1; /* for end null */
783 arglen += strlen (*targ++) + 1;
786 /* extra env vars... */
787 sprintf (ppid_env_var_buffer, "__PARENT_PROCESS_ID=%d",
788 GetCurrentProcessId ());
789 arglen += strlen (ppid_env_var_buffer) + 1;
792 /* merge env passed in and extra env into one, and sort it. */
793 targ = (char **) alloca (numenv * sizeof (char *));
794 merge_and_sort_env (envp, extra_env, targ);
796 /* concatenate env entries. */
797 env = alloca (arglen);
801 strcpy (parg, *targ);
802 parg += strlen (*targ++);
815 /* Now create the process. */
816 if (!create_child (cmdname, cmdline, env, &pid, cp))
826 /* Substitute for certain kill () operations */
829 find_child_console (HWND hwnd, child_process * cp)
834 thread_id = GetWindowThreadProcessId (hwnd, &process_id);
835 if (process_id == cp->procinfo.dwProcessId)
837 char window_class[32];
839 GetClassName (hwnd, window_class, sizeof (window_class));
840 if (strcmp (window_class,
841 (os_subtype == OS_WIN95)
843 : "ConsoleWindowClass") == 0)
854 sys_kill (int pid, int sig)
858 int need_to_free = 0;
861 /* Only handle signals that will result in the process dying */
862 if (sig != SIGINT && sig != SIGKILL && sig != SIGQUIT && sig != SIGHUP)
868 cp = find_child_pid (pid);
871 proc_hand = OpenProcess (PROCESS_TERMINATE, 0, pid);
872 if (proc_hand == NULL)
881 proc_hand = cp->procinfo.hProcess;
882 pid = cp->procinfo.dwProcessId;
884 /* Try to locate console window for process. */
885 EnumWindows (find_child_console, (LPARAM) cp);
890 if (NILP (Vwin32_start_process_share_console) && cp && cp->hwnd)
892 BYTE control_scan_code = (BYTE) MapVirtualKey (VK_CONTROL, 0);
893 BYTE vk_break_code = VK_CANCEL;
894 BYTE break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
895 HWND foreground_window;
897 if (break_scan_code == 0)
899 /* Fake Ctrl-C if we can't manage Ctrl-Break. */
901 break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
904 foreground_window = GetForegroundWindow ();
905 if (foreground_window && SetForegroundWindow (cp->hwnd))
907 /* Generate keystrokes as if user had typed Ctrl-Break or Ctrl-C. */
908 keybd_event (VK_CONTROL, control_scan_code, 0, 0);
909 keybd_event (vk_break_code, break_scan_code, 0, 0);
910 keybd_event (vk_break_code, break_scan_code, KEYEVENTF_KEYUP, 0);
911 keybd_event (VK_CONTROL, control_scan_code, KEYEVENTF_KEYUP, 0);
913 /* Sleep for a bit to give time for Emacs frame to respond
914 to focus change events (if Emacs was active app). */
917 SetForegroundWindow (foreground_window);
920 /* Ctrl-Break is NT equivalent of SIGINT. */
921 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, pid))
923 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
924 "for pid %lu\n", GetLastError (), pid));
931 if (NILP (Vwin32_start_process_share_console) && cp && cp->hwnd)
934 if (os_subtype == OS_WIN95)
937 Another possibility is to try terminating the VDM out-right by
938 calling the Shell VxD (id 0x17) V86 interface, function #4
939 "SHELL_Destroy_VM", ie.
945 First need to determine the current VM handle, and then arrange for
946 the shellapi call to be made from the system vm (by using
947 Switch_VM_and_callback).
949 Could try to invoke DestroyVM through CallVxD.
953 /* On Win95, posting WM_QUIT causes the 16-bit subsystem
954 to hang when cmdproxy is used in conjunction with
955 command.com for an interactive shell. Posting
956 WM_CLOSE pops up a dialog that, when Yes is selected,
957 does the same thing. TerminateProcess is also less
958 than ideal in that subprocesses tend to stick around
959 until the machine is shutdown, but at least it
960 doesn't freeze the 16-bit subsystem. */
961 PostMessage (cp->hwnd, WM_QUIT, 0xff, 0);
963 if (!TerminateProcess (proc_hand, 0xff))
965 DebPrint (("sys_kill.TerminateProcess returned %d "
966 "for pid %lu\n", GetLastError (), pid));
973 PostMessage (cp->hwnd, WM_CLOSE, 0, 0);
975 /* Kill the process. On Win32 this doesn't kill child processes
976 so it doesn't work very well for shells which is why it's not
977 used in every case. */
978 else if (!TerminateProcess (proc_hand, 0xff))
980 DebPrint (("sys_kill.TerminateProcess returned %d "
981 "for pid %lu\n", GetLastError (), pid));
988 CloseHandle (proc_hand);
994 /* Sync with FSF Emacs 19.34.6 note: ifdef'ed out in XEmacs */
995 extern int report_file_error (CONST char *, Lisp_Object);
997 /* The following two routines are used to manipulate stdin, stdout, and
998 stderr of our child processes.
1000 Assuming that in, out, and err are *not* inheritable, we make them
1001 stdin, stdout, and stderr of the child as follows:
1003 - Save the parent's current standard handles.
1004 - Set the std handles to inheritable duplicates of the ones being passed in.
1005 (Note that _get_osfhandle() is an io.h procedure that retrieves the
1006 NT file handle for a crt file descriptor.)
1007 - Spawn the child, which inherits in, out, and err as stdin,
1008 stdout, and stderr. (see Spawnve)
1009 - Close the std handles passed to the child.
1010 - Reset the parent's standard handles to the saved handles.
1011 (see reset_standard_handles)
1012 We assume that the caller closes in, out, and err after calling us. */
1015 prepare_standard_handles (int in, int out, int err, HANDLE handles[3])
1018 HANDLE newstdin, newstdout, newstderr;
1020 parent = GetCurrentProcess ();
1022 handles[0] = GetStdHandle (STD_INPUT_HANDLE);
1023 handles[1] = GetStdHandle (STD_OUTPUT_HANDLE);
1024 handles[2] = GetStdHandle (STD_ERROR_HANDLE);
1026 /* make inheritable copies of the new handles */
1027 if (!DuplicateHandle (parent,
1028 (HANDLE) _get_osfhandle (in),
1033 DUPLICATE_SAME_ACCESS))
1034 report_file_error ("Duplicating input handle for child", Qnil);
1036 if (!DuplicateHandle (parent,
1037 (HANDLE) _get_osfhandle (out),
1042 DUPLICATE_SAME_ACCESS))
1043 report_file_error ("Duplicating output handle for child", Qnil);
1045 if (!DuplicateHandle (parent,
1046 (HANDLE) _get_osfhandle (err),
1051 DUPLICATE_SAME_ACCESS))
1052 report_file_error ("Duplicating error handle for child", Qnil);
1054 /* and store them as our std handles */
1055 if (!SetStdHandle (STD_INPUT_HANDLE, newstdin))
1056 report_file_error ("Changing stdin handle", Qnil);
1058 if (!SetStdHandle (STD_OUTPUT_HANDLE, newstdout))
1059 report_file_error ("Changing stdout handle", Qnil);
1061 if (!SetStdHandle (STD_ERROR_HANDLE, newstderr))
1062 report_file_error ("Changing stderr handle", Qnil);
1066 reset_standard_handles (int in, int out, int err, HANDLE handles[3])
1068 /* close the duplicated handles passed to the child */
1069 CloseHandle (GetStdHandle (STD_INPUT_HANDLE));
1070 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE));
1071 CloseHandle (GetStdHandle (STD_ERROR_HANDLE));
1073 /* now restore parent's saved std handles */
1074 SetStdHandle (STD_INPUT_HANDLE, handles[0]);
1075 SetStdHandle (STD_OUTPUT_HANDLE, handles[1]);
1076 SetStdHandle (STD_ERROR_HANDLE, handles[2]);
1080 set_process_dir (const char * dir)
1085 /* Some miscellaneous functions that are Windows specific, but not GUI
1086 specific (ie. are applicable in terminal or batch mode as well). */
1088 /* lifted from fileio.c */
1089 #define CORRECT_DIR_SEPS(s) \
1090 do { if ('/' == DIRECTORY_SEP) dostounix_filename (s); \
1091 else unixtodos_filename (s); \
1094 DEFUN ("win32-short-file-name", Fwin32_short_file_name, 1, 1, "", /*
1095 Return the short file name version (8.3) of the full path of FILENAME.
1096 If FILENAME does not exist, return nil.
1097 All path elements in FILENAME are converted to their short names.
1101 char shortname[MAX_PATH];
1103 CHECK_STRING (filename);
1105 /* first expand it. */
1106 filename = Fexpand_file_name (filename, Qnil);
1108 /* luckily, this returns the short version of each element in the path. */
1109 if (GetShortPathName (XSTRING_DATA (filename), shortname, MAX_PATH) == 0)
1112 CORRECT_DIR_SEPS (shortname);
1114 return build_string (shortname);
1118 DEFUN ("win32-long-file-name", Fwin32_long_file_name, 1, 1, "", /*
1119 Return the long file name version of the full path of FILENAME.
1120 If FILENAME does not exist, return nil.
1121 All path elements in FILENAME are converted to their long names.
1125 char longname[ MAX_PATH ];
1127 CHECK_STRING (filename);
1129 /* first expand it. */
1130 filename = Fexpand_file_name (filename, Qnil);
1132 if (!win32_get_long_filename (XSTRING_DATA (filename), longname, MAX_PATH))
1135 CORRECT_DIR_SEPS (longname);
1137 return build_string (longname);
1140 DEFUN ("win32-set-process-priority", Fwin32_set_process_priority, 2, 2, "", /*
1141 Set the priority of PROCESS to PRIORITY.
1142 If PROCESS is nil, the priority of Emacs is changed, otherwise the
1143 priority of the process whose pid is PROCESS is changed.
1144 PRIORITY should be one of the symbols high, normal, or low;
1145 any other symbol will be interpreted as normal.
1147 If successful, the return value is t, otherwise nil.
1149 (process, priority))
1151 HANDLE proc_handle = GetCurrentProcess ();
1152 DWORD priority_class = NORMAL_PRIORITY_CLASS;
1153 Lisp_Object result = Qnil;
1155 CHECK_SYMBOL (priority);
1157 if (!NILP (process))
1162 CHECK_INT (process);
1164 /* Allow pid to be an internally generated one, or one obtained
1165 externally. This is necessary because real pids on Win95 are
1168 pid = XINT (process);
1169 cp = find_child_pid (pid);
1171 pid = cp->procinfo.dwProcessId;
1173 proc_handle = OpenProcess (PROCESS_SET_INFORMATION, FALSE, pid);
1176 if (EQ (priority, Qhigh))
1177 priority_class = HIGH_PRIORITY_CLASS;
1178 else if (EQ (priority, Qlow))
1179 priority_class = IDLE_PRIORITY_CLASS;
1181 if (proc_handle != NULL)
1183 if (SetPriorityClass (proc_handle, priority_class))
1185 if (!NILP (process))
1186 CloseHandle (proc_handle);
1193 DEFUN ("win32-get-locale-info", Fwin32_get_locale_info, 1, 2, "", /*
1194 "Return information about the Windows locale LCID.
1195 By default, return a three letter locale code which encodes the default
1196 language as the first two characters, and the country or regionial variant
1197 as the third letter. For example, ENU refers to `English (United States)',
1198 while ENC means `English (Canadian)'.
1200 If the optional argument LONGFORM is non-nil, the long form of the locale
1201 name is returned, e.g. `English (United States)' instead.
1203 If LCID (a 16-bit number) is not a valid locale, the result is nil.
1209 char abbrev_name[32] = { 0 };
1210 char full_name[256] = { 0 };
1214 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
1217 if (NILP (longform))
1219 got_abbrev = GetLocaleInfo (XINT (lcid),
1220 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
1221 abbrev_name, sizeof (abbrev_name));
1223 return build_string (abbrev_name);
1227 got_full = GetLocaleInfo (XINT (lcid),
1228 LOCALE_SLANGUAGE | LOCALE_USE_CP_ACP,
1229 full_name, sizeof (full_name));
1231 return build_string (full_name);
1238 DEFUN ("win32-get-current-locale-id", Fwin32_get_current_locale_id, 0, 0, "", /*
1239 "Return Windows locale id for current locale setting.
1240 This is a numerical value; use `win32-get-locale-info' to convert to a
1241 human-readable form.
1245 return make_int (GetThreadLocale ());
1249 DEFUN ("win32-get-default-locale-id", Fwin32_get_default_locale_id, 0, 1, "", /*
1250 "Return Windows locale id for default locale setting.
1251 By default, the system default locale setting is returned; if the optional
1252 parameter USERP is non-nil, the user default locale setting is returned.
1253 This is a numerical value; use `win32-get-locale-info' to convert to a
1254 human-readable form.
1259 return make_int (GetSystemDefaultLCID ());
1260 return make_int (GetUserDefaultLCID ());
1263 DWORD int_from_hex (char * s)
1266 static char hex[] = "0123456789abcdefABCDEF";
1269 while (*s && (p = strchr(hex, *s)) != NULL)
1271 unsigned digit = p - hex;
1274 val = val * 16 + digit;
1280 /* We need to build a global list, since the EnumSystemLocale callback
1281 function isn't given a context pointer. */
1282 Lisp_Object Vwin32_valid_locale_ids;
1284 BOOL CALLBACK enum_locale_fn (LPTSTR localeNum)
1286 DWORD id = int_from_hex (localeNum);
1287 Vwin32_valid_locale_ids = Fcons (make_int (id), Vwin32_valid_locale_ids);
1291 DEFUN ("win32-get-valid-locale-ids", Fwin32_get_valid_locale_ids, 0, 0, "", /*
1292 Return list of all valid Windows locale ids.
1293 Each id is a numerical value; use `win32-get-locale-info' to convert to a
1294 human-readable form.
1298 Vwin32_valid_locale_ids = Qnil;
1300 EnumSystemLocales (enum_locale_fn, LCID_SUPPORTED);
1302 Vwin32_valid_locale_ids = Fnreverse (Vwin32_valid_locale_ids);
1303 return Vwin32_valid_locale_ids;
1307 DEFUN ("win32-set-current-locale", Fwin32_set_current_locale, 1, 1, "", /*
1308 Make Windows locale LCID be the current locale setting for Emacs.
1309 If successful, the new locale id is returned, otherwise nil.
1315 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
1318 if (!SetThreadLocale (XINT (lcid)))
1321 /* Sync with FSF Emacs 19.34.6 note: dwWinThreadId declared in
1322 w32term.h and defined in w32fns.c, both of which are not in current
1323 XEmacs. ### Check what we lose by ifdef'ing out these. --marcpa */
1325 /* Need to set input thread locale if present. */
1327 /* Reply is not needed. */
1328 PostThreadMessage (dwWinThreadId, WM_EMACS_SETLOCALE, XINT (lcid), 0);
1331 return make_int (GetThreadLocale ());
1338 Qhigh = intern ("high");
1339 Qlow = intern ("low");
1341 DEFSUBR (Fwin32_short_file_name);
1342 DEFSUBR (Fwin32_long_file_name);
1343 DEFSUBR (Fwin32_set_process_priority);
1344 DEFSUBR (Fwin32_get_locale_info);
1345 DEFSUBR (Fwin32_get_current_locale_id);
1346 DEFSUBR (Fwin32_get_default_locale_id);
1347 DEFSUBR (Fwin32_get_valid_locale_ids);
1348 DEFSUBR (Fwin32_set_current_locale);
1350 DEFVAR_LISP ("win32-quote-process-args", &Vwin32_quote_process_args /*
1351 Non-nil enables quoting of process arguments to ensure correct parsing.
1352 Because Windows does not directly pass argv arrays to child processes,
1353 programs have to reconstruct the argv array by parsing the command
1354 line string. For an argument to contain a space, it must be enclosed
1355 in double quotes or it will be parsed as multiple arguments.
1357 If the value is a character, that character will be used to escape any
1358 quote characters that appear, otherwise a suitable escape character
1359 will be chosen based on the type of the program.
1361 Vwin32_quote_process_args = Qt;
1363 DEFVAR_LISP ("win32-start-process-show-window",
1364 &Vwin32_start_process_show_window /*
1365 When nil, processes started via start-process hide their windows.
1366 When non-nil, they show their window in the method of their choice.
1368 Vwin32_start_process_show_window = Qnil;
1370 DEFVAR_LISP ("win32-start-process-share-console",
1371 &Vwin32_start_process_share_console /*
1372 When nil, processes started via start-process are given a new console.
1373 When non-nil, they share the Emacs console; this has the limitation of
1374 allowing only only DOS subprocess to run at a time (whether started directly
1375 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
1376 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
1377 otherwise respond to interrupts from Emacs.
1379 Vwin32_start_process_share_console = Qnil;
1381 DEFVAR_LISP ("win32-pipe-read-delay", &Vwin32_pipe_read_delay /*
1382 Forced delay before reading subprocess output.
1383 This is done to improve the buffering of subprocess output, by
1384 avoiding the inefficiency of frequently reading small amounts of data.
1386 If positive, the value is the number of milliseconds to sleep before
1387 reading the subprocess output. If negative, the magnitude is the number
1388 of time slices to wait (effectively boosting the priority of the child
1389 process temporarily). A value of zero disables waiting entirely.
1391 Vwin32_pipe_read_delay = make_int (50);
1394 DEFVAR_LISP ("win32-generate-fake-inodes", &Vwin32_generate_fake_inodes /*
1395 "Non-nil means attempt to fake realistic inode values.
1396 This works by hashing the truename of files, and should detect
1397 aliasing between long and short (8.3 DOS) names, but can have
1398 false positives because of hash collisions. Note that determing
1399 the truename of a file can be slow.
1401 Vwin32_generate_fake_inodes = Qnil;
1404 /* end of ntproc.c */