#include "procimpl.h"
#include "sysdep.h"
-#include <windows.h>
#ifndef __MINGW32__
#include <shellapi.h>
#else
struct nt_process_data
{
HANDLE h_process;
+ int need_enable_child_signals;
};
#define NT_DATA(p) ((struct nt_process_data*)((p)->process_data))
/* This one breaks process abstraction. Prototype is in console-msw.h,
used by select_process method in event-msw.c */
HANDLE
-get_nt_process_handle (struct Lisp_Process *p)
+get_nt_process_handle (Lisp_Process *p)
{
return (NT_DATA (p)->h_process);
}
LPVOID data, size_t data_size)
{
process_memory pm;
- CONST size_t code_size = FRAGMENT_CODE_SIZE;
+ const size_t code_size = FRAGMENT_CODE_SIZE;
/* Need at most 3 extra bytes of memory, for data alignment */
size_t total_size = code_size + data_size + 3;
LPVOID remote_data;
*/
static void
-nt_alloc_process_data (struct Lisp_Process *p)
+nt_alloc_process_data (Lisp_Process *p)
{
p->process_data = xnew_and_zero (struct nt_process_data);
}
static void
-nt_finalize_process_data (struct Lisp_Process *p, int for_disksave)
+nt_finalize_process_data (Lisp_Process *p, int for_disksave)
{
assert (!for_disksave);
if (NT_DATA(p)->h_process)
}
static int
-nt_create_process (struct Lisp_Process *p,
+nt_create_process (Lisp_Process *p,
Lisp_Object *argv, int nargv,
Lisp_Object program, Lisp_Object cur_dir)
{
- HANDLE hmyshove, hmyslurp, hprocin, hprocout;
+ HANDLE hmyshove, hmyslurp, hprocin, hprocout, hprocerr;
LPTSTR command_line;
BOOL do_io, windowed;
char *proc_env;
CreatePipe (&hprocin, &hmyshove, &sa, 0);
CreatePipe (&hmyslurp, &hprocout, &sa, 0);
+ /* Duplicate the stdout handle for use as stderr */
+ DuplicateHandle(GetCurrentProcess(), hprocout, GetCurrentProcess(), &hprocerr,
+ 0, TRUE, DUPLICATE_SAME_ACCESS);
+
/* Stupid Win32 allows to create a pipe with *both* ends either
inheritable or not. We need process ends inheritable, and local
ends not inheritable. */
new_space++;
/* Allocate space and copy variables into it */
- penv = proc_env = alloca(new_space);
+ penv = proc_env = (char*) alloca(new_space);
for (i = 0; i < new_length; i++)
{
strcpy(penv, env[i]);
{
si.hStdInput = hprocin;
si.hStdOutput = hprocout;
- si.hStdError = hprocout;
+ si.hStdError = hprocerr;
si.dwFlags |= STARTF_USESTDHANDLES;
}
/* These just have been inherited; we do not need a copy */
CloseHandle (hprocin);
CloseHandle (hprocout);
+ CloseHandle (hprocerr);
}
/* Handle process creation failure */
CloseHandle (pi.hProcess);
}
- if (!windowed)
- enable_child_signals (pi.hProcess);
-
ResumeThread (pi.hThread);
CloseHandle (pi.hThread);
- /* Hack to support Windows 95 negative pids */
- return ((int)pi.dwProcessId < 0
- ? -(int)pi.dwProcessId : (int)pi.dwProcessId);
+ /* Remember to enable child signals later if this is not a windowed
+ app. Can't do it right now because that screws up the MKS Toolkit
+ shell. */
+ if (!windowed)
+ {
+ NT_DATA(p)->need_enable_child_signals = 10;
+ kick_status_notify ();
+ }
+
+ return ((int)pi.dwProcessId);
}
}
*/
static void
-nt_update_status_if_terminated (struct Lisp_Process* p)
+nt_update_status_if_terminated (Lisp_Process* p)
{
DWORD exit_code;
+
+ if (NT_DATA(p)->need_enable_child_signals > 1)
+ {
+ NT_DATA(p)->need_enable_child_signals -= 1;
+ kick_status_notify ();
+ }
+ else if (NT_DATA(p)->need_enable_child_signals == 1)
+ {
+ enable_child_signals(NT_DATA(p)->h_process);
+ NT_DATA(p)->need_enable_child_signals = 0;
+ }
+
if (GetExitCodeProcess (NT_DATA(p)->h_process, &exit_code)
&& exit_code != STILL_ACTIVE)
{
static void
nt_send_process (Lisp_Object proc, struct lstream* lstream)
{
- struct Lisp_Process *p = XPROCESS (proc);
+ volatile Lisp_Object vol_proc = proc;
+ Lisp_Process *volatile p = XPROCESS (proc);
/* use a reasonable-sized buffer (somewhere around the size of the
stream buffer) so as to avoid inundating the stream with blocked
while (1)
{
- int writeret;
+ ssize_t writeret;
chunklen = Lstream_read (lstream, chunkbuf, 128);
if (chunklen <= 0)
p->core_dumped = 0;
p->tick++;
process_tick++;
- deactivate_process (proc);
+ deactivate_process (*((Lisp_Object *) (&vol_proc)));
error ("Broken pipe error sending to process %s; closed it",
XSTRING_DATA (p->name));
}
nt_kill_child_process (Lisp_Object proc, int signo,
int current_group, int nomsg)
{
- struct Lisp_Process *p = XPROCESS (proc);
+ Lisp_Process *p = XPROCESS (proc);
+
+ /* Enable child signals if necessary. This may lose the first
+ but it's better than nothing. */
+ if (NT_DATA(p)->need_enable_child_signals > 0)
+ {
+ enable_child_signals(NT_DATA(p)->h_process);
+ NT_DATA(p)->need_enable_child_signals = 0;
+ }
/* Signal error if SIGNO cannot be sent */
validate_signal_number (signo);
/* Ok, got an answer */
if (WSAGETASYNCERROR(msg.lParam) == NO_ERROR)
success = 1;
+ else
+ {
+ warn_when_safe(Qstream, Qwarning,
+ "cannot get IP address for host \"%s\"",
+ XSTRING_DATA (host));
+ }
goto done;
}
else if (msg.message == WM_TIMER && msg.wParam == SOCK_TIMER_ID)
retval = connect (s, (struct sockaddr *) &address, sizeof (address));
if (retval != NO_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
goto connect_failed;
-
/* Wait while connection is established */
while (1)
{
connect_failed:
closesocket (s);
+ if (INTP (service)) {
+ warn_when_safe(Qstream, Qwarning,
+ "failure to open network stream to host \"%s\" for service \"%d\"",
+ XSTRING_DATA (host),
+ (unsigned short) XINT (service));
+ }
+ else {
+ warn_when_safe(Qstream, Qwarning,
+ "failure to open network stream to host \"%s\" for service \"%s\"",
+ XSTRING_DATA (host),
+ XSTRING_DATA (service));
+ }
report_file_error ("connection failed", list2 (host, name));
}