_WCRTLINK int (execvpe)(
const char *path, /* path name of path to be executed */
const char *const argv[], /* array of pointers to arguments */
const char *const envp[] ) /* array of pointers to environment strings */
{
return( spawnvpe( P_OVERLAY, path, argv, envp ) );
}
int spawnlpe(int mode, const char *file, const char *arg0, ...) {
char **argv;
char **envv;
CVT_L2V_ENV(arg0, argv, envv);
return spawnvpe(mode, file, argv, envv);
}
/* Open a pipe connected to a child process.
*
* write system read
* parent -> fd[1] -> STDIN_FILENO -> child if pipe_stdin
* parent <- fd[0] <- STDOUT_FILENO <- child if pipe_stdout
* read system write
*
* At least one of pipe_stdin, pipe_stdout must be true.
* pipe_stdin and prog_stdin together determine the child's standard input.
* pipe_stdout and prog_stdout together determine the child's standard output.
* If pipe_stdin is true, prog_stdin is ignored.
* If pipe_stdout is true, prog_stdout is ignored.
*/
static pid_t
create_pipe (const char *progname,
const char *prog_path, char **prog_argv,
bool pipe_stdin, bool pipe_stdout,
const char *prog_stdin, const char *prog_stdout,
bool null_stderr,
bool slave_process, bool exit_on_error,
int fd[2])
{
#if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
/* Native Windows API.
This uses _pipe(), dup2(), and spawnv(). It could also be implemented
using the low-level functions CreatePipe(), DuplicateHandle(),
CreateProcess() and _open_osfhandle(); see the GNU make and GNU clisp
and cvs source code. */
int ifd[2];
int ofd[2];
int orig_stdin;
int orig_stdout;
int orig_stderr;
int child;
int nulloutfd;
int stdinfd;
int stdoutfd;
int saved_errno;
/* FIXME: Need to free memory allocated by prepare_spawn. */
prog_argv = prepare_spawn (prog_argv);
if (pipe_stdout)
if (pipe2_safer (ifd, O_BINARY | O_CLOEXEC) < 0)
error (EXIT_FAILURE, errno, _("cannot create pipe"));
if (pipe_stdin)
if (pipe2_safer (ofd, O_BINARY | O_CLOEXEC) < 0)
error (EXIT_FAILURE, errno, _("cannot create pipe"));
/* Data flow diagram:
*
* write system read
* parent -> ofd[1] -> ofd[0] -> child if pipe_stdin
* parent <- ifd[0] <- ifd[1] <- child if pipe_stdout
* read system write
*
*/
/* Save standard file handles of parent process. */
if (pipe_stdin || prog_stdin != NULL)
orig_stdin = dup_safer_noinherit (STDIN_FILENO);
if (pipe_stdout || prog_stdout != NULL)
orig_stdout = dup_safer_noinherit (STDOUT_FILENO);
if (null_stderr)
orig_stderr = dup_safer_noinherit (STDERR_FILENO);
child = -1;
/* Create standard file handles of child process. */
nulloutfd = -1;
stdinfd = -1;
stdoutfd = -1;
if ((!pipe_stdin || dup2 (ofd[0], STDIN_FILENO) >= 0)
&& (!pipe_stdout || dup2 (ifd[1], STDOUT_FILENO) >= 0)
&& (!null_stderr
|| ((nulloutfd = open ("NUL", O_RDWR, 0)) >= 0
&& (nulloutfd == STDERR_FILENO
|| (dup2 (nulloutfd, STDERR_FILENO) >= 0
&& close (nulloutfd) >= 0))))
&& (pipe_stdin
|| prog_stdin == NULL
|| ((stdinfd = open (prog_stdin, O_RDONLY, 0)) >= 0
&& (stdinfd == STDIN_FILENO
|| (dup2 (stdinfd, STDIN_FILENO) >= 0
&& close (stdinfd) >= 0))))
&& (pipe_stdout
|| prog_stdout == NULL
|| ((stdoutfd = open (prog_stdout, O_WRONLY, 0)) >= 0
&& (stdoutfd == STDOUT_FILENO
|| (dup2 (stdoutfd, STDOUT_FILENO) >= 0
&& close (stdoutfd) >= 0)))))
/* The child process doesn't inherit ifd[0], ifd[1], ofd[0], ofd[1],
but it inherits all open()ed or dup2()ed file handles (which is what
we want in the case of STD*_FILENO). */
/* Use spawnvpe and pass the environment explicitly. This is needed if
the program has modified the environment using putenv() or [un]setenv().
On Windows, programs have two environments, one in the "environment
block" of the process and managed through SetEnvironmentVariable(), and
one inside the process, in the location retrieved by the 'environ'
macro. When using spawnvp() without 'e', the child process inherits a
copy of the environment block - ignoring the effects of putenv() and
[un]setenv(). */
{
child = spawnvpe (P_NOWAIT, prog_path, (const char **) prog_argv,
(const char **) environ);
if (child < 0 && errno == ENOEXEC)
{
/* prog is not a native executable. Try to execute it as a
shell script. Note that prepare_spawn() has already prepended
a hidden element "sh.exe" to prog_argv. */
--prog_argv;
child = spawnvpe (P_NOWAIT, prog_argv[0], (const char **) prog_argv,
(const char **) environ);
}
}
if (child == -1)
saved_errno = errno;
if (stdinfd >= 0)
close (stdinfd);
if (stdoutfd >= 0)
close (stdoutfd);
if (nulloutfd >= 0)
close (nulloutfd);
/* Restore standard file handles of parent process. */
if (null_stderr)
undup_safer_noinherit (orig_stderr, STDERR_FILENO);
if (pipe_stdout || prog_stdout != NULL)
undup_safer_noinherit (orig_stdout, STDOUT_FILENO);
if (pipe_stdin || prog_stdin != NULL)
undup_safer_noinherit (orig_stdin, STDIN_FILENO);
if (pipe_stdin)
close (ofd[0]);
if (pipe_stdout)
close (ifd[1]);
if (child == -1)
{
if (exit_on_error || !null_stderr)
error (exit_on_error ? EXIT_FAILURE : 0, saved_errno,
_("%s subprocess failed"), progname);
if (pipe_stdout)
close (ifd[0]);
if (pipe_stdin)
close (ofd[1]);
errno = saved_errno;
return -1;
}
if (pipe_stdout)
fd[0] = ifd[0];
if (pipe_stdin)
fd[1] = ofd[1];
return child;
#else
/* Unix API. */
int ifd[2];
int ofd[2];
sigset_t blocked_signals;
posix_spawn_file_actions_t actions;
bool actions_allocated;
posix_spawnattr_t attrs;
bool attrs_allocated;
int err;
pid_t child;
if (pipe_stdout)
if (pipe_safer (ifd) < 0)
error (EXIT_FAILURE, errno, _("cannot create pipe"));
if (pipe_stdin)
if (pipe_safer (ofd) < 0)
error (EXIT_FAILURE, errno, _("cannot create pipe"));
/* Data flow diagram:
*
* write system read
* parent -> ofd[1] -> ofd[0] -> child if pipe_stdin
* parent <- ifd[0] <- ifd[1] <- child if pipe_stdout
* read system write
*
*/
if (slave_process)
{
sigprocmask (SIG_SETMASK, NULL, &blocked_signals);
block_fatal_signals ();
}
actions_allocated = false;
attrs_allocated = false;
if ((err = posix_spawn_file_actions_init (&actions)) != 0
|| (actions_allocated = true,
(pipe_stdin
&& (err = posix_spawn_file_actions_adddup2 (&actions,
ofd[0], STDIN_FILENO))
!= 0)
|| (pipe_stdout
&& (err = posix_spawn_file_actions_adddup2 (&actions,
ifd[1], STDOUT_FILENO))
!= 0)
|| (pipe_stdin
&& (err = posix_spawn_file_actions_addclose (&actions, ofd[0]))
!= 0)
|| (pipe_stdout
&& (err = posix_spawn_file_actions_addclose (&actions, ifd[1]))
!= 0)
|| (pipe_stdin
&& (err = posix_spawn_file_actions_addclose (&actions, ofd[1]))
!= 0)
|| (pipe_stdout
&& (err = posix_spawn_file_actions_addclose (&actions, ifd[0]))
!= 0)
|| (null_stderr
&& (err = posix_spawn_file_actions_addopen (&actions,
STDERR_FILENO,
"/dev/null", O_RDWR,
0))
!= 0)
|| (!pipe_stdin
&& prog_stdin != NULL
&& (err = posix_spawn_file_actions_addopen (&actions,
STDIN_FILENO,
prog_stdin, O_RDONLY,
0))
!= 0)
|| (!pipe_stdout
&& prog_stdout != NULL
&& (err = posix_spawn_file_actions_addopen (&actions,
STDOUT_FILENO,
prog_stdout, O_WRONLY,
0))
!= 0)
|| (slave_process
&& ((err = posix_spawnattr_init (&attrs)) != 0
|| (attrs_allocated = true,
(err = posix_spawnattr_setsigmask (&attrs,
&blocked_signals))
!= 0
|| (err = posix_spawnattr_setflags (&attrs,
POSIX_SPAWN_SETSIGMASK))
!= 0)))
))
{
if (actions_allocated)
posix_spawn_file_actions_destroy (&actions);
if (attrs_allocated)
posix_spawnattr_destroy (&attrs);
if (slave_process)
unblock_fatal_signals ();
if (exit_on_error || !null_stderr)
error (exit_on_error ? EXIT_FAILURE : 0, err,
_("%s subprocess failed"), progname);
if (pipe_stdout)
{
close (ifd[0]);
close (ifd[1]);
}
if (pipe_stdin)
{
close (ofd[0]);
close (ofd[1]);
}
errno = err;
return -1;
}
posix_spawn_file_actions_destroy (&actions);
if (attrs_allocated)
posix_spawnattr_destroy (&attrs);
if (slave_process)
{
register_slave_subprocess (child);
unblock_fatal_signals ();
}
if (pipe_stdin)
close (ofd[0]);
if (pipe_stdout)
close (ifd[1]);
if (pipe_stdout)
fd[0] = ifd[0];
if (pipe_stdin)
fd[1] = ofd[1];
return child;
#endif
}
int
main (int argc, char *argv[])
{
const char *child_path;
int test;
int fd[2];
int child;
int exitcode;
set_program_name (argv[0]);
child_path = argv[1];
test = atoi (argv[2]);
/* Create a pipe. */
ASSERT (pipe (fd) >= 0);
/* Map fd[0] to STDIN_FILENO and fd[1] to STDOUT_FILENO, because on Windows,
the only three file descriptors that are inherited by child processes are
STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO. */
if (fd[0] != STDIN_FILENO)
{
ASSERT (dup2 (fd[0], STDIN_FILENO) >= 0);
close (fd[0]);
}
if (fd[1] != STDOUT_FILENO)
{
ASSERT (dup2 (fd[1], STDOUT_FILENO) >= 0);
close (fd[1]);
}
/* Prepare the file descriptors. */
if (test & 1)
ASSERT (set_nonblocking_flag (STDOUT_FILENO, true) >= 0);
if (test & 2)
ASSERT (set_nonblocking_flag (STDIN_FILENO, true) >= 0);
/* Spawn the child process. */
{
const char *child_argv[3];
child_argv[0] = child_path;
child_argv[1] = argv[2];
child_argv[2] = NULL;
#if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
child = spawnvpe (P_NOWAIT, child_path, child_argv,
(const char **) environ);
ASSERT (child >= 0);
#else
{
pid_t child_pid;
int err =
posix_spawnp (&child_pid, child_path, NULL, NULL, (char **) child_argv,
environ);
ASSERT (err == 0);
child = child_pid;
}
#endif
}
/* Close unused file descriptors. */
close (STDIN_FILENO);
exitcode =
main_writer_loop (test, PIPE_DATA_BLOCK_SIZE, STDOUT_FILENO, false);
{
int err =
wait_subprocess (child, child_path, false, false, false, false, NULL);
ASSERT (err == 0);
}
return exitcode;
}
int main( int argc, char * const argv[] )
{
char myfile[ sizeof __FILE__ ];
int child = argc > 1;
int handle;
int status;
int handle_out;
long size;
/*** Initialize ***/
strcpy( ProgramName, argv[0] ); /* store filename */
strlwr( ProgramName ); /* and lower case it */
strcpy( myfile, __FILE__ );
strlwr( myfile );
if( child ) {
char *env_var;
if( argc == 4 ) {
/* Verify expected command line contents */
VERIFY( !strcmp( argv[1], ARG1 ) );
VERIFY( !strcmp( argv[2], ARG2 ) );
VERIFY( !strcmp( argv[3], ARG3 ) );
/* Verify expected environment contents */
env_var = getenv( VAR_NAME );
VERIFY( env_var );
VERIFY( !strcmp( env_var, VAR_TEXT ) );
if( NumErrors != 0 ) {
return( EXIT_FAILURE );
} else {
return( CHILD_RC );
}
} else {
if( argc == 2 ) {
/* Verify expected command line contents */
VERIFY( !strcmp( argv[1], ARG_REDIR ) );
/* Write text to stdout */
printf( REDIR_TEXT );
if( NumErrors != 0 ) {
return( EXIT_FAILURE );
} else {
return( CHILD_RC );
}
}
else
return( EXIT_FAILURE );
}
} else {
int rc;
char **env;
const char *path = "PATH=."; /* Default PATH if none is found */
const char *child_args[] = { ProgramName, ARG1, ARG2, ARG3, NULL };
const char *child_envp[] = { NULL, VAR_NAME "=" VAR_TEXT, "DOS4G=QUIET", NULL };
/* We need to pass PATH down to the child because DOS/4GW style stub
* programs rely on it to function properly.
*/
for( env = environ; *env; ++env )
if( !strncmp( *env, "PATH=", 5 ) ) {
path = *env;
break;
}
child_envp[0] = path;
/* Test spawn functions */
rc = spawnle( P_WAIT, ProgramName, ProgramName, ARG1, ARG2, ARG3, NULL, child_envp );
VERIFY( rc == CHILD_RC );
rc = spawnlpe( P_WAIT, ProgramName, ProgramName, ARG1, ARG2, ARG3, NULL, child_envp );
VERIFY( rc == CHILD_RC );
rc = spawnve( P_WAIT, ProgramName, child_args, child_envp );
VERIFY( rc == CHILD_RC );
rc = spawnvpe( P_WAIT, ProgramName, child_args, child_envp );
VERIFY( rc == CHILD_RC );
/* Modify our environment that child will inherit */
VERIFY( !setenv( VAR_NAME, VAR_TEXT, 1 ) );
VERIFY( !setenv( "DOS4G", "QUIET", 1 ) );
rc = spawnl( P_WAIT, ProgramName, ProgramName, ARG1, ARG2, ARG3, NULL );
VERIFY( rc == CHILD_RC );
rc = spawnlp( P_WAIT, ProgramName, ProgramName, ARG1, ARG2, ARG3, NULL );
VERIFY( rc == CHILD_RC );
rc = spawnv( P_WAIT, ProgramName, child_args );
VERIFY( rc == CHILD_RC );
rc = spawnvp( P_WAIT, ProgramName, child_args );
VERIFY( rc == CHILD_RC );
/* Check inherited output redirection */
handle_out = dup( STDOUT_FILENO );
handle = creat( "test.fil", S_IREAD|S_IWRITE );
VERIFY( handle != -1 );
status = dup2( handle, STDOUT_FILENO );
VERIFY( status != -1 );
status = close( handle );
VERIFY( status == 0 );
rc = spawnl( P_WAIT, ProgramName, ProgramName, ARG_REDIR, NULL );
VERIFY( rc == CHILD_RC );
status = dup2( handle_out, STDOUT_FILENO );
VERIFY( status != -1 );
handle = open( "test.fil", O_RDWR );
VERIFY( handle != -1 );
size = filelength( handle );
VERIFY( size == strlen( REDIR_TEXT ) );
status = close( handle );
VERIFY( status == 0 );
status = unlink( "test.fil" );
VERIFY( status == 0 );
signal_count = 0;
signal_number = 0;
/* Install SIGBREAK handler */
VERIFY( signal( SIGBREAK, break_handler ) == SIG_DFL );
/* Raise signal and verify results */
VERIFY( raise( SIGBREAK ) == 0 );
VERIFY( signal_count == 1 );
VERIFY( signal_number == SIGBREAK );
/* Raise again - nothing should have happened */
VERIFY( raise( SIGBREAK ) == 0 );
VERIFY( signal_count == 1 );
/*** Print a pass/fail message and quit ***/
if( NumErrors != 0 ) {
printf( "%s: FAILURE (%d errors).\n", ProgramName, NumErrors );
return( EXIT_FAILURE );
}
printf( "Tests completed (%s).\n", ProgramName );
}
return( 0 );
}
int
main (int argc, char *argv[])
{
const char *child_path = argv[1];
int test = atoi (argv[2]);
int server;
int port;
int child;
int server_socket;
int exitcode;
/* Create a server socket. */
server = create_server (0, 1, &port);
/* Spawn the child process. */
{
char port_arg[10+1];
const char *child_argv[4];
sprintf (port_arg, "%u", port);
child_argv[0] = child_path;
child_argv[1] = argv[2];
child_argv[2] = port_arg;
child_argv[3] = NULL;
#if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
child = spawnvpe (P_NOWAIT, child_path, child_argv,
(const char **) environ);
ASSERT (child >= 0);
#else
{
pid_t child_pid;
int err =
posix_spawnp (&child_pid, child_path, NULL, NULL, (char **) child_argv,
environ);
ASSERT (err == 0);
child = child_pid;
}
#endif
}
/* Accept a connection from the child process. */
server_socket = create_server_socket (server);
/* Prepare the file descriptor. */
if (test & 1)
ASSERT (set_nonblocking_flag (server_socket, true) >= 0);
#if ENABLE_DEBUGGING
# ifdef SO_SNDBUF
{
int value;
socklen_t value_len = sizeof (value);
if (getsockopt (server_socket, SOL_SOCKET, SO_SNDBUF, &value, &value_len) >= 0)
fprintf (stderr, "SO_SNDBUF = %d\n", value);
}
# endif
# ifdef SO_RCVBUF
{
int value;
socklen_t value_len = sizeof (value);
if (getsockopt (server_socket, SOL_SOCKET, SO_RCVBUF, &value, &value_len) >= 0)
fprintf (stderr, "SO_RCVBUF = %d\n", value);
}
# endif
#endif
exitcode =
main_writer_loop (test, SOCKET_DATA_BLOCK_SIZE, server_socket,
SOCKET_HAS_LARGE_BUFFER);
{
int err =
wait_subprocess (child, child_path, false, false, false, false, NULL);
ASSERT (err == 0);
}
return exitcode;
}
/* Execute a command, optionally redirecting any of the three standard file
descriptors to /dev/null. Return its exit code.
If it didn't terminate correctly, exit if exit_on_error is true, otherwise
return 127.
If slave_process is true, the child process will be terminated when its
creator receives a catchable fatal signal. */
int
execute (const char *progname,
const char *prog_path, char **prog_argv,
bool ignore_sigpipe,
bool null_stdin, bool null_stdout, bool null_stderr,
bool slave_process, bool exit_on_error,
int *termsigp)
{
#if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
/* Native Windows API. */
int orig_stdin;
int orig_stdout;
int orig_stderr;
int exitcode;
int nullinfd;
int nulloutfd;
/* FIXME: Need to free memory allocated by prepare_spawn. */
prog_argv = prepare_spawn (prog_argv);
/* Save standard file handles of parent process. */
if (null_stdin)
orig_stdin = dup_safer_noinherit (STDIN_FILENO);
if (null_stdout)
orig_stdout = dup_safer_noinherit (STDOUT_FILENO);
if (null_stderr)
orig_stderr = dup_safer_noinherit (STDERR_FILENO);
exitcode = -1;
/* Create standard file handles of child process. */
nullinfd = -1;
nulloutfd = -1;
if ((!null_stdin
|| ((nullinfd = open ("NUL", O_RDONLY, 0)) >= 0
&& (nullinfd == STDIN_FILENO
|| (dup2 (nullinfd, STDIN_FILENO) >= 0
&& close (nullinfd) >= 0))))
&& (!(null_stdout || null_stderr)
|| ((nulloutfd = open ("NUL", O_RDWR, 0)) >= 0
&& (!null_stdout
|| nulloutfd == STDOUT_FILENO
|| dup2 (nulloutfd, STDOUT_FILENO) >= 0)
&& (!null_stderr
|| nulloutfd == STDERR_FILENO
|| dup2 (nulloutfd, STDERR_FILENO) >= 0)
&& ((null_stdout && nulloutfd == STDOUT_FILENO)
|| (null_stderr && nulloutfd == STDERR_FILENO)
|| close (nulloutfd) >= 0))))
/* Use spawnvpe and pass the environment explicitly. This is needed if
the program has modified the environment using putenv() or [un]setenv().
On Windows, programs have two environments, one in the "environment
block" of the process and managed through SetEnvironmentVariable(), and
one inside the process, in the location retrieved by the 'environ'
macro. When using spawnvp() without 'e', the child process inherits a
copy of the environment block - ignoring the effects of putenv() and
[un]setenv(). */
{
exitcode = spawnvpe (P_WAIT, prog_path, (const char **) prog_argv,
(const char **) environ);
if (exitcode < 0 && errno == ENOEXEC)
{
/* prog is not a native executable. Try to execute it as a
shell script. Note that prepare_spawn() has already prepended
a hidden element "sh.exe" to prog_argv. */
--prog_argv;
exitcode = spawnvpe (P_WAIT, prog_argv[0], (const char **) prog_argv,
(const char **) environ);
}
}
if (nulloutfd >= 0)
close (nulloutfd);
if (nullinfd >= 0)
close (nullinfd);
/* Restore standard file handles of parent process. */
if (null_stderr)
undup_safer_noinherit (orig_stderr, STDERR_FILENO);
if (null_stdout)
undup_safer_noinherit (orig_stdout, STDOUT_FILENO);
if (null_stdin)
undup_safer_noinherit (orig_stdin, STDIN_FILENO);
if (termsigp != NULL)
*termsigp = 0;
if (exitcode == -1)
{
if (exit_on_error || !null_stderr)
error (exit_on_error ? EXIT_FAILURE : 0, errno,
_("%s subprocess failed"), progname);
return 127;
}
return exitcode;
#else
/* Unix API. */
/* Note about 127: Some errors during posix_spawnp() cause the function
posix_spawnp() to return an error code; some other errors cause the
subprocess to exit with return code 127. It is implementation
dependent which error is reported which way. We treat both cases as
equivalent. */
sigset_t blocked_signals;
posix_spawn_file_actions_t actions;
bool actions_allocated;
posix_spawnattr_t attrs;
bool attrs_allocated;
int err;
pid_t child;
if (slave_process)
{
sigprocmask (SIG_SETMASK, NULL, &blocked_signals);
block_fatal_signals ();
}
actions_allocated = false;
attrs_allocated = false;
if ((err = posix_spawn_file_actions_init (&actions)) != 0
|| (actions_allocated = true,
(null_stdin
&& (err = posix_spawn_file_actions_addopen (&actions,
STDIN_FILENO,
"/dev/null", O_RDONLY,
0))
!= 0)
|| (null_stdout
&& (err = posix_spawn_file_actions_addopen (&actions,
STDOUT_FILENO,
"/dev/null", O_RDWR,
0))
!= 0)
|| (null_stderr
&& (err = posix_spawn_file_actions_addopen (&actions,
STDERR_FILENO,
"/dev/null", O_RDWR,
0))
!= 0)
|| (slave_process
&& ((err = posix_spawnattr_init (&attrs)) != 0
|| (attrs_allocated = true,
(err = posix_spawnattr_setsigmask (&attrs,
&blocked_signals))
!= 0
|| (err = posix_spawnattr_setflags (&attrs,
POSIX_SPAWN_SETSIGMASK))
!= 0)))
|| (err = posix_spawnp (&child, prog_path, &actions,
attrs_allocated ? &attrs : NULL, prog_argv,
environ))
!= 0))
{
if (actions_allocated)
posix_spawn_file_actions_destroy (&actions);
if (attrs_allocated)
posix_spawnattr_destroy (&attrs);
if (slave_process)
unblock_fatal_signals ();
if (termsigp != NULL)
*termsigp = 0;
if (exit_on_error || !null_stderr)
error (exit_on_error ? EXIT_FAILURE : 0, err,
_("%s subprocess failed"), progname);
return 127;
}
posix_spawn_file_actions_destroy (&actions);
if (attrs_allocated)
posix_spawnattr_destroy (&attrs);
if (slave_process)
{
register_slave_subprocess (child);
unblock_fatal_signals ();
}
return wait_subprocess (child, progname, ignore_sigpipe, null_stderr,
slave_process, exit_on_error, termsigp);
#endif
}
int main ( int argc, char **argv, char **env )
{
int i;
char *stmpdir;
char *buf = (char *)malloc(MAXPATHLEN);
#ifdef WIN32
typedef BOOL (WINAPI *pALLOW)(DWORD);
HINSTANCE hinstLib;
pALLOW ProcAdd;
#ifndef ASFW_ANY
#define ASFW_ANY -1
#endif
#endif
par_init_env();
par_mktmpdir( argv );
stmpdir = (char *)par_getenv("PAR_TEMP");
if ( stmpdir != NULL ) {
i = mkdir(stmpdir, 0755);
if ( (i != 0) && (i != EEXIST) && (i != -1) ) {
fprintf(stderr, "%s: creation of private temporary subdirectory %s failed - aborting with %i.\n", argv[0], stmpdir, errno);
return 2;
}
}
i = my_mkfile( argv[0], stmpdir, name_load_me_0, size_load_me_0 );
if ( !i ) return 2;
if ( i != -2 ) {
WRITE_load_me_0(i);
close(i); chmod(my_file, 0755);
}
my_file = par_basename(par_findprog(argv[0], strdup(par_getenv("PATH"))));
i = my_mkfile( argv[0], stmpdir, my_file, size_load_me_1 );
if ( !i ) return 2;
if ( i != -2 ) {
WRITE_load_me_1(i);
close(i); chmod(my_file, 0755);
}
sprintf(buf, "%i", argc);
par_setenv("PAR_ARGC", buf);
for (i = 0; i < argc; i++) {
buf = (char *)malloc(strlen(argv[i]) + 14);
sprintf(buf, "PAR_ARGV_%i", i);
par_setenv(buf, argv[i]);
}
#ifdef WIN32
hinstLib = LoadLibrary("user32");
if (hinstLib != NULL) {
ProcAdd = (pALLOW) GetProcAddress(hinstLib, "AllowSetForegroundWindow");
if (ProcAdd != NULL)
{
(ProcAdd)(ASFW_ANY);
}
}
par_setenv("PAR_SPAWNED", "1");
i = spawnvpe(P_WAIT, my_file, (const char* const*)argv, (const char* const*)environ);
#else
execvp(my_file, argv);
return 2;
#endif
par_cleanup(stmpdir);
return i;
}
int execvpe(const char *path, char * const argv[], char * const envp[])
{
return spawnvpe(P_OVERLAY, path, argv, envp);
}
int main ( int argc, char **argv, char **env )
{
int rc, i;
char *stmpdir;
embedded_file_t *emb_file;
char *my_file;
char *my_perl;
char *my_prog;
char buf[20]; /* must be large enough to hold "PAR_ARGV_###" */
#ifdef WIN32
typedef BOOL (WINAPI *pALLOW)(DWORD);
HINSTANCE hinstLib;
pALLOW ProcAdd;
#ifndef ASFW_ANY
#define ASFW_ANY -1
#endif
#endif
#define DIE exit(255)
par_init_env();
stmpdir = par_mktmpdir( argv );
if ( !stmpdir ) DIE; /* error message has already been printed */
rc = my_mkdir(stmpdir, 0700);
if ( rc == -1 && errno != EEXIST) {
fprintf(stderr, "%s: creation of private cache subdirectory %s failed (errno= %i)\n",
argv[0], stmpdir, errno);
DIE;
}
/* extract embedded_files[0] (i.e. the custom Perl interpreter)
* into stmpdir (but under the same basename as argv[0]) */
my_prog = par_findprog(argv[0], strdup(par_getenv("PATH")));
rc = extract_embedded_file(embedded_files, par_basename(my_prog), stmpdir, &my_perl);
if (rc == EXTRACT_FAIL) {
fprintf(stderr, "%s: extraction of %s (custom Perl interpreter) failed (errno=%i)\n",
argv[0], my_perl, errno);
DIE;
}
if (rc == EXTRACT_OK) /* i.e. file didn't already exist */
{
#ifdef __hpux
{
/* HPUX will only honour SHLIB_PATH if the executable is specially marked */
char *chatr_cmd = malloc(strlen(my_perl) + 200);
sprintf(chatr_cmd, "/usr/bin/chatr +s enable %s > /dev/null", my_perl);
system(chatr_cmd);
}
#endif
#ifdef WIN32
{
/* copy IMAGE_OPTIONAL_HEADER.Subsystem (GUI vs console)
* from this executable to the just extracted my_perl
*/
int fd;
WORD subsystem;
fd = open(my_prog, O_RDONLY | OPEN_O_BINARY, 0755);
ASSERT(fd != -1, "open my_prog");
seek_to_subsystem(fd);
read(fd, &subsystem, 2); // CHECK == 2
close(fd); // CHECK != -1
fd = open(my_perl, O_RDWR | OPEN_O_BINARY, 0755);
ASSERT(fd != -1, "open my_perl");
seek_to_subsystem(fd);
write(fd, &subsystem, 2); // CHECK == 2
close(fd); // CHECK != -1
}
#endif
}
/* extract the rest of embedded_files into stmpdir */
emb_file = embedded_files + 1;
while (emb_file->name) {
if (extract_embedded_file(emb_file, emb_file->name, stmpdir, &my_file) == EXTRACT_FAIL) {
fprintf(stderr, "%s: extraction of %s failed (errno=%i)\n",
argv[0], my_file, errno);
DIE;
}
emb_file++;
}
/* save original argv[] into environment variables PAR_ARGV_# */
sprintf(buf, "%i", argc);
par_setenv("PAR_ARGC", buf);
for (i = 0; i < argc; i++) {
sprintf(buf, "PAR_ARGV_%i", i);
par_unsetenv(buf);
par_setenv(buf, argv[i]);
}
/* finally spawn the custom Perl interpreter */
#ifdef WIN32
hinstLib = LoadLibrary("user32");
if (hinstLib != NULL) {
ProcAdd = (pALLOW) GetProcAddress(hinstLib, "AllowSetForegroundWindow");
if (ProcAdd != NULL)
{
(ProcAdd)(ASFW_ANY);
}
}
par_setenv("PAR_SPAWNED", "1");
rc = spawnvpe(P_WAIT, my_perl, (const char* const*)argv, (const char* const*)environ);
par_cleanup(stmpdir);
exit(rc);
#else
execvp(my_perl, argv);
DIE;
#endif
}
int spawnvp(int mode, const char *path, char *const argv[])
{
return spawnvpe(mode, path, (char * const *)argv, environ);
}
