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>
34 /* must include CRT headers *before* config.h */
45 /* This definition is missing from mingw32 headers. */
46 extern BOOL WINAPI
IsValidLocale (LCID
, DWORD
);
49 #ifdef HAVE_LANGINFO_CODESET
56 #include "w32common.h"
61 #include "syssignal.h"
63 #include "dispextern.h" /* for xstrcasecmp */
66 #define RVA_TO_PTR(var,section,filedata) \
67 ((void *)((section)->PointerToRawData \
68 + ((DWORD_PTR)(var) - (section)->VirtualAddress) \
69 + (filedata).file_base))
71 Lisp_Object Qhigh
, Qlow
;
73 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
74 static signal_handler sig_handlers
[NSIG
];
76 static sigset_t sig_mask
;
78 static CRITICAL_SECTION crit_sig
;
80 /* Improve on the CRT 'signal' implementation so that we could record
81 the SIGCHLD handler and fake interval timers. */
83 sys_signal (int sig
, signal_handler handler
)
87 /* SIGCHLD is needed for supporting subprocesses, see sys_kill
88 below. SIGALRM and SIGPROF are used by setitimer. All the
89 others are the only ones supported by the MS runtime. */
90 if (!(sig
== SIGCHLD
|| sig
== SIGSEGV
|| sig
== SIGILL
91 || sig
== SIGFPE
|| sig
== SIGABRT
|| sig
== SIGTERM
92 || sig
== SIGALRM
|| sig
== SIGPROF
))
97 old
= sig_handlers
[sig
];
98 /* SIGABRT is treated specially because w32.c installs term_ntproc
99 as its handler, so we don't want to override that afterwards.
100 Aborting Emacs works specially anyway: either by calling
101 emacs_abort directly or through terminate_due_to_signal, which
102 calls emacs_abort through emacs_raise. */
103 if (!(sig
== SIGABRT
&& old
== term_ntproc
))
105 sig_handlers
[sig
] = handler
;
106 if (!(sig
== SIGCHLD
|| sig
== SIGALRM
|| sig
== SIGPROF
))
107 signal (sig
, handler
);
112 /* Emulate sigaction. */
114 sigaction (int sig
, const struct sigaction
*act
, struct sigaction
*oact
)
116 signal_handler old
= SIG_DFL
;
120 old
= sys_signal (sig
, act
->sa_handler
);
122 old
= sig_handlers
[sig
];
131 oact
->sa_handler
= old
;
133 oact
->sa_mask
= empty_mask
;
138 /* Emulate signal sets and blocking of signals used by timers. */
141 sigemptyset (sigset_t
*set
)
148 sigaddset (sigset_t
*set
, int signo
)
155 if (signo
< 0 || signo
>= NSIG
)
161 *set
|= (1U << signo
);
167 sigfillset (sigset_t
*set
)
180 sigprocmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
182 if (!(how
== SIG_BLOCK
|| how
== SIG_UNBLOCK
|| how
== SIG_SETMASK
))
203 /* FIXME: Catch signals that are blocked and reissue them when
204 they are unblocked. Important for SIGALRM and SIGPROF only. */
213 pthread_sigmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
215 if (sigprocmask (how
, set
, oset
) == -1)
221 sigismember (const sigset_t
*set
, int signo
)
223 if (signo
< 0 || signo
>= NSIG
)
228 if (signo
> sizeof (*set
) * BITS_PER_CHAR
)
231 return (*set
& (1U << signo
)) != 0;
247 setpgid (pid_t pid
, pid_t pgid
)
258 /* Emulations of interval timers.
260 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
262 Implementation: a separate thread is started for each timer type,
263 the thread calls the appropriate signal handler when the timer
264 expires, after stopping the thread which installed the timer. */
267 volatile ULONGLONG expire
;
268 volatile ULONGLONG reload
;
269 volatile int terminate
;
271 HANDLE caller_thread
;
275 static ULONGLONG ticks_now
;
276 static struct itimer_data real_itimer
, prof_itimer
;
277 static ULONGLONG clocks_min
;
278 /* If non-zero, itimers are disabled. Used during shutdown, when we
279 delete the critical sections used by the timer threads. */
280 static int disable_itimers
;
282 static CRITICAL_SECTION crit_real
, crit_prof
;
284 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
285 typedef BOOL (WINAPI
*GetThreadTimes_Proc
) (
287 LPFILETIME lpCreationTime
,
288 LPFILETIME lpExitTime
,
289 LPFILETIME lpKernelTime
,
290 LPFILETIME lpUserTime
);
292 static GetThreadTimes_Proc s_pfn_Get_Thread_Times
;
294 #define MAX_SINGLE_SLEEP 30
295 #define TIMER_TICKS_PER_SEC 1000
297 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
298 to a thread. If THREAD is NULL or an invalid handle, return the
299 current wall-clock time since January 1, 1601 (UTC). Otherwise,
300 return the sum of kernel and user times used by THREAD since it was
301 created, plus its creation time. */
303 w32_get_timer_time (HANDLE thread
)
306 int use_system_time
= 1;
307 /* The functions below return times in 100-ns units. */
308 const int tscale
= 10 * TIMER_TICKS_PER_SEC
;
310 if (thread
&& thread
!= INVALID_HANDLE_VALUE
311 && s_pfn_Get_Thread_Times
!= NULL
)
313 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
314 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
316 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
317 &kernel_ftime
, &user_ftime
))
320 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
321 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
322 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
323 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
324 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
325 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
327 temp_creation
.QuadPart
/ tscale
+ temp_kernel
.QuadPart
/ tscale
328 + temp_user
.QuadPart
/ tscale
;
331 DebPrint (("GetThreadTimes failed with error code %lu\n",
337 FILETIME current_ftime
;
340 GetSystemTimeAsFileTime (¤t_ftime
);
342 temp
.LowPart
= current_ftime
.dwLowDateTime
;
343 temp
.HighPart
= current_ftime
.dwHighDateTime
;
345 retval
= temp
.QuadPart
/ tscale
;
351 /* Thread function for a timer thread. */
353 timer_loop (LPVOID arg
)
355 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
356 int which
= itimer
->type
;
357 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
358 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
359 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / TIMER_TICKS_PER_SEC
;
360 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
365 signal_handler handler
;
366 ULONGLONG now
, expire
, reload
;
368 /* Load new values if requested by setitimer. */
369 EnterCriticalSection (crit
);
370 expire
= itimer
->expire
;
371 reload
= itimer
->reload
;
372 LeaveCriticalSection (crit
);
373 if (itimer
->terminate
)
383 if (expire
> (now
= w32_get_timer_time (hth
)))
384 sleep_time
= expire
- now
;
387 /* Don't sleep too long at a time, to be able to see the
388 termination flag without too long a delay. */
389 while (sleep_time
> max_sleep
)
391 if (itimer
->terminate
)
394 EnterCriticalSection (crit
);
395 expire
= itimer
->expire
;
396 LeaveCriticalSection (crit
);
398 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
400 if (itimer
->terminate
)
404 Sleep (sleep_time
* 1000 / TIMER_TICKS_PER_SEC
);
405 /* Always sleep past the expiration time, to make sure we
406 never call the handler _before_ the expiration time,
407 always slightly after it. Sleep(5) makes sure we don't
408 hog the CPU by calling 'w32_get_timer_time' with high
409 frequency, and also let other threads work. */
410 while (w32_get_timer_time (hth
) < expire
)
414 EnterCriticalSection (crit
);
415 expire
= itimer
->expire
;
416 LeaveCriticalSection (crit
);
421 handler
= sig_handlers
[sig
];
422 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
423 /* FIXME: Don't ignore masked signals. Instead, record that
424 they happened and reissue them when the signal is
426 && !sigismember (&sig_mask
, sig
)
427 /* Simulate masking of SIGALRM and SIGPROF when processing
429 && !fatal_error_in_progress
430 && itimer
->caller_thread
)
432 /* Simulate a signal delivered to the thread which installed
433 the timer, by suspending that thread while the handler
435 HANDLE th
= itimer
->caller_thread
;
436 DWORD result
= SuspendThread (th
);
438 if (result
== (DWORD
)-1)
445 /* Update expiration time and loop. */
446 EnterCriticalSection (crit
);
447 expire
= itimer
->expire
;
450 LeaveCriticalSection (crit
);
453 reload
= itimer
->reload
;
456 now
= w32_get_timer_time (hth
);
459 ULONGLONG lag
= now
- expire
;
461 /* If we missed some opportunities (presumably while
462 sleeping or while the signal handler ran), skip
465 expire
= now
- (lag
% reload
);
471 expire
= 0; /* become idle */
472 itimer
->expire
= expire
;
473 LeaveCriticalSection (crit
);
479 stop_timer_thread (int which
)
481 struct itimer_data
*itimer
=
482 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
484 DWORD err
, exit_code
= 255;
487 /* Signal the thread that it should terminate. */
488 itimer
->terminate
= 1;
490 if (itimer
->timer_thread
== NULL
)
493 /* Wait for the timer thread to terminate voluntarily, then kill it
494 if it doesn't. This loop waits twice more than the maximum
495 amount of time a timer thread sleeps, see above. */
496 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
498 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
499 && exit_code
== STILL_ACTIVE
))
503 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
504 || exit_code
== STILL_ACTIVE
)
506 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
507 TerminateThread (itimer
->timer_thread
, 0);
511 CloseHandle (itimer
->timer_thread
);
512 itimer
->timer_thread
= NULL
;
513 if (itimer
->caller_thread
)
515 CloseHandle (itimer
->caller_thread
);
516 itimer
->caller_thread
= NULL
;
520 /* This is called at shutdown time from term_ntproc. */
524 if (real_itimer
.timer_thread
)
525 stop_timer_thread (ITIMER_REAL
);
526 if (prof_itimer
.timer_thread
)
527 stop_timer_thread (ITIMER_PROF
);
529 /* We are going to delete the critical sections, so timers cannot
533 DeleteCriticalSection (&crit_real
);
534 DeleteCriticalSection (&crit_prof
);
535 DeleteCriticalSection (&crit_sig
);
538 /* This is called at initialization time from init_ntproc. */
542 /* GetThreadTimes is not available on all versions of Windows, so
543 need to probe for its availability dynamically, and call it
544 through a pointer. */
545 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
546 if (os_subtype
!= OS_9X
)
547 s_pfn_Get_Thread_Times
=
548 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
551 /* Make sure we start with zeroed out itimer structures, since
552 dumping may have left there traces of threads long dead. */
553 memset (&real_itimer
, 0, sizeof real_itimer
);
554 memset (&prof_itimer
, 0, sizeof prof_itimer
);
556 InitializeCriticalSection (&crit_real
);
557 InitializeCriticalSection (&crit_prof
);
558 InitializeCriticalSection (&crit_sig
);
564 start_timer_thread (int which
)
568 struct itimer_data
*itimer
=
569 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
571 if (itimer
->timer_thread
572 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
573 && exit_code
== STILL_ACTIVE
)
576 /* Clean up after possibly exited thread. */
577 if (itimer
->timer_thread
)
579 CloseHandle (itimer
->timer_thread
);
580 itimer
->timer_thread
= NULL
;
582 if (itimer
->caller_thread
)
584 CloseHandle (itimer
->caller_thread
);
585 itimer
->caller_thread
= NULL
;
588 /* Start a new thread. */
589 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
590 GetCurrentProcess (), &th
, 0, FALSE
,
591 DUPLICATE_SAME_ACCESS
))
596 itimer
->terminate
= 0;
597 itimer
->type
= which
;
598 itimer
->caller_thread
= th
;
599 /* Request that no more than 64KB of stack be reserved for this
600 thread, to avoid reserving too much memory, which would get in
601 the way of threads we start to wait for subprocesses. See also
603 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
604 (void *)itimer
, 0x00010000, NULL
);
606 if (!itimer
->timer_thread
)
608 CloseHandle (itimer
->caller_thread
);
609 itimer
->caller_thread
= NULL
;
614 /* This is needed to make sure that the timer thread running for
615 profiling gets CPU as soon as the Sleep call terminates. */
616 if (which
== ITIMER_PROF
)
617 SetThreadPriority (itimer
->timer_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
622 /* Most of the code of getitimer and setitimer (but not of their
623 subroutines) was shamelessly stolen from itimer.c in the DJGPP
624 library, see www.delorie.com/djgpp. */
626 getitimer (int which
, struct itimerval
*value
)
628 volatile ULONGLONG
*t_expire
;
629 volatile ULONGLONG
*t_reload
;
630 ULONGLONG expire
, reload
;
632 CRITICAL_SECTION
*crit
;
633 struct itimer_data
*itimer
;
644 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
650 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
652 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
654 : GetCurrentThread ());
656 t_expire
= &itimer
->expire
;
657 t_reload
= &itimer
->reload
;
658 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
660 EnterCriticalSection (crit
);
663 LeaveCriticalSection (crit
);
668 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
670 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
671 value
->it_value
.tv_usec
= usecs
;
672 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
674 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
675 value
->it_interval
.tv_usec
= usecs
;
681 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
683 volatile ULONGLONG
*t_expire
, *t_reload
;
684 ULONGLONG expire
, reload
, expire_old
, reload_old
;
686 CRITICAL_SECTION
*crit
;
687 struct itimerval tem
, *ptem
;
692 /* Posix systems expect timer values smaller than the resolution of
693 the system clock be rounded up to the clock resolution. First
694 time we are called, measure the clock tick resolution. */
699 for (t1
= w32_get_timer_time (NULL
);
700 (t2
= w32_get_timer_time (NULL
)) == t1
; )
702 clocks_min
= t2
- t1
;
710 if (getitimer (which
, ptem
)) /* also sets ticks_now */
711 return -1; /* errno already set */
714 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
716 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
718 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
721 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
723 EnterCriticalSection (crit
);
724 /* Disable the timer. */
727 LeaveCriticalSection (crit
);
731 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
733 usecs
= value
->it_interval
.tv_usec
;
734 if (value
->it_interval
.tv_sec
== 0
735 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
739 usecs
*= TIMER_TICKS_PER_SEC
;
740 reload
+= usecs
/ 1000000;
743 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
744 usecs
= value
->it_value
.tv_usec
;
745 if (value
->it_value
.tv_sec
== 0
746 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
750 usecs
*= TIMER_TICKS_PER_SEC
;
751 expire
+= usecs
/ 1000000;
756 EnterCriticalSection (crit
);
757 expire_old
= *t_expire
;
758 reload_old
= *t_reload
;
759 if (!(expire
== expire_old
&& reload
== reload_old
))
764 LeaveCriticalSection (crit
);
766 return start_timer_thread (which
);
772 #ifdef HAVE_SETITIMER
773 struct itimerval new_values
, old_values
;
775 new_values
.it_value
.tv_sec
= seconds
;
776 new_values
.it_value
.tv_usec
= 0;
777 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
779 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
781 return old_values
.it_value
.tv_sec
;
787 /* Defined in <process.h> which conflicts with the local copy */
790 /* Child process management list. */
791 int child_proc_count
= 0;
792 child_process child_procs
[ MAX_CHILDREN
];
794 static DWORD WINAPI
reader_thread (void *arg
);
796 /* Find an unused process slot. */
803 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
804 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
806 if (child_proc_count
== MAX_CHILDREN
)
809 child_process
*dead_cp
= NULL
;
811 DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
812 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
813 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
817 if (!GetExitCodeProcess (cp
->procinfo
.hProcess
, &status
))
819 DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
820 GetLastError (), cp
->procinfo
.dwProcessId
));
821 status
= STILL_ACTIVE
;
823 if (status
!= STILL_ACTIVE
824 || WaitForSingleObject (cp
->procinfo
.hProcess
, 0) == WAIT_OBJECT_0
)
826 DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
827 cp
->procinfo
.dwProcessId
, cp
->fd
));
828 CloseHandle (cp
->procinfo
.hProcess
);
829 cp
->procinfo
.hProcess
= NULL
;
830 CloseHandle (cp
->procinfo
.hThread
);
831 cp
->procinfo
.hThread
= NULL
;
832 /* Free up to 2 dead slots at a time, so that if we
833 have a lot of them, they will eventually all be
834 freed when the tornado ends. */
848 if (child_proc_count
== MAX_CHILDREN
)
850 cp
= &child_procs
[child_proc_count
++];
853 /* Last opportunity to avoid leaking handles before we forget them
855 if (cp
->procinfo
.hProcess
)
856 CloseHandle (cp
->procinfo
.hProcess
);
857 if (cp
->procinfo
.hThread
)
858 CloseHandle (cp
->procinfo
.hThread
);
859 memset (cp
, 0, sizeof (*cp
));
862 cp
->procinfo
.hProcess
= NULL
;
863 cp
->status
= STATUS_READ_ERROR
;
864 cp
->input_file
= NULL
;
865 cp
->pending_deletion
= 0;
867 /* use manual reset event so that select() will function properly */
868 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
871 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
872 if (cp
->char_consumed
)
874 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
875 It means that the 64K stack we are requesting in the 2nd
876 argument is how much memory should be reserved for the
877 stack. If we don't use this flag, the memory requested
878 by the 2nd argument is the amount actually _committed_,
879 but Windows reserves 8MB of memory for each thread's
880 stack. (The 8MB figure comes from the -stack
881 command-line argument we pass to the linker when building
882 Emacs, but that's because we need a large stack for
883 Emacs's main thread.) Since we request 2GB of reserved
884 memory at startup (see w32heap.c), which is close to the
885 maximum memory available for a 32-bit process on Windows,
886 the 8MB reservation for each thread causes failures in
887 starting subprocesses, because we create a thread running
888 reader_thread for each subprocess. As 8MB of stack is
889 way too much for reader_thread, forcing Windows to
890 reserve less wins the day. */
891 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
902 delete_child (child_process
*cp
)
906 /* Should not be deleting a child that is still needed. */
907 for (i
= 0; i
< MAXDESC
; i
++)
908 if (fd_info
[i
].cp
== cp
)
911 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
914 /* Delete the child's temporary input file, if any, that is pending
918 if (cp
->pending_deletion
)
920 if (unlink (cp
->input_file
))
921 DebPrint (("delete_child.unlink (%s) failed, errno: %d\n",
922 cp
->input_file
, errno
));
923 cp
->pending_deletion
= 0;
925 xfree (cp
->input_file
);
926 cp
->input_file
= NULL
;
929 /* reap thread if necessary */
934 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
936 /* let the thread exit cleanly if possible */
937 cp
->status
= STATUS_READ_ERROR
;
938 SetEvent (cp
->char_consumed
);
940 /* We used to forcibly terminate the thread here, but it
941 is normally unnecessary, and in abnormal cases, the worst that
942 will happen is we have an extra idle thread hanging around
943 waiting for the zombie process. */
944 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
946 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
947 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
948 TerminateThread (cp
->thrd
, 0);
952 CloseHandle (cp
->thrd
);
957 CloseHandle (cp
->char_avail
);
958 cp
->char_avail
= NULL
;
960 if (cp
->char_consumed
)
962 CloseHandle (cp
->char_consumed
);
963 cp
->char_consumed
= NULL
;
966 /* update child_proc_count (highest numbered slot in use plus one) */
967 if (cp
== child_procs
+ child_proc_count
- 1)
969 for (i
= child_proc_count
-1; i
>= 0; i
--)
970 if (CHILD_ACTIVE (&child_procs
[i
])
971 || child_procs
[i
].procinfo
.hProcess
!= NULL
)
973 child_proc_count
= i
+ 1;
978 child_proc_count
= 0;
981 /* Find a child by pid. */
982 static child_process
*
983 find_child_pid (DWORD pid
)
987 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
988 if ((CHILD_ACTIVE (cp
) || cp
->procinfo
.hProcess
!= NULL
)
995 release_listen_threads (void)
999 for (i
= child_proc_count
- 1; i
>= 0; i
--)
1001 if (CHILD_ACTIVE (&child_procs
[i
])
1002 && (fd_info
[child_procs
[i
].fd
].flags
& FILE_LISTEN
))
1003 child_procs
[i
].status
= STATUS_READ_ERROR
;
1007 /* Thread proc for child process and socket reader threads. Each thread
1008 is normally blocked until woken by select() to check for input by
1009 reading one char. When the read completes, char_avail is signaled
1010 to wake up the select emulator and the thread blocks itself again. */
1012 reader_thread (void *arg
)
1017 cp
= (child_process
*)arg
;
1019 /* We have to wait for the go-ahead before we can start */
1021 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
1029 if (cp
->fd
>= 0 && fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
1030 rc
= _sys_wait_accept (cp
->fd
);
1032 rc
= _sys_read_ahead (cp
->fd
);
1034 /* Don't bother waiting for the event if we already have been
1035 told to exit by delete_child. */
1036 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_avail
)
1039 /* The name char_avail is a misnomer - it really just means the
1040 read-ahead has completed, whether successfully or not. */
1041 if (!SetEvent (cp
->char_avail
))
1043 DebPrint (("reader_thread.SetEvent(0x%x) failed with %lu for fd %ld (PID %d)\n",
1044 (DWORD_PTR
)cp
->char_avail
, GetLastError (),
1049 if (rc
== STATUS_READ_ERROR
)
1052 /* If the read died, the child has died so let the thread die */
1053 if (rc
== STATUS_READ_FAILED
)
1056 /* Don't bother waiting for the acknowledge if we already have
1057 been told to exit by delete_child. */
1058 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_consumed
)
1061 /* Wait until our input is acknowledged before reading again */
1062 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
1064 DebPrint (("reader_thread.WaitForSingleObject failed with "
1065 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
1068 /* delete_child sets status to STATUS_READ_ERROR when it wants
1070 if (cp
->status
== STATUS_READ_ERROR
)
1076 /* To avoid Emacs changing directory, we just record here the directory
1077 the new process should start in. This is set just before calling
1078 sys_spawnve, and is not generally valid at any other time. */
1079 static char * process_dir
;
1082 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
1083 int * pPid
, child_process
*cp
)
1086 SECURITY_ATTRIBUTES sec_attrs
;
1088 SECURITY_DESCRIPTOR sec_desc
;
1091 char dir
[ MAXPATHLEN
];
1093 if (cp
== NULL
) emacs_abort ();
1095 memset (&start
, 0, sizeof (start
));
1096 start
.cb
= sizeof (start
);
1099 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
1100 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
1102 start
.dwFlags
= STARTF_USESTDHANDLES
;
1103 start
.wShowWindow
= SW_HIDE
;
1105 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
1106 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
1107 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
1108 #endif /* HAVE_NTGUI */
1111 /* Explicitly specify no security */
1112 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
1114 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
1117 sec_attrs
.nLength
= sizeof (sec_attrs
);
1118 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
1119 sec_attrs
.bInheritHandle
= FALSE
;
1121 strcpy (dir
, process_dir
);
1122 unixtodos_filename (dir
);
1124 flags
= (!NILP (Vw32_start_process_share_console
)
1125 ? CREATE_NEW_PROCESS_GROUP
1126 : CREATE_NEW_CONSOLE
);
1127 if (NILP (Vw32_start_process_inherit_error_mode
))
1128 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1129 if (!CreateProcess (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1130 flags
, env
, dir
, &start
, &cp
->procinfo
))
1133 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1135 /* Hack for Windows 95, which assigns large (ie negative) pids */
1144 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1148 /* create_child doesn't know what emacs's file handle will be for waiting
1149 on output from the child, so we need to make this additional call
1150 to register the handle with the process
1151 This way the select emulator knows how to match file handles with
1152 entries in child_procs. */
1154 register_child (pid_t pid
, int fd
)
1158 cp
= find_child_pid ((DWORD
)pid
);
1161 DebPrint (("register_child unable to find pid %lu\n", pid
));
1166 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1171 /* thread is initially blocked until select is called; set status so
1172 that select will release thread */
1173 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1175 /* attach child_process to fd_info */
1176 if (fd_info
[fd
].cp
!= NULL
)
1178 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1182 fd_info
[fd
].cp
= cp
;
1185 /* Record INFILE as an input file for process PID. */
1187 record_infile (pid_t pid
, char *infile
)
1191 /* INFILE should never be NULL, since xstrdup would have signaled
1192 memory full condition in that case, see callproc.c where this
1193 function is called. */
1196 cp
= find_child_pid ((DWORD
)pid
);
1199 DebPrint (("record_infile is unable to find pid %lu\n", pid
));
1203 cp
->input_file
= infile
;
1206 /* Mark the input file INFILE of the corresponding subprocess as
1207 temporary, to be deleted when the subprocess exits. */
1209 record_pending_deletion (char *infile
)
1215 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1216 if (CHILD_ACTIVE (cp
)
1217 && cp
->input_file
&& xstrcasecmp (cp
->input_file
, infile
) == 0)
1219 cp
->pending_deletion
= 1;
1224 /* Called from waitpid when a process exits. */
1226 reap_subprocess (child_process
*cp
)
1228 if (cp
->procinfo
.hProcess
)
1230 /* Reap the process */
1232 /* Process should have already died before we are called. */
1233 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1234 DebPrint (("reap_subprocess: child for fd %d has not died yet!", cp
->fd
));
1236 CloseHandle (cp
->procinfo
.hProcess
);
1237 cp
->procinfo
.hProcess
= NULL
;
1238 CloseHandle (cp
->procinfo
.hThread
);
1239 cp
->procinfo
.hThread
= NULL
;
1242 /* If cp->fd was not closed yet, we might be still reading the
1243 process output, so don't free its resources just yet. The call
1244 to delete_child on behalf of this subprocess will be made by
1245 sys_read when the subprocess output is fully read. */
1250 /* Wait for a child process specified by PID, or for any of our
1251 existing child processes (if PID is nonpositive) to die. When it
1252 does, close its handle. Return the pid of the process that died
1253 and fill in STATUS if non-NULL. */
1256 waitpid (pid_t pid
, int *status
, int options
)
1258 DWORD active
, retval
;
1260 child_process
*cp
, *cps
[MAX_CHILDREN
];
1261 HANDLE wait_hnd
[MAX_CHILDREN
];
1263 int dont_wait
= (options
& WNOHANG
) != 0;
1266 /* According to Posix:
1268 PID = -1 means status is requested for any child process.
1270 PID > 0 means status is requested for a single child process
1273 PID = 0 means status is requested for any child process whose
1274 process group ID is equal to that of the calling process. But
1275 since Windows has only a limited support for process groups (only
1276 for console processes and only for the purposes of passing
1277 Ctrl-BREAK signal to them), and since we have no documented way
1278 of determining whether a given process belongs to our group, we
1281 PID < -1 means status is requested for any child process whose
1282 process group ID is equal to the absolute value of PID. Again,
1283 since we don't support process groups, we treat that as -1. */
1288 /* We are requested to wait for a specific child. */
1289 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1291 /* Some child_procs might be sockets; ignore them. Also
1292 ignore subprocesses whose output is not yet completely
1294 if (CHILD_ACTIVE (cp
)
1295 && cp
->procinfo
.hProcess
1304 if (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1306 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1312 /* PID specifies our subprocess, but its status is not
1319 /* No such child process, or nothing to wait for, so fail. */
1326 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1328 if (CHILD_ACTIVE (cp
)
1329 && cp
->procinfo
.hProcess
1330 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1332 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1339 /* Nothing to wait on, so fail. */
1348 timeout_ms
= 1000; /* check for quit about once a second. */
1353 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, timeout_ms
);
1354 } while (active
== WAIT_TIMEOUT
&& !dont_wait
);
1356 if (active
== WAIT_FAILED
)
1361 else if (active
== WAIT_TIMEOUT
&& dont_wait
)
1363 /* PID specifies our subprocess, but it didn't exit yet, so its
1364 status is not yet available. */
1366 DebPrint (("Wait: PID %d not reap yet\n", cp
->pid
));
1370 else if (active
>= WAIT_OBJECT_0
1371 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1373 active
-= WAIT_OBJECT_0
;
1375 else if (active
>= WAIT_ABANDONED_0
1376 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1378 active
-= WAIT_ABANDONED_0
;
1383 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1385 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1389 if (retval
== STILL_ACTIVE
)
1391 /* Should never happen. */
1392 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1393 if (pid
> 0 && dont_wait
)
1399 /* Massage the exit code from the process to match the format expected
1400 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1401 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1403 if (retval
== STATUS_CONTROL_C_EXIT
)
1408 if (pid
> 0 && active
!= 0)
1413 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1418 reap_subprocess (cp
);
1423 /* Old versions of w32api headers don't have separate 32-bit and
1424 64-bit defines, but the one they have matches the 32-bit variety. */
1425 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1426 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1427 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1431 w32_executable_type (char * filename
,
1433 int * is_cygnus_app
,
1436 file_data executable
;
1439 /* Default values in case we can't tell for sure. */
1440 *is_dos_app
= FALSE
;
1441 *is_cygnus_app
= FALSE
;
1442 *is_gui_app
= FALSE
;
1444 if (!open_input_file (&executable
, filename
))
1447 p
= strrchr (filename
, '.');
1449 /* We can only identify DOS .com programs from the extension. */
1450 if (p
&& xstrcasecmp (p
, ".com") == 0)
1452 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1453 || xstrcasecmp (p
, ".cmd") == 0))
1455 /* A DOS shell script - it appears that CreateProcess is happy to
1456 accept this (somewhat surprisingly); presumably it looks at
1457 COMSPEC to determine what executable to actually invoke.
1458 Therefore, we have to do the same here as well. */
1459 /* Actually, I think it uses the program association for that
1460 extension, which is defined in the registry. */
1461 p
= egetenv ("COMSPEC");
1463 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1467 /* Look for DOS .exe signature - if found, we must also check that
1468 it isn't really a 16- or 32-bit Windows exe, since both formats
1469 start with a DOS program stub. Note that 16-bit Windows
1470 executables use the OS/2 1.x format. */
1472 IMAGE_DOS_HEADER
* dos_header
;
1473 IMAGE_NT_HEADERS
* nt_header
;
1475 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1476 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1479 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1481 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1483 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1486 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1487 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1491 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1493 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1494 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1496 /* Ensure we are using the 32 bit structure. */
1497 IMAGE_OPTIONAL_HEADER32
*opt
1498 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1499 data_dir
= opt
->DataDirectory
;
1500 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1502 /* MingW 3.12 has the required 64 bit structs, but in case older
1503 versions don't, only check 64 bit exes if we know how. */
1504 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1505 else if (nt_header
->OptionalHeader
.Magic
1506 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1508 IMAGE_OPTIONAL_HEADER64
*opt
1509 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1510 data_dir
= opt
->DataDirectory
;
1511 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1516 /* Look for cygwin.dll in DLL import list. */
1517 IMAGE_DATA_DIRECTORY import_dir
=
1518 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1519 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1520 IMAGE_SECTION_HEADER
* section
;
1522 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1523 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1526 for ( ; imports
->Name
; imports
++)
1528 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1531 /* The exact name of the cygwin dll has changed with
1532 various releases, but hopefully this will be reasonably
1534 if (strncmp (dllname
, "cygwin", 6) == 0)
1536 *is_cygnus_app
= TRUE
;
1545 close_file_data (&executable
);
1549 compare_env (const void *strp1
, const void *strp2
)
1551 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1553 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1555 /* Sort order in command.com/cmd.exe is based on uppercasing
1556 names, so do the same here. */
1557 if (toupper (*str1
) > toupper (*str2
))
1559 else if (toupper (*str1
) < toupper (*str2
))
1564 if (*str1
== '=' && *str2
== '=')
1566 else if (*str1
== '=')
1573 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1575 char **optr
, **nptr
;
1587 num
+= optr
- envp2
;
1589 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1594 /* When a new child process is created we need to register it in our list,
1595 so intercept spawn requests. */
1597 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1599 Lisp_Object program
, full
;
1600 char *cmdline
, *env
, *parg
, **targ
;
1604 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1606 /* We pass our process ID to our children by setting up an environment
1607 variable in their environment. */
1608 char ppid_env_var_buffer
[64];
1609 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1610 /* These are the characters that cause an argument to need quoting.
1611 Arguments with whitespace characters need quoting to prevent the
1612 argument being split into two or more. Arguments with wildcards
1613 are also quoted, for consistency with posix platforms, where wildcards
1614 are not expanded if we run the program directly without a shell.
1615 Some extra whitespace characters need quoting in Cygwin programs,
1616 so this list is conditionally modified below. */
1617 char *sepchars
= " \t*?";
1618 /* This is for native w32 apps; modified below for Cygwin apps. */
1619 char escape_char
= '\\';
1621 /* We don't care about the other modes */
1622 if (mode
!= _P_NOWAIT
)
1628 /* Handle executable names without an executable suffix. */
1629 program
= build_string (cmdname
);
1630 if (NILP (Ffile_executable_p (program
)))
1632 struct gcpro gcpro1
;
1636 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
));
1646 /* make sure argv[0] and cmdname are both in DOS format */
1647 cmdname
= SDATA (program
);
1648 unixtodos_filename (cmdname
);
1651 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1652 executable that is implicitly linked to the Cygnus dll (implying it
1653 was compiled with the Cygnus GNU toolchain and hence relies on
1654 cygwin.dll to parse the command line - we use this to decide how to
1655 escape quote chars in command line args that must be quoted).
1657 Also determine whether it is a GUI app, so that we don't hide its
1658 initial window unless specifically requested. */
1659 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1661 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1662 application to start it by specifying the helper app as cmdname,
1663 while leaving the real app name as argv[0]. */
1666 cmdname
= alloca (MAXPATHLEN
);
1667 if (egetenv ("CMDPROXY"))
1668 strcpy (cmdname
, egetenv ("CMDPROXY"));
1671 strcpy (cmdname
, SDATA (Vinvocation_directory
));
1672 strcat (cmdname
, "cmdproxy.exe");
1674 unixtodos_filename (cmdname
);
1677 /* we have to do some conjuring here to put argv and envp into the
1678 form CreateProcess wants... argv needs to be a space separated/null
1679 terminated list of parameters, and envp is a null
1680 separated/double-null terminated list of parameters.
1682 Additionally, zero-length args and args containing whitespace or
1683 quote chars need to be wrapped in double quotes - for this to work,
1684 embedded quotes need to be escaped as well. The aim is to ensure
1685 the child process reconstructs the argv array we start with
1686 exactly, so we treat quotes at the beginning and end of arguments
1689 The w32 GNU-based library from Cygnus doubles quotes to escape
1690 them, while MSVC uses backslash for escaping. (Actually the MSVC
1691 startup code does attempt to recognize doubled quotes and accept
1692 them, but gets it wrong and ends up requiring three quotes to get a
1693 single embedded quote!) So by default we decide whether to use
1694 quote or backslash as the escape character based on whether the
1695 binary is apparently a Cygnus compiled app.
1697 Note that using backslash to escape embedded quotes requires
1698 additional special handling if an embedded quote is already
1699 preceded by backslash, or if an arg requiring quoting ends with
1700 backslash. In such cases, the run of escape characters needs to be
1701 doubled. For consistency, we apply this special handling as long
1702 as the escape character is not quote.
1704 Since we have no idea how large argv and envp are likely to be we
1705 figure out list lengths on the fly and allocate them. */
1707 if (!NILP (Vw32_quote_process_args
))
1710 /* Override escape char by binding w32-quote-process-args to
1711 desired character, or use t for auto-selection. */
1712 if (INTEGERP (Vw32_quote_process_args
))
1713 escape_char
= XINT (Vw32_quote_process_args
);
1715 escape_char
= is_cygnus_app
? '"' : '\\';
1718 /* Cygwin apps needs quoting a bit more often. */
1719 if (escape_char
== '"')
1720 sepchars
= "\r\n\t\f '";
1728 int need_quotes
= 0;
1729 int escape_char_run
= 0;
1735 if (escape_char
== '"' && *p
== '\\')
1736 /* If it's a Cygwin app, \ needs to be escaped. */
1740 /* allow for embedded quotes to be escaped */
1743 /* handle the case where the embedded quote is already escaped */
1744 if (escape_char_run
> 0)
1746 /* To preserve the arg exactly, we need to double the
1747 preceding escape characters (plus adding one to
1748 escape the quote character itself). */
1749 arglen
+= escape_char_run
;
1752 else if (strchr (sepchars
, *p
) != NULL
)
1757 if (*p
== escape_char
&& escape_char
!= '"')
1760 escape_char_run
= 0;
1765 /* handle the case where the arg ends with an escape char - we
1766 must not let the enclosing quote be escaped. */
1767 if (escape_char_run
> 0)
1768 arglen
+= escape_char_run
;
1770 arglen
+= strlen (*targ
++) + 1;
1772 cmdline
= alloca (arglen
);
1778 int need_quotes
= 0;
1786 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1791 int escape_char_run
= 0;
1797 last
= p
+ strlen (p
) - 1;
1800 /* This version does not escape quotes if they occur at the
1801 beginning or end of the arg - this could lead to incorrect
1802 behavior when the arg itself represents a command line
1803 containing quoted args. I believe this was originally done
1804 as a hack to make some things work, before
1805 `w32-quote-process-args' was added. */
1808 if (*p
== '"' && p
> first
&& p
< last
)
1809 *parg
++ = escape_char
; /* escape embedded quotes */
1817 /* double preceding escape chars if any */
1818 while (escape_char_run
> 0)
1820 *parg
++ = escape_char
;
1823 /* escape all quote chars, even at beginning or end */
1824 *parg
++ = escape_char
;
1826 else if (escape_char
== '"' && *p
== '\\')
1830 if (*p
== escape_char
&& escape_char
!= '"')
1833 escape_char_run
= 0;
1835 /* double escape chars before enclosing quote */
1836 while (escape_char_run
> 0)
1838 *parg
++ = escape_char
;
1846 strcpy (parg
, *targ
);
1847 parg
+= strlen (*targ
);
1857 numenv
= 1; /* for end null */
1860 arglen
+= strlen (*targ
++) + 1;
1863 /* extra env vars... */
1864 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
1865 GetCurrentProcessId ());
1866 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1869 /* merge env passed in and extra env into one, and sort it. */
1870 targ
= (char **) alloca (numenv
* sizeof (char *));
1871 merge_and_sort_env (envp
, extra_env
, targ
);
1873 /* concatenate env entries. */
1874 env
= alloca (arglen
);
1878 strcpy (parg
, *targ
);
1879 parg
+= strlen (*targ
++);
1892 /* Now create the process. */
1893 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1903 /* Emulate the select call
1904 Wait for available input on any of the given rfds, or timeout if
1905 a timeout is given and no input is detected
1906 wfds and efds are not supported and must be NULL.
1908 For simplicity, we detect the death of child processes here and
1909 synchronously call the SIGCHLD handler. Since it is possible for
1910 children to be created without a corresponding pipe handle from which
1911 to read output, we wait separately on the process handles as well as
1912 the char_avail events for each process pipe. We only call
1913 wait/reap_process when the process actually terminates.
1915 To reduce the number of places in which Emacs can be hung such that
1916 C-g is not able to interrupt it, we always wait on interrupt_handle
1917 (which is signaled by the input thread when C-g is detected). If we
1918 detect that we were woken up by C-g, we return -1 with errno set to
1919 EINTR as on Unix. */
1921 /* From w32console.c */
1922 extern HANDLE keyboard_handle
;
1924 /* From w32xfns.c */
1925 extern HANDLE interrupt_handle
;
1927 /* From process.c */
1928 extern int proc_buffered_char
[];
1931 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1932 struct timespec
*timeout
, void *ignored
)
1935 DWORD timeout_ms
, start_time
;
1938 child_process
*cp
, *cps
[MAX_CHILDREN
];
1939 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1940 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1943 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1945 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1946 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1952 /* Otherwise, we only handle rfds, so fail otherwise. */
1953 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1963 /* If interrupt_handle is available and valid, always wait on it, to
1964 detect C-g (quit). */
1966 if (interrupt_handle
&& interrupt_handle
!= INVALID_HANDLE_VALUE
)
1968 wait_hnd
[0] = interrupt_handle
;
1973 /* Build a list of pipe handles to wait on. */
1974 for (i
= 0; i
< nfds
; i
++)
1975 if (FD_ISSET (i
, &orfds
))
1979 if (keyboard_handle
)
1981 /* Handle stdin specially */
1982 wait_hnd
[nh
] = keyboard_handle
;
1987 /* Check for any emacs-generated input in the queue since
1988 it won't be detected in the wait */
1989 if (detect_input_pending ())
1994 else if (noninteractive
)
1996 if (handle_file_notifications (NULL
))
2002 /* Child process and socket/comm port input. */
2006 int current_status
= cp
->status
;
2008 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
2010 /* Tell reader thread which file handle to use. */
2012 /* Wake up the reader thread for this process */
2013 cp
->status
= STATUS_READ_READY
;
2014 if (!SetEvent (cp
->char_consumed
))
2015 DebPrint (("sys_select.SetEvent failed with "
2016 "%lu for fd %ld\n", GetLastError (), i
));
2019 #ifdef CHECK_INTERLOCK
2020 /* slightly crude cross-checking of interlock between threads */
2022 current_status
= cp
->status
;
2023 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
2025 /* char_avail has been signaled, so status (which may
2026 have changed) should indicate read has completed
2027 but has not been acknowledged. */
2028 current_status
= cp
->status
;
2029 if (current_status
!= STATUS_READ_SUCCEEDED
2030 && current_status
!= STATUS_READ_FAILED
)
2031 DebPrint (("char_avail set, but read not completed: status %d\n",
2036 /* char_avail has not been signaled, so status should
2037 indicate that read is in progress; small possibility
2038 that read has completed but event wasn't yet signaled
2039 when we tested it (because a context switch occurred
2040 or if running on separate CPUs). */
2041 if (current_status
!= STATUS_READ_READY
2042 && current_status
!= STATUS_READ_IN_PROGRESS
2043 && current_status
!= STATUS_READ_SUCCEEDED
2044 && current_status
!= STATUS_READ_FAILED
)
2045 DebPrint (("char_avail reset, but read status is bad: %d\n",
2049 wait_hnd
[nh
] = cp
->char_avail
;
2051 if (!wait_hnd
[nh
]) emacs_abort ();
2054 DebPrint (("select waiting on child %d fd %d\n",
2055 cp
-child_procs
, i
));
2060 /* Unable to find something to wait on for this fd, skip */
2062 /* Note that this is not a fatal error, and can in fact
2063 happen in unusual circumstances. Specifically, if
2064 sys_spawnve fails, eg. because the program doesn't
2065 exist, and debug-on-error is t so Fsignal invokes a
2066 nested input loop, then the process output pipe is
2067 still included in input_wait_mask with no child_proc
2068 associated with it. (It is removed when the debugger
2069 exits the nested input loop and the error is thrown.) */
2071 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
2077 /* Add handles of child processes. */
2079 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
2080 /* Some child_procs might be sockets; ignore them. Also some
2081 children may have died already, but we haven't finished reading
2082 the process output; ignore them too. */
2083 if ((CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
2085 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
2086 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
2089 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
2094 /* Nothing to look for, so we didn't find anything */
2101 if (handle_file_notifications (NULL
))
2107 start_time
= GetTickCount ();
2109 /* Wait for input or child death to be signaled. If user input is
2110 allowed, then also accept window messages. */
2111 if (FD_ISSET (0, &orfds
))
2112 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
2115 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
2117 if (active
== WAIT_FAILED
)
2119 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
2120 nh
+ nc
, timeout_ms
, GetLastError ()));
2121 /* don't return EBADF - this causes wait_reading_process_output to
2122 abort; WAIT_FAILED is returned when single-stepping under
2123 Windows 95 after switching thread focus in debugger, and
2124 possibly at other times. */
2128 else if (active
== WAIT_TIMEOUT
)
2132 if (handle_file_notifications (NULL
))
2137 else if (active
>= WAIT_OBJECT_0
2138 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
2140 active
-= WAIT_OBJECT_0
;
2142 else if (active
>= WAIT_ABANDONED_0
2143 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
2145 active
-= WAIT_ABANDONED_0
;
2150 /* Loop over all handles after active (now officially documented as
2151 being the first signaled handle in the array). We do this to
2152 ensure fairness, so that all channels with data available will be
2153 processed - otherwise higher numbered channels could be starved. */
2156 if (active
== nh
+ nc
)
2158 /* There are messages in the lisp thread's queue; we must
2159 drain the queue now to ensure they are processed promptly,
2160 because if we don't do so, we will not be woken again until
2161 further messages arrive.
2163 NB. If ever we allow window message procedures to callback
2164 into lisp, we will need to ensure messages are dispatched
2165 at a safe time for lisp code to be run (*), and we may also
2166 want to provide some hooks in the dispatch loop to cater
2167 for modeless dialogs created by lisp (ie. to register
2168 window handles to pass to IsDialogMessage).
2170 (*) Note that MsgWaitForMultipleObjects above is an
2171 internal dispatch point for messages that are sent to
2172 windows created by this thread. */
2173 if (drain_message_queue ()
2174 /* If drain_message_queue returns non-zero, that means
2175 we received a WM_EMACS_FILENOTIFY message. If this
2176 is a TTY frame, we must signal the caller that keyboard
2177 input is available, so that w32_console_read_socket
2178 will be called to pick up the notifications. If we
2179 don't do that, file notifications will only work when
2180 the Emacs TTY frame has focus. */
2181 && FRAME_TERMCAP_P (SELECTED_FRAME ())
2182 /* they asked for stdin reads */
2183 && FD_ISSET (0, &orfds
)
2184 /* the stdin handle is valid */
2192 else if (active
>= nh
)
2194 cp
= cps
[active
- nh
];
2196 /* We cannot always signal SIGCHLD immediately; if we have not
2197 finished reading the process output, we must delay sending
2198 SIGCHLD until we do. */
2200 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
2201 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
2202 /* SIG_DFL for SIGCHLD is ignore */
2203 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
2204 sig_handlers
[SIGCHLD
] != SIG_IGN
)
2207 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2210 sig_handlers
[SIGCHLD
] (SIGCHLD
);
2213 else if (fdindex
[active
] == -1)
2215 /* Quit (C-g) was detected. */
2219 else if (fdindex
[active
] == 0)
2221 /* Keyboard input available */
2227 /* must be a socket or pipe - read ahead should have
2228 completed, either succeeding or failing. */
2229 FD_SET (fdindex
[active
], rfds
);
2233 /* Even though wait_reading_process_output only reads from at most
2234 one channel, we must process all channels here so that we reap
2235 all children that have died. */
2236 while (++active
< nh
+ nc
)
2237 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2239 } while (active
< nh
+ nc
);
2243 if (handle_file_notifications (NULL
))
2247 /* If no input has arrived and timeout hasn't expired, wait again. */
2250 DWORD elapsed
= GetTickCount () - start_time
;
2252 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2254 if (timeout_ms
!= INFINITE
)
2255 timeout_ms
-= elapsed
;
2256 goto count_children
;
2263 /* Substitute for certain kill () operations */
2265 static BOOL CALLBACK
2266 find_child_console (HWND hwnd
, LPARAM arg
)
2268 child_process
* cp
= (child_process
*) arg
;
2272 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
2273 if (process_id
== cp
->procinfo
.dwProcessId
)
2275 char window_class
[32];
2277 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2278 if (strcmp (window_class
,
2279 (os_subtype
== OS_9X
)
2281 : "ConsoleWindowClass") == 0)
2291 /* Emulate 'kill', but only for other processes. */
2293 sys_kill (pid_t pid
, int sig
)
2297 int need_to_free
= 0;
2300 /* Each process is in its own process group. */
2304 /* Only handle signals that will result in the process dying */
2306 && sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2314 /* It will take _some_ time before PID 4 or less on Windows will
2321 proc_hand
= OpenProcess (PROCESS_QUERY_INFORMATION
, 0, pid
);
2322 if (proc_hand
== NULL
)
2324 DWORD err
= GetLastError ();
2328 case ERROR_ACCESS_DENIED
: /* existing process, but access denied */
2331 case ERROR_INVALID_PARAMETER
: /* process PID does not exist */
2337 CloseHandle (proc_hand
);
2341 cp
= find_child_pid (pid
);
2344 /* We were passed a PID of something other than our subprocess.
2345 If that is our own PID, we will send to ourself a message to
2346 close the selected frame, which does not necessarily
2347 terminates Emacs. But then we are not supposed to call
2348 sys_kill with our own PID. */
2349 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2350 if (proc_hand
== NULL
)
2359 proc_hand
= cp
->procinfo
.hProcess
;
2360 pid
= cp
->procinfo
.dwProcessId
;
2362 /* Try to locate console window for process. */
2363 EnumWindows (find_child_console
, (LPARAM
) cp
);
2366 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2368 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2370 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2371 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2372 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2373 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2374 HWND foreground_window
;
2376 if (break_scan_code
== 0)
2378 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2379 vk_break_code
= 'C';
2380 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2383 foreground_window
= GetForegroundWindow ();
2384 if (foreground_window
)
2386 /* NT 5.0, and apparently also Windows 98, will not allow
2387 a Window to be set to foreground directly without the
2388 user's involvement. The workaround is to attach
2389 ourselves to the thread that owns the foreground
2390 window, since that is the only thread that can set the
2391 foreground window. */
2392 DWORD foreground_thread
, child_thread
;
2394 GetWindowThreadProcessId (foreground_window
, NULL
);
2395 if (foreground_thread
== GetCurrentThreadId ()
2396 || !AttachThreadInput (GetCurrentThreadId (),
2397 foreground_thread
, TRUE
))
2398 foreground_thread
= 0;
2400 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2401 if (child_thread
== GetCurrentThreadId ()
2402 || !AttachThreadInput (GetCurrentThreadId (),
2403 child_thread
, TRUE
))
2406 /* Set the foreground window to the child. */
2407 if (SetForegroundWindow (cp
->hwnd
))
2409 /* Generate keystrokes as if user had typed Ctrl-Break or
2411 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2412 keybd_event (vk_break_code
, break_scan_code
,
2413 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2414 keybd_event (vk_break_code
, break_scan_code
,
2415 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2416 | KEYEVENTF_KEYUP
, 0);
2417 keybd_event (VK_CONTROL
, control_scan_code
,
2418 KEYEVENTF_KEYUP
, 0);
2420 /* Sleep for a bit to give time for Emacs frame to respond
2421 to focus change events (if Emacs was active app). */
2424 SetForegroundWindow (foreground_window
);
2426 /* Detach from the foreground and child threads now that
2427 the foreground switching is over. */
2428 if (foreground_thread
)
2429 AttachThreadInput (GetCurrentThreadId (),
2430 foreground_thread
, FALSE
);
2432 AttachThreadInput (GetCurrentThreadId (),
2433 child_thread
, FALSE
);
2436 /* Ctrl-Break is NT equivalent of SIGINT. */
2437 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2439 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2440 "for pid %lu\n", GetLastError (), pid
));
2447 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2450 if (os_subtype
== OS_9X
)
2453 Another possibility is to try terminating the VDM out-right by
2454 calling the Shell VxD (id 0x17) V86 interface, function #4
2455 "SHELL_Destroy_VM", ie.
2461 First need to determine the current VM handle, and then arrange for
2462 the shellapi call to be made from the system vm (by using
2463 Switch_VM_and_callback).
2465 Could try to invoke DestroyVM through CallVxD.
2469 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2470 to hang when cmdproxy is used in conjunction with
2471 command.com for an interactive shell. Posting
2472 WM_CLOSE pops up a dialog that, when Yes is selected,
2473 does the same thing. TerminateProcess is also less
2474 than ideal in that subprocesses tend to stick around
2475 until the machine is shutdown, but at least it
2476 doesn't freeze the 16-bit subsystem. */
2477 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2479 if (!TerminateProcess (proc_hand
, 0xff))
2481 DebPrint (("sys_kill.TerminateProcess returned %d "
2482 "for pid %lu\n", GetLastError (), pid
));
2489 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2491 /* Kill the process. On W32 this doesn't kill child processes
2492 so it doesn't work very well for shells which is why it's not
2493 used in every case. */
2494 else if (!TerminateProcess (proc_hand
, 0xff))
2496 DebPrint (("sys_kill.TerminateProcess returned %d "
2497 "for pid %lu\n", GetLastError (), pid
));
2504 CloseHandle (proc_hand
);
2509 /* The following two routines are used to manipulate stdin, stdout, and
2510 stderr of our child processes.
2512 Assuming that in, out, and err are *not* inheritable, we make them
2513 stdin, stdout, and stderr of the child as follows:
2515 - Save the parent's current standard handles.
2516 - Set the std handles to inheritable duplicates of the ones being passed in.
2517 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2518 NT file handle for a crt file descriptor.)
2519 - Spawn the child, which inherits in, out, and err as stdin,
2520 stdout, and stderr. (see Spawnve)
2521 - Close the std handles passed to the child.
2522 - Reset the parent's standard handles to the saved handles.
2523 (see reset_standard_handles)
2524 We assume that the caller closes in, out, and err after calling us. */
2527 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2530 HANDLE newstdin
, newstdout
, newstderr
;
2532 parent
= GetCurrentProcess ();
2534 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2535 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2536 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2538 /* make inheritable copies of the new handles */
2539 if (!DuplicateHandle (parent
,
2540 (HANDLE
) _get_osfhandle (in
),
2545 DUPLICATE_SAME_ACCESS
))
2546 report_file_error ("Duplicating input handle for child", Qnil
);
2548 if (!DuplicateHandle (parent
,
2549 (HANDLE
) _get_osfhandle (out
),
2554 DUPLICATE_SAME_ACCESS
))
2555 report_file_error ("Duplicating output handle for child", Qnil
);
2557 if (!DuplicateHandle (parent
,
2558 (HANDLE
) _get_osfhandle (err
),
2563 DUPLICATE_SAME_ACCESS
))
2564 report_file_error ("Duplicating error handle for child", Qnil
);
2566 /* and store them as our std handles */
2567 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2568 report_file_error ("Changing stdin handle", Qnil
);
2570 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2571 report_file_error ("Changing stdout handle", Qnil
);
2573 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2574 report_file_error ("Changing stderr handle", Qnil
);
2578 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2580 /* close the duplicated handles passed to the child */
2581 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2582 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2583 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2585 /* now restore parent's saved std handles */
2586 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2587 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2588 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2592 set_process_dir (char * dir
)
2597 /* To avoid problems with winsock implementations that work over dial-up
2598 connections causing or requiring a connection to exist while Emacs is
2599 running, Emacs no longer automatically loads winsock on startup if it
2600 is present. Instead, it will be loaded when open-network-stream is
2603 To allow full control over when winsock is loaded, we provide these
2604 two functions to dynamically load and unload winsock. This allows
2605 dial-up users to only be connected when they actually need to use
2609 extern HANDLE winsock_lib
;
2610 extern BOOL
term_winsock (void);
2611 extern BOOL
init_winsock (int load_now
);
2613 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2614 doc
: /* Test for presence of the Windows socket library `winsock'.
2615 Returns non-nil if winsock support is present, nil otherwise.
2617 If the optional argument LOAD-NOW is non-nil, the winsock library is
2618 also loaded immediately if not already loaded. If winsock is loaded,
2619 the winsock local hostname is returned (since this may be different from
2620 the value of `system-name' and should supplant it), otherwise t is
2621 returned to indicate winsock support is present. */)
2622 (Lisp_Object load_now
)
2626 have_winsock
= init_winsock (!NILP (load_now
));
2629 if (winsock_lib
!= NULL
)
2631 /* Return new value for system-name. The best way to do this
2632 is to call init_system_name, saving and restoring the
2633 original value to avoid side-effects. */
2634 Lisp_Object orig_hostname
= Vsystem_name
;
2635 Lisp_Object hostname
;
2637 init_system_name ();
2638 hostname
= Vsystem_name
;
2639 Vsystem_name
= orig_hostname
;
2647 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2649 doc
: /* Unload the Windows socket library `winsock' if loaded.
2650 This is provided to allow dial-up socket connections to be disconnected
2651 when no longer needed. Returns nil without unloading winsock if any
2652 socket connections still exist. */)
2655 return term_winsock () ? Qt
: Qnil
;
2659 /* Some miscellaneous functions that are Windows specific, but not GUI
2660 specific (ie. are applicable in terminal or batch mode as well). */
2662 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2663 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2664 If FILENAME does not exist, return nil.
2665 All path elements in FILENAME are converted to their short names. */)
2666 (Lisp_Object filename
)
2668 char shortname
[MAX_PATH
];
2670 CHECK_STRING (filename
);
2672 /* first expand it. */
2673 filename
= Fexpand_file_name (filename
, Qnil
);
2675 /* luckily, this returns the short version of each element in the path. */
2676 if (GetShortPathName (SDATA (ENCODE_FILE (filename
)), shortname
, MAX_PATH
) == 0)
2679 dostounix_filename (shortname
, 0);
2681 /* No need to DECODE_FILE, because 8.3 names are pure ASCII. */
2682 return build_string (shortname
);
2686 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2688 doc
: /* Return the long file name version of the full path of FILENAME.
2689 If FILENAME does not exist, return nil.
2690 All path elements in FILENAME are converted to their long names. */)
2691 (Lisp_Object filename
)
2693 char longname
[ MAX_PATH
];
2696 CHECK_STRING (filename
);
2698 if (SBYTES (filename
) == 2
2699 && *(SDATA (filename
) + 1) == ':')
2702 /* first expand it. */
2703 filename
= Fexpand_file_name (filename
, Qnil
);
2705 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
, MAX_PATH
))
2708 dostounix_filename (longname
, 0);
2710 /* If we were passed only a drive, make sure that a slash is not appended
2711 for consistency with directories. Allow for drive mapping via SUBST
2712 in case expand-file-name is ever changed to expand those. */
2713 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2716 return DECODE_FILE (build_string (longname
));
2719 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2720 Sw32_set_process_priority
, 2, 2, 0,
2721 doc
: /* Set the priority of PROCESS to PRIORITY.
2722 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2723 priority of the process whose pid is PROCESS is changed.
2724 PRIORITY should be one of the symbols high, normal, or low;
2725 any other symbol will be interpreted as normal.
2727 If successful, the return value is t, otherwise nil. */)
2728 (Lisp_Object process
, Lisp_Object priority
)
2730 HANDLE proc_handle
= GetCurrentProcess ();
2731 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2732 Lisp_Object result
= Qnil
;
2734 CHECK_SYMBOL (priority
);
2736 if (!NILP (process
))
2741 CHECK_NUMBER (process
);
2743 /* Allow pid to be an internally generated one, or one obtained
2744 externally. This is necessary because real pids on Windows 95 are
2747 pid
= XINT (process
);
2748 cp
= find_child_pid (pid
);
2750 pid
= cp
->procinfo
.dwProcessId
;
2752 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2755 if (EQ (priority
, Qhigh
))
2756 priority_class
= HIGH_PRIORITY_CLASS
;
2757 else if (EQ (priority
, Qlow
))
2758 priority_class
= IDLE_PRIORITY_CLASS
;
2760 if (proc_handle
!= NULL
)
2762 if (SetPriorityClass (proc_handle
, priority_class
))
2764 if (!NILP (process
))
2765 CloseHandle (proc_handle
);
2771 #ifdef HAVE_LANGINFO_CODESET
2772 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2774 nl_langinfo (nl_item item
)
2776 /* Conversion of Posix item numbers to their Windows equivalents. */
2777 static const LCTYPE w32item
[] = {
2778 LOCALE_IDEFAULTANSICODEPAGE
,
2779 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2780 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2781 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2782 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2783 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2784 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2787 static char *nl_langinfo_buf
= NULL
;
2788 static int nl_langinfo_len
= 0;
2790 if (nl_langinfo_len
<= 0)
2791 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2793 if (item
< 0 || item
>= _NL_NUM
)
2794 nl_langinfo_buf
[0] = 0;
2797 LCID cloc
= GetThreadLocale ();
2798 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2802 nl_langinfo_buf
[0] = 0;
2805 if (item
== CODESET
)
2807 need_len
+= 2; /* for the "cp" prefix */
2808 if (need_len
< 8) /* for the case we call GetACP */
2811 if (nl_langinfo_len
<= need_len
)
2812 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2813 nl_langinfo_len
= need_len
);
2814 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2815 nl_langinfo_buf
, nl_langinfo_len
))
2816 nl_langinfo_buf
[0] = 0;
2817 else if (item
== CODESET
)
2819 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2820 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2821 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2824 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2825 strlen (nl_langinfo_buf
) + 1);
2826 nl_langinfo_buf
[0] = 'c';
2827 nl_langinfo_buf
[1] = 'p';
2832 return nl_langinfo_buf
;
2834 #endif /* HAVE_LANGINFO_CODESET */
2836 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2837 Sw32_get_locale_info
, 1, 2, 0,
2838 doc
: /* Return information about the Windows locale LCID.
2839 By default, return a three letter locale code which encodes the default
2840 language as the first two characters, and the country or regional variant
2841 as the third letter. For example, ENU refers to `English (United States)',
2842 while ENC means `English (Canadian)'.
2844 If the optional argument LONGFORM is t, the long form of the locale
2845 name is returned, e.g. `English (United States)' instead; if LONGFORM
2846 is a number, it is interpreted as an LCTYPE constant and the corresponding
2847 locale information is returned.
2849 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2850 (Lisp_Object lcid
, Lisp_Object longform
)
2854 char abbrev_name
[32] = { 0 };
2855 char full_name
[256] = { 0 };
2857 CHECK_NUMBER (lcid
);
2859 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2862 if (NILP (longform
))
2864 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2865 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2866 abbrev_name
, sizeof (abbrev_name
));
2868 return build_string (abbrev_name
);
2870 else if (EQ (longform
, Qt
))
2872 got_full
= GetLocaleInfo (XINT (lcid
),
2873 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2874 full_name
, sizeof (full_name
));
2876 return DECODE_SYSTEM (build_string (full_name
));
2878 else if (NUMBERP (longform
))
2880 got_full
= GetLocaleInfo (XINT (lcid
),
2882 full_name
, sizeof (full_name
));
2883 /* GetLocaleInfo's return value includes the terminating null
2884 character, when the returned information is a string, whereas
2885 make_unibyte_string needs the string length without the
2886 terminating null. */
2888 return make_unibyte_string (full_name
, got_full
- 1);
2895 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
2896 Sw32_get_current_locale_id
, 0, 0, 0,
2897 doc
: /* Return Windows locale id for current locale setting.
2898 This is a numerical value; use `w32-get-locale-info' to convert to a
2899 human-readable form. */)
2902 return make_number (GetThreadLocale ());
2906 int_from_hex (char * s
)
2909 static char hex
[] = "0123456789abcdefABCDEF";
2912 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2914 unsigned digit
= p
- hex
;
2917 val
= val
* 16 + digit
;
2923 /* We need to build a global list, since the EnumSystemLocale callback
2924 function isn't given a context pointer. */
2925 Lisp_Object Vw32_valid_locale_ids
;
2927 static BOOL CALLBACK
2928 enum_locale_fn (LPTSTR localeNum
)
2930 DWORD id
= int_from_hex (localeNum
);
2931 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2935 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2936 Sw32_get_valid_locale_ids
, 0, 0, 0,
2937 doc
: /* Return list of all valid Windows locale ids.
2938 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2939 human-readable form. */)
2942 Vw32_valid_locale_ids
= Qnil
;
2944 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2946 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2947 return Vw32_valid_locale_ids
;
2951 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2952 doc
: /* Return Windows locale id for default locale setting.
2953 By default, the system default locale setting is returned; if the optional
2954 parameter USERP is non-nil, the user default locale setting is returned.
2955 This is a numerical value; use `w32-get-locale-info' to convert to a
2956 human-readable form. */)
2960 return make_number (GetSystemDefaultLCID ());
2961 return make_number (GetUserDefaultLCID ());
2965 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
2966 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
2967 If successful, the new locale id is returned, otherwise nil. */)
2970 CHECK_NUMBER (lcid
);
2972 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2975 if (!SetThreadLocale (XINT (lcid
)))
2978 /* Need to set input thread locale if present. */
2979 if (dwWindowsThreadId
)
2980 /* Reply is not needed. */
2981 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
2983 return make_number (GetThreadLocale ());
2987 /* We need to build a global list, since the EnumCodePages callback
2988 function isn't given a context pointer. */
2989 Lisp_Object Vw32_valid_codepages
;
2991 static BOOL CALLBACK
2992 enum_codepage_fn (LPTSTR codepageNum
)
2994 DWORD id
= atoi (codepageNum
);
2995 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
2999 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
3000 Sw32_get_valid_codepages
, 0, 0, 0,
3001 doc
: /* Return list of all valid Windows codepages. */)
3004 Vw32_valid_codepages
= Qnil
;
3006 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
3008 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
3009 return Vw32_valid_codepages
;
3013 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
3014 Sw32_get_console_codepage
, 0, 0, 0,
3015 doc
: /* Return current Windows codepage for console input. */)
3018 return make_number (GetConsoleCP ());
3022 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
3023 Sw32_set_console_codepage
, 1, 1, 0,
3024 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
3025 This codepage setting affects keyboard input in tty mode.
3026 If successful, the new CP is returned, otherwise nil. */)
3031 if (!IsValidCodePage (XINT (cp
)))
3034 if (!SetConsoleCP (XINT (cp
)))
3037 return make_number (GetConsoleCP ());
3041 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
3042 Sw32_get_console_output_codepage
, 0, 0, 0,
3043 doc
: /* Return current Windows codepage for console output. */)
3046 return make_number (GetConsoleOutputCP ());
3050 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
3051 Sw32_set_console_output_codepage
, 1, 1, 0,
3052 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
3053 This codepage setting affects display in tty mode.
3054 If successful, the new CP is returned, otherwise nil. */)
3059 if (!IsValidCodePage (XINT (cp
)))
3062 if (!SetConsoleOutputCP (XINT (cp
)))
3065 return make_number (GetConsoleOutputCP ());
3069 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
3070 Sw32_get_codepage_charset
, 1, 1, 0,
3071 doc
: /* Return charset ID corresponding to codepage CP.
3072 Returns nil if the codepage is not valid. */)
3079 if (!IsValidCodePage (XINT (cp
)))
3082 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
3083 return make_number (info
.ciCharset
);
3089 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
3090 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
3091 doc
: /* Return list of Windows keyboard languages and layouts.
3092 The return value is a list of pairs of language id and layout id. */)
3095 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
3096 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
3097 Lisp_Object obj
= Qnil
;
3099 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
3101 while (--num_layouts
>= 0)
3103 DWORD kl
= (DWORD
) layouts
[num_layouts
];
3105 obj
= Fcons (Fcons (make_number (kl
& 0xffff),
3106 make_number ((kl
>> 16) & 0xffff)),
3115 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
3116 Sw32_get_keyboard_layout
, 0, 0, 0,
3117 doc
: /* Return current Windows keyboard language and layout.
3118 The return value is the cons of the language id and the layout id. */)
3121 DWORD kl
= (DWORD
) GetKeyboardLayout (dwWindowsThreadId
);
3123 return Fcons (make_number (kl
& 0xffff),
3124 make_number ((kl
>> 16) & 0xffff));
3128 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
3129 Sw32_set_keyboard_layout
, 1, 1, 0,
3130 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
3131 The keyboard layout setting affects interpretation of keyboard input.
3132 If successful, the new layout id is returned, otherwise nil. */)
3133 (Lisp_Object layout
)
3137 CHECK_CONS (layout
);
3138 CHECK_NUMBER_CAR (layout
);
3139 CHECK_NUMBER_CDR (layout
);
3141 kl
= (XINT (XCAR (layout
)) & 0xffff)
3142 | (XINT (XCDR (layout
)) << 16);
3144 /* Synchronize layout with input thread. */
3145 if (dwWindowsThreadId
)
3147 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
3151 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3153 if (msg
.wParam
== 0)
3157 else if (!ActivateKeyboardLayout ((HKL
) kl
, 0))
3160 return Fw32_get_keyboard_layout ();
3165 syms_of_ntproc (void)
3167 DEFSYM (Qhigh
, "high");
3168 DEFSYM (Qlow
, "low");
3170 defsubr (&Sw32_has_winsock
);
3171 defsubr (&Sw32_unload_winsock
);
3173 defsubr (&Sw32_short_file_name
);
3174 defsubr (&Sw32_long_file_name
);
3175 defsubr (&Sw32_set_process_priority
);
3176 defsubr (&Sw32_get_locale_info
);
3177 defsubr (&Sw32_get_current_locale_id
);
3178 defsubr (&Sw32_get_default_locale_id
);
3179 defsubr (&Sw32_get_valid_locale_ids
);
3180 defsubr (&Sw32_set_current_locale
);
3182 defsubr (&Sw32_get_console_codepage
);
3183 defsubr (&Sw32_set_console_codepage
);
3184 defsubr (&Sw32_get_console_output_codepage
);
3185 defsubr (&Sw32_set_console_output_codepage
);
3186 defsubr (&Sw32_get_valid_codepages
);
3187 defsubr (&Sw32_get_codepage_charset
);
3189 defsubr (&Sw32_get_valid_keyboard_layouts
);
3190 defsubr (&Sw32_get_keyboard_layout
);
3191 defsubr (&Sw32_set_keyboard_layout
);
3193 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
3194 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
3195 Because Windows does not directly pass argv arrays to child processes,
3196 programs have to reconstruct the argv array by parsing the command
3197 line string. For an argument to contain a space, it must be enclosed
3198 in double quotes or it will be parsed as multiple arguments.
3200 If the value is a character, that character will be used to escape any
3201 quote characters that appear, otherwise a suitable escape character
3202 will be chosen based on the type of the program. */);
3203 Vw32_quote_process_args
= Qt
;
3205 DEFVAR_LISP ("w32-start-process-show-window",
3206 Vw32_start_process_show_window
,
3207 doc
: /* When nil, new child processes hide their windows.
3208 When non-nil, they show their window in the method of their choice.
3209 This variable doesn't affect GUI applications, which will never be hidden. */);
3210 Vw32_start_process_show_window
= Qnil
;
3212 DEFVAR_LISP ("w32-start-process-share-console",
3213 Vw32_start_process_share_console
,
3214 doc
: /* When nil, new child processes are given a new console.
3215 When non-nil, they share the Emacs console; this has the limitation of
3216 allowing only one DOS subprocess to run at a time (whether started directly
3217 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
3218 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3219 otherwise respond to interrupts from Emacs. */);
3220 Vw32_start_process_share_console
= Qnil
;
3222 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3223 Vw32_start_process_inherit_error_mode
,
3224 doc
: /* When nil, new child processes revert to the default error mode.
3225 When non-nil, they inherit their error mode setting from Emacs, which stops
3226 them blocking when trying to access unmounted drives etc. */);
3227 Vw32_start_process_inherit_error_mode
= Qt
;
3229 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
3230 doc
: /* Forced delay before reading subprocess output.
3231 This is done to improve the buffering of subprocess output, by
3232 avoiding the inefficiency of frequently reading small amounts of data.
3234 If positive, the value is the number of milliseconds to sleep before
3235 reading the subprocess output. If negative, the magnitude is the number
3236 of time slices to wait (effectively boosting the priority of the child
3237 process temporarily). A value of zero disables waiting entirely. */);
3238 w32_pipe_read_delay
= 50;
3240 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
3241 doc
: /* Non-nil means convert all-upper case file names to lower case.
3242 This applies when performing completions and file name expansion.
3243 Note that the value of this setting also affects remote file names,
3244 so you probably don't want to set to non-nil if you use case-sensitive
3245 filesystems via ange-ftp. */);
3246 Vw32_downcase_file_names
= Qnil
;
3249 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
3250 doc
: /* Non-nil means attempt to fake realistic inode values.
3251 This works by hashing the truename of files, and should detect
3252 aliasing between long and short (8.3 DOS) names, but can have
3253 false positives because of hash collisions. Note that determining
3254 the truename of a file can be slow. */);
3255 Vw32_generate_fake_inodes
= Qnil
;
3258 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
3259 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
3260 This option controls whether to issue additional system calls to determine
3261 accurate link counts, file type, and ownership information. It is more
3262 useful for files on NTFS volumes, where hard links and file security are
3263 supported, than on volumes of the FAT family.
3265 Without these system calls, link count will always be reported as 1 and file
3266 ownership will be attributed to the current user.
3267 The default value `local' means only issue these system calls for files
3268 on local fixed drives. A value of nil means never issue them.
3269 Any other non-nil value means do this even on remote and removable drives
3270 where the performance impact may be noticeable even on modern hardware. */);
3271 Vw32_get_true_file_attributes
= Qlocal
;
3273 staticpro (&Vw32_valid_locale_ids
);
3274 staticpro (&Vw32_valid_codepages
);
3276 /* end of w32proc.c */