xemacs-beta: src/process-nt.c comparison

comparison src/process-nt.c @ 371:cc15677e0335 r21-2b1

Import from CVS: tag r21-2b1

author	cvs
date	Mon, 13 Aug 2007 11:03:08 +0200
parents	972bbb6d6ca2
children	6240c7796c7a

comparison

equal deleted inserted replaced

-:bd866891f083
+:cc15677e0335
 #include <shellapi.h>
 #include <signal.h>
 #ifdef HAVE_SOCKETS
 #include <winsock.h>
 #endif
-/* Arbitrary size limit for code fragments passed to run_in_other_process */
-#define FRAGMENT_CODE_SIZE 32
 /* Bound by winnt.el */
 Lisp_Object Qnt_quote_process_args;
 /* Implemenation-specific data. Pointed to by Lisp_Process->process_data */
 ResumeThread (pmc->h_thread);
 }
 /*
 * Run ROUTINE in the context of process determined by H_PROCESS. The
-* routine is passed the address of DATA as parameter. The ROUTINE must
+* routine is passed the address of DATA as parameter. CODE_END is the
-* not be longer than ROUTINE_CODE_SIZE bytes. DATA_SIZE is the size of
+* address immediately after ROUTINE's code. DATA_SIZE is the size of
 * DATA structure.
 *
 * Note that the code must be positionally independent, and compiled
 * without stack checks (they cause implicit calls into CRT so will
 * fail). DATA should not refer any data in calling process, as both
 *
 * Return the value returned by ROUTINE, or (DWORD)-1 if call failed.
 */
 static DWORD
 run_in_other_process (HANDLE h_process,
-		      LPTHREAD_START_ROUTINE routine,
+		      LPTHREAD_START_ROUTINE routine, LPVOID code_end,
 		      LPVOID data, size_t data_size)
 {
 process_memory pm;
-CONST size_t code_size = FRAGMENT_CODE_SIZE;
+size_t code_size = (LPBYTE)code_end - (LPBYTE)routine;
 /* Need at most 3 extra bytes of memory, for data alignment */
 size_t total_size = code_size + data_size + 3;
 LPVOID remote_data;
 HANDLE h_thread;
 DWORD dw_unused;
 * We handle the following signals:
 *
 * SIGKILL, SIGTERM, SIGQUIT, SIGHUP - These four translate to ExitProcess
 *    executed by the remote process
 * SIGINT - The remote process is sent CTRL_BREAK_EVENT
-*
-* The MSVC5.0 compiler feels free to re-order functions within a
-* compilation unit, so we have no way of finding out the size of the
-* following functions. Therefore these functions must not be larger than
-* FRAGMENT_CODE_SIZE.
 */
 /*
 * Sending SIGKILL
 */
 static DWORD WINAPI
 sigkill_proc (sigkill_data* data)
 {
 (*data->adr_ExitProcess)(255);
 return 1;
+}
+/* Watermark in code space */
+static void
+sigkill_code_end (void)
+{
 }
 /*
 * Sending break or control c
 */
 sigint_proc (sigint_data* data)
 {
 return (*data->adr_GenerateConsoleCtrlEvent) (data->event, 0);
 }
+/* Watermark in code space */
+static void
+sigint_code_end (void)
+{
+}
 /*
 * Enabling signals
 */
 typedef struct
 {
 static DWORD WINAPI
 sig_enable_proc (sig_enable_data* data)
 {
 (*data->adr_SetConsoleCtrlHandler) (NULL, FALSE);
 return 1;
+}
+/* Watermark in code space */
+static void
+sig_enable_code_end (void)
+{
 }
 /*
 * Send signal SIGNO to process H_PROCESS.
 * Return nonzero if successful.
 case SIGHUP:
 {
 	sigkill_data d;
 	d.adr_ExitProcess = GetProcAddress (h_kernel, "ExitProcess");
 	assert (d.adr_ExitProcess);
-	retval = run_in_other_process (h_process, sigkill_proc,
+	retval = run_in_other_process (h_process,
+				       sigkill_proc, sigkill_code_end,
 				       &d, sizeof (d));
 	break;
 }
 case SIGINT:
 {
 	sigint_data d;
 	d.adr_GenerateConsoleCtrlEvent =
 	  GetProcAddress (h_kernel, "GenerateConsoleCtrlEvent");
 	assert (d.adr_GenerateConsoleCtrlEvent);
 	d.event = CTRL_C_EVENT;
-	retval = run_in_other_process (h_process, sigint_proc,
+	retval = run_in_other_process (h_process,
+				       sigint_proc, sigint_code_end,
 				       &d, sizeof (d));
 	break;
 }
 default:
 assert (0);
 assert (h_kernel != NULL);
 d.adr_SetConsoleCtrlHandler =
 GetProcAddress (h_kernel, "SetConsoleCtrlHandler");
 assert (d.adr_SetConsoleCtrlHandler);
-run_in_other_process (h_process, sig_enable_proc,
+run_in_other_process (h_process,
+			sig_enable_proc, sig_enable_code_end,
 			&d, sizeof (d));
 }
 #pragma warning (default : 4113)
 * The method must return PID of the new proces, a (positive??? ####) number
 * which fits into Lisp_Int. No return value indicates an error, the method
 * must signal an error instead.
 */
+/* #### This function completely ignores Vprocess_environment */
 static void
 signal_cannot_launch (Lisp_Object image_file, DWORD err)
 {
 mswindows_set_errno (err);
 signal_simple_error_2 ("Error starting", image_file, lisp_strerror (errno));
 static int
 nt_create_process (struct Lisp_Process *p,
 		   Lisp_Object *argv, int nargv,
 		   Lisp_Object program, Lisp_Object cur_dir)
 {
-HANDLE hmyshove, hmyslurp, hprocin, hprocout, hprocerr;
+HANDLE hmyshove, hmyslurp, hprocin, hprocout;
 LPTSTR command_line;
 BOOL do_io, windowed;
-char *proc_env;
 /* Find out whether the application is windowed or not */
 {
 /* SHGetFileInfo tends to return ERROR_FILE_NOT_FOUND on most
 errors. This leads to bogus error message. */
 sa.lpSecurityDescriptor = NULL;
 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. */
 DuplicateHandle (GetCurrentProcess(), hmyshove, GetCurrentProcess(), &htmp,
 		       0, FALSE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
 strcat (command_line, XSTRING_DATA (args_or_ret));
 UNGCPRO; /* args_or_ret */
 }
-/* Set `proc_env' to a nul-separated array of the strings in
-Vprocess_environment terminated by 2 nuls.  */
-{
-extern int compare_env (const char **strp1, const char **strp2);
-char **env;
-REGISTER Lisp_Object tem;
-REGISTER char **new_env;
-REGISTER int new_length = 0, i, new_space;
-char *penv;
-for (tem = Vprocess_environment;
-	 (CONSP (tem)
-	  && STRINGP (XCAR (tem)));
-	 tem = XCDR (tem))
-new_length++;
-/* new_length + 1 to include terminating 0.  */
-env = new_env = alloca_array (char *, new_length + 1);
-/* Copy the Vprocess_environment strings into new_env.  */
-for (tem = Vprocess_environment;
-	 (CONSP (tem)
-	  && STRINGP (XCAR (tem)));
-	 tem = XCDR (tem))
-{
-	char **ep = env;
-	char *string = (char *) XSTRING_DATA (XCAR (tem));
-	/* See if this string duplicates any string already in the env.
-	   If so, don't put it in.
-	   When an env var has multiple definitions,
-	   we keep the definition that comes first in process-environment.  */
-	for (; ep != new_env; ep++)
-	  {
-	    char *p = *ep, *q = string;
-	    while (1)
-	      {
-		if (*q == 0)
-		  /* The string is malformed; might as well drop it.  */
-		  goto duplicate;
-		if (*q != *p)
-		  break;
-		if (*q == '=')
-		  goto duplicate;
-		p++, q++;
-	      }
-	  }
-	*new_env++ = string;
-duplicate: ;
-}
-*new_env = 0;
-/* Sort the environment variables */
-new_length = new_env - env;
-qsort (env, new_length, sizeof (char *), compare_env);
-/* Work out how much space to allocate */
-new_space = 0;
-for (i = 0; i < new_length; i++)
-{
-	new_space += strlen(env[i]) + 1;
-}
-new_space++;
-/* Allocate space and copy variables into it */
-penv = proc_env = alloca(new_space);
-for (i = 0; i < new_length; i++)
-{
-	strcpy(penv, env[i]);
-	penv += strlen(env[i]) + 1;
-}
-*penv = 0;
-}
 /* Create process */
 {
 STARTUPINFO si;
 PROCESS_INFORMATION pi;
 DWORD err;
 si.wShowWindow = windowed ? SW_SHOWNORMAL : SW_HIDE;
 if (do_io)
 {
 	si.hStdInput = hprocin;
 	si.hStdOutput = hprocout;
-	si.hStdError = hprocerr;
+	si.hStdError = hprocout;
 	si.dwFlags |= STARTF_USESTDHANDLES;
 }
 err = (CreateProcess (NULL, command_line, NULL, NULL, TRUE,
 			  CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP
 			  | CREATE_SUSPENDED,
-			  proc_env, (char *) XSTRING_DATA (cur_dir), &si, &pi)
+			  NULL, (char *) XSTRING_DATA (cur_dir), &si, &pi)
 	   ? 0 : GetLastError ());
 if (do_io)
 {
 	/* These just have been inherited; we do not need a copy */
 	CloseHandle (hprocin);
 	CloseHandle (hprocout);
-	CloseHandle (hprocerr);
 }
 /* Handle process creation failure */
 if (err)
 {
 struct Lisp_Process *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
 data. */
-Bufbyte chunkbuf[128];
+Bufbyte chunkbuf[512];
 Bytecount chunklen;
 while (1)
 {
 int writeret;
-chunklen = Lstream_read (lstream, chunkbuf, 128);
+chunklen = Lstream_read (lstream, chunkbuf, 512);
 if (chunklen <= 0)
 	break; /* perhaps should abort() if < 0?
 		  This should never happen. */
 /* Lstream_write() will never successfully write less than the

Mercurial > hg > xemacs-beta

comparison src/process-nt.c @ 371:cc15677e0335 r21-2b1