1 /* Process support for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1992, 1995, 1999-2013 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 3 of the License, or
9 (at your option) 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. If not, see <http://www.gnu.org/licenses/>. */
20 Drew Bliss Oct 14, 1993
21 Adapted from alarm.c by Tim Fleehart
24 #include <mingw_time.h>
35 /* must include CRT headers *before* config.h */
46 /* This definition is missing from mingw32 headers. */
47 extern BOOL WINAPI
IsValidLocale (LCID
, DWORD
);
50 #ifdef HAVE_LANGINFO_CODESET
57 #include "w32common.h"
62 #include "syssignal.h"
64 #include "dispextern.h" /* for xstrcasecmp */
67 #define RVA_TO_PTR(var,section,filedata) \
68 ((void *)((section)->PointerToRawData \
69 + ((DWORD_PTR)(var) - (section)->VirtualAddress) \
70 + (filedata).file_base))
72 Lisp_Object Qhigh
, Qlow
;
74 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
75 static signal_handler sig_handlers
[NSIG
];
77 static sigset_t sig_mask
;
79 static CRITICAL_SECTION crit_sig
;
81 /* Improve on the CRT 'signal' implementation so that we could record
82 the SIGCHLD handler and fake interval timers. */
84 sys_signal (int sig
, signal_handler handler
)
88 /* SIGCHLD is needed for supporting subprocesses, see sys_kill
89 below. SIGALRM and SIGPROF are used by setitimer. All the
90 others are the only ones supported by the MS runtime. */
91 if (!(sig
== SIGCHLD
|| sig
== SIGSEGV
|| sig
== SIGILL
92 || sig
== SIGFPE
|| sig
== SIGABRT
|| sig
== SIGTERM
93 || sig
== SIGALRM
|| sig
== SIGPROF
))
98 old
= sig_handlers
[sig
];
99 /* SIGABRT is treated specially because w32.c installs term_ntproc
100 as its handler, so we don't want to override that afterwards.
101 Aborting Emacs works specially anyway: either by calling
102 emacs_abort directly or through terminate_due_to_signal, which
103 calls emacs_abort through emacs_raise. */
104 if (!(sig
== SIGABRT
&& old
== term_ntproc
))
106 sig_handlers
[sig
] = handler
;
107 if (!(sig
== SIGCHLD
|| sig
== SIGALRM
|| sig
== SIGPROF
))
108 signal (sig
, handler
);
113 /* Emulate sigaction. */
115 sigaction (int sig
, const struct sigaction
*act
, struct sigaction
*oact
)
117 signal_handler old
= SIG_DFL
;
121 old
= sys_signal (sig
, act
->sa_handler
);
123 old
= sig_handlers
[sig
];
132 oact
->sa_handler
= old
;
134 oact
->sa_mask
= empty_mask
;
139 /* Emulate signal sets and blocking of signals used by timers. */
142 sigemptyset (sigset_t
*set
)
149 sigaddset (sigset_t
*set
, int signo
)
156 if (signo
< 0 || signo
>= NSIG
)
162 *set
|= (1U << signo
);
168 sigfillset (sigset_t
*set
)
181 sigprocmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
183 if (!(how
== SIG_BLOCK
|| how
== SIG_UNBLOCK
|| how
== SIG_SETMASK
))
204 /* FIXME: Catch signals that are blocked and reissue them when
205 they are unblocked. Important for SIGALRM and SIGPROF only. */
214 pthread_sigmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
216 if (sigprocmask (how
, set
, oset
) == -1)
222 sigismember (const sigset_t
*set
, int signo
)
224 if (signo
< 0 || signo
>= NSIG
)
229 if (signo
> sizeof (*set
) * BITS_PER_CHAR
)
232 return (*set
& (1U << signo
)) != 0;
248 setpgid (pid_t pid
, pid_t pgid
)
259 /* Emulations of interval timers.
261 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
263 Implementation: a separate thread is started for each timer type,
264 the thread calls the appropriate signal handler when the timer
265 expires, after stopping the thread which installed the timer. */
268 volatile ULONGLONG expire
;
269 volatile ULONGLONG reload
;
270 volatile int terminate
;
272 HANDLE caller_thread
;
276 static ULONGLONG ticks_now
;
277 static struct itimer_data real_itimer
, prof_itimer
;
278 static ULONGLONG clocks_min
;
279 /* If non-zero, itimers are disabled. Used during shutdown, when we
280 delete the critical sections used by the timer threads. */
281 static int disable_itimers
;
283 static CRITICAL_SECTION crit_real
, crit_prof
;
285 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
286 typedef BOOL (WINAPI
*GetThreadTimes_Proc
) (
288 LPFILETIME lpCreationTime
,
289 LPFILETIME lpExitTime
,
290 LPFILETIME lpKernelTime
,
291 LPFILETIME lpUserTime
);
293 static GetThreadTimes_Proc s_pfn_Get_Thread_Times
;
295 #define MAX_SINGLE_SLEEP 30
296 #define TIMER_TICKS_PER_SEC 1000
298 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
299 to a thread. If THREAD is NULL or an invalid handle, return the
300 current wall-clock time since January 1, 1601 (UTC). Otherwise,
301 return the sum of kernel and user times used by THREAD since it was
302 created, plus its creation time. */
304 w32_get_timer_time (HANDLE thread
)
307 int use_system_time
= 1;
308 /* The functions below return times in 100-ns units. */
309 const int tscale
= 10 * TIMER_TICKS_PER_SEC
;
311 if (thread
&& thread
!= INVALID_HANDLE_VALUE
312 && s_pfn_Get_Thread_Times
!= NULL
)
314 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
315 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
317 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
318 &kernel_ftime
, &user_ftime
))
321 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
322 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
323 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
324 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
325 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
326 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
328 temp_creation
.QuadPart
/ tscale
+ temp_kernel
.QuadPart
/ tscale
329 + temp_user
.QuadPart
/ tscale
;
332 DebPrint (("GetThreadTimes failed with error code %lu\n",
338 FILETIME current_ftime
;
341 GetSystemTimeAsFileTime (¤t_ftime
);
343 temp
.LowPart
= current_ftime
.dwLowDateTime
;
344 temp
.HighPart
= current_ftime
.dwHighDateTime
;
346 retval
= temp
.QuadPart
/ tscale
;
352 /* Thread function for a timer thread. */
354 timer_loop (LPVOID arg
)
356 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
357 int which
= itimer
->type
;
358 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
359 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
360 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / TIMER_TICKS_PER_SEC
;
361 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
366 signal_handler handler
;
367 ULONGLONG now
, expire
, reload
;
369 /* Load new values if requested by setitimer. */
370 EnterCriticalSection (crit
);
371 expire
= itimer
->expire
;
372 reload
= itimer
->reload
;
373 LeaveCriticalSection (crit
);
374 if (itimer
->terminate
)
384 if (expire
> (now
= w32_get_timer_time (hth
)))
385 sleep_time
= expire
- now
;
388 /* Don't sleep too long at a time, to be able to see the
389 termination flag without too long a delay. */
390 while (sleep_time
> max_sleep
)
392 if (itimer
->terminate
)
395 EnterCriticalSection (crit
);
396 expire
= itimer
->expire
;
397 LeaveCriticalSection (crit
);
399 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
401 if (itimer
->terminate
)
405 Sleep (sleep_time
* 1000 / TIMER_TICKS_PER_SEC
);
406 /* Always sleep past the expiration time, to make sure we
407 never call the handler _before_ the expiration time,
408 always slightly after it. Sleep(5) makes sure we don't
409 hog the CPU by calling 'w32_get_timer_time' with high
410 frequency, and also let other threads work. */
411 while (w32_get_timer_time (hth
) < expire
)
415 EnterCriticalSection (crit
);
416 expire
= itimer
->expire
;
417 LeaveCriticalSection (crit
);
422 handler
= sig_handlers
[sig
];
423 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
424 /* FIXME: Don't ignore masked signals. Instead, record that
425 they happened and reissue them when the signal is
427 && !sigismember (&sig_mask
, sig
)
428 /* Simulate masking of SIGALRM and SIGPROF when processing
430 && !fatal_error_in_progress
431 && itimer
->caller_thread
)
433 /* Simulate a signal delivered to the thread which installed
434 the timer, by suspending that thread while the handler
436 HANDLE th
= itimer
->caller_thread
;
437 DWORD result
= SuspendThread (th
);
439 if (result
== (DWORD
)-1)
446 /* Update expiration time and loop. */
447 EnterCriticalSection (crit
);
448 expire
= itimer
->expire
;
451 LeaveCriticalSection (crit
);
454 reload
= itimer
->reload
;
457 now
= w32_get_timer_time (hth
);
460 ULONGLONG lag
= now
- expire
;
462 /* If we missed some opportunities (presumably while
463 sleeping or while the signal handler ran), skip
466 expire
= now
- (lag
% reload
);
472 expire
= 0; /* become idle */
473 itimer
->expire
= expire
;
474 LeaveCriticalSection (crit
);
480 stop_timer_thread (int which
)
482 struct itimer_data
*itimer
=
483 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
485 DWORD err
, exit_code
= 255;
488 /* Signal the thread that it should terminate. */
489 itimer
->terminate
= 1;
491 if (itimer
->timer_thread
== NULL
)
494 /* Wait for the timer thread to terminate voluntarily, then kill it
495 if it doesn't. This loop waits twice more than the maximum
496 amount of time a timer thread sleeps, see above. */
497 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
499 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
500 && exit_code
== STILL_ACTIVE
))
504 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
505 || exit_code
== STILL_ACTIVE
)
507 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
508 TerminateThread (itimer
->timer_thread
, 0);
512 CloseHandle (itimer
->timer_thread
);
513 itimer
->timer_thread
= NULL
;
514 if (itimer
->caller_thread
)
516 CloseHandle (itimer
->caller_thread
);
517 itimer
->caller_thread
= NULL
;
521 /* This is called at shutdown time from term_ntproc. */
525 if (real_itimer
.timer_thread
)
526 stop_timer_thread (ITIMER_REAL
);
527 if (prof_itimer
.timer_thread
)
528 stop_timer_thread (ITIMER_PROF
);
530 /* We are going to delete the critical sections, so timers cannot
534 DeleteCriticalSection (&crit_real
);
535 DeleteCriticalSection (&crit_prof
);
536 DeleteCriticalSection (&crit_sig
);
539 /* This is called at initialization time from init_ntproc. */
543 /* GetThreadTimes is not available on all versions of Windows, so
544 need to probe for its availability dynamically, and call it
545 through a pointer. */
546 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
547 if (os_subtype
!= OS_9X
)
548 s_pfn_Get_Thread_Times
=
549 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
552 /* Make sure we start with zeroed out itimer structures, since
553 dumping may have left there traces of threads long dead. */
554 memset (&real_itimer
, 0, sizeof real_itimer
);
555 memset (&prof_itimer
, 0, sizeof prof_itimer
);
557 InitializeCriticalSection (&crit_real
);
558 InitializeCriticalSection (&crit_prof
);
559 InitializeCriticalSection (&crit_sig
);
565 start_timer_thread (int which
)
569 struct itimer_data
*itimer
=
570 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
572 if (itimer
->timer_thread
573 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
574 && exit_code
== STILL_ACTIVE
)
577 /* Clean up after possibly exited thread. */
578 if (itimer
->timer_thread
)
580 CloseHandle (itimer
->timer_thread
);
581 itimer
->timer_thread
= NULL
;
583 if (itimer
->caller_thread
)
585 CloseHandle (itimer
->caller_thread
);
586 itimer
->caller_thread
= NULL
;
589 /* Start a new thread. */
590 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
591 GetCurrentProcess (), &th
, 0, FALSE
,
592 DUPLICATE_SAME_ACCESS
))
597 itimer
->terminate
= 0;
598 itimer
->type
= which
;
599 itimer
->caller_thread
= th
;
600 /* Request that no more than 64KB of stack be reserved for this
601 thread, to avoid reserving too much memory, which would get in
602 the way of threads we start to wait for subprocesses. See also
604 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
605 (void *)itimer
, 0x00010000, NULL
);
607 if (!itimer
->timer_thread
)
609 CloseHandle (itimer
->caller_thread
);
610 itimer
->caller_thread
= NULL
;
615 /* This is needed to make sure that the timer thread running for
616 profiling gets CPU as soon as the Sleep call terminates. */
617 if (which
== ITIMER_PROF
)
618 SetThreadPriority (itimer
->timer_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
623 /* Most of the code of getitimer and setitimer (but not of their
624 subroutines) was shamelessly stolen from itimer.c in the DJGPP
625 library, see www.delorie.com/djgpp. */
627 getitimer (int which
, struct itimerval
*value
)
629 volatile ULONGLONG
*t_expire
;
630 volatile ULONGLONG
*t_reload
;
631 ULONGLONG expire
, reload
;
633 CRITICAL_SECTION
*crit
;
634 struct itimer_data
*itimer
;
645 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
651 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
653 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
655 : GetCurrentThread ());
657 t_expire
= &itimer
->expire
;
658 t_reload
= &itimer
->reload
;
659 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
661 EnterCriticalSection (crit
);
664 LeaveCriticalSection (crit
);
669 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
671 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
672 value
->it_value
.tv_usec
= usecs
;
673 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
675 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
676 value
->it_interval
.tv_usec
= usecs
;
682 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
684 volatile ULONGLONG
*t_expire
, *t_reload
;
685 ULONGLONG expire
, reload
, expire_old
, reload_old
;
687 CRITICAL_SECTION
*crit
;
688 struct itimerval tem
, *ptem
;
693 /* Posix systems expect timer values smaller than the resolution of
694 the system clock be rounded up to the clock resolution. First
695 time we are called, measure the clock tick resolution. */
700 for (t1
= w32_get_timer_time (NULL
);
701 (t2
= w32_get_timer_time (NULL
)) == t1
; )
703 clocks_min
= t2
- t1
;
711 if (getitimer (which
, ptem
)) /* also sets ticks_now */
712 return -1; /* errno already set */
715 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
717 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
719 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
722 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
724 EnterCriticalSection (crit
);
725 /* Disable the timer. */
728 LeaveCriticalSection (crit
);
732 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
734 usecs
= value
->it_interval
.tv_usec
;
735 if (value
->it_interval
.tv_sec
== 0
736 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
740 usecs
*= TIMER_TICKS_PER_SEC
;
741 reload
+= usecs
/ 1000000;
744 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
745 usecs
= value
->it_value
.tv_usec
;
746 if (value
->it_value
.tv_sec
== 0
747 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
751 usecs
*= TIMER_TICKS_PER_SEC
;
752 expire
+= usecs
/ 1000000;
757 EnterCriticalSection (crit
);
758 expire_old
= *t_expire
;
759 reload_old
= *t_reload
;
760 if (!(expire
== expire_old
&& reload
== reload_old
))
765 LeaveCriticalSection (crit
);
767 return start_timer_thread (which
);
773 #ifdef HAVE_SETITIMER
774 struct itimerval new_values
, old_values
;
776 new_values
.it_value
.tv_sec
= seconds
;
777 new_values
.it_value
.tv_usec
= 0;
778 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
780 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
782 return old_values
.it_value
.tv_sec
;
788 /* Defined in <process.h> which conflicts with the local copy */
791 /* Child process management list. */
792 int child_proc_count
= 0;
793 child_process child_procs
[ MAX_CHILDREN
];
795 static DWORD WINAPI
reader_thread (void *arg
);
797 /* Find an unused process slot. */
804 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
805 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
807 if (child_proc_count
== MAX_CHILDREN
)
810 child_process
*dead_cp
= NULL
;
812 DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
813 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
814 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
818 if (!GetExitCodeProcess (cp
->procinfo
.hProcess
, &status
))
820 DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
821 GetLastError (), cp
->procinfo
.dwProcessId
));
822 status
= STILL_ACTIVE
;
824 if (status
!= STILL_ACTIVE
825 || WaitForSingleObject (cp
->procinfo
.hProcess
, 0) == WAIT_OBJECT_0
)
827 DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
828 cp
->procinfo
.dwProcessId
, cp
->fd
));
829 CloseHandle (cp
->procinfo
.hProcess
);
830 cp
->procinfo
.hProcess
= NULL
;
831 CloseHandle (cp
->procinfo
.hThread
);
832 cp
->procinfo
.hThread
= NULL
;
833 /* Free up to 2 dead slots at a time, so that if we
834 have a lot of them, they will eventually all be
835 freed when the tornado ends. */
849 if (child_proc_count
== MAX_CHILDREN
)
851 cp
= &child_procs
[child_proc_count
++];
854 /* Last opportunity to avoid leaking handles before we forget them
856 if (cp
->procinfo
.hProcess
)
857 CloseHandle (cp
->procinfo
.hProcess
);
858 if (cp
->procinfo
.hThread
)
859 CloseHandle (cp
->procinfo
.hThread
);
860 memset (cp
, 0, sizeof (*cp
));
863 cp
->procinfo
.hProcess
= NULL
;
864 cp
->status
= STATUS_READ_ERROR
;
866 /* use manual reset event so that select() will function properly */
867 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
870 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
871 if (cp
->char_consumed
)
873 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
874 It means that the 64K stack we are requesting in the 2nd
875 argument is how much memory should be reserved for the
876 stack. If we don't use this flag, the memory requested
877 by the 2nd argument is the amount actually _committed_,
878 but Windows reserves 8MB of memory for each thread's
879 stack. (The 8MB figure comes from the -stack
880 command-line argument we pass to the linker when building
881 Emacs, but that's because we need a large stack for
882 Emacs's main thread.) Since we request 2GB of reserved
883 memory at startup (see w32heap.c), which is close to the
884 maximum memory available for a 32-bit process on Windows,
885 the 8MB reservation for each thread causes failures in
886 starting subprocesses, because we create a thread running
887 reader_thread for each subprocess. As 8MB of stack is
888 way too much for reader_thread, forcing Windows to
889 reserve less wins the day. */
890 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
901 delete_child (child_process
*cp
)
905 /* Should not be deleting a child that is still needed. */
906 for (i
= 0; i
< MAXDESC
; i
++)
907 if (fd_info
[i
].cp
== cp
)
910 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
913 /* reap thread if necessary */
918 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
920 /* let the thread exit cleanly if possible */
921 cp
->status
= STATUS_READ_ERROR
;
922 SetEvent (cp
->char_consumed
);
924 /* We used to forcibly terminate the thread here, but it
925 is normally unnecessary, and in abnormal cases, the worst that
926 will happen is we have an extra idle thread hanging around
927 waiting for the zombie process. */
928 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
930 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
931 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
932 TerminateThread (cp
->thrd
, 0);
936 CloseHandle (cp
->thrd
);
941 CloseHandle (cp
->char_avail
);
942 cp
->char_avail
= NULL
;
944 if (cp
->char_consumed
)
946 CloseHandle (cp
->char_consumed
);
947 cp
->char_consumed
= NULL
;
950 /* update child_proc_count (highest numbered slot in use plus one) */
951 if (cp
== child_procs
+ child_proc_count
- 1)
953 for (i
= child_proc_count
-1; i
>= 0; i
--)
954 if (CHILD_ACTIVE (&child_procs
[i
])
955 || child_procs
[i
].procinfo
.hProcess
!= NULL
)
957 child_proc_count
= i
+ 1;
962 child_proc_count
= 0;
965 /* Find a child by pid. */
966 static child_process
*
967 find_child_pid (DWORD pid
)
971 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
972 if ((CHILD_ACTIVE (cp
) || cp
->procinfo
.hProcess
!= NULL
)
979 release_listen_threads (void)
983 for (i
= child_proc_count
- 1; i
>= 0; i
--)
985 if (CHILD_ACTIVE (&child_procs
[i
])
986 && (fd_info
[child_procs
[i
].fd
].flags
& FILE_LISTEN
))
987 child_procs
[i
].status
= STATUS_READ_ERROR
;
991 /* Thread proc for child process and socket reader threads. Each thread
992 is normally blocked until woken by select() to check for input by
993 reading one char. When the read completes, char_avail is signaled
994 to wake up the select emulator and the thread blocks itself again. */
996 reader_thread (void *arg
)
1001 cp
= (child_process
*)arg
;
1003 /* We have to wait for the go-ahead before we can start */
1005 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
1013 if (cp
->fd
>= 0 && fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
1014 rc
= _sys_wait_accept (cp
->fd
);
1016 rc
= _sys_read_ahead (cp
->fd
);
1018 /* Don't bother waiting for the event if we already have been
1019 told to exit by delete_child. */
1020 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_avail
)
1023 /* The name char_avail is a misnomer - it really just means the
1024 read-ahead has completed, whether successfully or not. */
1025 if (!SetEvent (cp
->char_avail
))
1027 DebPrint (("reader_thread.SetEvent(0x%x) failed with %lu for fd %ld (PID %d)\n",
1028 (DWORD_PTR
)cp
->char_avail
, GetLastError (),
1033 if (rc
== STATUS_READ_ERROR
)
1036 /* If the read died, the child has died so let the thread die */
1037 if (rc
== STATUS_READ_FAILED
)
1040 /* Don't bother waiting for the acknowledge if we already have
1041 been told to exit by delete_child. */
1042 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_consumed
)
1045 /* Wait until our input is acknowledged before reading again */
1046 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
1048 DebPrint (("reader_thread.WaitForSingleObject failed with "
1049 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
1052 /* delete_child sets status to STATUS_READ_ERROR when it wants
1054 if (cp
->status
== STATUS_READ_ERROR
)
1060 /* To avoid Emacs changing directory, we just record here the
1061 directory the new process should start in. This is set just before
1062 calling sys_spawnve, and is not generally valid at any other time.
1063 Note that this directory's name is UTF-8 encoded. */
1064 static char * process_dir
;
1067 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
1068 int * pPid
, child_process
*cp
)
1071 SECURITY_ATTRIBUTES sec_attrs
;
1073 SECURITY_DESCRIPTOR sec_desc
;
1076 char dir
[ MAX_PATH
];
1079 if (cp
== NULL
) emacs_abort ();
1081 memset (&start
, 0, sizeof (start
));
1082 start
.cb
= sizeof (start
);
1085 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
1086 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
1088 start
.dwFlags
= STARTF_USESTDHANDLES
;
1089 start
.wShowWindow
= SW_HIDE
;
1091 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
1092 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
1093 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
1094 #endif /* HAVE_NTGUI */
1097 /* Explicitly specify no security */
1098 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
1100 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
1103 sec_attrs
.nLength
= sizeof (sec_attrs
);
1104 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
1105 sec_attrs
.bInheritHandle
= FALSE
;
1107 filename_to_ansi (process_dir
, dir
);
1108 /* Can't use unixtodos_filename here, since that needs its file name
1109 argument encoded in UTF-8. OTOH, process_dir, which _is_ in
1110 UTF-8, points, to the directory computed by our caller, and we
1111 don't want to modify that, either. */
1112 for (p
= dir
; *p
; p
= CharNextA (p
))
1116 flags
= (!NILP (Vw32_start_process_share_console
)
1117 ? CREATE_NEW_PROCESS_GROUP
1118 : CREATE_NEW_CONSOLE
);
1119 if (NILP (Vw32_start_process_inherit_error_mode
))
1120 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1121 if (!CreateProcessA (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1122 flags
, env
, dir
, &start
, &cp
->procinfo
))
1125 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1127 /* Hack for Windows 95, which assigns large (ie negative) pids */
1136 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1140 /* create_child doesn't know what emacs's file handle will be for waiting
1141 on output from the child, so we need to make this additional call
1142 to register the handle with the process
1143 This way the select emulator knows how to match file handles with
1144 entries in child_procs. */
1146 register_child (pid_t pid
, int fd
)
1150 cp
= find_child_pid ((DWORD
)pid
);
1153 DebPrint (("register_child unable to find pid %lu\n", pid
));
1158 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1163 /* thread is initially blocked until select is called; set status so
1164 that select will release thread */
1165 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1167 /* attach child_process to fd_info */
1168 if (fd_info
[fd
].cp
!= NULL
)
1170 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1174 fd_info
[fd
].cp
= cp
;
1177 /* Called from waitpid when a process exits. */
1179 reap_subprocess (child_process
*cp
)
1181 if (cp
->procinfo
.hProcess
)
1183 /* Reap the process */
1185 /* Process should have already died before we are called. */
1186 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1187 DebPrint (("reap_subprocess: child for fd %d has not died yet!", cp
->fd
));
1189 CloseHandle (cp
->procinfo
.hProcess
);
1190 cp
->procinfo
.hProcess
= NULL
;
1191 CloseHandle (cp
->procinfo
.hThread
);
1192 cp
->procinfo
.hThread
= NULL
;
1195 /* If cp->fd was not closed yet, we might be still reading the
1196 process output, so don't free its resources just yet. The call
1197 to delete_child on behalf of this subprocess will be made by
1198 sys_read when the subprocess output is fully read. */
1203 /* Wait for a child process specified by PID, or for any of our
1204 existing child processes (if PID is nonpositive) to die. When it
1205 does, close its handle. Return the pid of the process that died
1206 and fill in STATUS if non-NULL. */
1209 waitpid (pid_t pid
, int *status
, int options
)
1211 DWORD active
, retval
;
1213 child_process
*cp
, *cps
[MAX_CHILDREN
];
1214 HANDLE wait_hnd
[MAX_CHILDREN
];
1216 int dont_wait
= (options
& WNOHANG
) != 0;
1219 /* According to Posix:
1221 PID = -1 means status is requested for any child process.
1223 PID > 0 means status is requested for a single child process
1226 PID = 0 means status is requested for any child process whose
1227 process group ID is equal to that of the calling process. But
1228 since Windows has only a limited support for process groups (only
1229 for console processes and only for the purposes of passing
1230 Ctrl-BREAK signal to them), and since we have no documented way
1231 of determining whether a given process belongs to our group, we
1234 PID < -1 means status is requested for any child process whose
1235 process group ID is equal to the absolute value of PID. Again,
1236 since we don't support process groups, we treat that as -1. */
1241 /* We are requested to wait for a specific child. */
1242 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1244 /* Some child_procs might be sockets; ignore them. Also
1245 ignore subprocesses whose output is not yet completely
1247 if (CHILD_ACTIVE (cp
)
1248 && cp
->procinfo
.hProcess
1257 if (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1259 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1265 /* PID specifies our subprocess, but its status is not
1272 /* No such child process, or nothing to wait for, so fail. */
1279 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1281 if (CHILD_ACTIVE (cp
)
1282 && cp
->procinfo
.hProcess
1283 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1285 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1292 /* Nothing to wait on, so fail. */
1301 timeout_ms
= 1000; /* check for quit about once a second. */
1306 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, timeout_ms
);
1307 } while (active
== WAIT_TIMEOUT
&& !dont_wait
);
1309 if (active
== WAIT_FAILED
)
1314 else if (active
== WAIT_TIMEOUT
&& dont_wait
)
1316 /* PID specifies our subprocess, but it didn't exit yet, so its
1317 status is not yet available. */
1319 DebPrint (("Wait: PID %d not reap yet\n", cp
->pid
));
1323 else if (active
>= WAIT_OBJECT_0
1324 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1326 active
-= WAIT_OBJECT_0
;
1328 else if (active
>= WAIT_ABANDONED_0
1329 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1331 active
-= WAIT_ABANDONED_0
;
1336 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1338 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1342 if (retval
== STILL_ACTIVE
)
1344 /* Should never happen. */
1345 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1346 if (pid
> 0 && dont_wait
)
1352 /* Massage the exit code from the process to match the format expected
1353 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1354 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1356 if (retval
== STATUS_CONTROL_C_EXIT
)
1361 if (pid
> 0 && active
!= 0)
1366 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1371 reap_subprocess (cp
);
1376 /* Old versions of w32api headers don't have separate 32-bit and
1377 64-bit defines, but the one they have matches the 32-bit variety. */
1378 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1379 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1380 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1383 /* Implementation note: This function works with file names encoded in
1384 the current ANSI codepage. */
1386 w32_executable_type (char * filename
,
1388 int * is_cygnus_app
,
1391 file_data executable
;
1394 /* Default values in case we can't tell for sure. */
1395 *is_dos_app
= FALSE
;
1396 *is_cygnus_app
= FALSE
;
1397 *is_gui_app
= FALSE
;
1399 if (!open_input_file (&executable
, filename
))
1402 p
= strrchr (filename
, '.');
1404 /* We can only identify DOS .com programs from the extension. */
1405 if (p
&& xstrcasecmp (p
, ".com") == 0)
1407 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1408 || xstrcasecmp (p
, ".cmd") == 0))
1410 /* A DOS shell script - it appears that CreateProcess is happy to
1411 accept this (somewhat surprisingly); presumably it looks at
1412 COMSPEC to determine what executable to actually invoke.
1413 Therefore, we have to do the same here as well. */
1414 /* Actually, I think it uses the program association for that
1415 extension, which is defined in the registry. */
1416 p
= egetenv ("COMSPEC");
1418 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1422 /* Look for DOS .exe signature - if found, we must also check that
1423 it isn't really a 16- or 32-bit Windows exe, since both formats
1424 start with a DOS program stub. Note that 16-bit Windows
1425 executables use the OS/2 1.x format. */
1427 IMAGE_DOS_HEADER
* dos_header
;
1428 IMAGE_NT_HEADERS
* nt_header
;
1430 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1431 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1434 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1436 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1438 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1441 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1442 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1446 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1448 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1449 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1451 /* Ensure we are using the 32 bit structure. */
1452 IMAGE_OPTIONAL_HEADER32
*opt
1453 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1454 data_dir
= opt
->DataDirectory
;
1455 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1457 /* MingW 3.12 has the required 64 bit structs, but in case older
1458 versions don't, only check 64 bit exes if we know how. */
1459 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1460 else if (nt_header
->OptionalHeader
.Magic
1461 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1463 IMAGE_OPTIONAL_HEADER64
*opt
1464 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1465 data_dir
= opt
->DataDirectory
;
1466 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1471 /* Look for cygwin.dll in DLL import list. */
1472 IMAGE_DATA_DIRECTORY import_dir
=
1473 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1474 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1475 IMAGE_SECTION_HEADER
* section
;
1477 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1478 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1481 for ( ; imports
->Name
; imports
++)
1483 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1486 /* The exact name of the cygwin dll has changed with
1487 various releases, but hopefully this will be reasonably
1489 if (strncmp (dllname
, "cygwin", 6) == 0)
1491 *is_cygnus_app
= TRUE
;
1500 close_file_data (&executable
);
1504 compare_env (const void *strp1
, const void *strp2
)
1506 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1508 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1510 /* Sort order in command.com/cmd.exe is based on uppercasing
1511 names, so do the same here. */
1512 if (toupper (*str1
) > toupper (*str2
))
1514 else if (toupper (*str1
) < toupper (*str2
))
1519 if (*str1
== '=' && *str2
== '=')
1521 else if (*str1
== '=')
1528 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1530 char **optr
, **nptr
;
1542 num
+= optr
- envp2
;
1544 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1549 /* When a new child process is created we need to register it in our list,
1550 so intercept spawn requests. */
1552 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1554 Lisp_Object program
, full
;
1555 char *cmdline
, *env
, *parg
, **targ
;
1559 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1561 /* We pass our process ID to our children by setting up an environment
1562 variable in their environment. */
1563 char ppid_env_var_buffer
[64];
1564 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1565 /* These are the characters that cause an argument to need quoting.
1566 Arguments with whitespace characters need quoting to prevent the
1567 argument being split into two or more. Arguments with wildcards
1568 are also quoted, for consistency with posix platforms, where wildcards
1569 are not expanded if we run the program directly without a shell.
1570 Some extra whitespace characters need quoting in Cygwin programs,
1571 so this list is conditionally modified below. */
1572 char *sepchars
= " \t*?";
1573 /* This is for native w32 apps; modified below for Cygwin apps. */
1574 char escape_char
= '\\';
1575 char cmdname_a
[MAX_PATH
];
1577 /* We don't care about the other modes */
1578 if (mode
!= _P_NOWAIT
)
1584 /* Handle executable names without an executable suffix. The caller
1585 already searched exec-path and verified the file is executable,
1586 but start-process doesn't do that for file names that are already
1587 absolute. So we double-check this here, just in case. */
1588 if (faccessat (AT_FDCWD
, cmdname
, X_OK
, AT_EACCESS
) != 0)
1590 struct gcpro gcpro1
;
1592 program
= build_string (cmdname
);
1595 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
));
1602 program
= ENCODE_FILE (full
);
1603 cmdname
= SDATA (program
);
1606 /* make sure argv[0] and cmdname are both in DOS format */
1607 unixtodos_filename (cmdname
);
1608 /* argv[0] was encoded by caller using ENCODE_FILE, so it is in
1609 UTF-8. All the other arguments are encoded by ENCODE_SYSTEM or
1610 some such, and are in some ANSI codepage. We need to have
1611 argv[0] encoded in ANSI codepage. */
1612 filename_to_ansi (cmdname
, cmdname_a
);
1613 /* We explicitly require that the command's file name be encodable
1614 in the current ANSI codepage, because we will be invoking it via
1616 if (_mbspbrk (cmdname_a
, "?"))
1621 /* From here on, CMDNAME is an ANSI-encoded string. */
1625 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1626 executable that is implicitly linked to the Cygnus dll (implying it
1627 was compiled with the Cygnus GNU toolchain and hence relies on
1628 cygwin.dll to parse the command line - we use this to decide how to
1629 escape quote chars in command line args that must be quoted).
1631 Also determine whether it is a GUI app, so that we don't hide its
1632 initial window unless specifically requested. */
1633 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1635 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1636 application to start it by specifying the helper app as cmdname,
1637 while leaving the real app name as argv[0]. */
1642 cmdname
= alloca (MAX_PATH
);
1643 if (egetenv ("CMDPROXY"))
1644 strcpy (cmdname
, egetenv ("CMDPROXY"));
1647 strcpy (cmdname
, SDATA (Vinvocation_directory
));
1648 strcat (cmdname
, "cmdproxy.exe");
1651 /* Can't use unixtodos_filename here, since that needs its file
1652 name argument encoded in UTF-8. */
1653 for (p
= cmdname
; *p
; p
= CharNextA (p
))
1658 /* we have to do some conjuring here to put argv and envp into the
1659 form CreateProcess wants... argv needs to be a space separated/null
1660 terminated list of parameters, and envp is a null
1661 separated/double-null terminated list of parameters.
1663 Additionally, zero-length args and args containing whitespace or
1664 quote chars need to be wrapped in double quotes - for this to work,
1665 embedded quotes need to be escaped as well. The aim is to ensure
1666 the child process reconstructs the argv array we start with
1667 exactly, so we treat quotes at the beginning and end of arguments
1670 The w32 GNU-based library from Cygnus doubles quotes to escape
1671 them, while MSVC uses backslash for escaping. (Actually the MSVC
1672 startup code does attempt to recognize doubled quotes and accept
1673 them, but gets it wrong and ends up requiring three quotes to get a
1674 single embedded quote!) So by default we decide whether to use
1675 quote or backslash as the escape character based on whether the
1676 binary is apparently a Cygnus compiled app.
1678 Note that using backslash to escape embedded quotes requires
1679 additional special handling if an embedded quote is already
1680 preceded by backslash, or if an arg requiring quoting ends with
1681 backslash. In such cases, the run of escape characters needs to be
1682 doubled. For consistency, we apply this special handling as long
1683 as the escape character is not quote.
1685 Since we have no idea how large argv and envp are likely to be we
1686 figure out list lengths on the fly and allocate them. */
1688 if (!NILP (Vw32_quote_process_args
))
1691 /* Override escape char by binding w32-quote-process-args to
1692 desired character, or use t for auto-selection. */
1693 if (INTEGERP (Vw32_quote_process_args
))
1694 escape_char
= XINT (Vw32_quote_process_args
);
1696 escape_char
= is_cygnus_app
? '"' : '\\';
1699 /* Cygwin apps needs quoting a bit more often. */
1700 if (escape_char
== '"')
1701 sepchars
= "\r\n\t\f '";
1709 int need_quotes
= 0;
1710 int escape_char_run
= 0;
1716 if (escape_char
== '"' && *p
== '\\')
1717 /* If it's a Cygwin app, \ needs to be escaped. */
1721 /* allow for embedded quotes to be escaped */
1724 /* handle the case where the embedded quote is already escaped */
1725 if (escape_char_run
> 0)
1727 /* To preserve the arg exactly, we need to double the
1728 preceding escape characters (plus adding one to
1729 escape the quote character itself). */
1730 arglen
+= escape_char_run
;
1733 else if (strchr (sepchars
, *p
) != NULL
)
1738 if (*p
== escape_char
&& escape_char
!= '"')
1741 escape_char_run
= 0;
1746 /* handle the case where the arg ends with an escape char - we
1747 must not let the enclosing quote be escaped. */
1748 if (escape_char_run
> 0)
1749 arglen
+= escape_char_run
;
1751 arglen
+= strlen (*targ
++) + 1;
1753 cmdline
= alloca (arglen
);
1759 int need_quotes
= 0;
1767 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1772 int escape_char_run
= 0;
1778 last
= p
+ strlen (p
) - 1;
1781 /* This version does not escape quotes if they occur at the
1782 beginning or end of the arg - this could lead to incorrect
1783 behavior when the arg itself represents a command line
1784 containing quoted args. I believe this was originally done
1785 as a hack to make some things work, before
1786 `w32-quote-process-args' was added. */
1789 if (*p
== '"' && p
> first
&& p
< last
)
1790 *parg
++ = escape_char
; /* escape embedded quotes */
1798 /* double preceding escape chars if any */
1799 while (escape_char_run
> 0)
1801 *parg
++ = escape_char
;
1804 /* escape all quote chars, even at beginning or end */
1805 *parg
++ = escape_char
;
1807 else if (escape_char
== '"' && *p
== '\\')
1811 if (*p
== escape_char
&& escape_char
!= '"')
1814 escape_char_run
= 0;
1816 /* double escape chars before enclosing quote */
1817 while (escape_char_run
> 0)
1819 *parg
++ = escape_char
;
1827 strcpy (parg
, *targ
);
1828 parg
+= strlen (*targ
);
1838 numenv
= 1; /* for end null */
1841 arglen
+= strlen (*targ
++) + 1;
1844 /* extra env vars... */
1845 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
1846 GetCurrentProcessId ());
1847 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1850 /* merge env passed in and extra env into one, and sort it. */
1851 targ
= (char **) alloca (numenv
* sizeof (char *));
1852 merge_and_sort_env (envp
, extra_env
, targ
);
1854 /* concatenate env entries. */
1855 env
= alloca (arglen
);
1859 strcpy (parg
, *targ
);
1860 parg
+= strlen (*targ
++);
1873 /* Now create the process. */
1874 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1884 /* Emulate the select call
1885 Wait for available input on any of the given rfds, or timeout if
1886 a timeout is given and no input is detected
1887 wfds and efds are not supported and must be NULL.
1889 For simplicity, we detect the death of child processes here and
1890 synchronously call the SIGCHLD handler. Since it is possible for
1891 children to be created without a corresponding pipe handle from which
1892 to read output, we wait separately on the process handles as well as
1893 the char_avail events for each process pipe. We only call
1894 wait/reap_process when the process actually terminates.
1896 To reduce the number of places in which Emacs can be hung such that
1897 C-g is not able to interrupt it, we always wait on interrupt_handle
1898 (which is signaled by the input thread when C-g is detected). If we
1899 detect that we were woken up by C-g, we return -1 with errno set to
1900 EINTR as on Unix. */
1902 /* From w32console.c */
1903 extern HANDLE keyboard_handle
;
1905 /* From w32xfns.c */
1906 extern HANDLE interrupt_handle
;
1908 /* From process.c */
1909 extern int proc_buffered_char
[];
1912 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1913 struct timespec
*timeout
, void *ignored
)
1916 DWORD timeout_ms
, start_time
;
1919 child_process
*cp
, *cps
[MAX_CHILDREN
];
1920 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1921 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1924 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1926 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1927 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1933 /* Otherwise, we only handle rfds, so fail otherwise. */
1934 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1944 /* Always wait on interrupt_handle, to detect C-g (quit). */
1945 wait_hnd
[0] = interrupt_handle
;
1948 /* Build a list of pipe handles to wait on. */
1950 for (i
= 0; i
< nfds
; i
++)
1951 if (FD_ISSET (i
, &orfds
))
1955 if (keyboard_handle
)
1957 /* Handle stdin specially */
1958 wait_hnd
[nh
] = keyboard_handle
;
1963 /* Check for any emacs-generated input in the queue since
1964 it won't be detected in the wait */
1965 if (detect_input_pending ())
1973 /* Child process and socket/comm port input. */
1977 int current_status
= cp
->status
;
1979 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
1981 /* Tell reader thread which file handle to use. */
1983 /* Wake up the reader thread for this process */
1984 cp
->status
= STATUS_READ_READY
;
1985 if (!SetEvent (cp
->char_consumed
))
1986 DebPrint (("sys_select.SetEvent failed with "
1987 "%lu for fd %ld\n", GetLastError (), i
));
1990 #ifdef CHECK_INTERLOCK
1991 /* slightly crude cross-checking of interlock between threads */
1993 current_status
= cp
->status
;
1994 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
1996 /* char_avail has been signaled, so status (which may
1997 have changed) should indicate read has completed
1998 but has not been acknowledged. */
1999 current_status
= cp
->status
;
2000 if (current_status
!= STATUS_READ_SUCCEEDED
2001 && current_status
!= STATUS_READ_FAILED
)
2002 DebPrint (("char_avail set, but read not completed: status %d\n",
2007 /* char_avail has not been signaled, so status should
2008 indicate that read is in progress; small possibility
2009 that read has completed but event wasn't yet signaled
2010 when we tested it (because a context switch occurred
2011 or if running on separate CPUs). */
2012 if (current_status
!= STATUS_READ_READY
2013 && current_status
!= STATUS_READ_IN_PROGRESS
2014 && current_status
!= STATUS_READ_SUCCEEDED
2015 && current_status
!= STATUS_READ_FAILED
)
2016 DebPrint (("char_avail reset, but read status is bad: %d\n",
2020 wait_hnd
[nh
] = cp
->char_avail
;
2022 if (!wait_hnd
[nh
]) emacs_abort ();
2025 DebPrint (("select waiting on child %d fd %d\n",
2026 cp
-child_procs
, i
));
2031 /* Unable to find something to wait on for this fd, skip */
2033 /* Note that this is not a fatal error, and can in fact
2034 happen in unusual circumstances. Specifically, if
2035 sys_spawnve fails, eg. because the program doesn't
2036 exist, and debug-on-error is t so Fsignal invokes a
2037 nested input loop, then the process output pipe is
2038 still included in input_wait_mask with no child_proc
2039 associated with it. (It is removed when the debugger
2040 exits the nested input loop and the error is thrown.) */
2042 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
2048 /* Add handles of child processes. */
2050 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
2051 /* Some child_procs might be sockets; ignore them. Also some
2052 children may have died already, but we haven't finished reading
2053 the process output; ignore them too. */
2054 if ((CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
2056 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
2057 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
2060 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
2065 /* Nothing to look for, so we didn't find anything */
2073 start_time
= GetTickCount ();
2075 /* Wait for input or child death to be signaled. If user input is
2076 allowed, then also accept window messages. */
2077 if (FD_ISSET (0, &orfds
))
2078 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
2081 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
2083 if (active
== WAIT_FAILED
)
2085 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
2086 nh
+ nc
, timeout_ms
, GetLastError ()));
2087 /* don't return EBADF - this causes wait_reading_process_output to
2088 abort; WAIT_FAILED is returned when single-stepping under
2089 Windows 95 after switching thread focus in debugger, and
2090 possibly at other times. */
2094 else if (active
== WAIT_TIMEOUT
)
2098 else if (active
>= WAIT_OBJECT_0
2099 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
2101 active
-= WAIT_OBJECT_0
;
2103 else if (active
>= WAIT_ABANDONED_0
2104 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
2106 active
-= WAIT_ABANDONED_0
;
2111 /* Loop over all handles after active (now officially documented as
2112 being the first signaled handle in the array). We do this to
2113 ensure fairness, so that all channels with data available will be
2114 processed - otherwise higher numbered channels could be starved. */
2117 if (active
== nh
+ nc
)
2119 /* There are messages in the lisp thread's queue; we must
2120 drain the queue now to ensure they are processed promptly,
2121 because if we don't do so, we will not be woken again until
2122 further messages arrive.
2124 NB. If ever we allow window message procedures to callback
2125 into lisp, we will need to ensure messages are dispatched
2126 at a safe time for lisp code to be run (*), and we may also
2127 want to provide some hooks in the dispatch loop to cater
2128 for modeless dialogs created by lisp (ie. to register
2129 window handles to pass to IsDialogMessage).
2131 (*) Note that MsgWaitForMultipleObjects above is an
2132 internal dispatch point for messages that are sent to
2133 windows created by this thread. */
2134 if (drain_message_queue ()
2135 /* If drain_message_queue returns non-zero, that means
2136 we received a WM_EMACS_FILENOTIFY message. If this
2137 is a TTY frame, we must signal the caller that keyboard
2138 input is available, so that w32_console_read_socket
2139 will be called to pick up the notifications. If we
2140 don't do that, file notifications will only work when
2141 the Emacs TTY frame has focus. */
2142 && FRAME_TERMCAP_P (SELECTED_FRAME ())
2143 /* they asked for stdin reads */
2144 && FD_ISSET (0, &orfds
)
2145 /* the stdin handle is valid */
2153 else if (active
>= nh
)
2155 cp
= cps
[active
- nh
];
2157 /* We cannot always signal SIGCHLD immediately; if we have not
2158 finished reading the process output, we must delay sending
2159 SIGCHLD until we do. */
2161 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
2162 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
2163 /* SIG_DFL for SIGCHLD is ignore */
2164 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
2165 sig_handlers
[SIGCHLD
] != SIG_IGN
)
2168 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2171 sig_handlers
[SIGCHLD
] (SIGCHLD
);
2174 else if (fdindex
[active
] == -1)
2176 /* Quit (C-g) was detected. */
2180 else if (fdindex
[active
] == 0)
2182 /* Keyboard input available */
2188 /* must be a socket or pipe - read ahead should have
2189 completed, either succeeding or failing. */
2190 FD_SET (fdindex
[active
], rfds
);
2194 /* Even though wait_reading_process_output only reads from at most
2195 one channel, we must process all channels here so that we reap
2196 all children that have died. */
2197 while (++active
< nh
+ nc
)
2198 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2200 } while (active
< nh
+ nc
);
2202 /* If no input has arrived and timeout hasn't expired, wait again. */
2205 DWORD elapsed
= GetTickCount () - start_time
;
2207 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2209 if (timeout_ms
!= INFINITE
)
2210 timeout_ms
-= elapsed
;
2211 goto count_children
;
2218 /* Substitute for certain kill () operations */
2220 static BOOL CALLBACK
2221 find_child_console (HWND hwnd
, LPARAM arg
)
2223 child_process
* cp
= (child_process
*) arg
;
2227 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
2228 if (process_id
== cp
->procinfo
.dwProcessId
)
2230 char window_class
[32];
2232 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2233 if (strcmp (window_class
,
2234 (os_subtype
== OS_9X
)
2236 : "ConsoleWindowClass") == 0)
2246 /* Emulate 'kill', but only for other processes. */
2248 sys_kill (pid_t pid
, int sig
)
2252 int need_to_free
= 0;
2255 /* Each process is in its own process group. */
2259 /* Only handle signals that will result in the process dying */
2261 && sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2269 /* It will take _some_ time before PID 4 or less on Windows will
2276 proc_hand
= OpenProcess (PROCESS_QUERY_INFORMATION
, 0, pid
);
2277 if (proc_hand
== NULL
)
2279 DWORD err
= GetLastError ();
2283 case ERROR_ACCESS_DENIED
: /* existing process, but access denied */
2286 case ERROR_INVALID_PARAMETER
: /* process PID does not exist */
2292 CloseHandle (proc_hand
);
2296 cp
= find_child_pid (pid
);
2299 /* We were passed a PID of something other than our subprocess.
2300 If that is our own PID, we will send to ourself a message to
2301 close the selected frame, which does not necessarily
2302 terminates Emacs. But then we are not supposed to call
2303 sys_kill with our own PID. */
2304 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2305 if (proc_hand
== NULL
)
2314 proc_hand
= cp
->procinfo
.hProcess
;
2315 pid
= cp
->procinfo
.dwProcessId
;
2317 /* Try to locate console window for process. */
2318 EnumWindows (find_child_console
, (LPARAM
) cp
);
2321 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2323 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2325 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2326 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2327 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2328 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2329 HWND foreground_window
;
2331 if (break_scan_code
== 0)
2333 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2334 vk_break_code
= 'C';
2335 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2338 foreground_window
= GetForegroundWindow ();
2339 if (foreground_window
)
2341 /* NT 5.0, and apparently also Windows 98, will not allow
2342 a Window to be set to foreground directly without the
2343 user's involvement. The workaround is to attach
2344 ourselves to the thread that owns the foreground
2345 window, since that is the only thread that can set the
2346 foreground window. */
2347 DWORD foreground_thread
, child_thread
;
2349 GetWindowThreadProcessId (foreground_window
, NULL
);
2350 if (foreground_thread
== GetCurrentThreadId ()
2351 || !AttachThreadInput (GetCurrentThreadId (),
2352 foreground_thread
, TRUE
))
2353 foreground_thread
= 0;
2355 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2356 if (child_thread
== GetCurrentThreadId ()
2357 || !AttachThreadInput (GetCurrentThreadId (),
2358 child_thread
, TRUE
))
2361 /* Set the foreground window to the child. */
2362 if (SetForegroundWindow (cp
->hwnd
))
2364 /* Generate keystrokes as if user had typed Ctrl-Break or
2366 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2367 keybd_event (vk_break_code
, break_scan_code
,
2368 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2369 keybd_event (vk_break_code
, break_scan_code
,
2370 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2371 | KEYEVENTF_KEYUP
, 0);
2372 keybd_event (VK_CONTROL
, control_scan_code
,
2373 KEYEVENTF_KEYUP
, 0);
2375 /* Sleep for a bit to give time for Emacs frame to respond
2376 to focus change events (if Emacs was active app). */
2379 SetForegroundWindow (foreground_window
);
2381 /* Detach from the foreground and child threads now that
2382 the foreground switching is over. */
2383 if (foreground_thread
)
2384 AttachThreadInput (GetCurrentThreadId (),
2385 foreground_thread
, FALSE
);
2387 AttachThreadInput (GetCurrentThreadId (),
2388 child_thread
, FALSE
);
2391 /* Ctrl-Break is NT equivalent of SIGINT. */
2392 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2394 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2395 "for pid %lu\n", GetLastError (), pid
));
2402 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2405 if (os_subtype
== OS_9X
)
2408 Another possibility is to try terminating the VDM out-right by
2409 calling the Shell VxD (id 0x17) V86 interface, function #4
2410 "SHELL_Destroy_VM", ie.
2416 First need to determine the current VM handle, and then arrange for
2417 the shellapi call to be made from the system vm (by using
2418 Switch_VM_and_callback).
2420 Could try to invoke DestroyVM through CallVxD.
2424 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2425 to hang when cmdproxy is used in conjunction with
2426 command.com for an interactive shell. Posting
2427 WM_CLOSE pops up a dialog that, when Yes is selected,
2428 does the same thing. TerminateProcess is also less
2429 than ideal in that subprocesses tend to stick around
2430 until the machine is shutdown, but at least it
2431 doesn't freeze the 16-bit subsystem. */
2432 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2434 if (!TerminateProcess (proc_hand
, 0xff))
2436 DebPrint (("sys_kill.TerminateProcess returned %d "
2437 "for pid %lu\n", GetLastError (), pid
));
2444 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2446 /* Kill the process. On W32 this doesn't kill child processes
2447 so it doesn't work very well for shells which is why it's not
2448 used in every case. */
2449 else if (!TerminateProcess (proc_hand
, 0xff))
2451 DebPrint (("sys_kill.TerminateProcess returned %d "
2452 "for pid %lu\n", GetLastError (), pid
));
2459 CloseHandle (proc_hand
);
2464 /* The following two routines are used to manipulate stdin, stdout, and
2465 stderr of our child processes.
2467 Assuming that in, out, and err are *not* inheritable, we make them
2468 stdin, stdout, and stderr of the child as follows:
2470 - Save the parent's current standard handles.
2471 - Set the std handles to inheritable duplicates of the ones being passed in.
2472 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2473 NT file handle for a crt file descriptor.)
2474 - Spawn the child, which inherits in, out, and err as stdin,
2475 stdout, and stderr. (see Spawnve)
2476 - Close the std handles passed to the child.
2477 - Reset the parent's standard handles to the saved handles.
2478 (see reset_standard_handles)
2479 We assume that the caller closes in, out, and err after calling us. */
2482 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2485 HANDLE newstdin
, newstdout
, newstderr
;
2487 parent
= GetCurrentProcess ();
2489 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2490 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2491 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2493 /* make inheritable copies of the new handles */
2494 if (!DuplicateHandle (parent
,
2495 (HANDLE
) _get_osfhandle (in
),
2500 DUPLICATE_SAME_ACCESS
))
2501 report_file_error ("Duplicating input handle for child", Qnil
);
2503 if (!DuplicateHandle (parent
,
2504 (HANDLE
) _get_osfhandle (out
),
2509 DUPLICATE_SAME_ACCESS
))
2510 report_file_error ("Duplicating output handle for child", Qnil
);
2512 if (!DuplicateHandle (parent
,
2513 (HANDLE
) _get_osfhandle (err
),
2518 DUPLICATE_SAME_ACCESS
))
2519 report_file_error ("Duplicating error handle for child", Qnil
);
2521 /* and store them as our std handles */
2522 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2523 report_file_error ("Changing stdin handle", Qnil
);
2525 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2526 report_file_error ("Changing stdout handle", Qnil
);
2528 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2529 report_file_error ("Changing stderr handle", Qnil
);
2533 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2535 /* close the duplicated handles passed to the child */
2536 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2537 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2538 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2540 /* now restore parent's saved std handles */
2541 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2542 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2543 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2547 set_process_dir (char * dir
)
2552 /* To avoid problems with winsock implementations that work over dial-up
2553 connections causing or requiring a connection to exist while Emacs is
2554 running, Emacs no longer automatically loads winsock on startup if it
2555 is present. Instead, it will be loaded when open-network-stream is
2558 To allow full control over when winsock is loaded, we provide these
2559 two functions to dynamically load and unload winsock. This allows
2560 dial-up users to only be connected when they actually need to use
2564 extern HANDLE winsock_lib
;
2565 extern BOOL
term_winsock (void);
2566 extern BOOL
init_winsock (int load_now
);
2568 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2569 doc
: /* Test for presence of the Windows socket library `winsock'.
2570 Returns non-nil if winsock support is present, nil otherwise.
2572 If the optional argument LOAD-NOW is non-nil, the winsock library is
2573 also loaded immediately if not already loaded. If winsock is loaded,
2574 the winsock local hostname is returned (since this may be different from
2575 the value of `system-name' and should supplant it), otherwise t is
2576 returned to indicate winsock support is present. */)
2577 (Lisp_Object load_now
)
2581 have_winsock
= init_winsock (!NILP (load_now
));
2584 if (winsock_lib
!= NULL
)
2586 /* Return new value for system-name. The best way to do this
2587 is to call init_system_name, saving and restoring the
2588 original value to avoid side-effects. */
2589 Lisp_Object orig_hostname
= Vsystem_name
;
2590 Lisp_Object hostname
;
2592 init_system_name ();
2593 hostname
= Vsystem_name
;
2594 Vsystem_name
= orig_hostname
;
2602 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2604 doc
: /* Unload the Windows socket library `winsock' if loaded.
2605 This is provided to allow dial-up socket connections to be disconnected
2606 when no longer needed. Returns nil without unloading winsock if any
2607 socket connections still exist. */)
2610 return term_winsock () ? Qt
: Qnil
;
2614 /* Some miscellaneous functions that are Windows specific, but not GUI
2615 specific (ie. are applicable in terminal or batch mode as well). */
2617 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2618 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2619 If FILENAME does not exist, return nil.
2620 All path elements in FILENAME are converted to their short names. */)
2621 (Lisp_Object filename
)
2623 char shortname
[MAX_PATH
];
2625 CHECK_STRING (filename
);
2627 /* first expand it. */
2628 filename
= Fexpand_file_name (filename
, Qnil
);
2630 /* luckily, this returns the short version of each element in the path. */
2631 if (w32_get_short_filename (SDATA (ENCODE_FILE (filename
)),
2632 shortname
, MAX_PATH
) == 0)
2635 dostounix_filename (shortname
);
2637 /* No need to DECODE_FILE, because 8.3 names are pure ASCII. */
2638 return build_string (shortname
);
2642 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2644 doc
: /* Return the long file name version of the full path of FILENAME.
2645 If FILENAME does not exist, return nil.
2646 All path elements in FILENAME are converted to their long names. */)
2647 (Lisp_Object filename
)
2649 char longname
[ MAX_UTF8_PATH
];
2652 CHECK_STRING (filename
);
2654 if (SBYTES (filename
) == 2
2655 && *(SDATA (filename
) + 1) == ':')
2658 /* first expand it. */
2659 filename
= Fexpand_file_name (filename
, Qnil
);
2661 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
,
2665 dostounix_filename (longname
);
2667 /* If we were passed only a drive, make sure that a slash is not appended
2668 for consistency with directories. Allow for drive mapping via SUBST
2669 in case expand-file-name is ever changed to expand those. */
2670 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2673 return DECODE_FILE (build_unibyte_string (longname
));
2676 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2677 Sw32_set_process_priority
, 2, 2, 0,
2678 doc
: /* Set the priority of PROCESS to PRIORITY.
2679 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2680 priority of the process whose pid is PROCESS is changed.
2681 PRIORITY should be one of the symbols high, normal, or low;
2682 any other symbol will be interpreted as normal.
2684 If successful, the return value is t, otherwise nil. */)
2685 (Lisp_Object process
, Lisp_Object priority
)
2687 HANDLE proc_handle
= GetCurrentProcess ();
2688 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2689 Lisp_Object result
= Qnil
;
2691 CHECK_SYMBOL (priority
);
2693 if (!NILP (process
))
2698 CHECK_NUMBER (process
);
2700 /* Allow pid to be an internally generated one, or one obtained
2701 externally. This is necessary because real pids on Windows 95 are
2704 pid
= XINT (process
);
2705 cp
= find_child_pid (pid
);
2707 pid
= cp
->procinfo
.dwProcessId
;
2709 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2712 if (EQ (priority
, Qhigh
))
2713 priority_class
= HIGH_PRIORITY_CLASS
;
2714 else if (EQ (priority
, Qlow
))
2715 priority_class
= IDLE_PRIORITY_CLASS
;
2717 if (proc_handle
!= NULL
)
2719 if (SetPriorityClass (proc_handle
, priority_class
))
2721 if (!NILP (process
))
2722 CloseHandle (proc_handle
);
2728 #ifdef HAVE_LANGINFO_CODESET
2729 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2731 nl_langinfo (nl_item item
)
2733 /* Conversion of Posix item numbers to their Windows equivalents. */
2734 static const LCTYPE w32item
[] = {
2735 LOCALE_IDEFAULTANSICODEPAGE
,
2736 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2737 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2738 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2739 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2740 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2741 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2744 static char *nl_langinfo_buf
= NULL
;
2745 static int nl_langinfo_len
= 0;
2747 if (nl_langinfo_len
<= 0)
2748 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2750 if (item
< 0 || item
>= _NL_NUM
)
2751 nl_langinfo_buf
[0] = 0;
2754 LCID cloc
= GetThreadLocale ();
2755 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2759 nl_langinfo_buf
[0] = 0;
2762 if (item
== CODESET
)
2764 need_len
+= 2; /* for the "cp" prefix */
2765 if (need_len
< 8) /* for the case we call GetACP */
2768 if (nl_langinfo_len
<= need_len
)
2769 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2770 nl_langinfo_len
= need_len
);
2771 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2772 nl_langinfo_buf
, nl_langinfo_len
))
2773 nl_langinfo_buf
[0] = 0;
2774 else if (item
== CODESET
)
2776 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2777 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2778 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2781 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2782 strlen (nl_langinfo_buf
) + 1);
2783 nl_langinfo_buf
[0] = 'c';
2784 nl_langinfo_buf
[1] = 'p';
2789 return nl_langinfo_buf
;
2791 #endif /* HAVE_LANGINFO_CODESET */
2793 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2794 Sw32_get_locale_info
, 1, 2, 0,
2795 doc
: /* Return information about the Windows locale LCID.
2796 By default, return a three letter locale code which encodes the default
2797 language as the first two characters, and the country or regional variant
2798 as the third letter. For example, ENU refers to `English (United States)',
2799 while ENC means `English (Canadian)'.
2801 If the optional argument LONGFORM is t, the long form of the locale
2802 name is returned, e.g. `English (United States)' instead; if LONGFORM
2803 is a number, it is interpreted as an LCTYPE constant and the corresponding
2804 locale information is returned.
2806 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2807 (Lisp_Object lcid
, Lisp_Object longform
)
2811 char abbrev_name
[32] = { 0 };
2812 char full_name
[256] = { 0 };
2814 CHECK_NUMBER (lcid
);
2816 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2819 if (NILP (longform
))
2821 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2822 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2823 abbrev_name
, sizeof (abbrev_name
));
2825 return build_string (abbrev_name
);
2827 else if (EQ (longform
, Qt
))
2829 got_full
= GetLocaleInfo (XINT (lcid
),
2830 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2831 full_name
, sizeof (full_name
));
2833 return DECODE_SYSTEM (build_string (full_name
));
2835 else if (NUMBERP (longform
))
2837 got_full
= GetLocaleInfo (XINT (lcid
),
2839 full_name
, sizeof (full_name
));
2840 /* GetLocaleInfo's return value includes the terminating null
2841 character, when the returned information is a string, whereas
2842 make_unibyte_string needs the string length without the
2843 terminating null. */
2845 return make_unibyte_string (full_name
, got_full
- 1);
2852 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
2853 Sw32_get_current_locale_id
, 0, 0, 0,
2854 doc
: /* Return Windows locale id for current locale setting.
2855 This is a numerical value; use `w32-get-locale-info' to convert to a
2856 human-readable form. */)
2859 return make_number (GetThreadLocale ());
2863 int_from_hex (char * s
)
2866 static char hex
[] = "0123456789abcdefABCDEF";
2869 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2871 unsigned digit
= p
- hex
;
2874 val
= val
* 16 + digit
;
2880 /* We need to build a global list, since the EnumSystemLocale callback
2881 function isn't given a context pointer. */
2882 Lisp_Object Vw32_valid_locale_ids
;
2884 static BOOL CALLBACK
2885 enum_locale_fn (LPTSTR localeNum
)
2887 DWORD id
= int_from_hex (localeNum
);
2888 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2892 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2893 Sw32_get_valid_locale_ids
, 0, 0, 0,
2894 doc
: /* Return list of all valid Windows locale ids.
2895 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2896 human-readable form. */)
2899 Vw32_valid_locale_ids
= Qnil
;
2901 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2903 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2904 return Vw32_valid_locale_ids
;
2908 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2909 doc
: /* Return Windows locale id for default locale setting.
2910 By default, the system default locale setting is returned; if the optional
2911 parameter USERP is non-nil, the user default locale setting is returned.
2912 This is a numerical value; use `w32-get-locale-info' to convert to a
2913 human-readable form. */)
2917 return make_number (GetSystemDefaultLCID ());
2918 return make_number (GetUserDefaultLCID ());
2922 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
2923 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
2924 If successful, the new locale id is returned, otherwise nil. */)
2927 CHECK_NUMBER (lcid
);
2929 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2932 if (!SetThreadLocale (XINT (lcid
)))
2935 /* Need to set input thread locale if present. */
2936 if (dwWindowsThreadId
)
2937 /* Reply is not needed. */
2938 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
2940 return make_number (GetThreadLocale ());
2944 /* We need to build a global list, since the EnumCodePages callback
2945 function isn't given a context pointer. */
2946 Lisp_Object Vw32_valid_codepages
;
2948 static BOOL CALLBACK
2949 enum_codepage_fn (LPTSTR codepageNum
)
2951 DWORD id
= atoi (codepageNum
);
2952 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
2956 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
2957 Sw32_get_valid_codepages
, 0, 0, 0,
2958 doc
: /* Return list of all valid Windows codepages. */)
2961 Vw32_valid_codepages
= Qnil
;
2963 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
2965 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
2966 return Vw32_valid_codepages
;
2970 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
2971 Sw32_get_console_codepage
, 0, 0, 0,
2972 doc
: /* Return current Windows codepage for console input. */)
2975 return make_number (GetConsoleCP ());
2979 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
2980 Sw32_set_console_codepage
, 1, 1, 0,
2981 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
2982 This codepage setting affects keyboard input in tty mode.
2983 If successful, the new CP is returned, otherwise nil. */)
2988 if (!IsValidCodePage (XINT (cp
)))
2991 if (!SetConsoleCP (XINT (cp
)))
2994 return make_number (GetConsoleCP ());
2998 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
2999 Sw32_get_console_output_codepage
, 0, 0, 0,
3000 doc
: /* Return current Windows codepage for console output. */)
3003 return make_number (GetConsoleOutputCP ());
3007 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
3008 Sw32_set_console_output_codepage
, 1, 1, 0,
3009 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
3010 This codepage setting affects display in tty mode.
3011 If successful, the new CP is returned, otherwise nil. */)
3016 if (!IsValidCodePage (XINT (cp
)))
3019 if (!SetConsoleOutputCP (XINT (cp
)))
3022 return make_number (GetConsoleOutputCP ());
3026 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
3027 Sw32_get_codepage_charset
, 1, 1, 0,
3028 doc
: /* Return charset ID corresponding to codepage CP.
3029 Returns nil if the codepage is not valid. */)
3036 if (!IsValidCodePage (XINT (cp
)))
3039 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
3040 return make_number (info
.ciCharset
);
3046 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
3047 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
3048 doc
: /* Return list of Windows keyboard languages and layouts.
3049 The return value is a list of pairs of language id and layout id. */)
3052 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
3053 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
3054 Lisp_Object obj
= Qnil
;
3056 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
3058 while (--num_layouts
>= 0)
3060 DWORD kl
= (DWORD
) layouts
[num_layouts
];
3062 obj
= Fcons (Fcons (make_number (kl
& 0xffff),
3063 make_number ((kl
>> 16) & 0xffff)),
3072 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
3073 Sw32_get_keyboard_layout
, 0, 0, 0,
3074 doc
: /* Return current Windows keyboard language and layout.
3075 The return value is the cons of the language id and the layout id. */)
3078 DWORD kl
= (DWORD
) GetKeyboardLayout (dwWindowsThreadId
);
3080 return Fcons (make_number (kl
& 0xffff),
3081 make_number ((kl
>> 16) & 0xffff));
3085 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
3086 Sw32_set_keyboard_layout
, 1, 1, 0,
3087 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
3088 The keyboard layout setting affects interpretation of keyboard input.
3089 If successful, the new layout id is returned, otherwise nil. */)
3090 (Lisp_Object layout
)
3094 CHECK_CONS (layout
);
3095 CHECK_NUMBER_CAR (layout
);
3096 CHECK_NUMBER_CDR (layout
);
3098 kl
= (XINT (XCAR (layout
)) & 0xffff)
3099 | (XINT (XCDR (layout
)) << 16);
3101 /* Synchronize layout with input thread. */
3102 if (dwWindowsThreadId
)
3104 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
3108 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3110 if (msg
.wParam
== 0)
3114 else if (!ActivateKeyboardLayout ((HKL
) kl
, 0))
3117 return Fw32_get_keyboard_layout ();
3122 syms_of_ntproc (void)
3124 DEFSYM (Qhigh
, "high");
3125 DEFSYM (Qlow
, "low");
3127 defsubr (&Sw32_has_winsock
);
3128 defsubr (&Sw32_unload_winsock
);
3130 defsubr (&Sw32_short_file_name
);
3131 defsubr (&Sw32_long_file_name
);
3132 defsubr (&Sw32_set_process_priority
);
3133 defsubr (&Sw32_get_locale_info
);
3134 defsubr (&Sw32_get_current_locale_id
);
3135 defsubr (&Sw32_get_default_locale_id
);
3136 defsubr (&Sw32_get_valid_locale_ids
);
3137 defsubr (&Sw32_set_current_locale
);
3139 defsubr (&Sw32_get_console_codepage
);
3140 defsubr (&Sw32_set_console_codepage
);
3141 defsubr (&Sw32_get_console_output_codepage
);
3142 defsubr (&Sw32_set_console_output_codepage
);
3143 defsubr (&Sw32_get_valid_codepages
);
3144 defsubr (&Sw32_get_codepage_charset
);
3146 defsubr (&Sw32_get_valid_keyboard_layouts
);
3147 defsubr (&Sw32_get_keyboard_layout
);
3148 defsubr (&Sw32_set_keyboard_layout
);
3150 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
3151 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
3152 Because Windows does not directly pass argv arrays to child processes,
3153 programs have to reconstruct the argv array by parsing the command
3154 line string. For an argument to contain a space, it must be enclosed
3155 in double quotes or it will be parsed as multiple arguments.
3157 If the value is a character, that character will be used to escape any
3158 quote characters that appear, otherwise a suitable escape character
3159 will be chosen based on the type of the program. */);
3160 Vw32_quote_process_args
= Qt
;
3162 DEFVAR_LISP ("w32-start-process-show-window",
3163 Vw32_start_process_show_window
,
3164 doc
: /* When nil, new child processes hide their windows.
3165 When non-nil, they show their window in the method of their choice.
3166 This variable doesn't affect GUI applications, which will never be hidden. */);
3167 Vw32_start_process_show_window
= Qnil
;
3169 DEFVAR_LISP ("w32-start-process-share-console",
3170 Vw32_start_process_share_console
,
3171 doc
: /* When nil, new child processes are given a new console.
3172 When non-nil, they share the Emacs console; this has the limitation of
3173 allowing only one DOS subprocess to run at a time (whether started directly
3174 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
3175 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3176 otherwise respond to interrupts from Emacs. */);
3177 Vw32_start_process_share_console
= Qnil
;
3179 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3180 Vw32_start_process_inherit_error_mode
,
3181 doc
: /* When nil, new child processes revert to the default error mode.
3182 When non-nil, they inherit their error mode setting from Emacs, which stops
3183 them blocking when trying to access unmounted drives etc. */);
3184 Vw32_start_process_inherit_error_mode
= Qt
;
3186 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
3187 doc
: /* Forced delay before reading subprocess output.
3188 This is done to improve the buffering of subprocess output, by
3189 avoiding the inefficiency of frequently reading small amounts of data.
3191 If positive, the value is the number of milliseconds to sleep before
3192 reading the subprocess output. If negative, the magnitude is the number
3193 of time slices to wait (effectively boosting the priority of the child
3194 process temporarily). A value of zero disables waiting entirely. */);
3195 w32_pipe_read_delay
= 50;
3197 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
3198 doc
: /* Non-nil means convert all-upper case file names to lower case.
3199 This applies when performing completions and file name expansion.
3200 Note that the value of this setting also affects remote file names,
3201 so you probably don't want to set to non-nil if you use case-sensitive
3202 filesystems via ange-ftp. */);
3203 Vw32_downcase_file_names
= Qnil
;
3206 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
3207 doc
: /* Non-nil means attempt to fake realistic inode values.
3208 This works by hashing the truename of files, and should detect
3209 aliasing between long and short (8.3 DOS) names, but can have
3210 false positives because of hash collisions. Note that determining
3211 the truename of a file can be slow. */);
3212 Vw32_generate_fake_inodes
= Qnil
;
3215 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
3216 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
3217 This option controls whether to issue additional system calls to determine
3218 accurate link counts, file type, and ownership information. It is more
3219 useful for files on NTFS volumes, where hard links and file security are
3220 supported, than on volumes of the FAT family.
3222 Without these system calls, link count will always be reported as 1 and file
3223 ownership will be attributed to the current user.
3224 The default value `local' means only issue these system calls for files
3225 on local fixed drives. A value of nil means never issue them.
3226 Any other non-nil value means do this even on remote and removable drives
3227 where the performance impact may be noticeable even on modern hardware. */);
3228 Vw32_get_true_file_attributes
= Qlocal
;
3230 staticpro (&Vw32_valid_locale_ids
);
3231 staticpro (&Vw32_valid_codepages
);
3233 /* end of w32proc.c */