blob: 3765aae0bc583902cd231481b83fa5b01f300e35 [file] [log] [blame]
/************************************************************************
*
* process.cpp - definitions of testsuite process helpers
*
* $Id$
*
************************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License.
*
**************************************************************************/
// expand _TEST_EXPORT macros
#define _RWSTD_TEST_SRC
#include <ctype.h> // for isspace()
#include <errno.h> // for EACCES, errno
#include <signal.h> // for SIGXXX, kill()
#include <stddef.h> // for size_t
#include <stdarg.h> // for va_copy, va_list, ...
#include <stdlib.h> // for free(), exit()
#include <string.h> // for strchr()
#include <sys/types.h> // for pid_t
#include <rw_process.h>
#include <rw_driver.h> // for rw_note(), ...
#include <rw_printf.h> // for rw_fprintf()
#ifdef __CYGWIN__
// use the Windows API on Cygwin
# define _WIN32
#endif
#ifndef E2BIG
# define E2BIG 7 /* AIX, HP-UX, Linux, Solaris */
#endif
#ifndef EINTR
# define EINTR 4
#endif
#ifndef SIGCHLD
# if defined (_RWSTD_OS_AIX) || defined (_RWSTD_OS_OSF)
// AIX, Tru64
# define SIGCHLD 20
# elif defined (_RWSTD_OS_LINUX)
# define SIGCHLD 17
# else
// (System V-based) HP-UX, IRIX, and Solaris
# define SIGCHLD 18
# endif
#endif
// all known Unices
#ifndef SIGALRM
# define SIGALRM 14
#endif
#ifndef SIGHUP
# define SIGHUP 1
#endif
#ifndef SIGQUIT
# define SIGQUIT 3
#endif
#ifndef SIGKILL
# define SIGKILL 9
#endif
#ifdef _RWSTD_EDG_ECCP
extern "C" {
int kill (pid_t, int);
} // extern "C"
#endif // _RWSTD_EDG_ECCP
/**************************************************************************/
_TEST_EXPORT int
rw_vasnprintf (char**, size_t*, const char*, va_list);
/**************************************************************************/
#ifdef _WIN32
# include <windows.h> // for WaitForSingleObject(), ...
static int
_rw_map_errno (DWORD err)
{
if (ERROR_WRITE_PROTECT <= err && ERROR_SHARING_BUFFER_EXCEEDED >= err)
return EACCES;
if ( ERROR_INVALID_STARTING_CODESEG <= err
&& ERROR_INFLOOP_IN_RELOC_CHAIN >= err) {
return ENOEXEC;
}
switch (err)
{
case ERROR_FILE_NOT_FOUND:
case ERROR_PATH_NOT_FOUND:
case ERROR_INVALID_DRIVE:
case ERROR_NO_MORE_FILES:
case ERROR_BAD_NETPATH:
case ERROR_BAD_NET_NAME:
case ERROR_INVALID_NAME:
case ERROR_BAD_PATHNAME:
case ERROR_FILENAME_EXCED_RANGE:
return ENOENT;
case ERROR_TOO_MANY_OPEN_FILES:
return EMFILE;
case ERROR_ACCESS_DENIED:
case ERROR_CURRENT_DIRECTORY:
case ERROR_NETWORK_ACCESS_DENIED:
case ERROR_CANNOT_MAKE:
case ERROR_FAIL_I24:
case ERROR_DRIVE_LOCKED:
case ERROR_SEEK_ON_DEVICE:
case ERROR_NOT_LOCKED:
case ERROR_LOCK_FAILED:
return EACCES;
case ERROR_INVALID_HANDLE:
case ERROR_INVALID_TARGET_HANDLE:
case ERROR_DIRECT_ACCESS_HANDLE:
return EBADF;
case ERROR_ARENA_TRASHED:
case ERROR_NOT_ENOUGH_MEMORY:
case ERROR_INVALID_BLOCK:
case ERROR_NOT_ENOUGH_QUOTA:
return ENOMEM;
case ERROR_BAD_ENVIRONMENT:
return E2BIG;
case ERROR_BAD_FORMAT:
return ENOEXEC;
case ERROR_NOT_SAME_DEVICE:
return EXDEV;
case ERROR_FILE_EXISTS:
return EEXIST;
case ERROR_NO_PROC_SLOTS:
case ERROR_MAX_THRDS_REACHED:
case ERROR_NESTING_NOT_ALLOWED:
return EAGAIN;
case ERROR_BROKEN_PIPE:
return EPIPE;
case ERROR_DISK_FULL:
return ENOSPC;
case ERROR_WAIT_NO_CHILDREN:
case ERROR_CHILD_NOT_COMPLETE:
return ECHILD;
case ERROR_DIR_NOT_EMPTY:
return ENOTEMPTY;
case ERROR_ALREADY_EXISTS:
return EEXIST;
}
return EINVAL;
}
#else // #if !defined (_WIN32)
# include <sys/types.h>
# include <sys/wait.h> // for waitpid()
# include <unistd.h> // for fork(), execv(), access(), sleep()
# include <setjmp.h> // for setjmp(), longjmp()
# include <signal.h> // for signal()
# include <time.h> // for time()
/**************************************************************************/
// splits command line to the array of parameters
// note: modifies the cmd string
// returns the number of parameters in cmd
// if argv != 0 fills argv up to size elements
static size_t
_rw_split_cmd (char* cmd, char** argv, size_t size)
{
RW_ASSERT (0 != cmd);
size_t ret = 0;
for (char* end = cmd + strlen (cmd); cmd != end; /*do nothing*/) {
// skip the leading spaces
while (isspace (*cmd))
++cmd;
if (end == cmd)
break;
if (argv && ret < size)
argv [ret] = cmd;
++ret;
if ('\'' == *cmd || '\"' == *cmd) {
char* const cmd1 = cmd + 1;
// search the closing quote
char* const pos = strchr (cmd1, *cmd);
if (pos) {
// found, remove the quotes
// remove the opening quote
memmove (cmd, cmd1, pos - cmd1);
// remove the closing quote
cmd = pos - 1;
memmove (cmd, pos + 1, end - pos);
end -= 2;
}
else {
// not found
break;
}
}
// search the space
while (*cmd && !isspace (*cmd))
++cmd;
if (cmd != end)
// found, replace to '\0'
*cmd++ = '\0';
}
return ret;
}
#endif // #if defined (_WIN32)
/**************************************************************************/
static int
_rw_vsystem (const char *cmd, va_list va)
{
RW_ASSERT (0 != cmd);
char *buf = 0;
rw_vasnprintf (&buf, 0, cmd, va);
rw_note (0, "file:" __FILE__, __LINE__, "executing \"%s\"", buf);
// avoid using const in order to prevent gcc warning on Linux
// issued for WIFSIGNALED() et al: cast from `const int*' to
// `int*' discards qualifiers from pointer target type:
// see http://sourceware.org/bugzilla/show_bug.cgi?id=1392
/* const */ int ret = system (buf);
if (ret) {
#ifndef _WIN32
if (-1 == ret) {
// system() failed, e.g., because fork() failed
rw_error (0, __FILE__, __LINE__,
"system (\"%s\") failed: errno = %{#m} (%{m})",
buf);
}
else if (WIFSIGNALED (ret)) {
// command exited with a signal
const int signo = WTERMSIG (ret);
rw_error (0, __FILE__, __LINE__,
"the command \"%s\" exited with signal %d (%{K})",
buf, signo, signo);
}
else {
// command exited with a non-zero status
const int status = WEXITSTATUS (ret);
rw_error (0, __FILE__, __LINE__,
"the command \"%s\" exited with status %d",
buf, status);
}
#else // if defined (_WIN32)
// FIXME: make this more descriptive
rw_error (0, __FILE__, __LINE__,
"the command \"%s\" failed with code %d",
buf, ret);
#endif // _WIN32
}
free (buf);
return ret;
}
/**************************************************************************/
_TEST_EXPORT int
rw_system (const char *cmd, ...)
{
va_list va;
va_start (va, cmd);
const int ret = _rw_vsystem (cmd, va);
va_end (va);
return ret;
}
/**************************************************************************/
static rw_pid_t
_rw_vprocess_create (const char* cmd, va_list va)
{
RW_ASSERT (0 != cmd);
char *buf = 0;
rw_vasnprintf (&buf, 0, cmd, va);
rw_pid_t ret = -1;
#ifdef _WIN32
STARTUPINFO si = { sizeof (si) };
PROCESS_INFORMATION pi;
if (CreateProcess (0, buf, 0, 0, FALSE,
CREATE_NEW_PROCESS_GROUP, 0, 0, &si, &pi)) {
CloseHandle (pi.hThread);
ret = rw_pid_t (pi.hProcess);
}
else {
const DWORD err = GetLastError ();
rw_error (0, __FILE__, __LINE__,
"CreateProcess () failed: GetLastError() = %zu",
size_t (err));
errno = _rw_map_errno (err);
}
#else // #if !defined (_WIN32)
const size_t MAX_PARAMS = 63;
char* argv [MAX_PARAMS + 1] = { 0 };
size_t argc = _rw_split_cmd (buf, argv, MAX_PARAMS);
if (0 < argc && MAX_PARAMS >= argc)
ret = rw_process_create (argv [0], argv);
else
errno = E2BIG;
#endif // _WIN32
free (buf);
return ret;
}
/**************************************************************************/
_TEST_EXPORT rw_pid_t
rw_process_create (const char* cmd, ...)
{
va_list va;
va_start (va, cmd);
const rw_pid_t ret = _rw_vprocess_create (cmd, va);
va_end (va);
return ret;
}
/**************************************************************************/
_TEST_EXPORT rw_pid_t
rw_process_create (const char* path, char* const argv[])
{
#if defined (_WIN32)
return rw_process_create ("\"%s\" %{ As}", path, argv + 1);
#else // #if !defined (_WIN32)
if (0 == access (path, X_OK)) {
const rw_pid_t child_pid = fork ();
if (0 == child_pid) {
// the child process
execvp (path, argv);
// the execvp returns only if an error occurs
rw_fprintf (rw_stderr, "%s:%d execvp (%#s, %{As}) failed: "
"errno = %{#m} (%{m})\n",
__FILE__, __LINE__, path, argv);
exit (1);
}
else if (-1 == child_pid)
rw_error (0, __FILE__, __LINE__,
"fork () failed: errno = %{#m} (%{m})");
return child_pid;
}
else
rw_error (0, __FILE__, __LINE__,
"access (%#s, X_OK) failed: errno = %{#m} (%{m})",
path);
return -1;
#endif // #if defined (_WIN32)
}
/**************************************************************************/
#if defined (_WIN32)
_TEST_EXPORT rw_pid_t
rw_waitpid (rw_pid_t pid, int* result, int timeout/* = -1*/)
{
/* Explicitly check for process_id being -1 or -2. In Windows NT,
* -1 is a handle on the current process, -2 is a handle on the
* current thread, and it is perfectly legal to to wait (forever)
* on either */
if (-1 == pid || -2 == pid) {
errno = ECHILD;
return -1;
}
const HANDLE handle = HANDLE (pid);
const DWORD milliseconds =
0 > timeout ? INFINITE : DWORD (timeout * 1000);
const DWORD res = WaitForSingleObject (handle, milliseconds);
DWORD err = ERROR_SUCCESS;
if (WAIT_OBJECT_0 == res) {
DWORD dwExitCode;
if (GetExitCodeProcess (handle, &dwExitCode)) {
CloseHandle (handle);
if (dwExitCode)
rw_error (0, __FILE__, __LINE__,
"the process (pid=%{P}) exited with return code %d",
pid, int (dwExitCode));
if (result)
*result = int (dwExitCode);
return pid;
}
err = GetLastError ();
rw_error (0, __FILE__, __LINE__,
"GetExitCodeProcess (%{P}, %#p) failed: GetLastError() = %zu",
pid, &dwExitCode, size_t (err));
}
else if (WAIT_FAILED == res) {
err = GetLastError ();
rw_error (0, __FILE__, __LINE__,
"WaitForSingleObject (%{P}, %{?}INFINITE%{:}%zu%{;}) failed: "
"GetLastError() = %zu",
pid, INFINITE == milliseconds,
size_t (milliseconds), size_t (err));
}
else {
// time-out elapsed
RW_ASSERT (WAIT_TIMEOUT == res);
return 0;
}
if (ERROR_INVALID_HANDLE == err)
errno = ECHILD;
else
errno = _rw_map_errno (err);
return -1;
}
#else // #if !defined (_WIN32)
extern "C" {
static int alarm_timeout;
static void handle_alarm_signal (int) {
alarm_timeout = 1;
}
typedef void (*signal_handler_t) (int);
}
_TEST_EXPORT rw_pid_t
rw_waitpid (rw_pid_t pid, int* presult, int timeout/* = -1*/)
{
#ifdef _RWSTD_EDG_ECCP
# define _RWSTD_NO_SIGACTION
#endif
#ifndef _RWSTD_NO_SIGACTION
struct sigaction prev_alarm_action;
#else
signal_handler_t prev_alarm_handler = 0;
#endif
int prev_alarm_timeout = 0;
alarm_timeout = 0;
if (0 < timeout) {
#ifndef _RWSTD_NO_SIGACTION
struct sigaction alarm_action;
memset (&alarm_action, 0, sizeof alarm_action);
const signal_handler_t handler_fun = handle_alarm_signal;
memcpy (&alarm_action.sa_handler, &handler_fun,
sizeof alarm_action.sa_handler);
sigaction (SIGALRM, &alarm_action, &prev_alarm_action);
#else
prev_alarm_handler = signal (SIGALRM, handle_alarm_signal);
#endif
prev_alarm_timeout = alarm (timeout);
}
int result = 0;
if (!presult)
presult = &result;
const time_t start = time(0);
int status = 0;
rw_pid_t ret = 0;
do {
ret = waitpid (pid_t (pid), &status, 0);
if (-1 == ret) {
if (EINTR == errno && alarm_timeout) {
// we are expected to return 0 on timeout
ret = 0;
}
else if (EINTR == errno) {
rw_warn (0, __FILE__, __LINE__,
"waitpid (%{P}, %#p, 0) interrupted: "
"errno = %{#m} (%{m})",
pid, &status);
continue; // try again
}
else {
rw_error (0, __FILE__, __LINE__,
"waitpid (%{P}, %#p, 0) failed: "
"errno = %{#m} (%{m})",
pid, &status);
}
}
else if (ret == pid) {
if (WIFSIGNALED (status)) {
// process exited with a signal
const int signo = WTERMSIG (status);
rw_error (0, __FILE__, __LINE__,
"the process (pid=%{P}) exited with signal %d (%{K})",
pid, signo, signo);
*presult = signo;
}
else if (WIFEXITED (status)) {
// process exited with a status
const int retcode = WEXITSTATUS (status);
if (retcode)
rw_error (0, __FILE__, __LINE__,
"the process (pid=%{P}) exited with return code %d",
pid, retcode);
*presult = retcode;
}
else {
*presult = -1;
}
}
else {
*presult = -1;
}
} while(false);
if (0 < timeout) {
if (prev_alarm_timeout) {
const int delta = int (time(0) - start);
if (delta < prev_alarm_timeout)
prev_alarm_timeout -= delta;
else
prev_alarm_timeout = 1;
}
alarm (prev_alarm_timeout);
#ifndef _RWSTD_NO_SIGACTION
sigaction (SIGALRM, &prev_alarm_action, 0);
#else
signal (SIGALRM, prev_alarm_handler);
#endif
}
return ret;
}
#endif // #if defined (_WIN32)
_TEST_EXPORT int
rw_process_kill (rw_pid_t pid, int signo)
{
// timeout for rw_wait_pid
const int timeout = 1;
#if defined (_WIN32)
// send signal
if (!TerminateProcess (HANDLE (pid), DWORD (signo))) {
const DWORD err = GetLastError ();
rw_error (0, __FILE__, __LINE__,
"TerminateProcess (%{P}, %i) failed: GetLastError() = %zu",
pid, signo, size_t (err));
if (ERROR_INVALID_HANDLE == err)
errno = ESRCH;
else if (ERROR_ACCESS_DENIED == err)
errno = EPERM;
else
errno = _rw_map_errno (err);
return -1;
}
// wait for process termination
rw_pid_t res = rw_waitpid (pid, 0, timeout);
if (pid == res)
return 0;
if (-1 == res)
rw_error (0, __FILE__, __LINE__,
"rw_waitpid (%{P}, 0, %i) failed: errno = %{#m} (%{m})",
pid, timeout);
return 1;
#else // #if !defined (_WIN32)
static const int signals_ [] = {
SIGHUP, SIGINT, SIGQUIT, SIGTERM, SIGKILL
};
const int* const signals = (-1 == signo) ? signals_ : &signo;
const unsigned sigcount =
(-1 == signo) ? unsigned (sizeof (signals_) / sizeof (*signals_)) : 1;
int ret = -1;
for (unsigned i = 0; i < sigcount; ++i) {
// send signal
ret = kill (pid_t (pid), signals [i]);
if (-1 == ret) {
rw_error (0, __FILE__, __LINE__,
"kill (%{P}, %{K}) failed: errno = %{#m} (%{m})",
pid, signals [i]);
continue;
}
// wait for process termination
rw_pid_t res = rw_waitpid (pid, 0, timeout);
if (pid == res)
return 0;
if (-1 == res)
rw_error (0, __FILE__, __LINE__,
"rw_waitpid (%{P}, 0, %i) failed: errno = %{#m} (%{m})",
pid, timeout);
ret = 1;
}
return ret;
#endif // #if defined (_WIN32)
}