(Fmake_temp_name): forgot the \n\ in the docstring
[emacs.git] / src / w32proc.c
blobc64918c5bd6439e821a78dea0653891a6abcdd79
1 /* Process support for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1992, 1995 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; 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
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <errno.h>
28 #include <io.h>
29 #include <fcntl.h>
30 #include <signal.h>
32 /* must include CRT headers *before* config.h */
33 #include "config.h"
34 #undef signal
35 #undef wait
36 #undef spawnve
37 #undef select
38 #undef kill
40 #include <windows.h>
42 #include "lisp.h"
43 #include "w32.h"
44 #include "w32heap.h"
45 #include "systime.h"
46 #include "syswait.h"
47 #include "process.h"
48 #include "w32term.h"
50 /* Control whether spawnve quotes arguments as necessary to ensure
51 correct parsing by child process. Because not all uses of spawnve
52 are careful about constructing argv arrays, we make this behaviour
53 conditional (off by default). */
54 Lisp_Object Vw32_quote_process_args;
56 /* Control whether create_child causes the process' window to be
57 hidden. The default is nil. */
58 Lisp_Object Vw32_start_process_show_window;
60 /* Control whether create_child causes the process to inherit Emacs'
61 console window, or be given a new one of its own. The default is
62 nil, to allow multiple DOS programs to run on Win95. Having separate
63 consoles also allows Emacs to cleanly terminate process groups. */
64 Lisp_Object Vw32_start_process_share_console;
66 /* Control whether create_child cause the process to inherit Emacs'
67 error mode setting. The default is t, to minimize the possibility of
68 subprocesses blocking when accessing unmounted drives. */
69 Lisp_Object Vw32_start_process_inherit_error_mode;
71 /* Time to sleep before reading from a subprocess output pipe - this
72 avoids the inefficiency of frequently reading small amounts of data.
73 This is primarily necessary for handling DOS processes on Windows 95,
74 but is useful for W32 processes on both Windows 95 and NT as well. */
75 Lisp_Object Vw32_pipe_read_delay;
77 /* Control conversion of upper case file names to lower case.
78 nil means no, t means yes. */
79 Lisp_Object Vw32_downcase_file_names;
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 Vw32_generate_fake_inodes;
87 /* Control whether stat() attempts to determine file type and link count
88 exactly, at the expense of slower operation. Since true hard links
89 are supported on NTFS volumes, this is only relevant on NT. */
90 Lisp_Object Vw32_get_true_file_attributes;
92 Lisp_Object Qhigh, Qlow;
94 #ifndef SYS_SIGLIST_DECLARED
95 extern char *sys_siglist[];
96 #endif
98 #ifdef EMACSDEBUG
99 void _DebPrint (const char *fmt, ...)
101 char buf[1024];
102 va_list args;
104 va_start (args, fmt);
105 vsprintf (buf, fmt, args);
106 va_end (args);
107 OutputDebugString (buf);
109 #endif
111 typedef void (_CALLBACK_ *signal_handler)(int);
113 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
114 static signal_handler sig_handlers[NSIG];
116 /* Fake signal implementation to record the SIGCHLD handler. */
117 signal_handler
118 sys_signal (int sig, signal_handler handler)
120 signal_handler old;
122 if (sig != SIGCHLD)
124 errno = EINVAL;
125 return SIG_ERR;
127 old = sig_handlers[sig];
128 sig_handlers[sig] = handler;
129 return old;
132 /* Defined in <process.h> which conflicts with the local copy */
133 #define _P_NOWAIT 1
135 /* Child process management list. */
136 int child_proc_count = 0;
137 child_process child_procs[ MAX_CHILDREN ];
138 child_process *dead_child = NULL;
140 DWORD WINAPI reader_thread (void *arg);
142 /* Find an unused process slot. */
143 child_process *
144 new_child (void)
146 child_process *cp;
147 DWORD id;
149 for (cp = child_procs+(child_proc_count-1); cp >= child_procs; cp--)
150 if (!CHILD_ACTIVE (cp))
151 goto Initialise;
152 if (child_proc_count == MAX_CHILDREN)
153 return NULL;
154 cp = &child_procs[child_proc_count++];
156 Initialise:
157 memset (cp, 0, sizeof(*cp));
158 cp->fd = -1;
159 cp->pid = -1;
160 cp->procinfo.hProcess = NULL;
161 cp->status = STATUS_READ_ERROR;
163 /* use manual reset event so that select() will function properly */
164 cp->char_avail = CreateEvent (NULL, TRUE, FALSE, NULL);
165 if (cp->char_avail)
167 cp->char_consumed = CreateEvent (NULL, FALSE, FALSE, NULL);
168 if (cp->char_consumed)
170 cp->thrd = CreateThread (NULL, 1024, reader_thread, cp, 0, &id);
171 if (cp->thrd)
172 return cp;
175 delete_child (cp);
176 return NULL;
179 void
180 delete_child (child_process *cp)
182 int i;
184 /* Should not be deleting a child that is still needed. */
185 for (i = 0; i < MAXDESC; i++)
186 if (fd_info[i].cp == cp)
187 abort ();
189 if (!CHILD_ACTIVE (cp))
190 return;
192 /* reap thread if necessary */
193 if (cp->thrd)
195 DWORD rc;
197 if (GetExitCodeThread (cp->thrd, &rc) && rc == STILL_ACTIVE)
199 /* let the thread exit cleanly if possible */
200 cp->status = STATUS_READ_ERROR;
201 SetEvent (cp->char_consumed);
202 if (WaitForSingleObject (cp->thrd, 1000) != WAIT_OBJECT_0)
204 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
205 "with %lu for fd %ld\n", GetLastError (), cp->fd));
206 TerminateThread (cp->thrd, 0);
209 CloseHandle (cp->thrd);
210 cp->thrd = NULL;
212 if (cp->char_avail)
214 CloseHandle (cp->char_avail);
215 cp->char_avail = NULL;
217 if (cp->char_consumed)
219 CloseHandle (cp->char_consumed);
220 cp->char_consumed = NULL;
223 /* update child_proc_count (highest numbered slot in use plus one) */
224 if (cp == child_procs + child_proc_count - 1)
226 for (i = child_proc_count-1; i >= 0; i--)
227 if (CHILD_ACTIVE (&child_procs[i]))
229 child_proc_count = i + 1;
230 break;
233 if (i < 0)
234 child_proc_count = 0;
237 /* Find a child by pid. */
238 static child_process *
239 find_child_pid (DWORD pid)
241 child_process *cp;
243 for (cp = child_procs+(child_proc_count-1); cp >= child_procs; cp--)
244 if (CHILD_ACTIVE (cp) && pid == cp->pid)
245 return cp;
246 return NULL;
250 /* Thread proc for child process and socket reader threads. Each thread
251 is normally blocked until woken by select() to check for input by
252 reading one char. When the read completes, char_avail is signalled
253 to wake up the select emulator and the thread blocks itself again. */
254 DWORD WINAPI
255 reader_thread (void *arg)
257 child_process *cp;
259 /* Our identity */
260 cp = (child_process *)arg;
262 /* We have to wait for the go-ahead before we can start */
263 if (cp == NULL
264 || WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0)
265 return 1;
267 for (;;)
269 int rc;
271 rc = _sys_read_ahead (cp->fd);
273 /* The name char_avail is a misnomer - it really just means the
274 read-ahead has completed, whether successfully or not. */
275 if (!SetEvent (cp->char_avail))
277 DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
278 GetLastError (), cp->fd));
279 return 1;
282 if (rc == STATUS_READ_ERROR)
283 return 1;
285 /* If the read died, the child has died so let the thread die */
286 if (rc == STATUS_READ_FAILED)
287 break;
289 /* Wait until our input is acknowledged before reading again */
290 if (WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0)
292 DebPrint (("reader_thread.WaitForSingleObject failed with "
293 "%lu for fd %ld\n", GetLastError (), cp->fd));
294 break;
297 return 0;
300 /* To avoid Emacs changing directory, we just record here the directory
301 the new process should start in. This is set just before calling
302 sys_spawnve, and is not generally valid at any other time. */
303 static char * process_dir;
305 static BOOL
306 create_child (char *exe, char *cmdline, char *env,
307 int * pPid, child_process *cp)
309 STARTUPINFO start;
310 SECURITY_ATTRIBUTES sec_attrs;
311 SECURITY_DESCRIPTOR sec_desc;
312 DWORD flags;
313 char dir[ MAXPATHLEN ];
315 if (cp == NULL) abort ();
317 memset (&start, 0, sizeof (start));
318 start.cb = sizeof (start);
320 #ifdef HAVE_NTGUI
321 if (NILP (Vw32_start_process_show_window))
322 start.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
323 else
324 start.dwFlags = STARTF_USESTDHANDLES;
325 start.wShowWindow = SW_HIDE;
327 start.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
328 start.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
329 start.hStdError = GetStdHandle (STD_ERROR_HANDLE);
330 #endif /* HAVE_NTGUI */
332 /* Explicitly specify no security */
333 if (!InitializeSecurityDescriptor (&sec_desc, SECURITY_DESCRIPTOR_REVISION))
334 goto EH_Fail;
335 if (!SetSecurityDescriptorDacl (&sec_desc, TRUE, NULL, FALSE))
336 goto EH_Fail;
337 sec_attrs.nLength = sizeof (sec_attrs);
338 sec_attrs.lpSecurityDescriptor = &sec_desc;
339 sec_attrs.bInheritHandle = FALSE;
341 strcpy (dir, process_dir);
342 unixtodos_filename (dir);
344 flags = (!NILP (Vw32_start_process_share_console)
345 ? CREATE_NEW_PROCESS_GROUP
346 : CREATE_NEW_CONSOLE);
347 if (NILP (Vw32_start_process_inherit_error_mode))
348 flags |= CREATE_DEFAULT_ERROR_MODE;
349 if (!CreateProcess (exe, cmdline, &sec_attrs, NULL, TRUE,
350 flags, env, dir, &start, &cp->procinfo))
351 goto EH_Fail;
353 cp->pid = (int) cp->procinfo.dwProcessId;
355 /* Hack for Windows 95, which assigns large (ie negative) pids */
356 if (cp->pid < 0)
357 cp->pid = -cp->pid;
359 /* pid must fit in a Lisp_Int */
360 cp->pid = (cp->pid & VALMASK);
362 *pPid = cp->pid;
364 return TRUE;
366 EH_Fail:
367 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError()););
368 return FALSE;
371 /* create_child doesn't know what emacs' file handle will be for waiting
372 on output from the child, so we need to make this additional call
373 to register the handle with the process
374 This way the select emulator knows how to match file handles with
375 entries in child_procs. */
376 void
377 register_child (int pid, int fd)
379 child_process *cp;
381 cp = find_child_pid (pid);
382 if (cp == NULL)
384 DebPrint (("register_child unable to find pid %lu\n", pid));
385 return;
388 #ifdef FULL_DEBUG
389 DebPrint (("register_child registered fd %d with pid %lu\n", fd, pid));
390 #endif
392 cp->fd = fd;
394 /* thread is initially blocked until select is called; set status so
395 that select will release thread */
396 cp->status = STATUS_READ_ACKNOWLEDGED;
398 /* attach child_process to fd_info */
399 if (fd_info[fd].cp != NULL)
401 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd));
402 abort ();
405 fd_info[fd].cp = cp;
408 /* When a process dies its pipe will break so the reader thread will
409 signal failure to the select emulator.
410 The select emulator then calls this routine to clean up.
411 Since the thread signaled failure we can assume it is exiting. */
412 static void
413 reap_subprocess (child_process *cp)
415 if (cp->procinfo.hProcess)
417 /* Reap the process */
418 #ifdef FULL_DEBUG
419 /* Process should have already died before we are called. */
420 if (WaitForSingleObject (cp->procinfo.hProcess, 0) != WAIT_OBJECT_0)
421 DebPrint (("reap_subprocess: child fpr fd %d has not died yet!", cp->fd));
422 #endif
423 CloseHandle (cp->procinfo.hProcess);
424 cp->procinfo.hProcess = NULL;
425 CloseHandle (cp->procinfo.hThread);
426 cp->procinfo.hThread = NULL;
429 /* For asynchronous children, the child_proc resources will be freed
430 when the last pipe read descriptor is closed; for synchronous
431 children, we must explicitly free the resources now because
432 register_child has not been called. */
433 if (cp->fd == -1)
434 delete_child (cp);
437 /* Wait for any of our existing child processes to die
438 When it does, close its handle
439 Return the pid and fill in the status if non-NULL. */
441 int
442 sys_wait (int *status)
444 DWORD active, retval;
445 int nh;
446 int pid;
447 child_process *cp, *cps[MAX_CHILDREN];
448 HANDLE wait_hnd[MAX_CHILDREN];
450 nh = 0;
451 if (dead_child != NULL)
453 /* We want to wait for a specific child */
454 wait_hnd[nh] = dead_child->procinfo.hProcess;
455 cps[nh] = dead_child;
456 if (!wait_hnd[nh]) abort ();
457 nh++;
458 active = 0;
459 goto get_result;
461 else
463 for (cp = child_procs+(child_proc_count-1); cp >= child_procs; cp--)
464 /* some child_procs might be sockets; ignore them */
465 if (CHILD_ACTIVE (cp) && cp->procinfo.hProcess)
467 wait_hnd[nh] = cp->procinfo.hProcess;
468 cps[nh] = cp;
469 nh++;
473 if (nh == 0)
475 /* Nothing to wait on, so fail */
476 errno = ECHILD;
477 return -1;
482 /* Check for quit about once a second. */
483 QUIT;
484 active = WaitForMultipleObjects (nh, wait_hnd, FALSE, 1000);
485 } while (active == WAIT_TIMEOUT);
487 if (active == WAIT_FAILED)
489 errno = EBADF;
490 return -1;
492 else if (active >= WAIT_OBJECT_0
493 && active < WAIT_OBJECT_0+MAXIMUM_WAIT_OBJECTS)
495 active -= WAIT_OBJECT_0;
497 else if (active >= WAIT_ABANDONED_0
498 && active < WAIT_ABANDONED_0+MAXIMUM_WAIT_OBJECTS)
500 active -= WAIT_ABANDONED_0;
502 else
503 abort ();
505 get_result:
506 if (!GetExitCodeProcess (wait_hnd[active], &retval))
508 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
509 GetLastError ()));
510 retval = 1;
512 if (retval == STILL_ACTIVE)
514 /* Should never happen */
515 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
516 errno = EINVAL;
517 return -1;
520 /* Massage the exit code from the process to match the format expected
521 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
522 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
524 if (retval == STATUS_CONTROL_C_EXIT)
525 retval = SIGINT;
526 else
527 retval <<= 8;
529 cp = cps[active];
530 pid = cp->pid;
531 #ifdef FULL_DEBUG
532 DebPrint (("Wait signaled with process pid %d\n", cp->pid));
533 #endif
535 if (status)
537 *status = retval;
539 else if (synch_process_alive)
541 synch_process_alive = 0;
543 /* Report the status of the synchronous process. */
544 if (WIFEXITED (retval))
545 synch_process_retcode = WRETCODE (retval);
546 else if (WIFSIGNALED (retval))
548 int code = WTERMSIG (retval);
549 char *signame = 0;
551 if (code < NSIG)
553 /* Suppress warning if the table has const char *. */
554 signame = (char *) sys_siglist[code];
556 if (signame == 0)
557 signame = "unknown";
559 synch_process_death = signame;
562 reap_subprocess (cp);
565 reap_subprocess (cp);
567 return pid;
570 void
571 w32_executable_type (char * filename, int * is_dos_app, int * is_cygnus_app)
573 file_data executable;
574 char * p;
576 /* Default values in case we can't tell for sure. */
577 *is_dos_app = FALSE;
578 *is_cygnus_app = FALSE;
580 if (!open_input_file (&executable, filename))
581 return;
583 p = strrchr (filename, '.');
585 /* We can only identify DOS .com programs from the extension. */
586 if (p && stricmp (p, ".com") == 0)
587 *is_dos_app = TRUE;
588 else if (p && (stricmp (p, ".bat") == 0
589 || stricmp (p, ".cmd") == 0))
591 /* A DOS shell script - it appears that CreateProcess is happy to
592 accept this (somewhat surprisingly); presumably it looks at
593 COMSPEC to determine what executable to actually invoke.
594 Therefore, we have to do the same here as well. */
595 /* Actually, I think it uses the program association for that
596 extension, which is defined in the registry. */
597 p = egetenv ("COMSPEC");
598 if (p)
599 w32_executable_type (p, is_dos_app, is_cygnus_app);
601 else
603 /* Look for DOS .exe signature - if found, we must also check that
604 it isn't really a 16- or 32-bit Windows exe, since both formats
605 start with a DOS program stub. Note that 16-bit Windows
606 executables use the OS/2 1.x format. */
608 IMAGE_DOS_HEADER * dos_header;
609 IMAGE_NT_HEADERS * nt_header;
611 dos_header = (PIMAGE_DOS_HEADER) executable.file_base;
612 if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
613 goto unwind;
615 nt_header = (PIMAGE_NT_HEADERS) ((char *) dos_header + dos_header->e_lfanew);
617 if ((char *) nt_header > (char *) dos_header + executable.size)
619 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
620 *is_dos_app = TRUE;
622 else if (nt_header->Signature != IMAGE_NT_SIGNATURE
623 && LOWORD (nt_header->Signature) != IMAGE_OS2_SIGNATURE)
625 *is_dos_app = TRUE;
627 else if (nt_header->Signature == IMAGE_NT_SIGNATURE)
629 /* Look for cygwin.dll in DLL import list. */
630 IMAGE_DATA_DIRECTORY import_dir =
631 nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
632 IMAGE_IMPORT_DESCRIPTOR * imports;
633 IMAGE_SECTION_HEADER * section;
635 section = rva_to_section (import_dir.VirtualAddress, nt_header);
636 imports = RVA_TO_PTR (import_dir.VirtualAddress, section, executable);
638 for ( ; imports->Name; imports++)
640 char * dllname = RVA_TO_PTR (imports->Name, section, executable);
642 /* The exact name of the cygwin dll has changed with
643 various releases, but hopefully this will be reasonably
644 future proof. */
645 if (strncmp (dllname, "cygwin", 6) == 0)
647 *is_cygnus_app = TRUE;
648 break;
654 unwind:
655 close_file_data (&executable);
659 compare_env (const char **strp1, const char **strp2)
661 const char *str1 = *strp1, *str2 = *strp2;
663 while (*str1 && *str2 && *str1 != '=' && *str2 != '=')
665 if (tolower (*str1) > tolower (*str2))
666 return 1;
667 else if (tolower (*str1) < tolower (*str2))
668 return -1;
669 str1++, str2++;
672 if (*str1 == '=' && *str2 == '=')
673 return 0;
674 else if (*str1 == '=')
675 return -1;
676 else
677 return 1;
680 void
681 merge_and_sort_env (char **envp1, char **envp2, char **new_envp)
683 char **optr, **nptr;
684 int num;
686 nptr = new_envp;
687 optr = envp1;
688 while (*optr)
689 *nptr++ = *optr++;
690 num = optr - envp1;
692 optr = envp2;
693 while (*optr)
694 *nptr++ = *optr++;
695 num += optr - envp2;
697 qsort (new_envp, num, sizeof (char *), compare_env);
699 *nptr = NULL;
702 /* When a new child process is created we need to register it in our list,
703 so intercept spawn requests. */
704 int
705 sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
707 Lisp_Object program, full;
708 char *cmdline, *env, *parg, **targ;
709 int arglen, numenv;
710 int pid;
711 child_process *cp;
712 int is_dos_app, is_cygnus_app;
713 int do_quoting = 0;
714 char escape_char;
715 /* We pass our process ID to our children by setting up an environment
716 variable in their environment. */
717 char ppid_env_var_buffer[64];
718 char *extra_env[] = {ppid_env_var_buffer, NULL};
720 /* We don't care about the other modes */
721 if (mode != _P_NOWAIT)
723 errno = EINVAL;
724 return -1;
727 /* Handle executable names without an executable suffix. */
728 program = make_string (cmdname, strlen (cmdname));
729 if (NILP (Ffile_executable_p (program)))
731 struct gcpro gcpro1;
733 full = Qnil;
734 GCPRO1 (program);
735 openp (Vexec_path, program, EXEC_SUFFIXES, &full, 1);
736 UNGCPRO;
737 if (NILP (full))
739 errno = EINVAL;
740 return -1;
742 program = full;
745 /* make sure argv[0] and cmdname are both in DOS format */
746 cmdname = XSTRING (program)->data;
747 unixtodos_filename (cmdname);
748 argv[0] = cmdname;
750 /* Determine whether program is a 16-bit DOS executable, or a w32
751 executable that is implicitly linked to the Cygnus dll (implying it
752 was compiled with the Cygnus GNU toolchain and hence relies on
753 cygwin.dll to parse the command line - we use this to decide how to
754 escape quote chars in command line args that must be quoted). */
755 w32_executable_type (cmdname, &is_dos_app, &is_cygnus_app);
757 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
758 application to start it by specifying the helper app as cmdname,
759 while leaving the real app name as argv[0]. */
760 if (is_dos_app)
762 cmdname = alloca (MAXPATHLEN);
763 if (egetenv ("CMDPROXY"))
764 strcpy (cmdname, egetenv ("CMDPROXY"));
765 else
767 strcpy (cmdname, XSTRING (Vinvocation_directory)->data);
768 strcat (cmdname, "cmdproxy.exe");
770 unixtodos_filename (cmdname);
773 /* we have to do some conjuring here to put argv and envp into the
774 form CreateProcess wants... argv needs to be a space separated/null
775 terminated list of parameters, and envp is a null
776 separated/double-null terminated list of parameters.
778 Additionally, zero-length args and args containing whitespace or
779 quote chars need to be wrapped in double quotes - for this to work,
780 embedded quotes need to be escaped as well. The aim is to ensure
781 the child process reconstructs the argv array we start with
782 exactly, so we treat quotes at the beginning and end of arguments
783 as embedded quotes.
785 The w32 GNU-based library from Cygnus doubles quotes to escape
786 them, while MSVC uses backslash for escaping. (Actually the MSVC
787 startup code does attempt to recognise doubled quotes and accept
788 them, but gets it wrong and ends up requiring three quotes to get a
789 single embedded quote!) So by default we decide whether to use
790 quote or backslash as the escape character based on whether the
791 binary is apparently a Cygnus compiled app.
793 Note that using backslash to escape embedded quotes requires
794 additional special handling if an embedded quote is already
795 preceeded by backslash, or if an arg requiring quoting ends with
796 backslash. In such cases, the run of escape characters needs to be
797 doubled. For consistency, we apply this special handling as long
798 as the escape character is not quote.
800 Since we have no idea how large argv and envp are likely to be we
801 figure out list lengths on the fly and allocate them. */
803 if (!NILP (Vw32_quote_process_args))
805 do_quoting = 1;
806 /* Override escape char by binding w32-quote-process-args to
807 desired character, or use t for auto-selection. */
808 if (INTEGERP (Vw32_quote_process_args))
809 escape_char = XINT (Vw32_quote_process_args);
810 else
811 escape_char = is_cygnus_app ? '"' : '\\';
814 /* do argv... */
815 arglen = 0;
816 targ = argv;
817 while (*targ)
819 char * p = *targ;
820 int need_quotes = 0;
821 int escape_char_run = 0;
823 if (*p == 0)
824 need_quotes = 1;
825 for ( ; *p; p++)
827 if (*p == '"')
829 /* allow for embedded quotes to be escaped */
830 arglen++;
831 need_quotes = 1;
832 /* handle the case where the embedded quote is already escaped */
833 if (escape_char_run > 0)
835 /* To preserve the arg exactly, we need to double the
836 preceding escape characters (plus adding one to
837 escape the quote character itself). */
838 arglen += escape_char_run;
841 else if (*p == ' ' || *p == '\t')
843 need_quotes = 1;
846 if (*p == escape_char && escape_char != '"')
847 escape_char_run++;
848 else
849 escape_char_run = 0;
851 if (need_quotes)
853 arglen += 2;
854 /* handle the case where the arg ends with an escape char - we
855 must not let the enclosing quote be escaped. */
856 if (escape_char_run > 0)
857 arglen += escape_char_run;
859 arglen += strlen (*targ++) + 1;
861 cmdline = alloca (arglen);
862 targ = argv;
863 parg = cmdline;
864 while (*targ)
866 char * p = *targ;
867 int need_quotes = 0;
869 if (*p == 0)
870 need_quotes = 1;
872 if (do_quoting)
874 for ( ; *p; p++)
875 if (*p == ' ' || *p == '\t' || *p == '"')
876 need_quotes = 1;
878 if (need_quotes)
880 int escape_char_run = 0;
881 char * first;
882 char * last;
884 p = *targ;
885 first = p;
886 last = p + strlen (p) - 1;
887 *parg++ = '"';
888 #if 0
889 /* This version does not escape quotes if they occur at the
890 beginning or end of the arg - this could lead to incorrect
891 behaviour when the arg itself represents a command line
892 containing quoted args. I believe this was originally done
893 as a hack to make some things work, before
894 `w32-quote-process-args' was added. */
895 while (*p)
897 if (*p == '"' && p > first && p < last)
898 *parg++ = escape_char; /* escape embedded quotes */
899 *parg++ = *p++;
901 #else
902 for ( ; *p; p++)
904 if (*p == '"')
906 /* double preceding escape chars if any */
907 while (escape_char_run > 0)
909 *parg++ = escape_char;
910 escape_char_run--;
912 /* escape all quote chars, even at beginning or end */
913 *parg++ = escape_char;
915 *parg++ = *p;
917 if (*p == escape_char && escape_char != '"')
918 escape_char_run++;
919 else
920 escape_char_run = 0;
922 /* double escape chars before enclosing quote */
923 while (escape_char_run > 0)
925 *parg++ = escape_char;
926 escape_char_run--;
928 #endif
929 *parg++ = '"';
931 else
933 strcpy (parg, *targ);
934 parg += strlen (*targ);
936 *parg++ = ' ';
937 targ++;
939 *--parg = '\0';
941 /* and envp... */
942 arglen = 1;
943 targ = envp;
944 numenv = 1; /* for end null */
945 while (*targ)
947 arglen += strlen (*targ++) + 1;
948 numenv++;
950 /* extra env vars... */
951 sprintf (ppid_env_var_buffer, "EM_PARENT_PROCESS_ID=%d",
952 GetCurrentProcessId ());
953 arglen += strlen (ppid_env_var_buffer) + 1;
954 numenv++;
956 /* merge env passed in and extra env into one, and sort it. */
957 targ = (char **) alloca (numenv * sizeof (char *));
958 merge_and_sort_env (envp, extra_env, targ);
960 /* concatenate env entries. */
961 env = alloca (arglen);
962 parg = env;
963 while (*targ)
965 strcpy (parg, *targ);
966 parg += strlen (*targ++);
967 *parg++ = '\0';
969 *parg++ = '\0';
970 *parg = '\0';
972 cp = new_child ();
973 if (cp == NULL)
975 errno = EAGAIN;
976 return -1;
979 /* Now create the process. */
980 if (!create_child (cmdname, cmdline, env, &pid, cp))
982 delete_child (cp);
983 errno = ENOEXEC;
984 return -1;
987 return pid;
990 /* Emulate the select call
991 Wait for available input on any of the given rfds, or timeout if
992 a timeout is given and no input is detected
993 wfds and efds are not supported and must be NULL.
995 For simplicity, we detect the death of child processes here and
996 synchronously call the SIGCHLD handler. Since it is possible for
997 children to be created without a corresponding pipe handle from which
998 to read output, we wait separately on the process handles as well as
999 the char_avail events for each process pipe. We only call
1000 wait/reap_process when the process actually terminates.
1002 To reduce the number of places in which Emacs can be hung such that
1003 C-g is not able to interrupt it, we always wait on interrupt_handle
1004 (which is signalled by the input thread when C-g is detected). If we
1005 detect that we were woken up by C-g, we return -1 with errno set to
1006 EINTR as on Unix. */
1008 /* From ntterm.c */
1009 extern HANDLE keyboard_handle;
1011 /* From w32xfns.c */
1012 extern HANDLE interrupt_handle;
1014 /* From process.c */
1015 extern int proc_buffered_char[];
1017 int
1018 sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
1019 EMACS_TIME *timeout)
1021 SELECT_TYPE orfds;
1022 DWORD timeout_ms, start_time;
1023 int i, nh, nc, nr;
1024 DWORD active;
1025 child_process *cp, *cps[MAX_CHILDREN];
1026 HANDLE wait_hnd[MAXDESC + MAX_CHILDREN];
1027 int fdindex[MAXDESC]; /* mapping from wait handles back to descriptors */
1029 timeout_ms = timeout ? (timeout->tv_sec * 1000 + timeout->tv_usec / 1000) : INFINITE;
1031 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1032 if (rfds == NULL && wfds == NULL && efds == NULL && timeout != NULL)
1034 Sleep (timeout_ms);
1035 return 0;
1038 /* Otherwise, we only handle rfds, so fail otherwise. */
1039 if (rfds == NULL || wfds != NULL || efds != NULL)
1041 errno = EINVAL;
1042 return -1;
1045 orfds = *rfds;
1046 FD_ZERO (rfds);
1047 nr = 0;
1049 /* Always wait on interrupt_handle, to detect C-g (quit). */
1050 wait_hnd[0] = interrupt_handle;
1051 fdindex[0] = -1;
1053 /* Build a list of pipe handles to wait on. */
1054 nh = 1;
1055 for (i = 0; i < nfds; i++)
1056 if (FD_ISSET (i, &orfds))
1058 if (i == 0)
1060 if (keyboard_handle)
1062 /* Handle stdin specially */
1063 wait_hnd[nh] = keyboard_handle;
1064 fdindex[nh] = i;
1065 nh++;
1068 /* Check for any emacs-generated input in the queue since
1069 it won't be detected in the wait */
1070 if (detect_input_pending ())
1072 FD_SET (i, rfds);
1073 return 1;
1076 else
1078 /* Child process and socket input */
1079 cp = fd_info[i].cp;
1080 if (cp)
1082 int current_status = cp->status;
1084 if (current_status == STATUS_READ_ACKNOWLEDGED)
1086 /* Tell reader thread which file handle to use. */
1087 cp->fd = i;
1088 /* Wake up the reader thread for this process */
1089 cp->status = STATUS_READ_READY;
1090 if (!SetEvent (cp->char_consumed))
1091 DebPrint (("nt_select.SetEvent failed with "
1092 "%lu for fd %ld\n", GetLastError (), i));
1095 #ifdef CHECK_INTERLOCK
1096 /* slightly crude cross-checking of interlock between threads */
1098 current_status = cp->status;
1099 if (WaitForSingleObject (cp->char_avail, 0) == WAIT_OBJECT_0)
1101 /* char_avail has been signalled, so status (which may
1102 have changed) should indicate read has completed
1103 but has not been acknowledged. */
1104 current_status = cp->status;
1105 if (current_status != STATUS_READ_SUCCEEDED
1106 && current_status != STATUS_READ_FAILED)
1107 DebPrint (("char_avail set, but read not completed: status %d\n",
1108 current_status));
1110 else
1112 /* char_avail has not been signalled, so status should
1113 indicate that read is in progress; small possibility
1114 that read has completed but event wasn't yet signalled
1115 when we tested it (because a context switch occurred
1116 or if running on separate CPUs). */
1117 if (current_status != STATUS_READ_READY
1118 && current_status != STATUS_READ_IN_PROGRESS
1119 && current_status != STATUS_READ_SUCCEEDED
1120 && current_status != STATUS_READ_FAILED)
1121 DebPrint (("char_avail reset, but read status is bad: %d\n",
1122 current_status));
1124 #endif
1125 wait_hnd[nh] = cp->char_avail;
1126 fdindex[nh] = i;
1127 if (!wait_hnd[nh]) abort ();
1128 nh++;
1129 #ifdef FULL_DEBUG
1130 DebPrint (("select waiting on child %d fd %d\n",
1131 cp-child_procs, i));
1132 #endif
1134 else
1136 /* Unable to find something to wait on for this fd, skip */
1138 /* Note that this is not a fatal error, and can in fact
1139 happen in unusual circumstances. Specifically, if
1140 sys_spawnve fails, eg. because the program doesn't
1141 exist, and debug-on-error is t so Fsignal invokes a
1142 nested input loop, then the process output pipe is
1143 still included in input_wait_mask with no child_proc
1144 associated with it. (It is removed when the debugger
1145 exits the nested input loop and the error is thrown.) */
1147 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i));
1152 count_children:
1153 /* Add handles of child processes. */
1154 nc = 0;
1155 for (cp = child_procs+(child_proc_count-1); cp >= child_procs; cp--)
1156 /* Some child_procs might be sockets; ignore them. Also some
1157 children may have died already, but we haven't finished reading
1158 the process output; ignore them too. */
1159 if (CHILD_ACTIVE (cp) && cp->procinfo.hProcess
1160 && (cp->fd < 0
1161 || (fd_info[cp->fd].flags & FILE_SEND_SIGCHLD) == 0
1162 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0)
1165 wait_hnd[nh + nc] = cp->procinfo.hProcess;
1166 cps[nc] = cp;
1167 nc++;
1170 /* Nothing to look for, so we didn't find anything */
1171 if (nh + nc == 0)
1173 if (timeout)
1174 Sleep (timeout_ms);
1175 return 0;
1178 start_time = GetTickCount ();
1180 /* Wait for input or child death to be signalled. If user input is
1181 allowed, then also accept window messages. */
1182 if (FD_ISSET (0, &orfds))
1183 active = MsgWaitForMultipleObjects (nh + nc, wait_hnd, FALSE, timeout_ms,
1184 QS_ALLINPUT);
1185 else
1186 active = WaitForMultipleObjects (nh + nc, wait_hnd, FALSE, timeout_ms);
1188 if (active == WAIT_FAILED)
1190 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
1191 nh + nc, timeout_ms, GetLastError ()));
1192 /* don't return EBADF - this causes wait_reading_process_input to
1193 abort; WAIT_FAILED is returned when single-stepping under
1194 Windows 95 after switching thread focus in debugger, and
1195 possibly at other times. */
1196 errno = EINTR;
1197 return -1;
1199 else if (active == WAIT_TIMEOUT)
1201 return 0;
1203 else if (active >= WAIT_OBJECT_0
1204 && active < WAIT_OBJECT_0+MAXIMUM_WAIT_OBJECTS)
1206 active -= WAIT_OBJECT_0;
1208 else if (active >= WAIT_ABANDONED_0
1209 && active < WAIT_ABANDONED_0+MAXIMUM_WAIT_OBJECTS)
1211 active -= WAIT_ABANDONED_0;
1213 else
1214 abort ();
1216 /* Loop over all handles after active (now officially documented as
1217 being the first signalled handle in the array). We do this to
1218 ensure fairness, so that all channels with data available will be
1219 processed - otherwise higher numbered channels could be starved. */
1222 if (active == nh + nc)
1224 /* There are messages in the lisp thread's queue; we must
1225 drain the queue now to ensure they are processed promptly,
1226 because if we don't do so, we will not be woken again until
1227 further messages arrive.
1229 NB. If ever we allow window message procedures to callback
1230 into lisp, we will need to ensure messages are dispatched
1231 at a safe time for lisp code to be run (*), and we may also
1232 want to provide some hooks in the dispatch loop to cater
1233 for modeless dialogs created by lisp (ie. to register
1234 window handles to pass to IsDialogMessage).
1236 (*) Note that MsgWaitForMultipleObjects above is an
1237 internal dispatch point for messages that are sent to
1238 windows created by this thread. */
1239 drain_message_queue ();
1241 else if (active >= nh)
1243 cp = cps[active - nh];
1245 /* We cannot always signal SIGCHLD immediately; if we have not
1246 finished reading the process output, we must delay sending
1247 SIGCHLD until we do. */
1249 if (cp->fd >= 0 && (fd_info[cp->fd].flags & FILE_AT_EOF) == 0)
1250 fd_info[cp->fd].flags |= FILE_SEND_SIGCHLD;
1251 /* SIG_DFL for SIGCHLD is ignore */
1252 else if (sig_handlers[SIGCHLD] != SIG_DFL &&
1253 sig_handlers[SIGCHLD] != SIG_IGN)
1255 #ifdef FULL_DEBUG
1256 DebPrint (("select calling SIGCHLD handler for pid %d\n",
1257 cp->pid));
1258 #endif
1259 dead_child = cp;
1260 sig_handlers[SIGCHLD] (SIGCHLD);
1261 dead_child = NULL;
1264 else if (fdindex[active] == -1)
1266 /* Quit (C-g) was detected. */
1267 errno = EINTR;
1268 return -1;
1270 else if (fdindex[active] == 0)
1272 /* Keyboard input available */
1273 FD_SET (0, rfds);
1274 nr++;
1276 else
1278 /* must be a socket or pipe - read ahead should have
1279 completed, either succeeding or failing. */
1280 FD_SET (fdindex[active], rfds);
1281 nr++;
1284 /* Even though wait_reading_process_output only reads from at most
1285 one channel, we must process all channels here so that we reap
1286 all children that have died. */
1287 while (++active < nh + nc)
1288 if (WaitForSingleObject (wait_hnd[active], 0) == WAIT_OBJECT_0)
1289 break;
1290 } while (active < nh + nc);
1292 /* If no input has arrived and timeout hasn't expired, wait again. */
1293 if (nr == 0)
1295 DWORD elapsed = GetTickCount () - start_time;
1297 if (timeout_ms > elapsed) /* INFINITE is MAX_UINT */
1299 if (timeout_ms != INFINITE)
1300 timeout_ms -= elapsed;
1301 goto count_children;
1305 return nr;
1308 /* Substitute for certain kill () operations */
1310 static BOOL CALLBACK
1311 find_child_console (HWND hwnd, child_process * cp)
1313 DWORD thread_id;
1314 DWORD process_id;
1316 thread_id = GetWindowThreadProcessId (hwnd, &process_id);
1317 if (process_id == cp->procinfo.dwProcessId)
1319 char window_class[32];
1321 GetClassName (hwnd, window_class, sizeof (window_class));
1322 if (strcmp (window_class,
1323 (os_subtype == OS_WIN95)
1324 ? "tty"
1325 : "ConsoleWindowClass") == 0)
1327 cp->hwnd = hwnd;
1328 return FALSE;
1331 /* keep looking */
1332 return TRUE;
1335 int
1336 sys_kill (int pid, int sig)
1338 child_process *cp;
1339 HANDLE proc_hand;
1340 int need_to_free = 0;
1341 int rc = 0;
1343 /* Only handle signals that will result in the process dying */
1344 if (sig != SIGINT && sig != SIGKILL && sig != SIGQUIT && sig != SIGHUP)
1346 errno = EINVAL;
1347 return -1;
1350 cp = find_child_pid (pid);
1351 if (cp == NULL)
1353 proc_hand = OpenProcess (PROCESS_TERMINATE, 0, pid);
1354 if (proc_hand == NULL)
1356 errno = EPERM;
1357 return -1;
1359 need_to_free = 1;
1361 else
1363 proc_hand = cp->procinfo.hProcess;
1364 pid = cp->procinfo.dwProcessId;
1366 /* Try to locate console window for process. */
1367 EnumWindows (find_child_console, (LPARAM) cp);
1370 if (sig == SIGINT)
1372 if (NILP (Vw32_start_process_share_console) && cp && cp->hwnd)
1374 BYTE control_scan_code = (BYTE) MapVirtualKey (VK_CONTROL, 0);
1375 BYTE vk_break_code = VK_CANCEL;
1376 BYTE break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
1377 HWND foreground_window;
1379 if (break_scan_code == 0)
1381 /* Fake Ctrl-C if we can't manage Ctrl-Break. */
1382 vk_break_code = 'C';
1383 break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
1386 foreground_window = GetForegroundWindow ();
1387 if (foreground_window)
1389 /* NT 5.0, and apparently also Windows 98, will not allow
1390 a Window to be set to foreground directly without the
1391 user's involvement. The workaround is to attach
1392 ourselves to the thread that owns the foreground
1393 window, since that is the only thread that can set the
1394 foreground window. */
1395 DWORD foreground_thread, child_thread;
1396 foreground_thread =
1397 GetWindowThreadProcessId (foreground_window, NULL);
1398 if (foreground_thread == GetCurrentThreadId ()
1399 || !AttachThreadInput (GetCurrentThreadId (),
1400 foreground_thread, TRUE))
1401 foreground_thread = 0;
1403 child_thread = GetWindowThreadProcessId (cp->hwnd, NULL);
1404 if (child_thread == GetCurrentThreadId ()
1405 || !AttachThreadInput (GetCurrentThreadId (),
1406 child_thread, TRUE))
1407 child_thread = 0;
1409 /* Set the foreground window to the child. */
1410 if (SetForegroundWindow (cp->hwnd))
1412 /* Generate keystrokes as if user had typed Ctrl-Break or
1413 Ctrl-C. */
1414 keybd_event (VK_CONTROL, control_scan_code, 0, 0);
1415 keybd_event (vk_break_code, break_scan_code,
1416 (vk_break_code == 'C' ? 0 : KEYEVENTF_EXTENDEDKEY), 0);
1417 keybd_event (vk_break_code, break_scan_code,
1418 (vk_break_code == 'C' ? 0 : KEYEVENTF_EXTENDEDKEY)
1419 | KEYEVENTF_KEYUP, 0);
1420 keybd_event (VK_CONTROL, control_scan_code,
1421 KEYEVENTF_KEYUP, 0);
1423 /* Sleep for a bit to give time for Emacs frame to respond
1424 to focus change events (if Emacs was active app). */
1425 Sleep (100);
1427 SetForegroundWindow (foreground_window);
1429 /* Detach from the foreground and child threads now that
1430 the foreground switching is over. */
1431 if (foreground_thread)
1432 AttachThreadInput (GetCurrentThreadId (),
1433 foreground_thread, FALSE);
1434 if (child_thread)
1435 AttachThreadInput (GetCurrentThreadId (),
1436 child_thread, FALSE);
1439 /* Ctrl-Break is NT equivalent of SIGINT. */
1440 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, pid))
1442 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
1443 "for pid %lu\n", GetLastError (), pid));
1444 errno = EINVAL;
1445 rc = -1;
1448 else
1450 if (NILP (Vw32_start_process_share_console) && cp && cp->hwnd)
1452 #if 1
1453 if (os_subtype == OS_WIN95)
1456 Another possibility is to try terminating the VDM out-right by
1457 calling the Shell VxD (id 0x17) V86 interface, function #4
1458 "SHELL_Destroy_VM", ie.
1460 mov edx,4
1461 mov ebx,vm_handle
1462 call shellapi
1464 First need to determine the current VM handle, and then arrange for
1465 the shellapi call to be made from the system vm (by using
1466 Switch_VM_and_callback).
1468 Could try to invoke DestroyVM through CallVxD.
1471 #if 0
1472 /* On Win95, posting WM_QUIT causes the 16-bit subsystem
1473 to hang when cmdproxy is used in conjunction with
1474 command.com for an interactive shell. Posting
1475 WM_CLOSE pops up a dialog that, when Yes is selected,
1476 does the same thing. TerminateProcess is also less
1477 than ideal in that subprocesses tend to stick around
1478 until the machine is shutdown, but at least it
1479 doesn't freeze the 16-bit subsystem. */
1480 PostMessage (cp->hwnd, WM_QUIT, 0xff, 0);
1481 #endif
1482 if (!TerminateProcess (proc_hand, 0xff))
1484 DebPrint (("sys_kill.TerminateProcess returned %d "
1485 "for pid %lu\n", GetLastError (), pid));
1486 errno = EINVAL;
1487 rc = -1;
1490 else
1491 #endif
1492 PostMessage (cp->hwnd, WM_CLOSE, 0, 0);
1494 /* Kill the process. On W32 this doesn't kill child processes
1495 so it doesn't work very well for shells which is why it's not
1496 used in every case. */
1497 else if (!TerminateProcess (proc_hand, 0xff))
1499 DebPrint (("sys_kill.TerminateProcess returned %d "
1500 "for pid %lu\n", GetLastError (), pid));
1501 errno = EINVAL;
1502 rc = -1;
1506 if (need_to_free)
1507 CloseHandle (proc_hand);
1509 return rc;
1512 /* extern int report_file_error (char *, Lisp_Object); */
1514 /* The following two routines are used to manipulate stdin, stdout, and
1515 stderr of our child processes.
1517 Assuming that in, out, and err are *not* inheritable, we make them
1518 stdin, stdout, and stderr of the child as follows:
1520 - Save the parent's current standard handles.
1521 - Set the std handles to inheritable duplicates of the ones being passed in.
1522 (Note that _get_osfhandle() is an io.h procedure that retrieves the
1523 NT file handle for a crt file descriptor.)
1524 - Spawn the child, which inherits in, out, and err as stdin,
1525 stdout, and stderr. (see Spawnve)
1526 - Close the std handles passed to the child.
1527 - Reset the parent's standard handles to the saved handles.
1528 (see reset_standard_handles)
1529 We assume that the caller closes in, out, and err after calling us. */
1531 void
1532 prepare_standard_handles (int in, int out, int err, HANDLE handles[3])
1534 HANDLE parent;
1535 HANDLE newstdin, newstdout, newstderr;
1537 parent = GetCurrentProcess ();
1539 handles[0] = GetStdHandle (STD_INPUT_HANDLE);
1540 handles[1] = GetStdHandle (STD_OUTPUT_HANDLE);
1541 handles[2] = GetStdHandle (STD_ERROR_HANDLE);
1543 /* make inheritable copies of the new handles */
1544 if (!DuplicateHandle (parent,
1545 (HANDLE) _get_osfhandle (in),
1546 parent,
1547 &newstdin,
1549 TRUE,
1550 DUPLICATE_SAME_ACCESS))
1551 report_file_error ("Duplicating input handle for child", Qnil);
1553 if (!DuplicateHandle (parent,
1554 (HANDLE) _get_osfhandle (out),
1555 parent,
1556 &newstdout,
1558 TRUE,
1559 DUPLICATE_SAME_ACCESS))
1560 report_file_error ("Duplicating output handle for child", Qnil);
1562 if (!DuplicateHandle (parent,
1563 (HANDLE) _get_osfhandle (err),
1564 parent,
1565 &newstderr,
1567 TRUE,
1568 DUPLICATE_SAME_ACCESS))
1569 report_file_error ("Duplicating error handle for child", Qnil);
1571 /* and store them as our std handles */
1572 if (!SetStdHandle (STD_INPUT_HANDLE, newstdin))
1573 report_file_error ("Changing stdin handle", Qnil);
1575 if (!SetStdHandle (STD_OUTPUT_HANDLE, newstdout))
1576 report_file_error ("Changing stdout handle", Qnil);
1578 if (!SetStdHandle (STD_ERROR_HANDLE, newstderr))
1579 report_file_error ("Changing stderr handle", Qnil);
1582 void
1583 reset_standard_handles (int in, int out, int err, HANDLE handles[3])
1585 /* close the duplicated handles passed to the child */
1586 CloseHandle (GetStdHandle (STD_INPUT_HANDLE));
1587 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE));
1588 CloseHandle (GetStdHandle (STD_ERROR_HANDLE));
1590 /* now restore parent's saved std handles */
1591 SetStdHandle (STD_INPUT_HANDLE, handles[0]);
1592 SetStdHandle (STD_OUTPUT_HANDLE, handles[1]);
1593 SetStdHandle (STD_ERROR_HANDLE, handles[2]);
1596 void
1597 set_process_dir (char * dir)
1599 process_dir = dir;
1602 #ifdef HAVE_SOCKETS
1604 /* To avoid problems with winsock implementations that work over dial-up
1605 connections causing or requiring a connection to exist while Emacs is
1606 running, Emacs no longer automatically loads winsock on startup if it
1607 is present. Instead, it will be loaded when open-network-stream is
1608 first called.
1610 To allow full control over when winsock is loaded, we provide these
1611 two functions to dynamically load and unload winsock. This allows
1612 dial-up users to only be connected when they actually need to use
1613 socket services. */
1615 /* From nt.c */
1616 extern HANDLE winsock_lib;
1617 extern BOOL term_winsock (void);
1618 extern BOOL init_winsock (int load_now);
1620 extern Lisp_Object Vsystem_name;
1622 DEFUN ("w32-has-winsock", Fw32_has_winsock, Sw32_has_winsock, 0, 1, 0,
1623 "Test for presence of the Windows socket library `winsock'.\n\
1624 Returns non-nil if winsock support is present, nil otherwise.\n\
1626 If the optional argument LOAD-NOW is non-nil, the winsock library is\n\
1627 also loaded immediately if not already loaded. If winsock is loaded,\n\
1628 the winsock local hostname is returned (since this may be different from\n\
1629 the value of `system-name' and should supplant it), otherwise t is\n\
1630 returned to indicate winsock support is present.")
1631 (load_now)
1632 Lisp_Object load_now;
1634 int have_winsock;
1636 have_winsock = init_winsock (!NILP (load_now));
1637 if (have_winsock)
1639 if (winsock_lib != NULL)
1641 /* Return new value for system-name. The best way to do this
1642 is to call init_system_name, saving and restoring the
1643 original value to avoid side-effects. */
1644 Lisp_Object orig_hostname = Vsystem_name;
1645 Lisp_Object hostname;
1647 init_system_name ();
1648 hostname = Vsystem_name;
1649 Vsystem_name = orig_hostname;
1650 return hostname;
1652 return Qt;
1654 return Qnil;
1657 DEFUN ("w32-unload-winsock", Fw32_unload_winsock, Sw32_unload_winsock,
1658 0, 0, 0,
1659 "Unload the Windows socket library `winsock' if loaded.\n\
1660 This is provided to allow dial-up socket connections to be disconnected\n\
1661 when no longer needed. Returns nil without unloading winsock if any\n\
1662 socket connections still exist.")
1665 return term_winsock () ? Qt : Qnil;
1668 #endif /* HAVE_SOCKETS */
1671 /* Some miscellaneous functions that are Windows specific, but not GUI
1672 specific (ie. are applicable in terminal or batch mode as well). */
1674 /* lifted from fileio.c */
1675 #define CORRECT_DIR_SEPS(s) \
1676 do { if ('/' == DIRECTORY_SEP) dostounix_filename (s); \
1677 else unixtodos_filename (s); \
1678 } while (0)
1680 DEFUN ("w32-short-file-name", Fw32_short_file_name, Sw32_short_file_name, 1, 1, 0,
1681 "Return the short file name version (8.3) of the full path of FILENAME.\n\
1682 If FILENAME does not exist, return nil.\n\
1683 All path elements in FILENAME are converted to their short names.")
1684 (filename)
1685 Lisp_Object filename;
1687 char shortname[MAX_PATH];
1689 CHECK_STRING (filename, 0);
1691 /* first expand it. */
1692 filename = Fexpand_file_name (filename, Qnil);
1694 /* luckily, this returns the short version of each element in the path. */
1695 if (GetShortPathName (XSTRING (filename)->data, shortname, MAX_PATH) == 0)
1696 return Qnil;
1698 CORRECT_DIR_SEPS (shortname);
1700 return build_string (shortname);
1704 DEFUN ("w32-long-file-name", Fw32_long_file_name, Sw32_long_file_name,
1705 1, 1, 0,
1706 "Return the long file name version of the full path of FILENAME.\n\
1707 If FILENAME does not exist, return nil.\n\
1708 All path elements in FILENAME are converted to their long names.")
1709 (filename)
1710 Lisp_Object filename;
1712 char longname[ MAX_PATH ];
1714 CHECK_STRING (filename, 0);
1716 /* first expand it. */
1717 filename = Fexpand_file_name (filename, Qnil);
1719 if (!w32_get_long_filename (XSTRING (filename)->data, longname, MAX_PATH))
1720 return Qnil;
1722 CORRECT_DIR_SEPS (longname);
1724 return build_string (longname);
1727 DEFUN ("w32-set-process-priority", Fw32_set_process_priority, Sw32_set_process_priority,
1728 2, 2, 0,
1729 "Set the priority of PROCESS to PRIORITY.\n\
1730 If PROCESS is nil, the priority of Emacs is changed, otherwise the\n\
1731 priority of the process whose pid is PROCESS is changed.\n\
1732 PRIORITY should be one of the symbols high, normal, or low;\n\
1733 any other symbol will be interpreted as normal.\n\
1735 If successful, the return value is t, otherwise nil.")
1736 (process, priority)
1737 Lisp_Object process, priority;
1739 HANDLE proc_handle = GetCurrentProcess ();
1740 DWORD priority_class = NORMAL_PRIORITY_CLASS;
1741 Lisp_Object result = Qnil;
1743 CHECK_SYMBOL (priority, 0);
1745 if (!NILP (process))
1747 DWORD pid;
1748 child_process *cp;
1750 CHECK_NUMBER (process, 0);
1752 /* Allow pid to be an internally generated one, or one obtained
1753 externally. This is necessary because real pids on Win95 are
1754 negative. */
1756 pid = XINT (process);
1757 cp = find_child_pid (pid);
1758 if (cp != NULL)
1759 pid = cp->procinfo.dwProcessId;
1761 proc_handle = OpenProcess (PROCESS_SET_INFORMATION, FALSE, pid);
1764 if (EQ (priority, Qhigh))
1765 priority_class = HIGH_PRIORITY_CLASS;
1766 else if (EQ (priority, Qlow))
1767 priority_class = IDLE_PRIORITY_CLASS;
1769 if (proc_handle != NULL)
1771 if (SetPriorityClass (proc_handle, priority_class))
1772 result = Qt;
1773 if (!NILP (process))
1774 CloseHandle (proc_handle);
1777 return result;
1781 DEFUN ("w32-get-locale-info", Fw32_get_locale_info, Sw32_get_locale_info, 1, 2, 0,
1782 "Return information about the Windows locale LCID.\n\
1783 By default, return a three letter locale code which encodes the default\n\
1784 language as the first two characters, and the country or regionial variant\n\
1785 as the third letter. For example, ENU refers to `English (United States)',\n\
1786 while ENC means `English (Canadian)'.\n\
1788 If the optional argument LONGFORM is t, the long form of the locale\n\
1789 name is returned, e.g. `English (United States)' instead; if LONGFORM\n\
1790 is a number, it is interpreted as an LCTYPE constant and the corresponding\n\
1791 locale information is returned.\n\
1793 If LCID (a 16-bit number) is not a valid locale, the result is nil.")
1794 (lcid, longform)
1795 Lisp_Object lcid, longform;
1797 int got_abbrev;
1798 int got_full;
1799 char abbrev_name[32] = { 0 };
1800 char full_name[256] = { 0 };
1802 CHECK_NUMBER (lcid, 0);
1804 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
1805 return Qnil;
1807 if (NILP (longform))
1809 got_abbrev = GetLocaleInfo (XINT (lcid),
1810 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
1811 abbrev_name, sizeof (abbrev_name));
1812 if (got_abbrev)
1813 return build_string (abbrev_name);
1815 else if (EQ (longform, Qt))
1817 got_full = GetLocaleInfo (XINT (lcid),
1818 LOCALE_SLANGUAGE | LOCALE_USE_CP_ACP,
1819 full_name, sizeof (full_name));
1820 if (got_full)
1821 return build_string (full_name);
1823 else if (NUMBERP (longform))
1825 got_full = GetLocaleInfo (XINT (lcid),
1826 XINT (longform),
1827 full_name, sizeof (full_name));
1828 if (got_full)
1829 return make_unibyte_string (full_name, got_full);
1832 return Qnil;
1836 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id, Sw32_get_current_locale_id, 0, 0, 0,
1837 "Return Windows locale id for current locale setting.\n\
1838 This is a numerical value; use `w32-get-locale-info' to convert to a\n\
1839 human-readable form.")
1842 return make_number (GetThreadLocale ());
1845 DWORD int_from_hex (char * s)
1847 DWORD val = 0;
1848 static char hex[] = "0123456789abcdefABCDEF";
1849 char * p;
1851 while (*s && (p = strchr(hex, *s)) != NULL)
1853 unsigned digit = p - hex;
1854 if (digit > 15)
1855 digit -= 6;
1856 val = val * 16 + digit;
1857 s++;
1859 return val;
1862 /* We need to build a global list, since the EnumSystemLocale callback
1863 function isn't given a context pointer. */
1864 Lisp_Object Vw32_valid_locale_ids;
1866 BOOL CALLBACK enum_locale_fn (LPTSTR localeNum)
1868 DWORD id = int_from_hex (localeNum);
1869 Vw32_valid_locale_ids = Fcons (make_number (id), Vw32_valid_locale_ids);
1870 return TRUE;
1873 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids, Sw32_get_valid_locale_ids, 0, 0, 0,
1874 "Return list of all valid Windows locale ids.\n\
1875 Each id is a numerical value; use `w32-get-locale-info' to convert to a\n\
1876 human-readable form.")
1879 Vw32_valid_locale_ids = Qnil;
1881 EnumSystemLocales (enum_locale_fn, LCID_SUPPORTED);
1883 Vw32_valid_locale_ids = Fnreverse (Vw32_valid_locale_ids);
1884 return Vw32_valid_locale_ids;
1888 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id, Sw32_get_default_locale_id, 0, 1, 0,
1889 "Return Windows locale id for default locale setting.\n\
1890 By default, the system default locale setting is returned; if the optional\n\
1891 parameter USERP is non-nil, the user default locale setting is returned.\n\
1892 This is a numerical value; use `w32-get-locale-info' to convert to a\n\
1893 human-readable form.")
1894 (userp)
1895 Lisp_Object userp;
1897 if (NILP (userp))
1898 return make_number (GetSystemDefaultLCID ());
1899 return make_number (GetUserDefaultLCID ());
1903 DEFUN ("w32-set-current-locale", Fw32_set_current_locale, Sw32_set_current_locale, 1, 1, 0,
1904 "Make Windows locale LCID be the current locale setting for Emacs.\n\
1905 If successful, the new locale id is returned, otherwise nil.")
1906 (lcid)
1907 Lisp_Object lcid;
1909 CHECK_NUMBER (lcid, 0);
1911 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
1912 return Qnil;
1914 if (!SetThreadLocale (XINT (lcid)))
1915 return Qnil;
1917 /* Need to set input thread locale if present. */
1918 if (dwWindowsThreadId)
1919 /* Reply is not needed. */
1920 PostThreadMessage (dwWindowsThreadId, WM_EMACS_SETLOCALE, XINT (lcid), 0);
1922 return make_number (GetThreadLocale ());
1926 /* We need to build a global list, since the EnumCodePages callback
1927 function isn't given a context pointer. */
1928 Lisp_Object Vw32_valid_codepages;
1930 BOOL CALLBACK enum_codepage_fn (LPTSTR codepageNum)
1932 DWORD id = atoi (codepageNum);
1933 Vw32_valid_codepages = Fcons (make_number (id), Vw32_valid_codepages);
1934 return TRUE;
1937 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages, Sw32_get_valid_codepages, 0, 0, 0,
1938 "Return list of all valid Windows codepages.")
1941 Vw32_valid_codepages = Qnil;
1943 EnumSystemCodePages (enum_codepage_fn, CP_SUPPORTED);
1945 Vw32_valid_codepages = Fnreverse (Vw32_valid_codepages);
1946 return Vw32_valid_codepages;
1950 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage, Sw32_get_console_codepage, 0, 0, 0,
1951 "Return current Windows codepage for console input.")
1954 return make_number (GetConsoleCP ());
1958 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage, Sw32_set_console_codepage, 1, 1, 0,
1959 "Make Windows codepage CP be the current codepage setting for Emacs.\n\
1960 The codepage setting affects keyboard input and display in tty mode.\n\
1961 If successful, the new CP is returned, otherwise nil.")
1962 (cp)
1963 Lisp_Object cp;
1965 CHECK_NUMBER (cp, 0);
1967 if (!IsValidCodePage (XINT (cp)))
1968 return Qnil;
1970 if (!SetConsoleCP (XINT (cp)))
1971 return Qnil;
1973 return make_number (GetConsoleCP ());
1977 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage, Sw32_get_console_output_codepage, 0, 0, 0,
1978 "Return current Windows codepage for console output.")
1981 return make_number (GetConsoleOutputCP ());
1985 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage, Sw32_set_console_output_codepage, 1, 1, 0,
1986 "Make Windows codepage CP be the current codepage setting for Emacs.\n\
1987 The codepage setting affects keyboard input and display in tty mode.\n\
1988 If successful, the new CP is returned, otherwise nil.")
1989 (cp)
1990 Lisp_Object cp;
1992 CHECK_NUMBER (cp, 0);
1994 if (!IsValidCodePage (XINT (cp)))
1995 return Qnil;
1997 if (!SetConsoleOutputCP (XINT (cp)))
1998 return Qnil;
2000 return make_number (GetConsoleOutputCP ());
2004 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset, Sw32_get_codepage_charset, 1, 1, 0,
2005 "Return charset of codepage CP.\n\
2006 Returns nil if the codepage is not valid.")
2007 (cp)
2008 Lisp_Object cp;
2010 CHARSETINFO info;
2012 CHECK_NUMBER (cp, 0);
2014 if (!IsValidCodePage (XINT (cp)))
2015 return Qnil;
2017 if (TranslateCharsetInfo ((DWORD *) XINT (cp), &info, TCI_SRCCODEPAGE))
2018 return make_number (info.ciCharset);
2020 return Qnil;
2024 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts, Sw32_get_valid_keyboard_layouts, 0, 0, 0,
2025 "Return list of Windows keyboard languages and layouts.\n\
2026 The return value is a list of pairs of language id and layout id.")
2029 int num_layouts = GetKeyboardLayoutList (0, NULL);
2030 HKL * layouts = (HKL *) alloca (num_layouts * sizeof (HKL));
2031 Lisp_Object obj = Qnil;
2033 if (GetKeyboardLayoutList (num_layouts, layouts) == num_layouts)
2035 while (--num_layouts >= 0)
2037 DWORD kl = (DWORD) layouts[num_layouts];
2039 obj = Fcons (Fcons (make_number (kl & 0xffff),
2040 make_number ((kl >> 16) & 0xffff)),
2041 obj);
2045 return obj;
2049 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout, Sw32_get_keyboard_layout, 0, 0, 0,
2050 "Return current Windows keyboard language and layout.\n\
2051 The return value is the cons of the language id and the layout id.")
2054 DWORD kl = (DWORD) GetKeyboardLayout (dwWindowsThreadId);
2056 return Fcons (make_number (kl & 0xffff),
2057 make_number ((kl >> 16) & 0xffff));
2061 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout, Sw32_set_keyboard_layout, 1, 1, 0,
2062 "Make LAYOUT be the current keyboard layout for Emacs.\n\
2063 The keyboard layout setting affects interpretation of keyboard input.\n\
2064 If successful, the new layout id is returned, otherwise nil.")
2065 (layout)
2066 Lisp_Object layout;
2068 DWORD kl;
2070 CHECK_CONS (layout, 0);
2071 CHECK_NUMBER (XCAR (layout), 0);
2072 CHECK_NUMBER (XCDR (layout), 0);
2074 kl = (XINT (XCAR (layout)) & 0xffff)
2075 | (XINT (XCDR (layout)) << 16);
2077 /* Synchronize layout with input thread. */
2078 if (dwWindowsThreadId)
2080 if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_SETKEYBOARDLAYOUT,
2081 (WPARAM) kl, 0))
2083 MSG msg;
2084 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
2086 if (msg.wParam == 0)
2087 return Qnil;
2090 else if (!ActivateKeyboardLayout ((HKL) kl, 0))
2091 return Qnil;
2093 return Fw32_get_keyboard_layout ();
2097 syms_of_ntproc ()
2099 Qhigh = intern ("high");
2100 Qlow = intern ("low");
2102 #ifdef HAVE_SOCKETS
2103 defsubr (&Sw32_has_winsock);
2104 defsubr (&Sw32_unload_winsock);
2105 #endif
2106 defsubr (&Sw32_short_file_name);
2107 defsubr (&Sw32_long_file_name);
2108 defsubr (&Sw32_set_process_priority);
2109 defsubr (&Sw32_get_locale_info);
2110 defsubr (&Sw32_get_current_locale_id);
2111 defsubr (&Sw32_get_default_locale_id);
2112 defsubr (&Sw32_get_valid_locale_ids);
2113 defsubr (&Sw32_set_current_locale);
2115 defsubr (&Sw32_get_console_codepage);
2116 defsubr (&Sw32_set_console_codepage);
2117 defsubr (&Sw32_get_console_output_codepage);
2118 defsubr (&Sw32_set_console_output_codepage);
2119 defsubr (&Sw32_get_valid_codepages);
2120 defsubr (&Sw32_get_codepage_charset);
2122 defsubr (&Sw32_get_valid_keyboard_layouts);
2123 defsubr (&Sw32_get_keyboard_layout);
2124 defsubr (&Sw32_set_keyboard_layout);
2126 DEFVAR_LISP ("w32-quote-process-args", &Vw32_quote_process_args,
2127 "Non-nil enables quoting of process arguments to ensure correct parsing.\n\
2128 Because Windows does not directly pass argv arrays to child processes,\n\
2129 programs have to reconstruct the argv array by parsing the command\n\
2130 line string. For an argument to contain a space, it must be enclosed\n\
2131 in double quotes or it will be parsed as multiple arguments.\n\
2133 If the value is a character, that character will be used to escape any\n\
2134 quote characters that appear, otherwise a suitable escape character\n\
2135 will be chosen based on the type of the program.");
2136 Vw32_quote_process_args = Qt;
2138 DEFVAR_LISP ("w32-start-process-show-window",
2139 &Vw32_start_process_show_window,
2140 "When nil, new child processes hide their windows.\n\
2141 When non-nil, they show their window in the method of their choice.");
2142 Vw32_start_process_show_window = Qnil;
2144 DEFVAR_LISP ("w32-start-process-share-console",
2145 &Vw32_start_process_share_console,
2146 "When nil, new child processes are given a new console.\n\
2147 When non-nil, they share the Emacs console; this has the limitation of\n\
2148 allowing only only DOS subprocess to run at a time (whether started directly\n\
2149 or indirectly by Emacs), and preventing Emacs from cleanly terminating the\n\
2150 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't\n\
2151 otherwise respond to interrupts from Emacs.");
2152 Vw32_start_process_share_console = Qnil;
2154 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
2155 &Vw32_start_process_inherit_error_mode,
2156 "When nil, new child processes revert to the default error mode.\n\
2157 When non-nil, they inherit their error mode setting from Emacs, which stops\n\
2158 them blocking when trying to access unmounted drives etc.");
2159 Vw32_start_process_inherit_error_mode = Qt;
2161 DEFVAR_INT ("w32-pipe-read-delay", &Vw32_pipe_read_delay,
2162 "Forced delay before reading subprocess output.\n\
2163 This is done to improve the buffering of subprocess output, by\n\
2164 avoiding the inefficiency of frequently reading small amounts of data.\n\
2166 If positive, the value is the number of milliseconds to sleep before\n\
2167 reading the subprocess output. If negative, the magnitude is the number\n\
2168 of time slices to wait (effectively boosting the priority of the child\n\
2169 process temporarily). A value of zero disables waiting entirely.");
2170 Vw32_pipe_read_delay = 50;
2172 DEFVAR_LISP ("w32-downcase-file-names", &Vw32_downcase_file_names,
2173 "Non-nil means convert all-upper case file names to lower case.\n\
2174 This applies when performing completions and file name expansion.");
2175 Vw32_downcase_file_names = Qnil;
2177 #if 0
2178 DEFVAR_LISP ("w32-generate-fake-inodes", &Vw32_generate_fake_inodes,
2179 "Non-nil means attempt to fake realistic inode values.\n\
2180 This works by hashing the truename of files, and should detect \n\
2181 aliasing between long and short (8.3 DOS) names, but can have\n\
2182 false positives because of hash collisions. Note that determing\n\
2183 the truename of a file can be slow.");
2184 Vw32_generate_fake_inodes = Qnil;
2185 #endif
2187 DEFVAR_LISP ("w32-get-true-file-attributes", &Vw32_get_true_file_attributes,
2188 "Non-nil means determine accurate link count in file-attributes.\n\
2189 This option slows down file-attributes noticeably, so is disabled by\n\
2190 default. Note that it is only useful for files on NTFS volumes,\n\
2191 where hard links are supported.");
2192 Vw32_get_true_file_attributes = Qnil;
2194 /* end of ntproc.c */