hyung-hwan/hawk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
f928ce5ec8
hawk/lib/pio.c
hyung-hwan f928ce5ec8
All checks were successful
continuous-integration/drone/push Build is passing
Details
code touch-up for recent c language standard
2024-04-28 13:32:29 +09:00

2383 lines
58 KiB
C
Raw Blame History

/*
Copyright (c) 2006-2020 Chung, Hyung-Hwan. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <hawk-pio.h>
#include "hawk-prv.h"
#if defined(_WIN32)
# include <windows.h>
# include <tchar.h>
#elif defined(__OS2__)
# define INCL_DOSQUEUES
# define INCL_DOSPROCESS
# define INCL_DOSERRORS
# include <os2.h>
#elif defined(__DOS__)
# include <io.h>
# include <errno.h>
#else
# if !defined(_GNU_SOURCE)
# define _GNU_SOURCE
# endif
# include "syscall.h"
# if defined(HAVE_SPAWN_H)
# include <spawn.h>
# endif
# if defined(HAVE_CRT_EXTERNS_H)
# include <crt_externs.h> /* MacOSX/darwin. _NSGetEnviron() */
# endif
#endif
static hawk_ooi_t pio_input (hawk_tio_t* tio, hawk_tio_cmd_t cmd, void* buf, hawk_oow_t size);
static hawk_ooi_t pio_output (hawk_tio_t* tio, hawk_tio_cmd_t cmd, void* buf, hawk_oow_t size);
#if !defined(_WIN32) && !defined(__OS2__) && !defined(__DOS__)
static int get_highest_fd (hawk_pio_t* pio)
{
#if defined(HAVE_GETRLIMIT)
struct rlimit rlim;
#endif
int fd = -1;
HAWK_DIR* d;
#if defined(F_MAXFD)
fd = HAWK_FCNTL(0, F_MAXFD, 0);
if (fd >= 0) return fd;
#endif
/* will getting the highest file descriptor be faster than
* attempting to close any files descriptors less than the
* system limit? */
d = HAWK_OPENDIR(HAWK_BT("/proc/self/fd"));
if (!d)
{
hawk_bch_t buf[64];
hawk_gem_fmttobcstr (pio->gem, buf, HAWK_COUNTOF(buf), HAWK_BT("/proc/%d/fd"), HAWK_GETPID());
d = HAWK_OPENDIR (buf);
if (!d) d = HAWK_OPENDIR(HAWK_BT("/dev/fd")); /* Darwin, FreeBSD */
}
if (d)
{
int maxfd = -1;
hawk_dirent_t* de;
while ((de = HAWK_READDIR(d)))
{
hawk_int_t l;
const hawk_bch_t* endptr;
if (de->d_name[0] == HAWK_BT('.')) continue;
l = hawk_bchars_to_int(de->d_name, hawk_count_bcstr(de->d_name), HAWK_OOCHARS_TO_INT_MAKE_OPTION(0, 0, 10), &endptr, HAWK_NULL);
if (*endptr == '\0')
{
fd = (int)l;
if ((hawk_intptr_t)fd == l && fd != HAWK_DIRFD(d))
{
if (fd > maxfd) maxfd = fd;
}
}
}
HAWK_CLOSEDIR (d);
return maxfd;
}
/* TODO: should i also use getdtablesize() if available? */
#if defined(HAVE_GETRLIMIT)
if (HAWK_GETRLIMIT(RLIMIT_NOFILE, &rlim) <= -1 ||
rlim.rlim_max == RLIM_INFINITY)
{
#if defined(HAVE_SYSCONF)
fd = sysconf(_SC_OPEN_MAX);
#endif
}
else fd = rlim.rlim_max;
#elif defined(HAVE_SYSCONF)
fd = sysconf(_SC_OPEN_MAX);
#endif
if (fd <= -1) fd = 1024; /* fallback */
/* F_MAXFD is the highest fd. but RLIMIT_NOFILE and
* _SC_OPEN_MAX returnes the maximum number of file
* descriptors. make adjustment */
if (fd > 0) fd--;
return fd;
}
static int close_open_fds_using_proc (hawk_pio_t* pio, int* excepts, hawk_oow_t count)
{
HAWK_DIR* d;
/* will getting the highest file descriptor be faster than
* attempting to close any files descriptors less than the
* system limit? */
d = HAWK_OPENDIR(HAWK_BT("/proc/self/fd"));
if (!d)
{
hawk_bch_t buf[64];
hawk_gem_fmttobcstr (pio->gem, buf, HAWK_COUNTOF(buf), HAWK_BT("/proc/%d/fd"), HAWK_GETPID());
d = HAWK_OPENDIR(buf);
#if !defined(_SCO_DS)
/* on SCO OpenServer, a range of file descriptors starting from 0 are
* listed under /dev/fd regardless of opening state. And some high
* numbered descriptors are not listed. not reliable */
if (!d) d = HAWK_OPENDIR(HAWK_BT("/dev/fd")); /* Darwin, FreeBSD */
#endif
}
if (d)
{
hawk_dirent_t* de;
while ((de = HAWK_READDIR(d)))
{
hawk_int_t l;
const hawk_bch_t* endptr;
if (de->d_name[0] == HAWK_BT('.')) continue;
l = hawk_bchars_to_int(de->d_name, hawk_count_bcstr(de->d_name), HAWK_OOCHARS_TO_INT_MAKE_OPTION(0, 0, 10), &endptr, HAWK_NULL);
if (*endptr == '\0')
{
int fd = (int)l;
if ((hawk_intptr_t)fd == l && fd != HAWK_DIRFD(d) && fd > 2)
{
hawk_oow_t i;
for (i = 0; i < count; i++)
{
if (fd == excepts[i]) goto skip_close;
}
HAWK_CLOSE (fd);
skip_close:
;
}
}
}
HAWK_CLOSEDIR (d);
return 0;
}
return -1;
}
#endif
hawk_pio_t* hawk_pio_open (hawk_gem_t* gem, hawk_oow_t xtnsize, const hawk_ooch_t* cmd, int flags)
{
hawk_pio_t* pio;
pio = (hawk_pio_t*)hawk_gem_allocmem(gem, HAWK_SIZEOF(hawk_pio_t) + xtnsize);
if (pio)
{
if (hawk_pio_init(pio, gem, cmd, flags) <= -1)
{
hawk_gem_freemem (gem, pio);
pio = HAWK_NULL;
}
else HAWK_MEMSET (pio + 1, 0, xtnsize);
}
return pio;
}
void hawk_pio_close (hawk_pio_t* pio)
{
hawk_pio_fini (pio);
hawk_gem_freemem (pio->gem, pio);
}
#if !defined(_WIN32) && !defined(__OS2__) && !defined(__DOS__)
struct param_t
{
hawk_bch_t* mcmd;
hawk_bch_t* fixed_argv[4];
hawk_bch_t** argv;
#if defined(HAWK_OOCH_IS_BCH)
/* nothing extra */
#else
hawk_bch_t fixed_mbuf[64];
#endif
};
typedef struct param_t param_t;
static void free_param (hawk_pio_t* pio, param_t* param)
{
if (param->argv && param->argv != param->fixed_argv)
hawk_gem_freemem (pio->gem, param->argv);
if (param->mcmd) hawk_gem_freemem (pio->gem, param->mcmd);
}
static int make_param (hawk_pio_t* pio, const hawk_ooch_t* cmd, int flags, param_t* param)
{
#if defined(HAWK_OOCH_IS_BCH)
hawk_bch_t* mcmd = HAWK_NULL;
#else
hawk_bch_t* mcmd = HAWK_NULL;
hawk_ooch_t* wcmd = HAWK_NULL;
#endif
int fcnt = 0;
HAWK_MEMSET (param, 0, HAWK_SIZEOF(*param));
#if defined(HAWK_OOCH_IS_BCH)
if (flags & HAWK_PIO_SHELL) mcmd = (hawk_ooch_t*)cmd;
else
{
mcmd = hawk_gem_dupoocstr(pio->gem, cmd, HAWK_NULL);
if (mcmd == HAWK_NULL) goto oops;
fcnt = hawk_split_oocstr(mcmd, HAWK_T(""), HAWK_T('\"'), HAWK_T('\"'), HAWK_T('\\'));
if (fcnt <= 0)
{
/* no field or an error */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EINVAL);
goto oops;
}
}
#else
if (flags & HAWK_PIO_BCSTRCMD)
{
/* the cmd is flagged to be of hawk_bch_t
* while the default character type is hawk_uch_t. */
if (flags & HAWK_PIO_SHELL) mcmd = (hawk_bch_t*)cmd;
else
{
mcmd = hawk_gem_dupbcstr(pio->gem, (const hawk_bch_t*)cmd, HAWK_NULL);
if (mcmd == HAWK_NULL) goto oops;
fcnt = hawk_split_bcstr(mcmd, "", '\"', '\"', '\\');
if (fcnt <= 0)
{
/* no field or an error */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EINVAL);
goto oops;
}
}
}
else
{
hawk_oow_t n, mn, wl;
if (flags & HAWK_PIO_SHELL)
{
/* use the cmgr of the gem, not pio->cmgr */
if (hawk_conv_ucstr_to_bcstr_with_cmgr(cmd, &wl, HAWK_NULL, &mn, pio->gem->cmgr) <= -1)
{
/* cmd has illegal sequence */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EINVAL);
goto oops;
}
}
else
{
wcmd = hawk_gem_dupoocstr(pio->gem, cmd, HAWK_NULL);
if (wcmd == HAWK_NULL) goto oops;
fcnt = hawk_split_oocstr(wcmd, HAWK_T(""), HAWK_T('\"'), HAWK_T('\"'), HAWK_T('\\'));
if (fcnt <= 0)
{
/* no field or an error */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EINVAL);
goto oops;
}
/* calculate the length of the string after splitting */
for (wl = 0, n = fcnt; n > 0; )
{
if (wcmd[wl++] == HAWK_T('\0')) n--;
}
if (hawk_conv_uchars_to_bchars_with_cmgr(wcmd, &wl, HAWK_NULL, &mn, pio->gem->cmgr) <= -1)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EINVAL);
goto oops;
}
}
/* prepare to reserve 1 more slot for the terminating '\0'
* by incrementing mn by 1. */
mn = mn + 1;
if (mn <= HAWK_COUNTOF(param->fixed_mbuf))
{
mcmd = param->fixed_mbuf;
mn = HAWK_COUNTOF(param->fixed_mbuf);
}
else
{
mcmd = hawk_gem_allocmem(pio->gem, mn * HAWK_SIZEOF(*mcmd));
if (mcmd == HAWK_NULL) goto oops;
}
if (flags & HAWK_PIO_SHELL)
{
/*HAWK_ASSERT (wcmd == HAWK_NULL);*/
/* hawk_wcstombs() should succeed as
* it was successful above */
hawk_conv_ucstr_to_bcstr_with_cmgr (cmd, &wl, mcmd, &mn, pio->gem->cmgr);
/* hawk_wcstombs() null-terminate mcmd */
}
else
{
HAWK_ASSERT (wcmd != HAWK_NULL);
/* hawk_wcsntombsn() should succeed as
* it was was successful above */
hawk_conv_uchars_to_bchars_with_cmgr (wcmd, &wl, mcmd, &mn, pio->gem->cmgr);
/* hawk_wcsntombsn() doesn't null-terminate mcmd */
mcmd[mn] = '\0';
hawk_gem_freemem (pio->gem, wcmd);
wcmd = HAWK_NULL;
}
}
#endif
if (flags & HAWK_PIO_SHELL)
{
param->argv = param->fixed_argv;
param->argv[0] = HAWK_BT("/bin/sh");
param->argv[1] = HAWK_BT("-c");
param->argv[2] = mcmd;
param->argv[3] = HAWK_NULL;
}
else
{
int i;
hawk_bch_t** argv;
hawk_bch_t* mcmdptr;
if (fcnt < HAWK_COUNTOF(param->fixed_argv))
{
param->argv = param->fixed_argv;
}
else
{
param->argv = hawk_gem_allocmem(pio->gem, (fcnt + 1) * HAWK_SIZEOF(argv[0]));
if (param->argv == HAWK_NULL) goto oops;
}
mcmdptr = mcmd;
for (i = 0; i < fcnt; i++)
{
param->argv[i] = mcmdptr;
while (*mcmdptr != HAWK_BT('\0')) mcmdptr++;
mcmdptr++;
}
param->argv[i] = HAWK_NULL;
}
#if defined(HAWK_OOCH_IS_BCH)
if (mcmd && mcmd != (hawk_bch_t*)cmd) param->mcmd = mcmd;
#else
if (mcmd && mcmd != (hawk_bch_t*)cmd &&
mcmd != param->fixed_mbuf) param->mcmd = mcmd;
#endif
return 0;
oops:
#if defined(HAWK_OOCH_IS_BCH)
if (mcmd && mcmd != cmd) hawk_gem_freemem (pio->gem, mcmd);
#else
if (mcmd && mcmd != (hawk_bch_t*)cmd &&
mcmd != param->fixed_mbuf) hawk_gem_freemem (pio->gem, mcmd);
if (wcmd) hawk_gem_freemem (pio->gem, wcmd);
#endif
return -1;
}
static int assert_executable (hawk_pio_t* pio, const hawk_bch_t* path)
{
hawk_lstat_t st;
if (HAWK_ACCESS(path, X_OK) <= -1)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
return -1;
}
/*if (HAWK_LSTAT(path, &st) <= -1)*/
if (HAWK_STAT(path, &st) <= -1)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
return -1;
}
if (!S_ISREG(st.st_mode))
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EACCES);
return -1;
}
return 0;
}
static HAWK_INLINE int is_fd_valid (int fd)
{
return HAWK_FCNTL (fd, F_GETFD, 0) != -1 || errno != EBADF;
}
static HAWK_INLINE int is_fd_valid_and_nocloexec (int fd)
{
int flags = HAWK_FCNTL (fd, F_GETFD, 0);
if (flags == -1)
{
if (errno == EBADF) return 0; /* invalid. return false */
return -1; /* unknown. true but negative to indicate unknown */
}
return !(flags & FD_CLOEXEC)? 1: 0;
}
static hawk_pio_pid_t standard_fork_and_exec (hawk_pio_t* pio, int pipes[], param_t* param)
{
hawk_pio_pid_t pid;
#if defined(HAVE_CRT_EXTERNS_H)
# define environ (*(_NSGetEnviron()))
#else
extern char** environ;
#endif
pid = HAWK_FORK();
if (pid <= -1)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
return -1;
}
if (pid == 0)
{
/* child */
hawk_pio_hnd_t devnull = -1;
if (!(pio->flags & HAWK_PIO_NOCLOEXEC))
{
if (close_open_fds_using_proc(pio, pipes, 6) <= -1)
{
int fd = get_highest_fd(pio);
/* close all other unknown open handles except
* stdin/out/err and the pipes. */
while (fd > 2)
{
if (fd != pipes[0] && fd != pipes[1] &&
fd != pipes[2] && fd != pipes[3] &&
fd != pipes[4] && fd != pipes[5])
{
HAWK_CLOSE (fd);
}
fd--;
}
}
}
if (pio->flags & HAWK_PIO_WRITEIN)
{
/* child should read */
HAWK_CLOSE (pipes[1]);
pipes[1] = HAWK_PIO_HND_NIL;
if (HAWK_DUP2 (pipes[0], 0) <= -1) goto child_oops;
HAWK_CLOSE (pipes[0]);
pipes[0] = HAWK_PIO_HND_NIL;
}
if (pio->flags & HAWK_PIO_READOUT)
{
/* child should write */
HAWK_CLOSE (pipes[2]);
pipes[2] = HAWK_PIO_HND_NIL;
if (HAWK_DUP2 (pipes[3], 1) <= -1) goto child_oops;
if (pio->flags & HAWK_PIO_ERRTOOUT)
{
if (HAWK_DUP2 (pipes[3], 2) <= -1) goto child_oops;
}
HAWK_CLOSE (pipes[3]);
pipes[3] = HAWK_PIO_HND_NIL;
}
if (pio->flags & HAWK_PIO_READERR)
{
/* child should write */
HAWK_CLOSE (pipes[4]);
pipes[4] = HAWK_PIO_HND_NIL;
if (HAWK_DUP2 (pipes[5], 2) <= -1) goto child_oops;
if (pio->flags & HAWK_PIO_OUTTOERR)
{
if (HAWK_DUP2 (pipes[5], 1) <= -1) goto child_oops;
}
HAWK_CLOSE (pipes[5]);
pipes[5] = HAWK_PIO_HND_NIL;
}
if ((pio->flags & HAWK_PIO_INTONUL) ||
(pio->flags & HAWK_PIO_OUTTONUL) ||
(pio->flags & HAWK_PIO_ERRTONUL))
{
#if defined(O_LARGEFILE)
devnull = HAWK_OPEN (HAWK_BT("/dev/null"), O_RDWR|O_LARGEFILE, 0);
#else
devnull = HAWK_OPEN (HAWK_BT("/dev/null"), O_RDWR, 0);
#endif
if (devnull <= -1) goto child_oops;
}
if ((pio->flags & HAWK_PIO_INTONUL) &&
HAWK_DUP2(devnull,0) <= -1) goto child_oops;
if ((pio->flags & HAWK_PIO_OUTTONUL) &&
HAWK_DUP2(devnull,1) <= -1) goto child_oops;
if ((pio->flags & HAWK_PIO_ERRTONUL) &&
HAWK_DUP2(devnull,2) <= -1) goto child_oops;
if ((pio->flags & HAWK_PIO_INTONUL) ||
(pio->flags & HAWK_PIO_OUTTONUL) ||
(pio->flags & HAWK_PIO_ERRTONUL))
{
HAWK_CLOSE (devnull);
devnull = -1;
}
if (pio->flags & HAWK_PIO_DROPIN) HAWK_CLOSE(0);
if (pio->flags & HAWK_PIO_DROPOUT) HAWK_CLOSE(1);
if (pio->flags & HAWK_PIO_DROPERR) HAWK_CLOSE(2);
if (pio->flags & HAWK_PIO_FNCCMD)
{
/* -----------------------------------------------
* the function pointer to execute has been given.
* -----------------------------------------------*/
hawk_pio_fnc_t* fnc = (hawk_pio_fnc_t*)param;
int retx;
retx = fnc->ptr(fnc->ctx);
if (devnull >= 0) HAWK_CLOSE (devnull);
HAWK_EXIT (retx);
}
else
{
HAWK_EXECVE (param->argv[0], param->argv, environ);
/* if exec fails, free 'param' parameter which is an inherited pointer */
free_param (pio, param);
}
child_oops:
if (devnull >= 0) HAWK_CLOSE (devnull);
HAWK_EXIT (128);
}
return pid;
}
#endif
static int set_pipe_nonblock (hawk_pio_t* pio, hawk_pio_hnd_t fd, int enabled)
{
#if defined(O_NONBLOCK)
int flag = HAWK_FCNTL (fd, F_GETFL, 0);
if (flag >= 0) flag = HAWK_FCNTL (fd, F_SETFL, (enabled? (flag | O_NONBLOCK): (flag & ~O_NONBLOCK)));
if (flag <= -1) hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
return flag;
#else
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_ENOIMPL);
return -1;
#endif
}
int hawk_pio_init (hawk_pio_t* pio, hawk_gem_t* gem, const hawk_ooch_t* cmd, int flags)
{
hawk_pio_hnd_t handle[6] /*=
{
HAWK_PIO_HND_NIL,
HAWK_PIO_HND_NIL,
HAWK_PIO_HND_NIL,
HAWK_PIO_HND_NIL,
HAWK_PIO_HND_NIL,
HAWK_PIO_HND_NIL
}*/;
hawk_tio_t* tio[3] /*=
{
HAWK_NULL,
HAWK_NULL,
HAWK_NULL
}*/;
int i, minidx = -1, maxidx = -1;
#if defined(_WIN32)
SECURITY_ATTRIBUTES secattr;
PROCESS_INFORMATION procinfo;
STARTUPINFO startup;
HANDLE windevnul = INVALID_HANDLE_VALUE;
BOOL apiret;
hawk_ooch_t* dupcmd;
int create_retried;
#elif defined(__OS2__)
APIRET rc;
ULONG pipe_size = 4096;
UCHAR load_error[CCHMAXPATH];
RESULTCODES child_rc;
HFILE old_in = HAWK_PIO_HND_NIL;
HFILE old_out = HAWK_PIO_HND_NIL;
HFILE old_err = HAWK_PIO_HND_NIL;
HFILE std_in = 0, std_out = 1, std_err = 2;
hawk_bch_t* cmd_line = HAWK_NULL;
hawk_bch_t* cmd_file;
HFILE os2devnul = (HFILE)-1;
#elif defined(__DOS__)
/* DOS not multi-processed. can't support pio */
#elif defined(HAVE_POSIX_SPAWN) && !(defined(HAWK_SYSCALL0) && defined(SYS_vfork))
posix_spawn_file_actions_t fa;
int fa_inited = 0;
int pserr;
posix_spawnattr_t psattr;
hawk_pio_pid_t pid;
param_t param;
#if defined(HAVE_CRT_EXTERNS_H)
#define environ (*(_NSGetEnviron()))
#else
extern char** environ;
#endif
#elif defined(HAWK_SYSCALL0) && defined(SYS_vfork)
hawk_pio_pid_t pid;
param_t param;
#if defined(HAVE_CRT_EXTERNS_H)
#define environ (*(_NSGetEnviron()))
#else
extern char** environ;
#endif
int highest_fd;
int dummy;
#else
hawk_pio_pid_t pid;
param_t param;
#if defined(HAVE_CRT_EXTERNS_H)
#define environ (*(_NSGetEnviron()))
#else
extern char** environ;
#endif
#endif
HAWK_MEMSET (pio, 0, HAWK_SIZEOF(*pio));
pio->gem = gem;
pio->flags = flags;
handle[0] = HAWK_PIO_HND_NIL;
handle[1] = HAWK_PIO_HND_NIL;
handle[2] = HAWK_PIO_HND_NIL;
handle[3] = HAWK_PIO_HND_NIL;
handle[4] = HAWK_PIO_HND_NIL;
handle[5] = HAWK_PIO_HND_NIL;
tio[0] = HAWK_NULL;
tio[1] = HAWK_NULL;
tio[2] = HAWK_NULL;
#if defined(_WIN32)
/* http://msdn.microsoft.com/en-us/library/ms682499(VS.85).aspx */
secattr.nLength = HAWK_SIZEOF(secattr);
secattr.bInheritHandle = TRUE;
secattr.lpSecurityDescriptor = HAWK_NULL;
if (flags & HAWK_PIO_WRITEIN)
{
/* child reads, parent writes */
if (CreatePipe(&handle[0], &handle[1], &secattr, 0) == FALSE)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(GetLastError()));
goto oops;
}
/* don't inherit write handle */
if (SetHandleInformation(handle[1], HANDLE_FLAG_INHERIT, 0) == FALSE)
{
DWORD e = GetLastError();
if (e != ERROR_CALL_NOT_IMPLEMENTED)
{
/* SetHandleInformation() is not implemented on win9x.
* so let's care only if it is implemented */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(e));
goto oops;
}
}
minidx = 0; maxidx = 1;
}
if (flags & HAWK_PIO_READOUT)
{
/* child writes, parent reads */
if (CreatePipe(&handle[2], &handle[3], &secattr, 0) == FALSE)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(GetLastError()));
goto oops;
}
/* don't inherit read handle */
if (SetHandleInformation(handle[2], HANDLE_FLAG_INHERIT, 0) == FALSE)
{
DWORD e = GetLastError();
if (e != ERROR_CALL_NOT_IMPLEMENTED)
{
/* SetHandleInformation() is not implemented on win9x.
* so let's care only if it is implemented */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(e));
goto oops;
}
}
if (minidx == -1) minidx = 2;
maxidx = 3;
}
if (flags & HAWK_PIO_READERR)
{
/* child writes, parent reads */
if (CreatePipe(&handle[4], &handle[5], &secattr, 0) == FALSE)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(GetLastError()));
goto oops;
}
/* don't inherit read handle */
if (SetHandleInformation(handle[4], HANDLE_FLAG_INHERIT, 0) == FALSE)
{
DWORD e = GetLastError();
if (e != ERROR_CALL_NOT_IMPLEMENTED)
{
/* SetHandleInformation() is not implemented on win9x.
* so let's care only if it is implemented */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(e));
goto oops;
}
}
if (minidx == -1) minidx = 4;
maxidx = 5;
}
if (maxidx == -1)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EINVAL);
goto oops;
}
if ((flags & HAWK_PIO_INTONUL) ||
(flags & HAWK_PIO_OUTTONUL) ||
(flags & HAWK_PIO_ERRTONUL))
{
windevnul = CreateFile(
HAWK_T("NUL"), GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
&secattr, OPEN_EXISTING, 0, NULL
);
if (windevnul == INVALID_HANDLE_VALUE)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(GetLastError()));
goto oops;
}
}
HAWK_MEMSET (&procinfo, 0, HAWK_SIZEOF(procinfo));
HAWK_MEMSET (&startup, 0, HAWK_SIZEOF(startup));
startup.cb = HAWK_SIZEOF(startup);
/*
startup.hStdInput = INVALID_HANDLE_VALUE;
startup.hStdOutput = INVALID_HANDLE_VALUE;
startup.hStdOutput = INVALID_HANDLE_VALUE;
*/
startup.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
startup.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
startup.hStdOutput = GetStdHandle(STD_ERROR_HANDLE);
if (startup.hStdInput == INVALID_HANDLE_VALUE ||
startup.hStdOutput == INVALID_HANDLE_VALUE ||
startup.hStdError == INVALID_HANDLE_VALUE)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(GetLastError()));
goto oops;
}
if (flags & HAWK_PIO_WRITEIN)
{
startup.hStdInput = handle[0];
}
if (flags & HAWK_PIO_READOUT)
{
startup.hStdOutput = handle[3];
if (flags & HAWK_PIO_ERRTOOUT) startup.hStdError = handle[3];
}
if (flags & HAWK_PIO_READERR)
{
startup.hStdError = handle[5];
if (flags & HAWK_PIO_OUTTOERR) startup.hStdOutput = handle[5];
}
if (flags & HAWK_PIO_INTONUL) startup.hStdInput = windevnul;
if (flags & HAWK_PIO_OUTTONUL) startup.hStdOutput = windevnul;
if (flags & HAWK_PIO_ERRTONUL) startup.hStdError = windevnul;
if (flags & HAWK_PIO_DROPIN) startup.hStdInput = INVALID_HANDLE_VALUE;
if (flags & HAWK_PIO_DROPOUT) startup.hStdOutput = INVALID_HANDLE_VALUE;
if (flags & HAWK_PIO_DROPERR) startup.hStdError = INVALID_HANDLE_VALUE;
startup.dwFlags |= STARTF_USESTDHANDLES;
/* there is nothing to do for HAWK_PIO_SHELL as CreateProcess
* takes the entire command line */
create_retried = 0;
create_process:
if (flags & HAWK_PIO_SHELL)
{
static const hawk_ooch_t* cmdname[] =
{
HAWK_T("cmd.exe /c "),
HAWK_T("command.com /c ")
};
static const hawk_bch_t* mcmdname[] =
{
HAWK_BT("cmd.exe /c "),
HAWK_BT("command.com /c ")
};
#if defined(HAWK_OOCH_IS_UCH)
if (flags & HAWK_PIO_BCSTRCMD)
{
const hawk_bch_t* x[3];
x[0] = mcmdname[create_retried];
x[1] = (const hawk_bch_t*)cmd;
x[2] = HAWK_NULL;
dupcmd = hawk_gem_dupbcstrarrtoucstr(pio->gem, x, HAWK_NULL, 0);
}
else
#endif
{
const hawk_ooch_t* x[3];
x[0] = cmdname[create_retried];
x[1] = cmd;
x[2] = HAWK_NULL;
dupcmd = hawk_gem_dupoocstrarr(pio->gem, x, HAWK_NULL);
}
}
else
{
#if defined(HAWK_OOCH_IS_UCH)
if (flags & HAWK_PIO_BCSTRCMD)
{
dupcmd = hawk_gem_dupbtoucstr(pio->gem, (const hawk_bch_t*)cmd, HAWK_NULL, 0);
}
else
{
#endif
/* CreateProcess requires command buffer to be read-write. */
dupcmd = hawk_gem_dupoocstr(pio->gem, cmd, HAWK_NULL);
#if defined(HAWK_OOCH_IS_UCH)
}
#endif
}
if (dupcmd == HAWK_NULL) goto oops;
apiret = CreateProcess (
HAWK_NULL, /* LPCTSTR lpApplicationName */
dupcmd, /* LPTSTR lpCommandLine */
HAWK_NULL, /* LPSECURITY_ATTRIBUTES lpProcessAttributes */
HAWK_NULL, /* LPSECURITY_ATTRIBUTES lpThreadAttributes */
TRUE, /* BOOL bInheritHandles */
#if defined(HAWK_OOCH_IS_BCH)
0, /* DWORD dwCreationFlags */
#else
CREATE_UNICODE_ENVIRONMENT, /* DWORD dwCreationFlags */
#endif
HAWK_NULL, /* LPVOID lpEnvironment */
HAWK_NULL, /* LPCTSTR lpCurrentDirectory */
&startup, /* LPSTARTUPINFO lpStartupInfo */
&procinfo /* LPPROCESS_INFORMATION lpProcessInformation */
);
hawk_gem_freemem (pio->gem, dupcmd);
if (apiret == FALSE)
{
DWORD e = GetLastError();
if (create_retried == 0 && (flags & HAWK_PIO_SHELL) &&
e == ERROR_FILE_NOT_FOUND)
{
/* if it failed to exeucte cmd.exe,
* attempt to execute command.com.
* this is provision for old windows platforms */
create_retried = 1;
goto create_process;
}
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(e));
goto oops;
}
if (windevnul != INVALID_HANDLE_VALUE)
{
CloseHandle (windevnul);
windevnul = INVALID_HANDLE_VALUE;
}
if (flags & HAWK_PIO_WRITEIN)
{
CloseHandle (handle[0]);
handle[0] = HAWK_PIO_HND_NIL;
}
if (flags & HAWK_PIO_READOUT)
{
CloseHandle (handle[3]);
handle[3] = HAWK_PIO_HND_NIL;
}
if (flags & HAWK_PIO_READERR)
{
CloseHandle (handle[5]);
handle[5] = HAWK_PIO_HND_NIL;
}
CloseHandle (procinfo.hThread);
pio->child = procinfo.hProcess;
#elif defined(__OS2__)
#define DOS_DUP_HANDLE(x,y) HAWK_BLOCK ( \
rc = DosDupHandle(x,y); \
if (rc != NO_ERROR) \
{ \
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc)); \
goto oops; \
} \
)
if (flags & HAWK_PIO_WRITEIN)
{
/* child reads, parent writes */
rc = DosCreatePipe (&handle[0], &handle[1], pipe_size);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
goto oops;
}
/* the parent writes to handle[1] and the child reads from
* handle[0] inherited. set the flag not to inherit handle[1]. */
rc = DosSetFHState (handle[1], OPEN_FLAGS_NOINHERIT);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
goto oops;
}
/* Need to do somthing like this to set the flag instead?
ULONG state;
DosQueryFHState (handle[1], &state);
DosSetFHState (handle[1], state | OPEN_FLAGS_NOINHERIT); */
minidx = 0; maxidx = 1;
}
if (flags & HAWK_PIO_READOUT)
{
/* child writes, parent reads */
rc = DosCreatePipe (&handle[2], &handle[3], pipe_size);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
goto oops;
}
/* the parent reads from handle[2] and the child writes to
* handle[3] inherited. set the flag not to inherit handle[2] */
rc = DosSetFHState(handle[2], OPEN_FLAGS_NOINHERIT);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
goto oops;
}
if (minidx == -1) minidx = 2;
maxidx = 3;
}
if (flags & HAWK_PIO_READERR)
{
/* child writes, parent reads */
rc = DosCreatePipe(&handle[4], &handle[5], pipe_size);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
goto oops;
}
/* the parent reads from handle[4] and the child writes to
* handle[5] inherited. set the flag not to inherit handle[4] */
rc = DosSetFHState (handle[4], OPEN_FLAGS_NOINHERIT);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
goto oops;
}
if (minidx == -1) minidx = 4;
maxidx = 5;
}
if (maxidx == -1)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EINVAL);
goto oops;
}
if ((flags & HAWK_PIO_INTONUL) ||
(flags & HAWK_PIO_OUTTONUL) ||
(flags & HAWK_PIO_ERRTONUL))
{
ULONG action_taken;
/*
LONGLONG zero;
zero.ulLo = 0;
zero.ulHi = 0;
*/
/* TODO: selective between DosOpenL and DosOpen */
rc = DosOpen/*DosOpenL*/(
HAWK_BT("NUL"),
&os2devnul,
&action_taken,
0, /*zero,*/
FILE_NORMAL,
OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW,
OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYNONE,
0L
);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
goto oops;
}
}
/* duplicate the current stdin/out/err to old_in/out/err as a new handle */
rc = DosDupHandle(std_in, &old_in);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
goto oops;
}
rc = DosDupHandle(std_out, &old_out);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
DosClose (old_in); old_in = HAWK_PIO_HND_NIL;
goto oops;
}
rc = DosDupHandle(std_err, &old_err);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
DosClose (old_out); old_out = HAWK_PIO_HND_NIL;
DosClose (old_in); old_in = HAWK_PIO_HND_NIL;
goto oops;
}
/* we must not let our own stdin/out/err duplicated
* into old_in/out/err be inherited */
DosSetFHState (old_in, OPEN_FLAGS_NOINHERIT);
DosSetFHState (old_out, OPEN_FLAGS_NOINHERIT);
DosSetFHState (old_err, OPEN_FLAGS_NOINHERIT);
if (flags & HAWK_PIO_WRITEIN)
{
/* the child reads from handle[0] inherited and expects it to
* be stdin(0). so we duplicate handle[0] to stdin */
DOS_DUP_HANDLE (handle[0], &std_in);
/* the parent writes to handle[1] but does not read from handle[0].
* so we close it */
DosClose (handle[0]); handle[0] = HAWK_PIO_HND_NIL;
}
if (flags & HAWK_PIO_READOUT)
{
/* the child writes to handle[3] inherited and expects it to
* be stdout(1). so we duplicate handle[3] to stdout. */
DOS_DUP_HANDLE (handle[3], &std_out);
if (flags & HAWK_PIO_ERRTOOUT) DOS_DUP_HANDLE (handle[3], &std_err);
/* the parent reads from handle[2] but does not write to handle[3].
* so we close it */
DosClose (handle[3]); handle[3] = HAWK_PIO_HND_NIL;
}
if (flags & HAWK_PIO_READERR)
{
DOS_DUP_HANDLE (handle[5], &std_err);
if (flags & HAWK_PIO_OUTTOERR) DOS_DUP_HANDLE (handle[5], &std_out);
DosClose (handle[5]); handle[5] = HAWK_PIO_HND_NIL;
}
if (flags & HAWK_PIO_INTONUL) DOS_DUP_HANDLE (os2devnul, &std_in);
if (flags & HAWK_PIO_OUTTONUL) DOS_DUP_HANDLE (os2devnul, &std_out);
if (flags & HAWK_PIO_ERRTONUL) DOS_DUP_HANDLE (os2devnul, &std_err);
if (os2devnul != HAWK_PIO_HND_NIL)
{
/* close NUL early as we've duplicated it already */
DosClose (os2devnul);
os2devnul = HAWK_PIO_HND_NIL;
}
/* at this moment, stdin/out/err are already redirected to pipes
* if proper flags have been set. we close them selectively if
* dropping is requested */
if (flags & HAWK_PIO_DROPIN) DosClose (std_in);
if (flags & HAWK_PIO_DROPOUT) DosClose (std_out);
if (flags & HAWK_PIO_DROPERR) DosClose (std_err);
if (flags & HAWK_PIO_SHELL)
{
hawk_oow_t n, mn;
#if defined(HAWK_OOCH_IS_BCH)
mn = hawk_count_oocstr(cmd);
#else
if (flags & HAWK_PIO_BCSTRCMD)
{
mn = hawk_count_bcstr((const hawk_bch_t*)cmd);
}
else
{
if (hawk_gem_convutobcstr(pio->gem, cmd, &n, HAWK_NULL, &mn) <= -1) goto oops; /* illegal sequence found */
}
#endif
cmd_line = hawk_gem_allocmem(pio->gem, ((11+mn+1+1) * HAWK_SIZEOF(*cmd_line)));
if (cmd_line == HAWK_NULL) goto oops;
hawk_copy_bcstr_unlimited (cmd_line, "cmd.exe"); /* cmd.exe\0/c */
hawk_copy_bcstr_unlimited (&cmd_line[8], "/c ");
#if defined(HAWK_OOCH_IS_BCH)
hawk_copy_bcstr_unlimited (&cmd_line[11], cmd);
#else
if (flags & HAWK_PIO_BCSTRCMD)
{
hawk_copy_bcstr_unlimited (&cmd_line[11], (const hawk_bch_t*)cmd);
}
else
{
mn = mn + 1; /* update the buffer size */
hawk_gem_convutobcstr (pio->gem, cmd, &n, &cmd_line[11], &mn);
}
#endif
cmd_line[11+mn+1] = '\0'; /* additional \0 after \0 */
cmd_file = "cmd.exe";
}
else
{
hawk_bch_t* mptr;
hawk_oow_t mn;
#if defined(HAWK_OOCH_IS_BCH)
const hawk_ooch_t* strarr[3];
strarr[0] = cmd;
strarr[1] = HAWK_T(" ");
strarr[2] = HAWK_NULL;
mn = hawk_count_oocstr(cmd);
cmd_line = hawk_dupucstrarr(pio->gem, strarr HAWK_NULL);
if (cmd_line == HAWK_NULL) goto oops;
#else
if (flags & HAWK_PIO_BCSTRCMD)
{
const hawk_bch_t* mbsarr[3];
mbsarr[0] = (const hawk_bch_t*)cmd;
mbsarr[1] = " ";
mbsarr[2] = HAWK_NULL;
mn = hawk_count_bcstr((const hawk_bch_t*)cmd);
cmd_line = hawk_dupbcstrarr(pio->gem, mbsarr, HAWK_NULL);
if (cmd_line == HAWK_NULL) goto oops;
}
else
{
cmd_line = hawk_gem_duputobcstr(gem, cmd, &mn);
if (!cmd_line) goto oops; /* illegal sequence in cmd or out of memory */
}
#endif
/* TODO: enhance this part by:
* supporting file names containing whitespaces.
* detecting the end of the file name better.
* doing better parsing of the command line.
*/
/* NOTE: you must separate the command name and the parameters
* with a space. "pstat.exe /c" is ok while "pstat.exe/c"
* is not. */
mptr = hawk_mbspbrk(cmd_line, HAWK_BT(" \t"));
if (mptr) *mptr = '\0';
cmd_line[mn+1] = '\0'; /* the second '\0' at the end */
cmd_file = cmd_line;
}
/* execute the command line */
rc = DosExecPgm (
&load_error,
HAWK_SIZEOF(load_error),
EXEC_ASYNCRESULT,
cmd_line,
HAWK_NULL,
&child_rc,
cmd_file
);
hawk_gem_freemem (pio->gem, cmd_line);
cmd_line = HAWK_NULL;
/* Once execution is completed regardless of success or failure,
* Restore stdin/out/err using handles duplicated into old_in/out/err */
DosDupHandle (old_in, &std_in); /* I can't do much if this fails */
DosClose (old_in); old_in = HAWK_PIO_HND_NIL;
DosDupHandle (old_out, &std_out);
DosClose (old_out); old_out = HAWK_PIO_HND_NIL;
DosDupHandle (old_err, &std_err);
DosClose (old_err); old_err = HAWK_PIO_HND_NIL;
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
goto oops;
}
pio->child = child_rc.codeTerminate;
#elif defined(__DOS__)
/* DOS not multi-processed. can't support pio */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_ENOIMPL);
return -1;
#else
if (flags & HAWK_PIO_WRITEIN)
{
if (HAWK_PIPE(&handle[0]) <= -1)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
goto oops;
}
minidx = 0; maxidx = 1;
}
if (flags & HAWK_PIO_READOUT)
{
if (HAWK_PIPE(&handle[2]) <= -1)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
goto oops;
}
if (minidx == -1) minidx = 2;
maxidx = 3;
}
if (flags & HAWK_PIO_READERR)
{
if (HAWK_PIPE(&handle[4]) <= -1)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
goto oops;
}
if (minidx == -1) minidx = 4;
maxidx = 5;
}
if (maxidx == -1)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EINVAL);
goto oops;
}
if (pio->flags & HAWK_PIO_FNCCMD)
{
/* i know i'm abusing typecasting here.
* cmd is supposed to be hawk_pio_fnc_t*, anyway */
pid = standard_fork_and_exec(pio, handle, (param_t*)cmd);
if (pid <= -1) goto oops;
pio->child = pid;
}
else
{
#if defined(HAVE_POSIX_SPAWN) && !(defined(HAWK_SYSCALL0) && defined(SYS_vfork))
if ((pserr = posix_spawn_file_actions_init(&fa)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
fa_inited = 1;
if (flags & HAWK_PIO_WRITEIN)
{
/* child should read */
if ((pserr = posix_spawn_file_actions_addclose(&fa, handle[1])) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((pserr = posix_spawn_file_actions_adddup2(&fa, handle[0], 0)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((pserr = posix_spawn_file_actions_addclose(&fa, handle[0])) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
}
if (flags & HAWK_PIO_READOUT)
{
/* child should write */
if ((pserr = posix_spawn_file_actions_addclose(&fa, handle[2])) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((pserr = posix_spawn_file_actions_adddup2(&fa, handle[3], 1)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((flags & HAWK_PIO_ERRTOOUT) &&
(pserr = posix_spawn_file_actions_adddup2 (&fa, handle[3], 2)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((pserr = posix_spawn_file_actions_addclose(&fa, handle[3])) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
}
if (flags & HAWK_PIO_READERR)
{
/* child should write */
if ((pserr = posix_spawn_file_actions_addclose (&fa, handle[4])) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((pserr = posix_spawn_file_actions_adddup2 (&fa, handle[5], 2)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((flags & HAWK_PIO_OUTTOERR) &&
(pserr = posix_spawn_file_actions_adddup2 (&fa, handle[5], 1)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((pserr = posix_spawn_file_actions_addclose (&fa, handle[5])) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
}
{
int oflags = O_RDWR;
#if defined(O_LARGEFILE)
oflags |= O_LARGEFILE;
#endif
if ((flags & HAWK_PIO_INTONUL) &&
(pserr = posix_spawn_file_actions_addopen (&fa, 0, HAWK_BT("/dev/null"), oflags, 0)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((flags & HAWK_PIO_OUTTONUL) &&
(pserr = posix_spawn_file_actions_addopen (&fa, 1, HAWK_BT("/dev/null"), oflags, 0)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((flags & HAWK_PIO_ERRTONUL) &&
(pserr = posix_spawn_file_actions_addopen (&fa, 2, HAWK_BT("/dev/null"), oflags, 0)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
}
/* there remains the chance of race condition that
* 0, 1, 2 can be closed between addclose() and posix_spawn().
* so checking the file descriptors with is_fd_valid() is
* just on the best-effort basis.
*/
if ((flags & HAWK_PIO_DROPIN) && is_fd_valid(0) &&
(pserr = posix_spawn_file_actions_addclose (&fa, 0)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((flags & HAWK_PIO_DROPOUT) && is_fd_valid(1) &&
(pserr = posix_spawn_file_actions_addclose (&fa, 1)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if ((flags & HAWK_PIO_DROPERR) && is_fd_valid(2) &&
(pserr = posix_spawn_file_actions_addclose (&fa, 2)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
if (!(flags & HAWK_PIO_NOCLOEXEC))
{
int fd = get_highest_fd(pio);
while (fd > 2)
{
if (fd != handle[0] && fd != handle[1] &&
fd != handle[2] && fd != handle[3] &&
fd != handle[4] && fd != handle[5])
{
/* closing attempt on a best-effort basis.
* posix_spawn() fails if the file descriptor added
* with addclose() is closed before posix_spawn().
* addclose() if no FD_CLOEXEC is set or it's unknown. */
if (is_fd_valid_and_nocloexec(fd) &&
(pserr = posix_spawn_file_actions_addclose (&fa, fd)) != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
}
fd--;
}
}
if (make_param (pio, cmd, flags, &param) <= -1) goto oops;
/* check if the command(the command requested or /bin/sh) is
* exectuable to return an error without trying to execute it
* though this check alone isn't sufficient */
if (assert_executable (pio, param.argv[0]) <= -1)
{
free_param (pio, &param);
goto oops;
}
posix_spawnattr_init (&psattr);
#if defined(__linux)
#if !defined(POSIX_SPAWN_USEVFORK)
# define POSIX_SPAWN_USEVFORK 0x40
#endif
posix_spawnattr_setflags (&psattr, POSIX_SPAWN_USEVFORK);
#endif
pserr = posix_spawn(&pid, param.argv[0], &fa, &psattr, param.argv, environ);
#if defined(__linux)
posix_spawnattr_destroy (&psattr);
#endif
free_param (pio, &param);
if (fa_inited)
{
posix_spawn_file_actions_destroy (&fa);
fa_inited = 0;
}
if (pserr != 0)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(pserr));
goto oops;
}
pio->child = pid;
#elif defined(HAWK_SYSCALL0) && defined(SYS_vfork)
if (make_param (pio, cmd, flags, &param) <= -1) goto oops;
/* check if the command(the command requested or /bin/sh) is
* exectuable to return an error without trying to execute it
* though this check alone isn't sufficient */
if (assert_executable(pio, param.argv[0]) <= -1)
{
free_param (pio, &param);
goto oops;
}
/* prepare some data before vforking for vfork limitation.
* the child in vfork should not make function calls or
* change data shared with the parent. */
if (!(flags & HAWK_PIO_NOCLOEXEC)) highest_fd = get_highest_fd (pio);
HAWK_SYSCALL0 (pid, SYS_vfork);
if (pid <= -1)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EINVAL);
free_param (pio, &param);
goto oops;
}
if (pid == 0)
{
/* the child after vfork should not make function calls.
* since the system call like close() are also normal
* functions, i have to use assembly macros to make
* system calls. */
hawk_pio_hnd_t devnull = -1;
if (!(flags & HAWK_PIO_NOCLOEXEC))
{
/* cannot call close_open_fds_using_proc() in the vfork() context */
int fd = highest_fd;
/* close all other unknown open handles except
* stdin/out/err and the pipes. */
while (fd > 2)
{
if (fd != handle[0] && fd != handle[1] &&
fd != handle[2] && fd != handle[3] &&
fd != handle[4] && fd != handle[5])
{
HAWK_SYSCALL1 (dummy, SYS_close, fd);
}
fd--;
}
}
if (flags & HAWK_PIO_WRITEIN)
{
/* child should read */
HAWK_SYSCALL1 (dummy, SYS_close, handle[1]);
HAWK_SYSCALL2 (dummy, SYS_dup2, handle[0], 0);
if (dummy <= -1) goto child_oops;
HAWK_SYSCALL1 (dummy, SYS_close, handle[0]);
}
if (flags & HAWK_PIO_READOUT)
{
/* child should write */
HAWK_SYSCALL1 (dummy, SYS_close, handle[2]);
HAWK_SYSCALL2 (dummy, SYS_dup2, handle[3], 1);
if (dummy <= -1) goto child_oops;
if (flags & HAWK_PIO_ERRTOOUT)
{
HAWK_SYSCALL2 (dummy, SYS_dup2, handle[3], 2);
if (dummy <= -1) goto child_oops;
}
HAWK_SYSCALL1 (dummy, SYS_close, handle[3]);
}
if (flags & HAWK_PIO_READERR)
{
/* child should write */
HAWK_SYSCALL1 (dummy, SYS_close, handle[4]);
HAWK_SYSCALL2 (dummy, SYS_dup2, handle[5], 2);
if (dummy <= -1) goto child_oops;
if (flags & HAWK_PIO_OUTTOERR)
{
HAWK_SYSCALL2 (dummy, SYS_dup2, handle[5], 1);
if (dummy <= -1) goto child_oops;
}
HAWK_SYSCALL1 (dummy, SYS_close, handle[5]);
}
if (flags & (HAWK_PIO_INTONUL | HAWK_PIO_OUTTONUL | HAWK_PIO_ERRTONUL))
{
#if defined(O_LARGEFILE)
HAWK_SYSCALL3 (devnull, SYS_open, HAWK_BT("/dev/null"), O_RDWR|O_LARGEFILE, 0);
#else
HAWK_SYSCALL3 (devnull, SYS_open, HAWK_BT("/dev/null"), O_RDWR, 0);
#endif
if (devnull <= -1) goto child_oops;
}
if (flags & HAWK_PIO_INTONUL)
{
HAWK_SYSCALL2 (dummy, SYS_dup2, devnull, 0);
if (dummy <= -1) goto child_oops;
}
if (flags & HAWK_PIO_OUTTONUL)
{
HAWK_SYSCALL2 (dummy, SYS_dup2, devnull, 1);
if (dummy <= -1) goto child_oops;
}
if (flags & HAWK_PIO_ERRTONUL)
{
HAWK_SYSCALL2 (dummy, SYS_dup2, devnull, 2);
if (dummy <= -1) goto child_oops;
}
if (flags & (HAWK_PIO_INTONUL | HAWK_PIO_OUTTONUL | HAWK_PIO_ERRTONUL))
{
HAWK_SYSCALL1 (dummy, SYS_close, devnull);
devnull = -1;
}
if (flags & HAWK_PIO_DROPIN) HAWK_SYSCALL1 (dummy, SYS_close, 0);
if (flags & HAWK_PIO_DROPOUT) HAWK_SYSCALL1 (dummy, SYS_close, 1);
if (flags & HAWK_PIO_DROPERR) HAWK_SYSCALL1 (dummy, SYS_close, 2);
HAWK_SYSCALL3 (dummy, SYS_execve, param.argv[0], param.argv, environ);
/*free_param (pio, &param); don't free this in the vfork version */
child_oops:
if (devnull >= 0) HAWK_SYSCALL1 (dummy, SYS_close, devnull);
HAWK_SYSCALL1 (dummy, SYS_exit, 128);
}
/* parent */
free_param (pio, &param);
pio->child = pid;
#else
if (make_param (pio, cmd, flags, &param) <= -1) goto oops;
/* check if the command(the command requested or /bin/sh) is
* exectuable to return an error without trying to execute it
* though this check alone isn't sufficient */
if (assert_executable (pio, param.argv[0]) <= -1)
{
free_param (pio, &param);
goto oops;
}
pid = standard_fork_and_exec(pio, handle, &param);
if (pid <= -1)
{
free_param (pio, &param);
goto oops;
}
/* parent */
free_param (pio, &param);
pio->child = pid;
#endif
}
if (flags & HAWK_PIO_WRITEIN)
{
/*
* 012345
* rw----
* X
* WRITE => 1
*/
HAWK_CLOSE (handle[0]);
handle[0] = HAWK_PIO_HND_NIL;
}
if (flags & HAWK_PIO_READOUT)
{
/*
* 012345
* --rw--
* X
* READ => 2
*/
HAWK_CLOSE (handle[3]);
handle[3] = HAWK_PIO_HND_NIL;
}
if (flags & HAWK_PIO_READERR)
{
/*
* 012345
* ----rw
* X
* READ => 4
*/
HAWK_CLOSE (handle[5]);
handle[5] = HAWK_PIO_HND_NIL;
}
#endif
if (((flags & HAWK_PIO_INNOBLOCK) && set_pipe_nonblock(pio, handle[1], 1) <= -1) ||
((flags & HAWK_PIO_OUTNOBLOCK) && set_pipe_nonblock(pio, handle[2], 1) <= -1) ||
((flags & HAWK_PIO_ERRNOBLOCK) && set_pipe_nonblock(pio, handle[4], 1) <= -1))
{
goto oops;
}
/* store back references */
pio->pin[HAWK_PIO_IN].self = pio;
pio->pin[HAWK_PIO_OUT].self = pio;
pio->pin[HAWK_PIO_ERR].self = pio;
/* store actual pipe handles */
pio->pin[HAWK_PIO_IN].handle = handle[1];
pio->pin[HAWK_PIO_OUT].handle = handle[2];
pio->pin[HAWK_PIO_ERR].handle = handle[4];
if (flags & HAWK_PIO_TEXT)
{
int topt = 0;
if (flags & HAWK_PIO_IGNOREECERR) topt |= HAWK_TIO_IGNOREECERR;
if (flags & HAWK_PIO_NOAUTOFLUSH) topt |= HAWK_TIO_NOAUTOFLUSH;
HAWK_ASSERT (HAWK_COUNTOF(tio) == HAWK_COUNTOF(pio->pin));
for (i = 0; i < HAWK_COUNTOF(tio); i++)
{
int r;
tio[i] = hawk_tio_open(pio->gem, HAWK_SIZEOF(&pio->pin[i]), topt);
if (HAWK_UNLIKELY(!tio[i])) goto oops;
*(hawk_pio_pin_t**)hawk_tio_getxtn(tio[i]) = &pio->pin[i];
r = (i == HAWK_PIO_IN)?
hawk_tio_attachout(tio[i], pio_output, HAWK_NULL, 4096):
hawk_tio_attachin(tio[i], pio_input, HAWK_NULL, 4096);
if (r <= -1) goto oops;
pio->pin[i].tio = tio[i];
}
}
return 0;
oops:
#if defined(_WIN32)
if (windevnul != INVALID_HANDLE_VALUE) CloseHandle (windevnul);
#elif defined(__OS2__)
if (cmd_line) hawk_gem_freemem (pio->gem, cmd_line);
if (old_in != HAWK_PIO_HND_NIL)
{
DosDupHandle (old_in, &std_in);
DosClose (old_in);
}
if (old_out != HAWK_PIO_HND_NIL)
{
DosDupHandle (old_out, &std_out);
DosClose (old_out);
}
if (old_err != HAWK_PIO_HND_NIL)
{
DosDupHandle (old_err, &std_err);
DosClose (old_err);
}
if (os2devnul != HAWK_PIO_HND_NIL) DosClose (os2devnul);
#endif
for (i = 0; i < HAWK_COUNTOF(tio); i++)
{
if (tio[i]) hawk_tio_close (tio[i]);
}
#if defined(_WIN32)
for (i = minidx; i < maxidx; i++) CloseHandle (handle[i]);
#elif defined(__OS2__)
for (i = minidx; i < maxidx; i++)
{
if (handle[i] != HAWK_PIO_HND_NIL) DosClose (handle[i]);
}
#elif defined(__DOS__)
/* DOS not multi-processed. can't support pio */
#elif defined(HAVE_POSIX_SPAWN) && !(defined(HAWK_SYSCALL0) && defined(SYS_vfork))
if (fa_inited)
{
posix_spawn_file_actions_destroy (&fa);
fa_inited = 0;
}
for (i = minidx; i < maxidx; i++)
{
if (handle[i] != HAWK_PIO_HND_NIL) HAWK_CLOSE (handle[i]);
}
#elif defined(HAWK_SYSCALL0) && defined(SYS_vfork)
for (i = minidx; i < maxidx; i++)
{
if (handle[i] != HAWK_PIO_HND_NIL) HAWK_CLOSE (handle[i]);
}
#else
for (i = minidx; i < maxidx; i++)
{
if (handle[i] != HAWK_PIO_HND_NIL) HAWK_CLOSE (handle[i]);
}
#endif
return -1;
}
void hawk_pio_fini (hawk_pio_t* pio)
{
hawk_pio_end (pio, HAWK_PIO_ERR);
hawk_pio_end (pio, HAWK_PIO_OUT);
hawk_pio_end (pio, HAWK_PIO_IN);
/* when closing, enable blocking and retrying */
pio->flags &= ~HAWK_PIO_WAITNOBLOCK;
pio->flags &= ~HAWK_PIO_WAITNORETRY;
hawk_pio_wait (pio);
}
hawk_cmgr_t* hawk_pio_getcmgr (hawk_pio_t* pio, hawk_pio_hid_t hid)
{
return pio->pin[hid].tio? hawk_tio_getcmgr(pio->pin[hid].tio): HAWK_NULL;
}
void hawk_pio_setcmgr (hawk_pio_t* pio, hawk_pio_hid_t hid, hawk_cmgr_t* cmgr)
{
if (pio->pin[hid].tio) hawk_tio_setcmgr (pio->pin[hid].tio, cmgr);
}
hawk_pio_hnd_t hawk_pio_gethnd (const hawk_pio_t* pio, hawk_pio_hid_t hid)
{
return pio->pin[hid].handle;
}
hawk_pio_pid_t hawk_pio_getchild (const hawk_pio_t* pio)
{
return pio->child;
}
static hawk_ooi_t pio_read (hawk_pio_t* pio, void* buf, hawk_oow_t size, hawk_pio_hnd_t hnd)
{
#if defined(_WIN32)
DWORD count;
#elif defined(__OS2__)
ULONG count;
APIRET rc;
#elif defined(__DOS__)
int n;
#else
hawk_ooi_t n;
#endif
if (hnd == HAWK_PIO_HND_NIL)
{
/* the stream is already closed */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_ENOHND);
return (hawk_ooi_t)-1;
}
#if defined(_WIN32)
if (size > (HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(DWORD)))
size = HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(DWORD);
if (ReadFile(hnd, buf, (DWORD)size, &count, HAWK_NULL) == FALSE)
{
/* ReadFile receives ERROR_BROKEN_PIPE when the write end
* is closed in the child process */
if (GetLastError() == ERROR_BROKEN_PIPE) return 0;
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(GetLastError()));
return -1;
}
return (hawk_ooi_t)count;
#elif defined(__OS2__)
if (size > (HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(ULONG)))
size = HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(ULONG);
rc = DosRead (hnd, buf, (ULONG)size, &count);
if (rc != NO_ERROR)
{
if (rc == ERROR_BROKEN_PIPE) return 0; /* TODO: check this */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
return -1;
}
return (hawk_ooi_t)count;
#elif defined(__DOS__)
/* TODO: verify this */
if (size > (HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(unsigned int)))
size = HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(unsigned int);
n = read (hnd, buf, size);
if (n <= -1) hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
return n;
#else
if (size > (HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(size_t)))
size = HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(size_t);
reread:
n = HAWK_READ(hnd, buf, size);
if (n <= -1)
{
if (errno == EINTR)
{
if (pio->flags & HAWK_PIO_READNORETRY)
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EINTR);
else goto reread;
}
else
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
}
}
return n;
#endif
}
hawk_ooi_t hawk_pio_read (hawk_pio_t* pio, hawk_pio_hid_t hid, void* buf, hawk_oow_t size)
{
return (pio->pin[hid].tio == HAWK_NULL)?
pio_read(pio, buf, size, pio->pin[hid].handle):
hawk_tio_read(pio->pin[hid].tio, buf, size);
}
hawk_ooi_t hawk_pio_readbytes (hawk_pio_t* pio, hawk_pio_hid_t hid, void* buf, hawk_oow_t size)
{
return (pio->pin[hid].tio == HAWK_NULL)?
pio_read(pio, buf, size, pio->pin[hid].handle):
hawk_tio_readbchars(pio->pin[hid].tio, buf, size);
}
static hawk_ooi_t pio_write (hawk_pio_t* pio, const void* data, hawk_oow_t size, hawk_pio_hnd_t hnd)
{
#if defined(_WIN32)
DWORD count;
#elif defined(__OS2__)
ULONG count;
APIRET rc;
#elif defined(__DOS__)
int n;
#else
hawk_ooi_t n;
#endif
if (hnd == HAWK_PIO_HND_NIL)
{
/* the stream is already closed */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_ENOHND);
return (hawk_ooi_t)-1;
}
#if defined(_WIN32)
if (size > (HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(DWORD)))
size = HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(DWORD);
if (WriteFile (hnd, data, (DWORD)size, &count, HAWK_NULL) == FALSE)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(GetLastError()));
return -1;
}
return (hawk_ooi_t)count;
#elif defined(__OS2__)
if (size > (HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(ULONG)))
size = HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(ULONG);
rc = DosWrite (hnd, (PVOID)data, (ULONG)size, &count);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
return -1;
}
return (hawk_ooi_t)count;
#elif defined(__DOS__)
if (size > (HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(unsigned int)))
size = HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(unsigned int);
n = write (hnd, data, size);
if (n <= -1) hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
return n;
#else
if (size > (HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(size_t)))
size = HAWK_TYPE_MAX(hawk_ooi_t) & HAWK_TYPE_MAX(size_t);
rewrite:
n = HAWK_WRITE(hnd, data, size);
if (n <= -1)
{
if (errno == EINTR)
{
if (pio->flags & HAWK_PIO_WRITENORETRY)
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_EINTR);
else goto rewrite;
}
else
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
}
}
return n;
#endif
}
hawk_ooi_t hawk_pio_write (hawk_pio_t* pio, hawk_pio_hid_t hid, const void* data, hawk_oow_t size)
{
return (pio->pin[hid].tio == HAWK_NULL)?
pio_write(pio, data, size, pio->pin[hid].handle):
hawk_tio_write(pio->pin[hid].tio, data, size);
}
hawk_ooi_t hawk_pio_writebytes (hawk_pio_t* pio, hawk_pio_hid_t hid, const void* data, hawk_oow_t size)
{
return (pio->pin[hid].tio == HAWK_NULL)?
pio_write(pio, data, size, pio->pin[hid].handle):
hawk_tio_writebchars(pio->pin[hid].tio, data, size);
}
hawk_ooi_t hawk_pio_flush (hawk_pio_t* pio, hawk_pio_hid_t hid)
{
if (pio->pin[hid].tio == HAWK_NULL) return 0;
return hawk_tio_flush(pio->pin[hid].tio);
}
void hawk_pio_drain (hawk_pio_t* pio, hawk_pio_hid_t hid)
{
if (pio->pin[hid].tio) hawk_tio_drain (pio->pin[hid].tio);
}
void hawk_pio_end (hawk_pio_t* pio, hawk_pio_hid_t hid)
{
if (pio->pin[hid].tio)
{
hawk_tio_close (pio->pin[hid].tio);
pio->pin[hid].tio = HAWK_NULL;
}
if (pio->pin[hid].handle != HAWK_PIO_HND_NIL)
{
#if defined(_WIN32)
CloseHandle (pio->pin[hid].handle);
#elif defined(__OS2__)
DosClose (pio->pin[hid].handle);
#elif defined(__DOS__)
close (pio->pin[hid].handle);
#else
HAWK_CLOSE (pio->pin[hid].handle);
#endif
pio->pin[hid].handle = HAWK_PIO_HND_NIL;
}
}
int hawk_pio_wait (hawk_pio_t* pio)
{
#if defined(_WIN32)
DWORD ecode, w;
if (pio->child == HAWK_PIO_PID_NIL)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_ECHILD);
return -1;
}
w = WaitForSingleObject (pio->child,
((pio->flags & HAWK_PIO_WAITNOBLOCK)? 0: INFINITE)
);
if (w == WAIT_TIMEOUT)
{
/* the child process is still alive */
return 255 + 1;
}
if (w != WAIT_OBJECT_0)
{
/* WAIT_FAILED, WAIT_ABANDONED */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(GetLastError()));
return -1;
}
HAWK_ASSERT (w == WAIT_OBJECT_0);
if (GetExitCodeProcess(pio->child, &ecode) == FALSE)
{
/* close the handle anyway to prevent further
* errors when this function is called again */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(GetLastError()));
CloseHandle (pio->child);
pio->child = HAWK_PIO_PID_NIL;
return -1;
}
/* close handle here to emulate waitpid() as much as possible. */
CloseHandle (pio->child);
pio->child = HAWK_PIO_PID_NIL;
if (ecode == STILL_ACTIVE)
{
/* this should not happen as the control reaches here
* only when WaitforSingleObject() is successful.
* if it happends, close the handle and return an error */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_ESYSERR);
return -1;
}
return ecode;
#elif defined(__OS2__)
APIRET rc;
RESULTCODES child_rc;
PID ppid;
if (pio->child == HAWK_PIO_PID_NIL)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_ECHILD);
return -1;
}
rc = DosWaitChild (
DCWA_PROCESSTREE,
((pio->flags & HAWK_PIO_WAITNOBLOCK)? DCWW_NOWAIT: DCWW_WAIT),
&child_rc,
&ppid,
pio->child
);
if (rc == ERROR_CHILD_NOT_COMPLETE)
{
/* the child process is still alive */
return 255 + 1;
}
if (rc != NO_ERROR)
{
/* WAIT_FAILED, WAIT_ABANDONED */
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
return -1;
}
/* close handle here to emulate waitpid() as much as possible. */
/*DosClose (pio->child);*/
pio->child = HAWK_PIO_PID_NIL;
return (child_rc.codeTerminate == TC_EXIT)?
child_rc.codeResult: (255 + 1 + child_rc.codeTerminate);
#elif defined(__DOS__)
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_ENOIMPL);
return -1;
#else
int opt = 0;
int ret = -1;
if (pio->child == HAWK_PIO_PID_NIL)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_ECHILD);
return -1;
}
if (pio->flags & HAWK_PIO_WAITNOBLOCK) opt |= WNOHANG;
while (1)
{
int status, n;
n = HAWK_WAITPID (pio->child, &status, opt);
if (n <= -1)
{
if (errno == ECHILD)
{
/* most likely, the process has already been
* waitpid()ed on. */
pio->child = HAWK_PIO_PID_NIL;
}
else if (errno == EINTR)
{
if (!(pio->flags & HAWK_PIO_WAITNORETRY)) continue;
}
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
break;
}
if (n == 0)
{
/* when WNOHANG is not specified, 0 can't be returned */
/*HAWK_ASSERT (pio->flags & HAWK_PIO_WAITNOBLOCK);*/
ret = 255 + 1;
/* the child process is still alive */
break;
}
if (n == pio->child)
{
if (WIFEXITED(status))
{
/* the child process ended normally */
ret = WEXITSTATUS(status);
}
else if (WIFSIGNALED(status))
{
/* the child process was killed by a signal */
ret = 255 + 1 + WTERMSIG (status);
}
else
{
/* not interested in WIFSTOPPED & WIFCONTINUED.
* in fact, this else-block should not be reached
* as WIFEXITED or WIFSIGNALED must be true.
* anyhow, just set the return value to 0. */
ret = 0;
}
pio->child = HAWK_PIO_PID_NIL;
break;
}
}
return ret;
#endif
}
int hawk_pio_kill (hawk_pio_t* pio)
{
#if defined(_WIN32)
DWORD n;
#elif defined(__OS2__)
APIRET rc;
#elif defined(__DOS__)
/* TODO: implement this */
#else
int n;
#endif
if (pio->child == HAWK_PIO_PID_NIL)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_ECHILD);
return -1;
}
#if defined(_WIN32)
/* 9 was chosen below to treat TerminateProcess as kill -KILL. */
n = TerminateProcess(pio->child, 255 + 1 + 9);
if (n == FALSE)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(GetLastError()));
return -1;
}
return 0;
#elif defined(__OS2__)
/*TODO: must use DKP_PROCESS? */
rc = DosKillProcess(pio->child, DKP_PROCESSTREE);
if (rc != NO_ERROR)
{
hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(rc));
return -1;
}
return 0;
#elif defined(__DOS__)
hawk_gem_seterrnum (pio->gem, HAWK_NULL, HAWK_ENOIMPL);
return -1;
#else
n = HAWK_KILL(pio->child, SIGKILL);
if (n <= -1) hawk_gem_seterrnum (pio->gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
return n;
#endif
}
static hawk_ooi_t pio_input (hawk_tio_t* tio, hawk_tio_cmd_t cmd, void* buf, hawk_oow_t size)
{
if (cmd == HAWK_TIO_DATA)
{
hawk_pio_pin_t* pin = *(hawk_pio_pin_t**)hawk_tio_getxtn(tio);
HAWK_ASSERT (pin != HAWK_NULL);
HAWK_ASSERT (pin->self != HAWK_NULL);
return pio_read(pin->self, buf, size, pin->handle);
}
/* take no actions for OPEN and CLOSE as they are handled
* by pio */
return 0;
}
static hawk_ooi_t pio_output (hawk_tio_t* tio, hawk_tio_cmd_t cmd, void* buf, hawk_oow_t size)
{
if (cmd == HAWK_TIO_DATA)
{
hawk_pio_pin_t* pin = *(hawk_pio_pin_t**)hawk_tio_getxtn(tio);
HAWK_ASSERT (pin != HAWK_NULL);
HAWK_ASSERT (pin->self != HAWK_NULL);
return pio_write(pin->self, buf, size, pin->handle);
}
/* take no actions for OPEN and CLOSE as they are handled
* by pio */
return 0;
}
Reference in New Issue View Git Blame Copy Permalink