2000-02-17 20:38:33 +01:00
|
|
|
/* spawn.cc
|
|
|
|
|
2002-01-13 21:03:03 +01:00
|
|
|
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
This file is part of Cygwin.
|
|
|
|
|
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
|
|
details. */
|
|
|
|
|
2000-08-02 18:28:18 +02:00
|
|
|
#include "winsup.h"
|
2000-02-17 20:38:33 +01:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <process.h>
|
|
|
|
#include <sys/wait.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <limits.h>
|
2000-07-27 19:30:51 +02:00
|
|
|
#include <wingdi.h>
|
|
|
|
#include <winuser.h>
|
2000-02-17 20:38:33 +01:00
|
|
|
#include <ctype.h>
|
2000-08-22 07:10:20 +02:00
|
|
|
#include "cygerrno.h"
|
2000-09-08 04:56:55 +02:00
|
|
|
#include <sys/cygwin.h>
|
2001-07-26 21:22:24 +02:00
|
|
|
#include "security.h"
|
2000-08-22 07:10:20 +02:00
|
|
|
#include "fhandler.h"
|
|
|
|
#include "path.h"
|
2000-08-12 07:35:42 +02:00
|
|
|
#include "dtable.h"
|
2000-08-22 07:10:20 +02:00
|
|
|
#include "sigproc.h"
|
2000-09-06 23:03:10 +02:00
|
|
|
#include "cygheap.h"
|
2000-09-01 22:54:22 +02:00
|
|
|
#include "child_info.h"
|
2001-01-28 06:51:15 +01:00
|
|
|
#include "shared_info.h"
|
2000-08-12 07:35:42 +02:00
|
|
|
#include "pinfo.h"
|
2000-09-08 04:56:55 +02:00
|
|
|
#define NEED_VFORK
|
2000-08-22 07:10:20 +02:00
|
|
|
#include "perthread.h"
|
2000-09-08 04:56:55 +02:00
|
|
|
#include "registry.h"
|
|
|
|
#include "environ.h"
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
#define LINE_BUF_CHUNK (MAX_PATH * 2)
|
|
|
|
|
2000-10-24 04:25:27 +02:00
|
|
|
static suffix_info std_suffixes[] =
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
|
|
|
suffix_info (".exe", 1), suffix_info ("", 1),
|
|
|
|
suffix_info (".com"), suffix_info (".cmd"),
|
|
|
|
suffix_info (".bat"), suffix_info (".dll"),
|
|
|
|
suffix_info (NULL)
|
|
|
|
};
|
|
|
|
|
2000-10-24 04:25:27 +02:00
|
|
|
HANDLE hExeced;
|
2002-01-10 04:21:27 +01:00
|
|
|
DWORD dwExeced;
|
2000-10-24 04:25:27 +02:00
|
|
|
|
2000-02-17 20:38:33 +01:00
|
|
|
/* Add .exe to PROG if not already present and see if that exists.
|
|
|
|
If not, return PROG (converted from posix to win32 rules if necessary).
|
|
|
|
The result is always BUF.
|
|
|
|
|
|
|
|
Returns (possibly NULL) suffix */
|
|
|
|
|
|
|
|
static const char *
|
2002-01-10 04:21:27 +01:00
|
|
|
perhaps_suffix (const char *prog, path_conv& buf)
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
|
|
|
char *ext;
|
|
|
|
|
|
|
|
debug_printf ("prog '%s'", prog);
|
2000-07-17 21:18:21 +02:00
|
|
|
buf.check (prog, PC_SYM_FOLLOW | PC_FULL, std_suffixes);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2001-10-05 03:39:08 +02:00
|
|
|
if (!buf.exists () || buf.isdir ())
|
2000-02-17 20:38:33 +01:00
|
|
|
ext = NULL;
|
2000-04-26 07:13:32 +02:00
|
|
|
else if (buf.known_suffix)
|
2001-10-01 06:10:07 +02:00
|
|
|
ext = (char *) buf + (buf.known_suffix - buf.get_win32 ());
|
2000-02-17 20:38:33 +01:00
|
|
|
else
|
|
|
|
ext = strchr (buf, '\0');
|
|
|
|
|
2000-04-26 07:13:32 +02:00
|
|
|
debug_printf ("buf %s, suffix found '%s'", (char *) buf, ext);
|
2000-02-17 20:38:33 +01:00
|
|
|
return ext;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find an executable name, possibly by appending known executable
|
|
|
|
suffixes to it. The win32-translated name is placed in 'buf'.
|
|
|
|
Any found suffix is returned in known_suffix.
|
|
|
|
|
|
|
|
If the file is not found and !null_if_not_found then the win32 version
|
|
|
|
of name is placed in buf and returned. Otherwise the contents of buf
|
|
|
|
is undefined and NULL is returned. */
|
|
|
|
|
|
|
|
const char * __stdcall
|
2000-04-26 07:13:32 +02:00
|
|
|
find_exec (const char *name, path_conv& buf, const char *mywinenv,
|
2001-10-31 01:55:32 +01:00
|
|
|
unsigned opt, const char **known_suffix)
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
|
|
|
const char *suffix = "";
|
|
|
|
debug_printf ("find_exec (%s)", name);
|
2002-03-22 04:24:30 +01:00
|
|
|
const char *retval = buf;
|
2001-10-31 01:55:32 +01:00
|
|
|
char tmp[MAX_PATH];
|
|
|
|
const char *posix = (opt & FE_NATIVE) ? NULL : name;
|
|
|
|
bool has_slash = strchr (name, '/');
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
/* Check to see if file can be opened as is first.
|
|
|
|
Win32 systems always check . first, but PATH may not be set up to
|
|
|
|
do this. */
|
2001-10-31 01:55:32 +01:00
|
|
|
if ((has_slash || opt & FE_CWD)
|
|
|
|
&& (suffix = perhaps_suffix (name, buf)) != NULL)
|
|
|
|
{
|
|
|
|
if (posix && !has_slash)
|
|
|
|
{
|
|
|
|
tmp[0] = '.';
|
|
|
|
tmp[1] = '/';
|
|
|
|
strcpy (tmp + 2, name);
|
|
|
|
posix = tmp;
|
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
win_env *winpath;
|
|
|
|
const char *path;
|
2001-10-31 01:55:32 +01:00
|
|
|
const char *posix_path;
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
/* Return the error condition if this is an absolute path or if there
|
|
|
|
is no PATH to search. */
|
|
|
|
if (strchr (name, '/') || strchr (name, '\\') ||
|
2000-05-30 02:38:51 +02:00
|
|
|
isdrive (name) ||
|
2000-02-17 20:38:33 +01:00
|
|
|
!(winpath = getwinenv (mywinenv)) ||
|
|
|
|
!(path = winpath->get_native ()) ||
|
|
|
|
*path == '\0')
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
debug_printf ("%s%s", mywinenv, path);
|
|
|
|
|
2001-10-31 01:55:32 +01:00
|
|
|
posix = (opt & FE_NATIVE) ? NULL : tmp;
|
|
|
|
posix_path = winpath->get_posix () - 1;
|
2000-02-17 20:38:33 +01:00
|
|
|
/* Iterate over the specified path, looking for the file with and
|
|
|
|
without executable extensions. */
|
|
|
|
do
|
|
|
|
{
|
2001-10-31 01:55:32 +01:00
|
|
|
posix_path++;
|
2000-02-17 20:38:33 +01:00
|
|
|
char *eotmp = strccpy (tmp, &path, ';');
|
|
|
|
/* An empty path or '.' means the current directory, but we've
|
|
|
|
already tried that. */
|
2001-10-31 01:55:32 +01:00
|
|
|
if (opt & FE_CWD && (tmp[0] == '\0' || (tmp[0] == '.' && tmp[1] == '\0')))
|
2000-02-17 20:38:33 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
*eotmp++ = '\\';
|
|
|
|
strcpy (eotmp, name);
|
|
|
|
|
|
|
|
debug_printf ("trying %s", tmp);
|
|
|
|
|
|
|
|
if ((suffix = perhaps_suffix (tmp, buf)) != NULL)
|
2001-10-31 01:55:32 +01:00
|
|
|
{
|
|
|
|
if (posix == tmp)
|
|
|
|
{
|
|
|
|
eotmp = strccpy (tmp, &posix_path, ':');
|
|
|
|
if (eotmp == tmp)
|
|
|
|
*eotmp++ = '.';
|
|
|
|
*eotmp++ = '/';
|
|
|
|
strcpy (eotmp, name);
|
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
2001-10-31 01:55:32 +01:00
|
|
|
while (*path && *++path && (posix_path = strchr (posix_path, ':')));
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2001-08-22 19:50:22 +02:00
|
|
|
errout:
|
2001-10-31 01:55:32 +01:00
|
|
|
posix = NULL;
|
2000-02-17 20:38:33 +01:00
|
|
|
/* Couldn't find anything in the given path.
|
|
|
|
Take the appropriate action based on null_if_not_found. */
|
2001-10-31 01:55:32 +01:00
|
|
|
if (opt & FE_NNF)
|
2000-02-17 20:38:33 +01:00
|
|
|
retval = NULL;
|
2001-10-31 01:55:32 +01:00
|
|
|
else if (opt & FE_NATIVE)
|
2000-04-26 07:13:32 +02:00
|
|
|
buf.check (name);
|
2002-03-22 04:24:30 +01:00
|
|
|
else
|
|
|
|
retval = name;
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2001-08-22 19:50:22 +02:00
|
|
|
out:
|
2001-10-31 01:55:32 +01:00
|
|
|
if (posix)
|
|
|
|
buf.set_path (posix);
|
2000-04-26 07:13:32 +02:00
|
|
|
debug_printf ("%s = find_exec (%s)", (char *) buf, name);
|
2000-02-17 20:38:33 +01:00
|
|
|
if (known_suffix)
|
|
|
|
*known_suffix = suffix ?: strchr (buf, '\0');
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Utility for spawn_guts. */
|
|
|
|
|
|
|
|
static HANDLE
|
|
|
|
handle (int n, int direction)
|
|
|
|
{
|
2001-04-18 23:10:15 +02:00
|
|
|
fhandler_base *fh = cygheap->fdtab[n];
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
if (!fh)
|
|
|
|
return INVALID_HANDLE_VALUE;
|
|
|
|
if (fh->get_close_on_exec ())
|
|
|
|
return INVALID_HANDLE_VALUE;
|
|
|
|
if (direction == 0)
|
|
|
|
return fh->get_handle ();
|
|
|
|
return fh->get_output_handle ();
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
iscmd (const char *argv0, const char *what)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
n = strlen (argv0) - strlen (what);
|
|
|
|
if (n >= 2 && argv0[1] != ':')
|
|
|
|
return 0;
|
2000-07-01 19:30:35 +02:00
|
|
|
return n >= 0 && strcasematch (argv0 + n, what) &&
|
2000-02-17 20:38:33 +01:00
|
|
|
(n == 0 || isdirsep (argv0[n - 1]));
|
|
|
|
}
|
|
|
|
|
|
|
|
class linebuf
|
|
|
|
{
|
2001-08-22 19:50:22 +02:00
|
|
|
public:
|
2000-02-17 20:38:33 +01:00
|
|
|
size_t ix;
|
|
|
|
char *buf;
|
|
|
|
size_t alloced;
|
2000-10-20 06:20:21 +02:00
|
|
|
linebuf () : ix (0), buf (NULL), alloced (0) {}
|
2000-02-17 20:38:33 +01:00
|
|
|
~linebuf () {/* if (buf) free (buf);*/}
|
|
|
|
void add (const char *what, int len);
|
|
|
|
void add (const char *what) {add (what, strlen (what));}
|
|
|
|
void prepend (const char *what, int len);
|
|
|
|
};
|
|
|
|
|
|
|
|
void
|
|
|
|
linebuf::add (const char *what, int len)
|
|
|
|
{
|
|
|
|
size_t newix;
|
|
|
|
if ((newix = ix + len) >= alloced || !buf)
|
|
|
|
{
|
|
|
|
alloced += LINE_BUF_CHUNK + newix;
|
|
|
|
buf = (char *) realloc (buf, alloced + 1);
|
|
|
|
}
|
|
|
|
memcpy (buf + ix, what, len);
|
|
|
|
ix = newix;
|
|
|
|
buf[ix] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
linebuf::prepend (const char *what, int len)
|
|
|
|
{
|
|
|
|
int buflen;
|
|
|
|
size_t newix;
|
|
|
|
if ((newix = ix + len) >= alloced)
|
|
|
|
{
|
|
|
|
alloced += LINE_BUF_CHUNK + newix;
|
|
|
|
buf = (char *) realloc (buf, alloced + 1);
|
|
|
|
buf[ix] = '\0';
|
|
|
|
}
|
|
|
|
if ((buflen = strlen (buf)))
|
|
|
|
memmove (buf + len, buf, buflen + 1);
|
|
|
|
else
|
|
|
|
buf[newix] = '\0';
|
|
|
|
memcpy (buf, what, len);
|
|
|
|
ix = newix;
|
|
|
|
}
|
|
|
|
|
2000-09-13 21:57:00 +02:00
|
|
|
class av
|
2000-09-03 06:16:35 +02:00
|
|
|
{
|
|
|
|
char **argv;
|
2000-09-13 21:57:00 +02:00
|
|
|
int calloced;
|
2001-08-22 19:50:22 +02:00
|
|
|
public:
|
2000-09-13 21:57:00 +02:00
|
|
|
int argc;
|
|
|
|
av (int ac, const char * const *av) : calloced (0), argc (ac)
|
2000-09-03 06:16:35 +02:00
|
|
|
{
|
2000-10-14 07:52:38 +02:00
|
|
|
argv = (char **) cmalloc (HEAP_1_ARGV, (argc + 5) * sizeof (char *));
|
2000-09-03 06:16:35 +02:00
|
|
|
memcpy (argv, av, (argc + 1) * sizeof (char *));
|
|
|
|
}
|
|
|
|
~av ()
|
|
|
|
{
|
|
|
|
for (int i = 0; i < calloced; i++)
|
|
|
|
cfree (argv[i]);
|
|
|
|
cfree (argv);
|
|
|
|
}
|
|
|
|
int unshift (const char *what, int conv = 0);
|
|
|
|
operator char **() {return argv;}
|
2000-09-13 21:57:00 +02:00
|
|
|
void all_calloced () {calloced = argc;}
|
|
|
|
void replace0_maybe (const char *arg0)
|
|
|
|
{
|
|
|
|
/* Note: Assumes that argv array has not yet been "unshifted" */
|
|
|
|
if (!calloced)
|
|
|
|
{
|
2000-09-27 07:12:09 +02:00
|
|
|
argv[0] = cstrdup1 (arg0);
|
2000-09-13 21:57:00 +02:00
|
|
|
calloced = 1;
|
|
|
|
}
|
|
|
|
}
|
2000-09-25 18:36:12 +02:00
|
|
|
void dup_maybe (int i)
|
2000-09-13 21:57:00 +02:00
|
|
|
{
|
|
|
|
if (i >= calloced)
|
2000-09-27 07:12:09 +02:00
|
|
|
argv[i] = cstrdup1 (argv[i]);
|
2000-09-13 21:57:00 +02:00
|
|
|
}
|
|
|
|
void dup_all ()
|
|
|
|
{
|
|
|
|
for (int i = calloced; i < argc; i++)
|
2000-09-27 07:12:09 +02:00
|
|
|
argv[i] = cstrdup1 (argv[i]);
|
2000-09-13 21:57:00 +02:00
|
|
|
}
|
2000-09-03 06:16:35 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
int
|
|
|
|
av::unshift (const char *what, int conv)
|
|
|
|
{
|
|
|
|
char **av;
|
|
|
|
av = (char **) crealloc (argv, (argc + 2) * sizeof (char *));
|
|
|
|
if (!av)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
argv = av;
|
|
|
|
memmove (argv + 1, argv, (argc + 1) * sizeof (char *));
|
|
|
|
char buf[MAX_PATH + 1];
|
|
|
|
if (conv)
|
|
|
|
{
|
|
|
|
cygwin_conv_to_posix_path (what, buf);
|
|
|
|
char *p = strchr (buf, '\0') - 4;
|
|
|
|
if (p > buf && strcasematch (p, ".exe"))
|
|
|
|
*p = '\0';
|
|
|
|
what = buf;
|
|
|
|
}
|
2000-09-27 07:12:09 +02:00
|
|
|
*argv = cstrdup1 (what);
|
2000-09-03 06:16:35 +02:00
|
|
|
argc++;
|
|
|
|
calloced++;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2000-07-29 18:24:59 +02:00
|
|
|
static int __stdcall
|
2002-06-11 04:08:00 +02:00
|
|
|
spawn_guts (const char * prog_arg, const char *const *argv,
|
2000-07-29 18:24:59 +02:00
|
|
|
const char *const envp[], int mode)
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
|
|
|
BOOL rc;
|
2000-07-29 18:24:59 +02:00
|
|
|
pid_t cygpid;
|
2000-11-04 06:54:57 +01:00
|
|
|
sigframe thisframe (mainthread);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
MALLOC_CHECK;
|
|
|
|
|
|
|
|
if (prog_arg == NULL)
|
|
|
|
{
|
|
|
|
syscall_printf ("prog_arg is NULL");
|
2001-03-18 21:58:18 +01:00
|
|
|
set_errno (EINVAL);
|
2000-02-17 20:38:33 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2001-06-24 23:57:50 +02:00
|
|
|
syscall_printf ("spawn_guts (%d, %.132s)", mode, prog_arg);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
if (argv == NULL)
|
|
|
|
{
|
|
|
|
syscall_printf ("argv is NULL");
|
2001-03-18 21:58:18 +01:00
|
|
|
set_errno (EINVAL);
|
2000-02-17 20:38:33 +01:00
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
2000-09-03 06:16:35 +02:00
|
|
|
path_conv real_path;
|
|
|
|
|
|
|
|
linebuf one_line;
|
|
|
|
|
|
|
|
STARTUPINFO si = {0, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL};
|
|
|
|
|
|
|
|
child_info_spawn ciresrv;
|
|
|
|
si.lpReserved2 = (LPBYTE) &ciresrv;
|
|
|
|
si.cbReserved2 = sizeof (ciresrv);
|
|
|
|
|
|
|
|
DWORD chtype;
|
2001-10-04 04:34:20 +02:00
|
|
|
if (mode != _P_OVERLAY)
|
2000-09-03 06:16:35 +02:00
|
|
|
chtype = PROC_SPAWN;
|
|
|
|
else
|
2000-10-14 07:52:38 +02:00
|
|
|
chtype = PROC_EXEC;
|
|
|
|
|
2002-07-13 22:00:27 +02:00
|
|
|
HANDLE subproc_ready;
|
2001-10-04 04:34:20 +02:00
|
|
|
if (chtype != PROC_EXEC)
|
2002-07-13 22:00:27 +02:00
|
|
|
subproc_ready = NULL;
|
2001-07-17 05:41:52 +02:00
|
|
|
else
|
|
|
|
{
|
2002-07-13 22:00:27 +02:00
|
|
|
subproc_ready = CreateEvent (&sec_all, TRUE, FALSE, NULL);
|
|
|
|
ProtectHandleINH (subproc_ready);
|
2001-07-17 05:41:52 +02:00
|
|
|
}
|
2000-09-03 06:16:35 +02:00
|
|
|
|
2001-10-04 04:34:20 +02:00
|
|
|
init_child_info (chtype, &ciresrv, (mode == _P_OVERLAY) ? myself->pid : 1,
|
2002-07-13 22:00:27 +02:00
|
|
|
subproc_ready);
|
2000-09-03 06:16:35 +02:00
|
|
|
if (!DuplicateHandle (hMainProc, hMainProc, hMainProc, &ciresrv.parent, 0, 1,
|
|
|
|
DUPLICATE_SAME_ACCESS))
|
|
|
|
{
|
|
|
|
system_printf ("couldn't create handle to myself for child, %E");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2000-09-27 07:12:09 +02:00
|
|
|
ciresrv.moreinfo = (cygheap_exec_info *) ccalloc (HEAP_1_EXEC, 1, sizeof (cygheap_exec_info));
|
2000-10-15 03:37:07 +02:00
|
|
|
ciresrv.moreinfo->old_title = NULL;
|
2000-09-03 06:16:35 +02:00
|
|
|
|
2000-02-17 20:38:33 +01:00
|
|
|
/* CreateProcess takes one long string that is the command line (sigh).
|
|
|
|
We need to quote any argument that has whitespace or embedded "'s. */
|
|
|
|
|
2000-09-03 06:16:35 +02:00
|
|
|
int ac;
|
|
|
|
for (ac = 0; argv[ac]; ac++)
|
2000-02-17 20:38:33 +01:00
|
|
|
/* nothing */;
|
|
|
|
|
2000-09-03 06:16:35 +02:00
|
|
|
av newargv (ac, argv);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2000-10-20 06:20:21 +02:00
|
|
|
int null_app_name = 0;
|
2000-09-03 06:16:35 +02:00
|
|
|
if (ac == 3 && argv[1][0] == '/' && argv[1][1] == 'c' &&
|
2000-02-17 20:38:33 +01:00
|
|
|
(iscmd (argv[0], "command.com") || iscmd (argv[0], "cmd.exe")))
|
|
|
|
{
|
2000-10-20 06:20:21 +02:00
|
|
|
real_path.check (prog_arg);
|
2000-10-21 06:53:49 +02:00
|
|
|
one_line.add ("\"");
|
2000-10-20 06:20:21 +02:00
|
|
|
if (!real_path.error)
|
|
|
|
one_line.add (real_path);
|
|
|
|
else
|
|
|
|
one_line.add (argv[0]);
|
2000-10-21 06:53:49 +02:00
|
|
|
one_line.add ("\"");
|
2000-02-17 20:38:33 +01:00
|
|
|
one_line.add (" ");
|
|
|
|
one_line.add (argv[1]);
|
|
|
|
one_line.add (" ");
|
|
|
|
one_line.add (argv[2]);
|
2000-09-03 06:16:35 +02:00
|
|
|
strcpy (real_path, argv[0]);
|
2000-10-20 06:20:21 +02:00
|
|
|
null_app_name = 1;
|
2000-02-17 20:38:33 +01:00
|
|
|
goto skip_arg_parsing;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *ext;
|
2000-09-03 06:16:35 +02:00
|
|
|
if ((ext = perhaps_suffix (prog_arg, real_path)) == NULL)
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
|
|
|
set_errno (ENOENT);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
MALLOC_CHECK;
|
|
|
|
|
|
|
|
/* If the file name ends in either .exe, .com, .bat, or .cmd we assume
|
|
|
|
that it is NOT a script file */
|
|
|
|
while (*ext == '\0')
|
|
|
|
{
|
|
|
|
HANDLE hnd = CreateFileA (real_path,
|
|
|
|
GENERIC_READ,
|
|
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
|
|
&sec_none_nih,
|
|
|
|
OPEN_EXISTING,
|
|
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
|
|
0);
|
|
|
|
if (hnd == INVALID_HANDLE_VALUE)
|
|
|
|
{
|
|
|
|
__seterrno ();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
DWORD done;
|
|
|
|
|
|
|
|
char buf[2 * MAX_PATH + 1];
|
2001-03-18 21:58:18 +01:00
|
|
|
buf[0] = buf[1] = buf[2] = buf[sizeof (buf) - 1] = '\0';
|
2000-09-30 03:56:40 +02:00
|
|
|
if (!ReadFile (hnd, buf, sizeof (buf) - 1, &done, 0))
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
|
|
|
CloseHandle (hnd);
|
|
|
|
__seterrno ();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
CloseHandle (hnd);
|
|
|
|
|
|
|
|
if (buf[0] == 'M' && buf[1] == 'Z')
|
|
|
|
break;
|
|
|
|
|
2000-09-13 21:57:00 +02:00
|
|
|
debug_printf ("%s is a script", (char *) real_path);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2000-09-13 21:57:00 +02:00
|
|
|
char *pgm, *arg1;
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
if (buf[0] != '#' || buf[1] != '!')
|
|
|
|
{
|
2000-09-03 06:16:35 +02:00
|
|
|
pgm = (char *) "/bin/sh";
|
2000-02-17 20:38:33 +01:00
|
|
|
arg1 = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2000-09-13 21:57:00 +02:00
|
|
|
char *ptr;
|
2000-02-17 20:38:33 +01:00
|
|
|
pgm = buf + 2;
|
|
|
|
pgm += strspn (pgm, " \t");
|
|
|
|
for (ptr = pgm, arg1 = NULL;
|
|
|
|
*ptr && *ptr != '\r' && *ptr != '\n';
|
|
|
|
ptr++)
|
|
|
|
if (!arg1 && (*ptr == ' ' || *ptr == '\t'))
|
|
|
|
{
|
|
|
|
/* Null terminate the initial command and step over
|
|
|
|
any additional white space. If we've hit the
|
2000-09-30 03:56:40 +02:00
|
|
|
end of the line, exit the loop. Otherwise, we've
|
|
|
|
found the first argument. Position the current
|
2000-02-17 20:38:33 +01:00
|
|
|
pointer on the last known white space. */
|
|
|
|
*ptr = '\0';
|
|
|
|
char *newptr = ptr + 1;
|
|
|
|
newptr += strspn (newptr, " \t");
|
|
|
|
if (!*newptr || *newptr == '\r' || *newptr == '\n')
|
|
|
|
break;
|
|
|
|
arg1 = newptr;
|
|
|
|
ptr = newptr - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*ptr = '\0';
|
|
|
|
}
|
|
|
|
|
2000-09-13 21:57:00 +02:00
|
|
|
/* Replace argv[0] with the full path to the script if this is the
|
|
|
|
first time through the loop. */
|
2000-09-19 15:48:52 +02:00
|
|
|
newargv.replace0_maybe (prog_arg);
|
2000-10-28 07:41:44 +02:00
|
|
|
|
2000-02-17 20:38:33 +01:00
|
|
|
/* pointers:
|
|
|
|
* pgm interpreter name
|
|
|
|
* arg1 optional string
|
|
|
|
*/
|
2000-09-03 06:16:35 +02:00
|
|
|
if (arg1)
|
|
|
|
newargv.unshift (arg1);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2001-10-31 01:55:32 +01:00
|
|
|
/* FIXME: This should not be using FE_NATIVE. It should be putting
|
2001-11-05 07:09:15 +01:00
|
|
|
the posix path on the argv list. */
|
2001-10-31 01:55:32 +01:00
|
|
|
find_exec (pgm, real_path, "PATH=", FE_NATIVE, &ext);
|
2000-09-03 06:16:35 +02:00
|
|
|
newargv.unshift (real_path, 1);
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
|
|
|
|
2000-09-03 06:16:35 +02:00
|
|
|
if (real_path.iscygexec ())
|
2000-09-13 21:57:00 +02:00
|
|
|
newargv.dup_all ();
|
2000-09-03 06:16:35 +02:00
|
|
|
else
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
2000-09-03 06:16:35 +02:00
|
|
|
for (int i = 0; i < newargv.argc; i++)
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
2000-09-03 06:16:35 +02:00
|
|
|
char *p = NULL;
|
|
|
|
const char *a;
|
|
|
|
|
2000-09-13 21:57:00 +02:00
|
|
|
newargv.dup_maybe (i);
|
2000-09-26 02:52:21 +02:00
|
|
|
a = i ? newargv[i] : (char *) real_path;
|
2000-09-03 06:16:35 +02:00
|
|
|
int len = strlen (a);
|
|
|
|
if (len != 0 && !strpbrk (a, " \t\n\r\""))
|
|
|
|
one_line.add (a, len);
|
|
|
|
else
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
2000-09-03 06:16:35 +02:00
|
|
|
one_line.add ("\"", 1);
|
2000-11-20 23:10:13 +01:00
|
|
|
/* Handle embedded special characters " and \.
|
|
|
|
A " is always preceded by a \.
|
|
|
|
A \ is not special unless it precedes a ". If it does,
|
|
|
|
then all preceding \'s must be doubled to avoid having
|
|
|
|
the Windows command line parser interpret the \ as quoting
|
|
|
|
the ". This rule applies to a string of \'s before the end
|
|
|
|
of the string, since cygwin/windows uses a " to delimit the
|
|
|
|
argument. */
|
2000-09-03 06:16:35 +02:00
|
|
|
for (; (p = strpbrk (a, "\"\\")); a = ++p)
|
|
|
|
{
|
|
|
|
one_line.add (a, p - a);
|
2000-11-20 23:10:13 +01:00
|
|
|
/* Find length of string of backslashes */
|
|
|
|
int n = strspn (p, "\\");
|
|
|
|
if (!n)
|
|
|
|
one_line.add ("\\\"", 2); /* No backslashes, so it must be a ".
|
|
|
|
The " has to be protected with a backslash. */
|
|
|
|
else
|
2000-11-20 20:35:45 +01:00
|
|
|
{
|
2000-11-20 23:10:13 +01:00
|
|
|
one_line.add (p, n); /* Add the run of backslashes */
|
|
|
|
/* Need to double up all of the preceding
|
|
|
|
backslashes if they precede a quote or EOS. */
|
|
|
|
if (!p[n] || p[n] == '"')
|
|
|
|
one_line.add (p, n);
|
|
|
|
p += n - 1; /* Point to last backslash */
|
2000-11-20 20:35:45 +01:00
|
|
|
}
|
2000-09-03 06:16:35 +02:00
|
|
|
}
|
|
|
|
if (*a)
|
|
|
|
one_line.add (a);
|
|
|
|
one_line.add ("\"", 1);
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
2000-09-03 06:16:35 +02:00
|
|
|
MALLOC_CHECK;
|
|
|
|
one_line.add (" ", 1);
|
|
|
|
MALLOC_CHECK;
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
2000-09-03 06:16:35 +02:00
|
|
|
|
2000-02-17 20:38:33 +01:00
|
|
|
MALLOC_CHECK;
|
2000-09-03 06:16:35 +02:00
|
|
|
if (one_line.ix)
|
|
|
|
one_line.buf[one_line.ix - 1] = '\0';
|
|
|
|
else
|
|
|
|
one_line.add ("", 1);
|
2000-02-17 20:38:33 +01:00
|
|
|
MALLOC_CHECK;
|
|
|
|
}
|
2000-09-13 21:57:00 +02:00
|
|
|
|
2002-06-12 07:13:54 +02:00
|
|
|
char *envblock;
|
2000-09-13 21:57:00 +02:00
|
|
|
newargv.all_calloced ();
|
2000-09-03 06:16:35 +02:00
|
|
|
ciresrv.moreinfo->argc = newargv.argc;
|
|
|
|
ciresrv.moreinfo->argv = newargv;
|
2000-10-17 01:55:58 +02:00
|
|
|
ciresrv.hexec_proc = hexec_proc;
|
2002-06-12 07:13:54 +02:00
|
|
|
|
2000-09-03 06:16:35 +02:00
|
|
|
if (mode != _P_OVERLAY ||
|
2001-07-18 19:05:34 +02:00
|
|
|
!DuplicateHandle (hMainProc, myself.shared_handle (), hMainProc,
|
|
|
|
&ciresrv.moreinfo->myself_pinfo, 0,
|
2000-09-03 06:16:35 +02:00
|
|
|
TRUE, DUPLICATE_SAME_ACCESS))
|
|
|
|
ciresrv.moreinfo->myself_pinfo = NULL;
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2001-08-22 19:50:22 +02:00
|
|
|
skip_arg_parsing:
|
2000-02-23 05:07:13 +01:00
|
|
|
PROCESS_INFORMATION pi = {NULL, 0, 0, 0};
|
2000-02-17 20:38:33 +01:00
|
|
|
si.lpReserved = NULL;
|
|
|
|
si.lpDesktop = NULL;
|
|
|
|
si.dwFlags = STARTF_USESTDHANDLES;
|
|
|
|
si.hStdInput = handle (0, 0); /* Get input handle */
|
|
|
|
si.hStdOutput = handle (1, 1); /* Get output handle */
|
|
|
|
si.hStdError = handle (2, 1); /* Get output handle */
|
|
|
|
si.cb = sizeof (si);
|
|
|
|
|
2000-10-17 01:55:58 +02:00
|
|
|
int flags = CREATE_DEFAULT_ERROR_MODE | GetPriorityClass (hMainProc);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
if (mode == _P_DETACH || !set_console_state_for_spawn ())
|
|
|
|
flags |= DETACHED_PROCESS;
|
2000-10-17 01:55:58 +02:00
|
|
|
if (mode != _P_OVERLAY)
|
|
|
|
flags |= CREATE_SUSPENDED;
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2000-10-26 12:13:41 +02:00
|
|
|
/* Some file types (currently only sockets) need extra effort in the
|
|
|
|
parent after CreateProcess and before copying the datastructures
|
|
|
|
to the child. So we have to start the child in suspend state,
|
|
|
|
unfortunately, to avoid a race condition. */
|
2001-04-18 23:10:15 +02:00
|
|
|
if (cygheap->fdtab.need_fixup_before ())
|
2000-10-26 12:13:41 +02:00
|
|
|
flags |= CREATE_SUSPENDED;
|
|
|
|
|
|
|
|
|
2000-10-20 06:20:21 +02:00
|
|
|
const char *runpath = null_app_name ? NULL : (const char *) real_path;
|
|
|
|
|
2002-06-11 04:08:00 +02:00
|
|
|
syscall_printf ("null_app_name %d (%s, %.132s)", null_app_name, runpath, one_line.buf);
|
2000-10-20 06:20:21 +02:00
|
|
|
|
2001-09-14 02:49:00 +02:00
|
|
|
void *newheap;
|
2002-06-11 04:08:00 +02:00
|
|
|
/* Preallocated buffer for `sec_user' call */
|
|
|
|
char sa_buf[1024];
|
|
|
|
|
2000-10-20 06:20:21 +02:00
|
|
|
cygbench ("spawn-guts");
|
2002-06-14 20:01:21 +02:00
|
|
|
|
2002-06-17 01:34:43 +02:00
|
|
|
if (!cygheap->user.issetuid ())
|
2000-10-17 01:55:58 +02:00
|
|
|
{
|
2002-06-11 04:22:02 +02:00
|
|
|
PSECURITY_ATTRIBUTES sec_attribs = sec_user_nih (sa_buf);
|
2002-06-14 20:01:21 +02:00
|
|
|
ciresrv.moreinfo->envp = build_env (envp, envblock, ciresrv.moreinfo->envc,
|
|
|
|
real_path.iscygexec ());
|
2002-06-14 23:46:19 +02:00
|
|
|
newheap = cygheap_setup_for_child (&ciresrv, cygheap->fdtab.need_fixup_before ());
|
2000-10-20 06:20:21 +02:00
|
|
|
rc = CreateProcess (runpath, /* image name - with full path */
|
2000-10-17 01:55:58 +02:00
|
|
|
one_line.buf, /* what was passed to exec */
|
2002-06-11 04:22:02 +02:00
|
|
|
sec_attribs, /* process security attrs */
|
|
|
|
sec_attribs, /* thread security attrs */
|
|
|
|
TRUE, /* inherit handles from parent */
|
2000-10-17 01:55:58 +02:00
|
|
|
flags,
|
2002-06-11 04:22:02 +02:00
|
|
|
envblock, /* environment */
|
|
|
|
0, /* use current drive/directory */
|
2000-10-17 01:55:58 +02:00
|
|
|
&si,
|
|
|
|
&pi);
|
|
|
|
}
|
|
|
|
else
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
2002-06-14 20:01:21 +02:00
|
|
|
PSID sid = cygheap->user.sid ();
|
|
|
|
|
|
|
|
/* Set security attributes with sid */
|
2002-02-19 06:58:44 +01:00
|
|
|
PSECURITY_ATTRIBUTES sec_attribs = sec_user_nih (sa_buf, sid);
|
2001-04-30 23:19:42 +02:00
|
|
|
|
2002-06-11 18:06:16 +02:00
|
|
|
RevertToSelf ();
|
2001-04-30 23:19:42 +02:00
|
|
|
|
|
|
|
/* Load users registry hive. */
|
|
|
|
load_registry_hive (sid);
|
|
|
|
|
2000-02-17 20:38:33 +01:00
|
|
|
/* allow the child to interact with our window station/desktop */
|
|
|
|
HANDLE hwst, hdsk;
|
|
|
|
SECURITY_INFORMATION dsi = DACL_SECURITY_INFORMATION;
|
|
|
|
DWORD n;
|
|
|
|
char wstname[1024];
|
|
|
|
char dskname[1024];
|
|
|
|
|
2002-06-16 06:25:54 +02:00
|
|
|
ciresrv.moreinfo->uid = ILLEGAL_UID;
|
2001-03-18 21:58:18 +01:00
|
|
|
hwst = GetProcessWindowStation ();
|
|
|
|
SetUserObjectSecurity (hwst, &dsi, get_null_sd ());
|
|
|
|
GetUserObjectInformation (hwst, UOI_NAME, wstname, 1024, &n);
|
|
|
|
hdsk = GetThreadDesktop (GetCurrentThreadId ());
|
|
|
|
SetUserObjectSecurity (hdsk, &dsi, get_null_sd ());
|
|
|
|
GetUserObjectInformation (hdsk, UOI_NAME, dskname, 1024, &n);
|
2000-02-17 20:38:33 +01:00
|
|
|
strcat (wstname, "\\");
|
|
|
|
strcat (wstname, dskname);
|
|
|
|
si.lpDesktop = wstname;
|
|
|
|
|
2002-06-14 20:01:21 +02:00
|
|
|
ciresrv.moreinfo->envp = build_env (envp, envblock, ciresrv.moreinfo->envc,
|
|
|
|
real_path.iscygexec ());
|
2002-06-14 23:46:19 +02:00
|
|
|
newheap = cygheap_setup_for_child (&ciresrv, cygheap->fdtab.need_fixup_before ());
|
2002-06-11 04:08:00 +02:00
|
|
|
rc = CreateProcessAsUser (cygheap->user.token,
|
2000-10-20 06:20:21 +02:00
|
|
|
runpath, /* image name - with full path */
|
2000-02-17 20:38:33 +01:00
|
|
|
one_line.buf, /* what was passed to exec */
|
2000-09-03 06:16:35 +02:00
|
|
|
sec_attribs, /* process security attrs */
|
|
|
|
sec_attribs, /* thread security attrs */
|
2002-06-11 04:22:02 +02:00
|
|
|
TRUE, /* inherit handles from parent */
|
2000-02-17 20:38:33 +01:00
|
|
|
flags,
|
2002-06-11 04:22:02 +02:00
|
|
|
envblock, /* environment */
|
|
|
|
0, /* use current drive/directory */
|
2000-02-17 20:38:33 +01:00
|
|
|
&si,
|
|
|
|
&pi);
|
2000-07-19 22:27:27 +02:00
|
|
|
/* Restore impersonation. In case of _P_OVERLAY this isn't
|
2000-09-03 06:16:35 +02:00
|
|
|
allowed since it would overwrite child data. */
|
2002-06-11 18:06:16 +02:00
|
|
|
if (mode != _P_OVERLAY)
|
* autoload.cc: Add load statements for `LookupAccountNameW',
`LsaClose', `LsaEnumerateAccountRights', `LsaFreeMemory',
`LsaOpenPolicy', `LsaQueryInformationPolicy', `NetLocalGroupEnum',
`NetLocalGroupGetMembers', `NetServerEnum', `NetUserGetGroups' and
`NtCreateToken'.
* ntdll.h: Add declaration for `NtCreateToken'.
* sec_helper.cc: Add `well_known_local_sid', `well_known_dialup_sid',
`well_known_network_sid', `well_known_batch_sid',
`well_known_interactive_sid', `well_known_service_sid' and
`well_known_authenticated_users_sid'.
(cygsid::string): Define as const method.
(cygsid::get_sid): Set psid to NO_SID on error.
(cygsid::getfromstr): Ditto.
(cygsid::getfrompw): Simplify.
(cygsid::getfromgr): Check for gr == NULL.
(legal_sid_type): Move to security.h.
(set_process_privilege): Return -1 on error, otherwise 0 or 1 related
to previous privilege setting.
* security.cc (extract_nt_dom_user): Remove `static'.
(lsa2wchar): New function.
(open_local_policy): Ditto.
(close_local_policy): Ditto.
(get_lsa_srv_inf): Ditto.
(get_logon_server): Ditto.
(get_logon_server_and_user_domain): Ditto.
(get_user_groups): Ditto.
(is_group_member): Ditto.
(get_user_local_groups): Ditto.
(sid_in_token_groups): Ditto.
(get_user_primary_group): Ditto.
(get_group_sidlist): Ditto.
(get_system_priv_list): Ditto.
(get_priv_list): Ditto.
(get_dacl): Ditto.
(create_token): Ditto.
(subauth): Return immediately if SE_TCB_NAME can't be assigned.
Change all return statements in case of error to jumps to `out'
label. Add `out' label to support cleanup.
* security.h: Add extern declarations for `well_known_local_sid',
`well_known_dialup_sid', `well_known_network_sid',
`well_known_batch_sid', `well_known_interactive_sid',
`well_known_service_sid' and `well_known_authenticated_users_sid'.
Add extern declarations for functions `create_token',
`extract_nt_dom_user' and `get_logon_server_and_user_domain'.
(class cygsid): Add method `assign'. Change operator= to call new
`assign' method. Add `debug_print' method.
(class cygsidlist): New class.
(legal_sid_type): Moved from sec_helper.cc to here.
* spawn.cc (spawn_guts) Revert reversion of previous patch.
Call `RevertToSelf' and `ImpersonateLoggedOnUser' instead of `seteuid'
again.
* syscalls.cc (seteuid): Rearranged. Call `create_token' now when
needed. Call `subauth' if `create_token' fails. Try setting token
owner and primary group only if token was not explicitely created
by `create_token'.
* uinfo.cc (internal_getlogin): Try harder to generate correct user
information. Especially don't trust return value of `GetUserName'.
2001-05-20 10:10:47 +02:00
|
|
|
ImpersonateLoggedOnUser (cygheap->user.token);
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
MALLOC_CHECK;
|
2000-09-03 06:16:35 +02:00
|
|
|
if (envblock)
|
|
|
|
free (envblock);
|
2000-02-17 20:38:33 +01:00
|
|
|
MALLOC_CHECK;
|
|
|
|
|
|
|
|
/* Set errno now so that debugging messages from it appear before our
|
|
|
|
final debugging message [this is a general rule for debugging
|
|
|
|
messages]. */
|
2000-08-03 05:02:41 +02:00
|
|
|
if (!rc)
|
|
|
|
{
|
|
|
|
__seterrno ();
|
|
|
|
syscall_printf ("CreateProcess failed, %E");
|
2002-07-13 22:00:27 +02:00
|
|
|
if (subproc_ready)
|
|
|
|
ForceCloseHandle (subproc_ready);
|
2001-09-14 02:49:00 +02:00
|
|
|
cygheap_setup_for_child_cleanup (newheap, &ciresrv, 0);
|
2000-08-03 05:02:41 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2000-10-26 12:13:41 +02:00
|
|
|
/* Fixup the parent datastructure if needed and resume the child's
|
|
|
|
main thread. */
|
2001-09-14 02:49:00 +02:00
|
|
|
if (!cygheap->fdtab.need_fixup_before ())
|
|
|
|
cygheap_setup_for_child_cleanup (newheap, &ciresrv, 0);
|
|
|
|
else
|
2000-10-26 12:13:41 +02:00
|
|
|
{
|
2001-04-18 23:10:15 +02:00
|
|
|
cygheap->fdtab.fixup_before_exec (pi.dwProcessId);
|
2001-09-14 02:49:00 +02:00
|
|
|
cygheap_setup_for_child_cleanup (newheap, &ciresrv, 1);
|
2000-10-26 12:13:41 +02:00
|
|
|
if (mode == _P_OVERLAY)
|
2001-09-07 23:32:07 +02:00
|
|
|
ResumeThread (pi.hThread);
|
2000-10-26 12:13:41 +02:00
|
|
|
}
|
|
|
|
|
2000-07-29 18:24:59 +02:00
|
|
|
if (mode == _P_OVERLAY)
|
|
|
|
cygpid = myself->pid;
|
|
|
|
else
|
|
|
|
cygpid = cygwin_pid (pi.dwProcessId);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
/* We print the original program name here so the user can see that too. */
|
|
|
|
syscall_printf ("%d = spawn_guts (%s, %.132s)",
|
2000-10-09 04:53:44 +02:00
|
|
|
rc ? cygpid : (unsigned int) -1, prog_arg, one_line.buf);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2000-07-29 18:24:59 +02:00
|
|
|
/* Name the handle similarly to proc_subproc. */
|
|
|
|
ProtectHandle1 (pi.hProcess, childhProc);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
if (mode == _P_OVERLAY)
|
|
|
|
{
|
2000-10-17 01:55:58 +02:00
|
|
|
/* These are both duplicated in the child code. We do this here,
|
|
|
|
primarily for strace. */
|
2000-10-24 04:25:27 +02:00
|
|
|
strace.execing = 1;
|
|
|
|
hExeced = pi.hProcess;
|
2002-01-10 04:21:27 +01:00
|
|
|
dwExeced = pi.dwProcessId;
|
2001-06-24 23:57:50 +02:00
|
|
|
strcpy (myself->progname, real_path);
|
2001-08-04 23:10:52 +02:00
|
|
|
close_all_files ();
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2000-10-25 05:54:50 +02:00
|
|
|
myself->set_has_pgid_children ();
|
2000-10-17 01:55:58 +02:00
|
|
|
ProtectHandle (pi.hThread);
|
2000-07-29 18:24:59 +02:00
|
|
|
pinfo child (cygpid, 1);
|
|
|
|
if (!child)
|
|
|
|
{
|
|
|
|
set_errno (EAGAIN);
|
|
|
|
syscall_printf ("-1 = spawnve (), process table full");
|
|
|
|
return -1;
|
|
|
|
}
|
2000-02-17 20:38:33 +01:00
|
|
|
child->dwProcessId = pi.dwProcessId;
|
|
|
|
child->hProcess = pi.hProcess;
|
2000-07-29 18:24:59 +02:00
|
|
|
child.remember ();
|
2001-06-24 23:57:50 +02:00
|
|
|
strcpy (child->progname, real_path);
|
2001-10-04 04:34:20 +02:00
|
|
|
/* FIXME: This introduces an unreferenced, open handle into the child.
|
2001-11-05 07:09:15 +01:00
|
|
|
The purpose is to keep the pid shared memory open so that all of
|
2001-10-04 04:34:20 +02:00
|
|
|
the fields filled out by child.remember do not disappear and so there
|
|
|
|
is not a brief period during which the pid is not available.
|
|
|
|
However, we should try to find another way to do this eventually. */
|
|
|
|
(void) DuplicateHandle (hMainProc, child.shared_handle (), pi.hProcess,
|
|
|
|
NULL, 0, 0, DUPLICATE_SAME_ACCESS);
|
2000-10-17 01:55:58 +02:00
|
|
|
/* Start the child running */
|
|
|
|
ResumeThread (pi.hThread);
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ForceCloseHandle (pi.hThread);
|
|
|
|
|
2000-10-17 01:55:58 +02:00
|
|
|
sigproc_printf ("spawned windows pid %d", pi.dwProcessId);
|
|
|
|
|
2000-02-17 20:38:33 +01:00
|
|
|
DWORD res;
|
2000-10-14 07:52:38 +02:00
|
|
|
BOOL exited;
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2000-10-14 07:52:38 +02:00
|
|
|
res = 0;
|
|
|
|
exited = FALSE;
|
|
|
|
MALLOC_CHECK;
|
2001-07-17 05:41:52 +02:00
|
|
|
if (mode == _P_OVERLAY)
|
2000-10-14 07:52:38 +02:00
|
|
|
{
|
2001-07-17 05:41:52 +02:00
|
|
|
int nwait = 3;
|
2002-07-13 22:00:27 +02:00
|
|
|
HANDLE waitbuf[3] = {pi.hProcess, signal_arrived, subproc_ready};
|
2001-07-17 05:41:52 +02:00
|
|
|
for (int i = 0; i < 100; i++)
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
2001-07-17 05:41:52 +02:00
|
|
|
switch (WaitForMultipleObjects (nwait, waitbuf, FALSE, INFINITE))
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
2001-07-17 05:41:52 +02:00
|
|
|
case WAIT_OBJECT_0:
|
|
|
|
sigproc_printf ("subprocess exited");
|
|
|
|
DWORD exitcode;
|
|
|
|
if (!GetExitCodeProcess (pi.hProcess, &exitcode))
|
|
|
|
exitcode = 1;
|
|
|
|
res |= exitcode;
|
|
|
|
exited = TRUE;
|
|
|
|
break;
|
|
|
|
case WAIT_OBJECT_0 + 1:
|
|
|
|
sigproc_printf ("signal arrived");
|
|
|
|
reset_signal_arrived ();
|
|
|
|
continue;
|
|
|
|
case WAIT_OBJECT_0 + 2:
|
2001-03-12 15:49:29 +01:00
|
|
|
if (myself->ppid_handle)
|
|
|
|
res |= EXIT_REPARENTING;
|
2000-11-15 07:27:48 +01:00
|
|
|
if (!my_parent_is_alive ())
|
2000-03-15 05:49:36 +01:00
|
|
|
{
|
2001-07-17 05:41:52 +02:00
|
|
|
nwait = 2;
|
2000-10-14 07:52:38 +02:00
|
|
|
sigproc_terminate ();
|
|
|
|
continue;
|
2000-03-15 05:49:36 +01:00
|
|
|
}
|
2001-07-17 05:41:52 +02:00
|
|
|
break;
|
|
|
|
case WAIT_FAILED:
|
|
|
|
system_printf ("wait failed: nwait %d, pid %d, winpid %d, %E",
|
|
|
|
nwait, myself->pid, myself->dwProcessId);
|
|
|
|
system_printf ("waitbuf[0] %p %d", waitbuf[0],
|
|
|
|
WaitForSingleObject (waitbuf[0], 0));
|
|
|
|
system_printf ("waitbuf[1] %p = %d", waitbuf[1],
|
|
|
|
WaitForSingleObject (waitbuf[1], 0));
|
|
|
|
system_printf ("waitbuf[w] %p = %d", waitbuf[2],
|
|
|
|
WaitForSingleObject (waitbuf[2], 0));
|
|
|
|
set_errno (ECHILD);
|
|
|
|
try_to_debug ();
|
|
|
|
return -1;
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2002-07-13 22:00:27 +02:00
|
|
|
ForceCloseHandle (subproc_ready);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2001-07-17 05:41:52 +02:00
|
|
|
sigproc_printf ("res = %x", res);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2001-07-17 05:41:52 +02:00
|
|
|
if (res & EXIT_REPARENTING)
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
2001-07-17 05:41:52 +02:00
|
|
|
/* Try to reparent child process.
|
|
|
|
* Make handles to child available to parent process and exit with
|
|
|
|
* EXIT_REPARENTING status. Wait() syscall in parent will then wait
|
|
|
|
* for newly created child.
|
|
|
|
*/
|
|
|
|
HANDLE oldh = myself->hProcess;
|
|
|
|
HANDLE h = myself->ppid_handle;
|
|
|
|
sigproc_printf ("parent handle %p", h);
|
|
|
|
int rc = DuplicateHandle (hMainProc, pi.hProcess, h, &myself->hProcess,
|
|
|
|
0, FALSE, DUPLICATE_SAME_ACCESS);
|
|
|
|
sigproc_printf ("%d = DuplicateHandle, oldh %p, newh %p",
|
|
|
|
rc, oldh, myself->hProcess);
|
|
|
|
if (!rc && my_parent_is_alive ())
|
|
|
|
{
|
|
|
|
system_printf ("Reparent failed, parent handle %p, %E", h);
|
|
|
|
system_printf ("my dwProcessId %d, myself->dwProcessId %d",
|
|
|
|
GetCurrentProcessId (), myself->dwProcessId);
|
|
|
|
system_printf ("old hProcess %p, hProcess %p", oldh, myself->hProcess);
|
|
|
|
}
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
2000-10-14 07:52:38 +02:00
|
|
|
|
2001-07-17 05:41:52 +02:00
|
|
|
}
|
2001-06-26 23:03:08 +02:00
|
|
|
|
2000-10-14 07:52:38 +02:00
|
|
|
MALLOC_CHECK;
|
2000-02-17 20:38:33 +01:00
|
|
|
|
2000-09-03 06:16:35 +02:00
|
|
|
switch (mode)
|
|
|
|
{
|
2000-10-14 07:52:38 +02:00
|
|
|
case _P_OVERLAY:
|
2000-10-17 01:55:58 +02:00
|
|
|
ForceCloseHandle1 (pi.hProcess, childhProc);
|
2000-10-14 07:52:38 +02:00
|
|
|
proc_terminate ();
|
2000-10-21 07:53:43 +02:00
|
|
|
myself->exit (res, 1);
|
2000-10-14 07:52:38 +02:00
|
|
|
break;
|
2000-09-03 06:16:35 +02:00
|
|
|
case _P_WAIT:
|
|
|
|
waitpid (cygpid, (int *) &res, 0);
|
|
|
|
break;
|
|
|
|
case _P_DETACH:
|
|
|
|
res = 0; /* Lose all memory of this child. */
|
|
|
|
break;
|
|
|
|
case _P_NOWAIT:
|
|
|
|
case _P_NOWAITO:
|
|
|
|
case _P_VFORK:
|
|
|
|
res = cygpid;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
return (int) res;
|
|
|
|
}
|
|
|
|
|
2001-08-22 19:50:22 +02:00
|
|
|
extern "C" int
|
2000-02-17 20:38:33 +01:00
|
|
|
cwait (int *result, int pid, int)
|
|
|
|
{
|
|
|
|
return waitpid (pid, result, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper function for spawn runtime calls.
|
|
|
|
* Doesn't search the path.
|
|
|
|
*/
|
|
|
|
|
|
|
|
extern "C" int
|
2002-06-11 04:08:00 +02:00
|
|
|
spawnve (int mode, const char *path, const char *const *argv,
|
|
|
|
const char *const *envp)
|
2000-02-17 20:38:33 +01:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
vfork_save *vf = vfork_storage.val ();
|
|
|
|
|
|
|
|
if (vf != NULL && (vf->pid < 0) && mode == _P_OVERLAY)
|
|
|
|
mode = _P_NOWAIT;
|
|
|
|
else
|
|
|
|
vf = NULL;
|
|
|
|
|
2002-06-11 04:08:00 +02:00
|
|
|
syscall_printf ("spawnve (%s, %s, %x)", path, argv[0], envp);
|
2000-02-17 20:38:33 +01:00
|
|
|
|
|
|
|
switch (mode)
|
|
|
|
{
|
2000-09-03 06:16:35 +02:00
|
|
|
case _P_OVERLAY:
|
|
|
|
/* We do not pass _P_SEARCH_PATH here. execve doesn't search PATH.*/
|
|
|
|
/* Just act as an exec if _P_OVERLAY set. */
|
2002-06-11 04:08:00 +02:00
|
|
|
spawn_guts (path, argv, envp, mode);
|
2000-09-03 06:16:35 +02:00
|
|
|
/* Errno should be set by spawn_guts. */
|
|
|
|
ret = -1;
|
|
|
|
break;
|
|
|
|
case _P_VFORK:
|
|
|
|
case _P_NOWAIT:
|
|
|
|
case _P_NOWAITO:
|
|
|
|
case _P_WAIT:
|
|
|
|
case _P_DETACH:
|
|
|
|
subproc_init ();
|
2002-06-11 04:08:00 +02:00
|
|
|
ret = spawn_guts (path, argv, envp, mode);
|
2000-09-03 06:16:35 +02:00
|
|
|
if (vf && ret > 0)
|
|
|
|
{
|
2001-06-24 23:57:50 +02:00
|
|
|
debug_printf ("longjmping due to vfork");
|
2000-09-03 06:16:35 +02:00
|
|
|
vf->pid = ret;
|
|
|
|
longjmp (vf->j, 1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
set_errno (EINVAL);
|
|
|
|
ret = -1;
|
|
|
|
break;
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* spawn functions as implemented in the MS runtime library.
|
|
|
|
* Most of these based on (and copied from) newlib/libc/posix/execXX.c
|
|
|
|
*/
|
|
|
|
|
2001-08-22 19:50:22 +02:00
|
|
|
extern "C" int
|
2000-02-17 20:38:33 +01:00
|
|
|
spawnl (int mode, const char *path, const char *arg0, ...)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
va_list args;
|
|
|
|
const char *argv[256];
|
|
|
|
|
|
|
|
va_start (args, arg0);
|
|
|
|
argv[0] = arg0;
|
|
|
|
i = 1;
|
|
|
|
|
|
|
|
do
|
|
|
|
argv[i] = va_arg (args, const char *);
|
|
|
|
while (argv[i++] != NULL);
|
|
|
|
|
|
|
|
va_end (args);
|
|
|
|
|
2002-06-11 04:08:00 +02:00
|
|
|
return spawnve (mode, path, (char * const *) argv, cur_environ ());
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
|
|
|
|
2001-08-22 19:50:22 +02:00
|
|
|
extern "C" int
|
2000-02-17 20:38:33 +01:00
|
|
|
spawnle (int mode, const char *path, const char *arg0, ...)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
va_list args;
|
|
|
|
const char * const *envp;
|
|
|
|
const char *argv[256];
|
|
|
|
|
|
|
|
va_start (args, arg0);
|
|
|
|
argv[0] = arg0;
|
|
|
|
i = 1;
|
|
|
|
|
|
|
|
do
|
|
|
|
argv[i] = va_arg (args, const char *);
|
|
|
|
while (argv[i++] != NULL);
|
|
|
|
|
|
|
|
envp = va_arg (args, const char * const *);
|
|
|
|
va_end (args);
|
|
|
|
|
2002-06-11 04:08:00 +02:00
|
|
|
return spawnve (mode, path, (char * const *) argv, (char * const *) envp);
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
|
|
|
|
2001-08-22 19:50:22 +02:00
|
|
|
extern "C" int
|
2000-02-17 20:38:33 +01:00
|
|
|
spawnlp (int mode, const char *path, const char *arg0, ...)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
va_list args;
|
|
|
|
const char *argv[256];
|
|
|
|
|
|
|
|
va_start (args, arg0);
|
|
|
|
argv[0] = arg0;
|
|
|
|
i = 1;
|
|
|
|
|
|
|
|
do
|
|
|
|
argv[i] = va_arg (args, const char *);
|
|
|
|
while (argv[i++] != NULL);
|
|
|
|
|
|
|
|
va_end (args);
|
|
|
|
|
2000-08-02 18:28:18 +02:00
|
|
|
return spawnvpe (mode, path, (char * const *) argv, cur_environ ());
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
|
|
|
|
2001-08-22 19:50:22 +02:00
|
|
|
extern "C" int
|
2000-02-17 20:38:33 +01:00
|
|
|
spawnlpe (int mode, const char *path, const char *arg0, ...)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
va_list args;
|
|
|
|
const char * const *envp;
|
|
|
|
const char *argv[256];
|
|
|
|
|
|
|
|
va_start (args, arg0);
|
|
|
|
argv[0] = arg0;
|
|
|
|
i = 1;
|
|
|
|
|
|
|
|
do
|
|
|
|
argv[i] = va_arg (args, const char *);
|
|
|
|
while (argv[i++] != NULL);
|
|
|
|
|
|
|
|
envp = va_arg (args, const char * const *);
|
|
|
|
va_end (args);
|
|
|
|
|
|
|
|
return spawnvpe (mode, path, (char * const *) argv, envp);
|
|
|
|
}
|
|
|
|
|
2001-08-22 19:50:22 +02:00
|
|
|
extern "C" int
|
2000-02-17 20:38:33 +01:00
|
|
|
spawnv (int mode, const char *path, const char * const *argv)
|
|
|
|
{
|
2002-06-11 04:08:00 +02:00
|
|
|
return spawnve (mode, path, argv, cur_environ ());
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
|
|
|
|
2001-08-22 19:50:22 +02:00
|
|
|
extern "C" int
|
2000-02-17 20:38:33 +01:00
|
|
|
spawnvp (int mode, const char *path, const char * const *argv)
|
|
|
|
{
|
2000-08-02 18:28:18 +02:00
|
|
|
return spawnvpe (mode, path, argv, cur_environ ());
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|
|
|
|
|
2001-08-22 19:50:22 +02:00
|
|
|
extern "C" int
|
2000-02-17 20:38:33 +01:00
|
|
|
spawnvpe (int mode, const char *file, const char * const *argv,
|
|
|
|
const char * const *envp)
|
|
|
|
{
|
2000-04-26 07:13:32 +02:00
|
|
|
path_conv buf;
|
2002-06-11 04:08:00 +02:00
|
|
|
return spawnve (mode, find_exec (file, buf), argv, envp);
|
2000-02-17 20:38:33 +01:00
|
|
|
}
|