�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2F'>ext</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fpcntl%2F'>pcntl</a>/</p><hr><h3>✏️ Editing: pcntl.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
   +----------------------------------------------------------------------+
   | Copyright (c) The PHP Group                                          |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | https://www.php.net/license/3_01.txt                                 |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | Author: Jason Greene &lt;jason@inetgurus.net&gt;                           |
   +----------------------------------------------------------------------+
 */

#define PCNTL_DEBUG 0

#if PCNTL_DEBUG
#define DEBUG_OUT printf(&quot;DEBUG: &quot;);printf
#define IF_DEBUG(z) z
#else
#define IF_DEBUG(z)
#endif

#ifdef HAVE_CONFIG_H
#include &lt;config.h&gt;
#endif

#include &quot;php.h&quot;
#include &quot;ext/standard/info.h&quot;
#include &quot;php_signal.h&quot;
#include &quot;php_ticks.h&quot;
#include &quot;zend_fibers.h&quot;

#if defined(HAVE_GETPRIORITY) || defined(HAVE_SETPRIORITY) || defined(HAVE_WAIT3)
#include &lt;sys/wait.h&gt;
#include &lt;sys/time.h&gt;
#include &lt;sys/resource.h&gt;
#endif

#ifdef HAVE_WAITID
#if defined (HAVE_DECL_P_ALL) &amp;&amp; HAVE_DECL_P_ALL == 1
#define HAVE_POSIX_IDTYPES 1
#endif
#if defined (HAVE_DECL_P_PIDFD) &amp;&amp; HAVE_DECL_P_PIDFD == 1
#define HAVE_LINUX_IDTYPES 1
#endif
#if defined (HAVE_DECL_P_UID) &amp;&amp; HAVE_DECL_P_UID == 1
#define HAVE_NETBSD_IDTYPES 1
#endif
#if defined (HAVE_DECL_P_JAILID) &amp;&amp; HAVE_DECL_P_JAILID == 1
#define HAVE_FREEBSD_IDTYPES 1
#endif
#endif

#include &quot;php_pcntl.h&quot;
#include &lt;errno.h&gt;
#if defined(HAVE_UNSHARE) || defined(HAVE_SCHED_SETAFFINITY) || defined(HAVE_SCHED_GETCPU)
#include &lt;sched.h&gt;
#if defined(__FreeBSD__)
#include &lt;sys/types.h&gt;
#include &lt;sys/cpuset.h&gt;
typedef cpuset_t cpu_set_t;
#endif
 #define PCNTL_CPUSET(mask) &amp;mask
 #define PCNTL_CPUSET_SIZE(mask) sizeof(mask)
 #define PCNTL_CPU_ISSET(i, mask) CPU_ISSET(i, &amp;mask)
 #define PCNTL_CPU_SET(i, mask) CPU_SET(i, &amp;mask)
 #define PCNTL_CPU_ZERO(mask) CPU_ZERO(&amp;mask)
 #define PCNTL_CPU_DESTROY(mask) ((void)0)
#elif defined(__NetBSD__)
#include &lt;sys/syscall.h&gt;
#include &lt;sched.h&gt;
typedef cpuset_t *cpu_set_t;
 #define sched_getaffinity(p, c, m) syscall(SYS__sched_getaffinity, p, 0, c, m)
 #define sched_setaffinity(p, c, m) syscall(SYS__sched_setaffinity, p, 0, c, m)
 #define PCNTL_CPUSET(mask) mask
 #define PCNTL_CPUSET_SIZE(mask) cpuset_size(mask)
 #define PCNTL_CPU_ISSET(i, mask) cpuset_isset((cpuid_t)i, mask)
 #define PCNTL_CPU_SET(i, mask) cpuset_set((cpuid_t)i, mask)
 #define PCNTL_CPU_ZERO(mask)										\
	do {												\
		mask = cpuset_create(); 								\
		if (UNEXPECTED(!mask)) {								\
			php_error_docref(NULL, E_WARNING, &quot;cpuset_create: Insufficient memory&quot;);	\
			RETURN_FALSE;   								\
		}											\
		cpuset_zero(mask);									\
	} while(0)
 #define PCNTL_CPU_DESTROY(mask) cpuset_destroy(mask)
 #define HAVE_SCHED_SETAFFINITY 1
#elif defined(HAVE_PSET_BIND)
#include &lt;sys/pset.h&gt;
typedef psetid_t cpu_set_t;
 #define sched_getaffinity(p, c, m) pset_bind(PS_QUERY, P_PID, (p &lt;= 0 ? getpid() : p), &amp;m)
 #define sched_setaffinity(p, c, m) pset_bind(m, P_PID, (p &lt;= 0 ? getpid() : p), NULL)
 #define PCNTL_CPUSET(mask) mask
 #define PCNTL_CPU_ISSET(i, mask) (pset_assign(PS_QUERY, (processorid_t)i, &amp;query) == 0 &amp;&amp; query == mask)
 #define PCNTL_CPU_SET(i, mask) pset_assign(mask, (processorid_t)i, NULL)
 #define PCNTL_CPU_ZERO(mask) 														\
	psetid_t query;																	\
	do {																			\
		if (UNEXPECTED(pset_create(&amp;mask) != 0)) {									\
			php_error_docref(NULL, E_WARNING, &quot;pset_create: %s&quot;, strerror(errno));	\
			RETURN_FALSE;															\
		}																			\
	 } while (0)
 #define PCNTL_CPU_DESTROY(mask) 													\
	do {																			\
		if (UNEXPECTED(mask != PS_NONE &amp;&amp; pset_destroy(mask) != 0)) {				\
			php_error_docref(NULL, E_WARNING, &quot;pset_destroy: %s&quot;, strerror(errno));	\
		}																			\
	} while (0)
 #define HAVE_SCHED_SETAFFINITY 1
#endif

#if defined(HAVE_GETCPUID)
#include &lt;sys/processor.h&gt;
#define sched_getcpu getcpuid
#define HAVE_SCHED_GETCPU 1
#endif

#if defined(HAVE_PTHREAD_SET_QOS_CLASS_SELF_NP)
#include &lt;pthread/qos.h&gt;
#endif

#ifdef HAVE_PIDFD_OPEN
#include &lt;sys/syscall.h&gt;
#endif

#ifdef HAVE_FORKX
#include &lt;sys/fork.h&gt;
#endif

#ifndef NSIG
# define NSIG 32
#endif

#define LONG_CONST(c) (zend_long) c

#include &quot;Zend/zend_enum.h&quot;
#include &quot;Zend/zend_max_execution_timer.h&quot;

#include &quot;pcntl_arginfo.h&quot;
static zend_class_entry *QosClass_ce;

ZEND_DECLARE_MODULE_GLOBALS(pcntl)
static PHP_GINIT_FUNCTION(pcntl);

zend_module_entry pcntl_module_entry = {
	STANDARD_MODULE_HEADER,
	&quot;pcntl&quot;,
	ext_functions,
	PHP_MINIT(pcntl),
	PHP_MSHUTDOWN(pcntl),
	PHP_RINIT(pcntl),
	PHP_RSHUTDOWN(pcntl),
	PHP_MINFO(pcntl),
	PHP_PCNTL_VERSION,
	PHP_MODULE_GLOBALS(pcntl),
	PHP_GINIT(pcntl),
	NULL,
	NULL,
	STANDARD_MODULE_PROPERTIES_EX
};

#ifdef COMPILE_DL_PCNTL
#ifdef ZTS
ZEND_TSRMLS_CACHE_DEFINE()
#endif
ZEND_GET_MODULE(pcntl)
#endif

static void (*orig_interrupt_function)(zend_execute_data *execute_data);

#ifdef HAVE_STRUCT_SIGINFO_T
static void pcntl_signal_handler(int, siginfo_t*, void*);
static void pcntl_siginfo_to_zval(int, siginfo_t*, zval*);
#else
static void pcntl_signal_handler(int);
#endif
static void pcntl_signal_dispatch(void);
static void pcntl_signal_dispatch_tick_function(int dummy_int, void *dummy_pointer);
static void pcntl_interrupt_function(zend_execute_data *execute_data);

static PHP_GINIT_FUNCTION(pcntl)
{
#if defined(COMPILE_DL_PCNTL) &amp;&amp; defined(ZTS)
	ZEND_TSRMLS_CACHE_UPDATE();
#endif
	memset(pcntl_globals, 0, sizeof(*pcntl_globals));
}

PHP_RINIT_FUNCTION(pcntl)
{
	php_add_tick_function(pcntl_signal_dispatch_tick_function, NULL);
	zend_hash_init(&amp;PCNTL_G(php_signal_table), 16, NULL, ZVAL_PTR_DTOR, 0);
	PCNTL_G(head) = PCNTL_G(tail) = PCNTL_G(spares) = NULL;
	PCNTL_G(async_signals) = 0;
	PCNTL_G(last_error) = 0;
	PCNTL_G(num_signals) = NSIG;
#ifdef SIGRTMAX
	/* At least FreeBSD reports an incorrecrt NSIG that does not include realtime signals.
	 * As SIGRTMAX may be a dynamic value, adjust the value in INIT. */
	if (NSIG &lt; SIGRTMAX + 1) {
		PCNTL_G(num_signals) = SIGRTMAX + 1;
	}
#endif
	return SUCCESS;
}

PHP_MINIT_FUNCTION(pcntl)
{
	QosClass_ce = register_class_Pcntl_QosClass();
	register_pcntl_symbols(module_number);
	orig_interrupt_function = zend_interrupt_function;
	zend_interrupt_function = pcntl_interrupt_function;

	return SUCCESS;
}

PHP_MSHUTDOWN_FUNCTION(pcntl)
{
	return SUCCESS;
}

PHP_RSHUTDOWN_FUNCTION(pcntl)
{
	struct php_pcntl_pending_signal *sig;
	zend_long signo;
	zval *handle;

	/* Reset all signals to their default disposition */
	ZEND_HASH_FOREACH_NUM_KEY_VAL(&amp;PCNTL_G(php_signal_table), signo, handle) {
		if (Z_TYPE_P(handle) != IS_LONG || Z_LVAL_P(handle) != (zend_long)SIG_DFL) {
			php_signal(signo, (Sigfunc *)(zend_long)SIG_DFL, 0);
		}
	} ZEND_HASH_FOREACH_END();

	zend_hash_destroy(&amp;PCNTL_G(php_signal_table));

	while (PCNTL_G(head)) {
		sig = PCNTL_G(head);
		PCNTL_G(head) = sig-&gt;next;
		efree(sig);
	}
	while (PCNTL_G(spares)) {
		sig = PCNTL_G(spares);
		PCNTL_G(spares) = sig-&gt;next;
		efree(sig);
	}

	return SUCCESS;
}

PHP_MINFO_FUNCTION(pcntl)
{
	php_info_print_table_start();
	php_info_print_table_row(2, &quot;pcntl support&quot;, &quot;enabled&quot;);
	php_info_print_table_end();
}

/* {{{ Forks the currently running process following the same behavior as the UNIX fork() system call*/
PHP_FUNCTION(pcntl_fork)
{
	pid_t id;

	ZEND_PARSE_PARAMETERS_NONE();

	id = fork();
	if (id == -1) {
		PCNTL_G(last_error) = errno;
		switch (errno) {
			case EAGAIN:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: Reached the maximum limit of number of processes&quot;, errno);
				break;
			case ENOMEM:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: Insufficient memory&quot;, errno);
				break;
			// unlikely, especially nowadays.
			case ENOSYS:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: Unimplemented&quot;, errno);
				break;
			// QNX is the only platform returning it so far and is a different case from EAGAIN.
			// Retries can be handled with sleep eventually.
			case EBADF:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: File descriptor concurrency issue&quot;, errno);
				break;
			default:
				php_error_docref(NULL, E_WARNING, &quot;Error %d&quot;, errno);

		}
	} else if (id == 0) {
		zend_max_execution_timer_init();
	}

	RETURN_LONG((zend_long) id);
}
/* }}} */

/* {{{ Set an alarm clock for delivery of a signal*/
PHP_FUNCTION(pcntl_alarm)
{
	zend_long seconds;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(seconds);
	ZEND_PARSE_PARAMETERS_END();

	RETURN_LONG((zend_long) alarm(seconds));
}
/* }}} */

#define PHP_RUSAGE_PARA(from, to, field) \
	add_assoc_long(to, #field, from.field)
#ifndef _OSD_POSIX
	#define PHP_RUSAGE_SPECIAL(from, to) \
		PHP_RUSAGE_PARA(from, to, ru_oublock); \
		PHP_RUSAGE_PARA(from, to, ru_inblock); \
		PHP_RUSAGE_PARA(from, to, ru_msgsnd); \
		PHP_RUSAGE_PARA(from, to, ru_msgrcv); \
		PHP_RUSAGE_PARA(from, to, ru_maxrss); \
		PHP_RUSAGE_PARA(from, to, ru_ixrss); \
		PHP_RUSAGE_PARA(from, to, ru_idrss); \
		PHP_RUSAGE_PARA(from, to, ru_minflt); \
		PHP_RUSAGE_PARA(from, to, ru_majflt); \
		PHP_RUSAGE_PARA(from, to, ru_nsignals); \
		PHP_RUSAGE_PARA(from, to, ru_nvcsw); \
		PHP_RUSAGE_PARA(from, to, ru_nivcsw); \
		PHP_RUSAGE_PARA(from, to, ru_nswap);
#else /*_OSD_POSIX*/
	#define PHP_RUSAGE_SPECIAL(from, to)
#endif

#define PHP_RUSAGE_COMMON(from ,to) \
	PHP_RUSAGE_PARA(from, to, ru_utime.tv_usec); \
	PHP_RUSAGE_PARA(from, to, ru_utime.tv_sec); \
	PHP_RUSAGE_PARA(from, to, ru_stime.tv_usec); \
	PHP_RUSAGE_PARA(from, to, ru_stime.tv_sec);

#define PHP_RUSAGE_TO_ARRAY(from, to) \
	if (to) { \
		PHP_RUSAGE_SPECIAL(from, to) \
		PHP_RUSAGE_COMMON(from, to); \
	}

/* {{{ Waits on or returns the status of a forked child as defined by the waitpid() system call */
PHP_FUNCTION(pcntl_waitpid)
{
	zend_long pid, options = 0;
	zval *z_status = NULL, *z_rusage = NULL;
	int status;
	pid_t child_id;
#ifdef HAVE_WAIT4
	struct rusage rusage;
#endif

	ZEND_PARSE_PARAMETERS_START(2, 4)
		Z_PARAM_LONG(pid)
		Z_PARAM_ZVAL(z_status)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG(options)
		Z_PARAM_ZVAL(z_rusage)
	ZEND_PARSE_PARAMETERS_END();

	status = zval_get_long(z_status);

#ifdef HAVE_WAIT4
	if (z_rusage) {
		z_rusage = zend_try_array_init(z_rusage);
		if (!z_rusage) {
			RETURN_THROWS();
		}

		memset(&amp;rusage, 0, sizeof(struct rusage));
		child_id = wait4((pid_t) pid, &amp;status, options, &amp;rusage);
	} else {
		child_id = waitpid((pid_t) pid, &amp;status, options);
	}
#else
	child_id = waitpid((pid_t) pid, &amp;status, options);
#endif

	if (child_id &lt; 0) {
		PCNTL_G(last_error) = errno;
	}

#ifdef HAVE_WAIT4
	if (child_id &gt; 0) {
		PHP_RUSAGE_TO_ARRAY(rusage, z_rusage);
	}
#endif

	ZEND_TRY_ASSIGN_REF_LONG(z_status, status);

	RETURN_LONG((zend_long) child_id);
}
/* }}} */

#if defined (HAVE_WAITID) &amp;&amp; defined (HAVE_POSIX_IDTYPES) &amp;&amp; defined (HAVE_DECL_WEXITED) &amp;&amp; HAVE_DECL_WEXITED == 1
PHP_FUNCTION(pcntl_waitid)
{
	zend_long idtype = P_ALL;
	zend_long id = 0;
	bool id_is_null = 1;
	zval *user_siginfo = NULL;
	zend_long options = WEXITED;

	ZEND_PARSE_PARAMETERS_START(0, 4)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG(idtype)
		Z_PARAM_LONG_OR_NULL(id, id_is_null)
		Z_PARAM_ZVAL(user_siginfo)
		Z_PARAM_LONG(options)
	ZEND_PARSE_PARAMETERS_END();

	errno = 0;
	siginfo_t siginfo;

	int status = waitid((idtype_t) idtype, (id_t) id, &amp;siginfo, (int) options);

	if (status == -1) {
		PCNTL_G(last_error) = errno;
		RETURN_FALSE;
	}

	pcntl_siginfo_to_zval(SIGCHLD, &amp;siginfo, user_siginfo);

	RETURN_TRUE;
}
#endif

/* {{{ Waits on or returns the status of a forked child as defined by the waitpid() system call */
PHP_FUNCTION(pcntl_wait)
{
	zend_long options = 0;
	zval *z_status = NULL, *z_rusage = NULL;
	int status;
	pid_t child_id;
#ifdef HAVE_WAIT3
	struct rusage rusage;
#endif

	ZEND_PARSE_PARAMETERS_START(1, 3)
		Z_PARAM_ZVAL(z_status)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG(options)
		Z_PARAM_ZVAL(z_rusage)
	ZEND_PARSE_PARAMETERS_END();

	status = zval_get_long(z_status);
#ifdef HAVE_WAIT3
	if (z_rusage) {
		z_rusage = zend_try_array_init(z_rusage);
		if (!z_rusage) {
			RETURN_THROWS();
		}

		memset(&amp;rusage, 0, sizeof(struct rusage));
		child_id = wait3(&amp;status, options, &amp;rusage);
	} else if (options) {
		child_id = wait3(&amp;status, options, NULL);
	} else {
		child_id = wait(&amp;status);
	}
#else
	child_id = wait(&amp;status);
#endif
	if (child_id &lt; 0) {
		PCNTL_G(last_error) = errno;
	}

#ifdef HAVE_WAIT3
	if (child_id &gt; 0) {
		PHP_RUSAGE_TO_ARRAY(rusage, z_rusage);
	}
#endif

	ZEND_TRY_ASSIGN_REF_LONG(z_status, status);

	RETURN_LONG((zend_long) child_id);
}
/* }}} */

#undef PHP_RUSAGE_PARA
#undef PHP_RUSAGE_SPECIAL
#undef PHP_RUSAGE_COMMON
#undef PHP_RUSAGE_TO_ARRAY

/* {{{ Returns true if the child status code represents a successful exit */
PHP_FUNCTION(pcntl_wifexited)
{
	zend_long status_word;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(status_word)
	ZEND_PARSE_PARAMETERS_END();

#ifdef WIFEXITED
	int int_status_word = (int) status_word;
	if (WIFEXITED(int_status_word)) {
		RETURN_TRUE;
	}
#endif

	RETURN_FALSE;
}
/* }}} */

/* {{{ Returns true if the child status code represents a stopped process (WUNTRACED must have been used with waitpid) */
PHP_FUNCTION(pcntl_wifstopped)
{
	zend_long status_word;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(status_word)
	ZEND_PARSE_PARAMETERS_END();

#ifdef WIFSTOPPED
	int int_status_word = (int) status_word;
	if (WIFSTOPPED(int_status_word)) {
		RETURN_TRUE;
	}
#endif

	RETURN_FALSE;
}
/* }}} */

/* {{{ Returns true if the child status code represents a process that was terminated due to a signal */
PHP_FUNCTION(pcntl_wifsignaled)
{
	zend_long status_word;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(status_word)
	ZEND_PARSE_PARAMETERS_END();

#ifdef WIFSIGNALED
	int int_status_word = (int) status_word;
	if (WIFSIGNALED(int_status_word)) {
		RETURN_TRUE;
	}
#endif

	RETURN_FALSE;
}
/* }}} */

/* {{{ Returns true if the child status code represents a process that was resumed due to a SIGCONT signal */
PHP_FUNCTION(pcntl_wifcontinued)
{
	zend_long status_word;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(status_word)
	ZEND_PARSE_PARAMETERS_END();

#ifdef HAVE_WCONTINUED
	int int_status_word = (int) status_word;
	if (WIFCONTINUED(int_status_word)) {
		RETURN_TRUE;
	}
#endif
	RETURN_FALSE;
}
/* }}} */


/* {{{ Returns the status code of a child&#039;s exit */
PHP_FUNCTION(pcntl_wexitstatus)
{
	zend_long status_word;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(status_word)
	ZEND_PARSE_PARAMETERS_END();

#ifdef WEXITSTATUS
	int int_status_word = (int) status_word;
	RETURN_LONG(WEXITSTATUS(int_status_word));
#else
	RETURN_FALSE;
#endif
}
/* }}} */

/* {{{ Returns the number of the signal that terminated the process who&#039;s status code is passed  */
PHP_FUNCTION(pcntl_wtermsig)
{
	zend_long status_word;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(status_word)
	ZEND_PARSE_PARAMETERS_END();

#ifdef WTERMSIG
	int int_status_word = (int) status_word;
	RETURN_LONG(WTERMSIG(int_status_word));
#else
	RETURN_FALSE;
#endif
}
/* }}} */

/* {{{ Returns the number of the signal that caused the process to stop who&#039;s status code is passed */
PHP_FUNCTION(pcntl_wstopsig)
{
	zend_long status_word;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(status_word)
	ZEND_PARSE_PARAMETERS_END();

#ifdef WSTOPSIG
	int int_status_word = (int) status_word;
	RETURN_LONG(WSTOPSIG(int_status_word));
#else
	RETURN_FALSE;
#endif
}
/* }}} */

/* {{{ Executes specified program in current process space as defined by exec(2) */
PHP_FUNCTION(pcntl_exec)
{
	zval *args = NULL, *envs = NULL;
	zval *element;
	HashTable *args_hash, *envs_hash;
	int argc = 0, argi = 0;
	int envc = 0, envi = 0;
	char **argv = NULL, **envp = NULL;
	char **current_arg, **pair;
	size_t pair_length;
	zend_string *key;
	char *path;
	size_t path_len;
	zend_ulong key_num;

	ZEND_PARSE_PARAMETERS_START(1, 3)
		Z_PARAM_PATH(path, path_len)
		Z_PARAM_OPTIONAL
		Z_PARAM_ARRAY(args)
		Z_PARAM_ARRAY(envs)
	ZEND_PARSE_PARAMETERS_END();

	if (ZEND_NUM_ARGS() &gt; 1) {
		/* Build argument list */
		SEPARATE_ARRAY(args);
		args_hash = Z_ARRVAL_P(args);
		argc = zend_hash_num_elements(args_hash);

		argv = safe_emalloc((argc + 2), sizeof(char *), 0);
		*argv = path;
		current_arg = argv+1;
		ZEND_HASH_FOREACH_VAL(args_hash, element) {
			if (argi &gt;= argc) break;
			if (!try_convert_to_string(element)) {
				efree(argv);
				RETURN_THROWS();
			}

			*current_arg = Z_STRVAL_P(element);
			argi++;
			current_arg++;
		} ZEND_HASH_FOREACH_END();
		*current_arg = NULL;
	} else {
		argv = emalloc(2 * sizeof(char *));
		argv[0] = path;
		argv[1] = NULL;
	}

	if ( ZEND_NUM_ARGS() == 3 ) {
		/* Build environment pair list */
		SEPARATE_ARRAY(envs);
		envs_hash = Z_ARRVAL_P(envs);
		envc = zend_hash_num_elements(envs_hash);

		size_t envp_len = (envc + 1);
		pair = envp = safe_emalloc(envp_len, sizeof(char *), 0);
		memset(envp, 0, sizeof(char *) * envp_len);
		ZEND_HASH_FOREACH_KEY_VAL(envs_hash, key_num, key, element) {
			if (envi &gt;= envc) break;
			if (!key) {
				key = zend_long_to_str(key_num);
			} else {
				zend_string_addref(key);
			}

			if (!try_convert_to_string(element)) {
				zend_string_release(key);
				goto cleanup_env_vars;
			}

			/* Length of element + equal sign + length of key + null */
			ZEND_ASSERT(Z_STRLEN_P(element) &lt; SIZE_MAX &amp;&amp; ZSTR_LEN(key) &lt; SIZE_MAX);
			*pair = safe_emalloc(Z_STRLEN_P(element) + 1, sizeof(char), ZSTR_LEN(key) + 1);
			pair_length = Z_STRLEN_P(element) + ZSTR_LEN(key) + 2;
			strlcpy(*pair, ZSTR_VAL(key), ZSTR_LEN(key) + 1);
			strlcat(*pair, &quot;=&quot;, pair_length);
			strlcat(*pair, Z_STRVAL_P(element), pair_length);

			/* Cleanup */
			zend_string_release_ex(key, 0);
			envi++;
			pair++;
		} ZEND_HASH_FOREACH_END();
		*(pair) = NULL;

		if (execve(path, argv, envp) == -1) {
			PCNTL_G(last_error) = errno;
			php_error_docref(NULL, E_WARNING, &quot;Error has occurred: (errno %d) %s&quot;, errno, strerror(errno));
		}

cleanup_env_vars:
		/* Cleanup */
		for (pair = envp; *pair != NULL; pair++) efree(*pair);
		efree(envp);
	} else {

		if (execv(path, argv) == -1) {
			PCNTL_G(last_error) = errno;
			php_error_docref(NULL, E_WARNING, &quot;Error has occurred: (errno %d) %s&quot;, errno, strerror(errno));
		}
	}

	efree(argv);

	RETURN_FALSE;
}
/* }}} */

/* {{{ Assigns a system signal handler to a PHP function */
PHP_FUNCTION(pcntl_signal)
{
	zval *handle;
	zend_long signo;
	bool restart_syscalls = 1;
	bool restart_syscalls_is_null = 1;

	ZEND_PARSE_PARAMETERS_START(2, 3)
		Z_PARAM_LONG(signo)
		Z_PARAM_ZVAL(handle)
		Z_PARAM_OPTIONAL
		Z_PARAM_BOOL_OR_NULL(restart_syscalls, restart_syscalls_is_null)
	ZEND_PARSE_PARAMETERS_END();

	if (signo &lt; 1) {
		zend_argument_value_error(1, &quot;must be greater than or equal to 1&quot;);
		RETURN_THROWS();
	}

	if (signo &gt;= PCNTL_G(num_signals)) {
		zend_argument_value_error(1, &quot;must be less than %d&quot;, PCNTL_G(num_signals));
		RETURN_THROWS();
	}

	if (!PCNTL_G(spares)) {
		/* since calling malloc() from within a signal handler is not portable,
		 * pre-allocate a few records for recording signals */
		for (unsigned int i = 0; i &lt; PCNTL_G(num_signals); i++) {
			struct php_pcntl_pending_signal *psig;

			psig = emalloc(sizeof(*psig));
			psig-&gt;next = PCNTL_G(spares);
			PCNTL_G(spares) = psig;
		}
	}

	/* If restart_syscalls was not explicitly specified and the signal is SIGALRM, then default
	 * restart_syscalls to false. PHP used to enforce that restart_syscalls is false for SIGALRM,
	 * so we keep this differing default to reduce the degree of BC breakage. */
	if (restart_syscalls_is_null &amp;&amp; signo == SIGALRM) {
		restart_syscalls = 0;
	}

	/* Special long value case for SIG_DFL and SIG_IGN */
	if (Z_TYPE_P(handle) == IS_LONG) {
		if (Z_LVAL_P(handle) != (zend_long) SIG_DFL &amp;&amp; Z_LVAL_P(handle) != (zend_long) SIG_IGN) {
			zend_argument_value_error(2, &quot;must be either SIG_DFL or SIG_IGN when an integer value is given&quot;);
			RETURN_THROWS();
		}
		if (php_signal(signo, (Sigfunc *) Z_LVAL_P(handle), (int) restart_syscalls) == (void *)SIG_ERR) {
			PCNTL_G(last_error) = errno;
			php_error_docref(NULL, E_WARNING, &quot;Error assigning signal&quot;);
			RETURN_FALSE;
		}
		zend_hash_index_update(&amp;PCNTL_G(php_signal_table), signo, handle);
		RETURN_TRUE;
	}

	if (!zend_is_callable_ex(handle, NULL, 0, NULL, NULL, NULL)) {
		PCNTL_G(last_error) = EINVAL;

		zend_argument_type_error(2, &quot;must be of type callable|int, %s given&quot;, zend_zval_value_name(handle));
		RETURN_THROWS();
	}

	/* Add the function name to our signal table */
	handle = zend_hash_index_update(&amp;PCNTL_G(php_signal_table), signo, handle);
	Z_TRY_ADDREF_P(handle);

	if (php_signal4(signo, pcntl_signal_handler, (int) restart_syscalls, 1) == (void *)SIG_ERR) {
		PCNTL_G(last_error) = errno;
		php_error_docref(NULL, E_WARNING, &quot;Error assigning signal&quot;);
		RETURN_FALSE;
	}
	RETURN_TRUE;
}
/* }}} */

/* {{{ Gets signal handler */
PHP_FUNCTION(pcntl_signal_get_handler)
{
	zval *prev_handle;
	zend_long signo;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(signo)
	ZEND_PARSE_PARAMETERS_END();

	// note: max signal on mac is SIGUSR2 (31), no real time signals.
	int sigmax = NSIG - 1;
#if defined(SIGRTMAX)
	// oddily enough, NSIG on freebsd reports only 32 whereas SIGRTMIN starts at 65.
	if (sigmax &lt; SIGRTMAX) {
		sigmax = SIGRTMAX;
	}
#endif

	if (signo &lt; 1 || signo &gt; sigmax) {
		zend_argument_value_error(1, &quot;must be between 1 and %d&quot;, sigmax);
		RETURN_THROWS();
	}

	if ((prev_handle = zend_hash_index_find(&amp;PCNTL_G(php_signal_table), signo)) != NULL) {
		RETURN_COPY(prev_handle);
	} else {
		RETURN_LONG((zend_long)SIG_DFL);
	}
}

/* {{{ Dispatch signals to signal handlers */
PHP_FUNCTION(pcntl_signal_dispatch)
{
	ZEND_PARSE_PARAMETERS_NONE();

	pcntl_signal_dispatch();
	RETURN_TRUE;
}
/* }}} */

/* Common helper function for these 3 wrapper functions */
#if defined(HAVE_SIGWAITINFO) || defined(HAVE_SIGTIMEDWAIT) || defined(HAVE_SIGPROCMASK)
static bool php_pcntl_set_user_signal_infos(
	/* const */ HashTable *const user_signals,
	sigset_t *const set,
	size_t arg_num,
	bool allow_empty_signal_array
) {
	if (!allow_empty_signal_array &amp;&amp; zend_hash_num_elements(user_signals) == 0) {
		zend_argument_must_not_be_empty_error(arg_num);
		return false;
	}

	errno = 0;
	if (sigemptyset(set) != 0) {
		PCNTL_G(last_error) = errno;
		php_error_docref(NULL, E_WARNING, &quot;%s&quot;, strerror(errno));
		return false;
	}

	zval *user_signal_no;
	ZEND_HASH_FOREACH_VAL(user_signals, user_signal_no) {
		bool failed = true;
		ZVAL_DEREF(user_signal_no);
		zend_long tmp = zval_try_get_long(user_signal_no, &amp;failed);

		if (failed) {
			zend_argument_type_error(arg_num, &quot;signals must be of type int, %s given&quot;, zend_zval_value_name(user_signal_no));
			return false;
		}
		/* Signals are positive integers */
		if (tmp &lt; 1 || tmp &gt;= PCNTL_G(num_signals)) {
			/* PCNTL_G(num_signals) stores +1 from the last valid signal */
			zend_argument_value_error(arg_num, &quot;signals must be between 1 and %d&quot;, PCNTL_G(num_signals)-1);
			return false;
		}

		int signal_no = (int) tmp;
		errno = 0;
		if (sigaddset(set, signal_no) != 0) {
			PCNTL_G(last_error) = errno;
			php_error_docref(NULL, E_WARNING, &quot;%s&quot;, strerror(errno));
			return false;
		}
	} ZEND_HASH_FOREACH_END();
	return true;
}
#endif

#ifdef HAVE_SIGPROCMASK
/* {{{ Examine and change blocked signals */
PHP_FUNCTION(pcntl_sigprocmask)
{
	zend_long how;
	HashTable *user_set;
	/* Optional by-ref out-param array of old signals */
	zval *user_old_set = NULL;

	ZEND_PARSE_PARAMETERS_START(2, 3)
		Z_PARAM_LONG(how)
		Z_PARAM_ARRAY_HT(user_set)
		Z_PARAM_OPTIONAL
		Z_PARAM_ZVAL(user_old_set)
	ZEND_PARSE_PARAMETERS_END();

	if (how != SIG_BLOCK &amp;&amp; how != SIG_UNBLOCK &amp;&amp; how != SIG_SETMASK) {
		zend_argument_value_error(1, &quot;must be one of SIG_BLOCK, SIG_UNBLOCK, or SIG_SETMASK&quot;);
		RETURN_THROWS();
	}

	errno = 0;
	sigset_t old_set;
	if (sigemptyset(&amp;old_set) != 0) {
		PCNTL_G(last_error) = errno;
		php_error_docref(NULL, E_WARNING, &quot;%s&quot;, strerror(errno));
		RETURN_FALSE;
	}

	sigset_t set;
	bool status = php_pcntl_set_user_signal_infos(user_set, &amp;set, 2, /* allow_empty_signal_array */ how == SIG_SETMASK);
	/* Some error occurred */
	if (!status) {
		RETURN_FALSE;
	}

	if (sigprocmask(how, &amp;set, &amp;old_set) != 0) {
		PCNTL_G(last_error) = errno;
		php_error_docref(NULL, E_WARNING, &quot;%s&quot;, strerror(errno));
		RETURN_FALSE;
	}

	if (user_old_set != NULL) {
		user_old_set = zend_try_array_init(user_old_set);
		if (!user_old_set) {
			RETURN_THROWS();
		}

		for (unsigned int signal_no = 1; signal_no &lt; PCNTL_G(num_signals); ++signal_no) {
			if (sigismember(&amp;old_set, signal_no) != 1) {
				continue;
			}
			add_next_index_long(user_old_set, signal_no);
		}
	}

	RETURN_TRUE;
}
/* }}} */
#endif

#ifdef HAVE_STRUCT_SIGINFO_T
# ifdef HAVE_SIGWAITINFO

/* {{{ Synchronously wait for queued signals */
PHP_FUNCTION(pcntl_sigwaitinfo)
{
	HashTable *user_set;
	/* Optional by-ref array of ints */
	zval *user_siginfo = NULL;

	ZEND_PARSE_PARAMETERS_START(1, 2)
		Z_PARAM_ARRAY_HT(user_set)
		Z_PARAM_OPTIONAL
		Z_PARAM_ZVAL(user_siginfo)
	ZEND_PARSE_PARAMETERS_END();

	sigset_t set;
	bool status = php_pcntl_set_user_signal_infos(user_set, &amp;set, 1, /* allow_empty_signal_array */ false);
	/* Some error occurred */
	if (!status) {
		RETURN_FALSE;
	}

	errno = 0;
	siginfo_t siginfo;
	int signal_no = sigwaitinfo(&amp;set, &amp;siginfo);
	/* sigwaitinfo() never sets errno to EAGAIN according to POSIX */
	if (signal_no == -1) {
		PCNTL_G(last_error) = errno;
		php_error_docref(NULL, E_WARNING, &quot;%s&quot;, strerror(errno));
		RETURN_FALSE;
	}

	/* sigwaitinfo can return 0 on success on some platforms, e.g. NetBSD */
	if (!signal_no &amp;&amp; siginfo.si_signo) {
		signal_no = siginfo.si_signo;
	}

	pcntl_siginfo_to_zval(signal_no, &amp;siginfo, user_siginfo);

	RETURN_LONG(signal_no);
}
/* }}} */
# endif
# ifdef HAVE_SIGTIMEDWAIT
/* {{{ Wait for queued signals */
PHP_FUNCTION(pcntl_sigtimedwait)
{
	HashTable *user_set;
	/* Optional by-ref array of ints */
	zval *user_siginfo = NULL;
	zend_long tv_sec = 0;
	zend_long tv_nsec = 0;

	ZEND_PARSE_PARAMETERS_START(1, 4)
		Z_PARAM_ARRAY_HT(user_set)
		Z_PARAM_OPTIONAL
		Z_PARAM_ZVAL(user_siginfo)
		Z_PARAM_LONG(tv_sec)
		Z_PARAM_LONG(tv_nsec)
	ZEND_PARSE_PARAMETERS_END();

	sigset_t set;
	bool status = php_pcntl_set_user_signal_infos(user_set, &amp;set, 1, /* allow_empty_signal_array */ false);
	/* Some error occurred */
	if (!status) {
		RETURN_FALSE;
	}
	if (tv_sec &lt; 0) {
		zend_argument_value_error(3, &quot;must be greater than or equal to 0&quot;);
		RETURN_THROWS();
	}
	/* Nanosecond between 0 and 1e9 */
	if (tv_nsec &lt; 0 || tv_nsec &gt;= 1000000000) {
		zend_argument_value_error(4, &quot;must be between 0 and 1e9&quot;);
		RETURN_THROWS();
	}
	if (UNEXPECTED(tv_sec == 0 &amp;&amp; tv_nsec == 0)) {
		zend_value_error(&quot;pcntl_sigtimedwait(): At least one of argument #3 ($seconds) or argument #4 ($nanoseconds) must be greater than 0&quot;);
		RETURN_THROWS();
	}

	errno = 0;
	siginfo_t siginfo;
	struct timespec timeout;
	timeout.tv_sec  = (time_t) tv_sec;
	timeout.tv_nsec = tv_nsec;
	int signal_no = sigtimedwait(&amp;set, &amp;siginfo, &amp;timeout);
	if (signal_no == -1) {
		if (errno != EAGAIN) {
			PCNTL_G(last_error) = errno;
			php_error_docref(NULL, E_WARNING, &quot;%s&quot;, strerror(errno));
		}
		RETURN_FALSE;
	}

	/* sigtimedwait can return 0 on success on some platforms, e.g. NetBSD */
	if (!signal_no &amp;&amp; siginfo.si_signo) {
		signal_no = siginfo.si_signo;
	}

	pcntl_siginfo_to_zval(signal_no, &amp;siginfo, user_siginfo);

	RETURN_LONG(signal_no);
}
/* }}} */
# endif

static void pcntl_siginfo_to_zval(int signo, siginfo_t *siginfo, zval *user_siginfo) /* {{{ */
{
	if (signo &gt; 0 &amp;&amp; user_siginfo) {
		user_siginfo = zend_try_array_init(user_siginfo);
		if (!user_siginfo) {
			return;
		}

		add_assoc_long_ex(user_siginfo, &quot;signo&quot;, sizeof(&quot;signo&quot;)-1, siginfo-&gt;si_signo);
		add_assoc_long_ex(user_siginfo, &quot;errno&quot;, sizeof(&quot;errno&quot;)-1, siginfo-&gt;si_errno);
		add_assoc_long_ex(user_siginfo, &quot;code&quot;,  sizeof(&quot;code&quot;)-1,  siginfo-&gt;si_code);
		switch(signo) {
#ifdef SIGCHLD
			case SIGCHLD:
				add_assoc_long_ex(user_siginfo,   &quot;status&quot;, sizeof(&quot;status&quot;)-1, siginfo-&gt;si_status);
# ifdef si_utime
				add_assoc_double_ex(user_siginfo, &quot;utime&quot;,  sizeof(&quot;utime&quot;)-1,  siginfo-&gt;si_utime);
# endif
# ifdef si_stime
				add_assoc_double_ex(user_siginfo, &quot;stime&quot;,  sizeof(&quot;stime&quot;)-1,  siginfo-&gt;si_stime);
# endif
				add_assoc_long_ex(user_siginfo,   &quot;pid&quot;,    sizeof(&quot;pid&quot;)-1,    siginfo-&gt;si_pid);
				add_assoc_long_ex(user_siginfo,   &quot;uid&quot;,    sizeof(&quot;uid&quot;)-1,    siginfo-&gt;si_uid);
				break;
			case SIGUSR1:
			case SIGUSR2:
				add_assoc_long_ex(user_siginfo,   &quot;pid&quot;,    sizeof(&quot;pid&quot;)-1,    siginfo-&gt;si_pid);
				add_assoc_long_ex(user_siginfo,   &quot;uid&quot;,    sizeof(&quot;uid&quot;)-1,    siginfo-&gt;si_uid);
				break;
#endif
			case SIGILL:
			case SIGFPE:
			case SIGSEGV:
			case SIGBUS:
				add_assoc_double_ex(user_siginfo, &quot;addr&quot;, sizeof(&quot;addr&quot;)-1, (zend_long)siginfo-&gt;si_addr);
				break;
#if defined(SIGPOLL) &amp;&amp; !defined(__CYGWIN__)
			case SIGPOLL:
				add_assoc_long_ex(user_siginfo, &quot;band&quot;, sizeof(&quot;band&quot;)-1, siginfo-&gt;si_band);
# ifdef si_fd
				add_assoc_long_ex(user_siginfo, &quot;fd&quot;,   sizeof(&quot;fd&quot;)-1,   siginfo-&gt;si_fd);
# endif
				break;
#endif

#ifdef SIGTRAP
			case SIGTRAP:
# if defined(si_syscall) &amp;&amp; defined(__FreeBSD__)
				if (siginfo-&gt;si_code == TRAP_CAP) {
					add_assoc_long_ex(user_siginfo, &quot;syscall&quot;, sizeof(&quot;syscall&quot;)-1, (zend_long)siginfo-&gt;si_syscall);
				} else {
					add_assoc_long_ex(user_siginfo, &quot;trapno&quot;, sizeof(&quot;trapno&quot;)-1, (zend_long)siginfo-&gt;si_trapno);
				}

# endif
				break;

#endif
		}
#if defined(SIGRTMIN) &amp;&amp; defined(SIGRTMAX)
		if (SIGRTMIN &lt;= signo &amp;&amp; signo &lt;= SIGRTMAX) {
			add_assoc_long_ex(user_siginfo, &quot;pid&quot;, sizeof(&quot;pid&quot;)-1, siginfo-&gt;si_pid);
			add_assoc_long_ex(user_siginfo, &quot;uid&quot;, sizeof(&quot;uid&quot;)-1, siginfo-&gt;si_uid);
		}
#endif
	}
}
/* }}} */
#endif

#ifdef HAVE_GETPRIORITY
/* {{{ Get the priority of any process */
PHP_FUNCTION(pcntl_getpriority)
{
	zend_long who = PRIO_PROCESS;
	zend_long pid;
	bool pid_is_null = 1;
	int pri;

	ZEND_PARSE_PARAMETERS_START(0, 2)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG_OR_NULL(pid, pid_is_null)
		Z_PARAM_LONG(who)
	ZEND_PARSE_PARAMETERS_END();

	/* needs to be cleared, since any returned value is valid */
	errno = 0;

	pid = pid_is_null ? 0 : pid;
	pri = getpriority(who, pid);

	if (errno) {
		PCNTL_G(last_error) = errno;
		switch (errno) {
			case ESRCH:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: No process was located using the given parameters&quot;, errno);
				break;
			case EINVAL:
#ifdef PRIO_DARWIN_BG
				if (who != PRIO_PGRP &amp;&amp; who != PRIO_USER &amp;&amp; who != PRIO_PROCESS &amp;&amp; who != PRIO_DARWIN_THREAD) {
					zend_argument_value_error(2, &quot;must be one of PRIO_PGRP, PRIO_USER, PRIO_PROCESS or PRIO_DARWIN_THREAD&quot;);
					RETURN_THROWS();
				} else if (who == PRIO_DARWIN_THREAD &amp;&amp; pid != 0) {
					zend_argument_value_error(1, &quot;must be 0 (zero) if PRIO_DARWIN_THREAD is provided as second parameter&quot;);
					RETURN_THROWS();
				} else {
					zend_argument_value_error(1, &quot;is not a valid process, process group, or user ID&quot;);
					RETURN_THROWS();
				}
#else
				zend_argument_value_error(2, &quot;must be one of PRIO_PGRP, PRIO_USER, or PRIO_PROCESS&quot;);
				RETURN_THROWS();
#endif

			default:
				php_error_docref(NULL, E_WARNING, &quot;Unknown error %d has occurred&quot;, errno);
				break;
		}
		RETURN_FALSE;
	}

	RETURN_LONG(pri);
}
/* }}} */
#endif

#ifdef HAVE_SETPRIORITY
/* {{{ Change the priority of any process */
PHP_FUNCTION(pcntl_setpriority)
{
	zend_long who = PRIO_PROCESS;
	zend_long pid;
	bool pid_is_null = 1;
	zend_long pri;

	ZEND_PARSE_PARAMETERS_START(1, 3)
		Z_PARAM_LONG(pri)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG_OR_NULL(pid, pid_is_null)
		Z_PARAM_LONG(who)
	ZEND_PARSE_PARAMETERS_END();

	pid = pid_is_null ? 0 : pid;

	if (setpriority(who, pid, pri)) {
		PCNTL_G(last_error) = errno;
		switch (errno) {
			case ESRCH:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: No process was located using the given parameters&quot;, errno);
				break;
			case EINVAL:
#ifdef PRIO_DARWIN_BG
				if (who != PRIO_PGRP &amp;&amp; who != PRIO_USER &amp;&amp; who != PRIO_PROCESS &amp;&amp; who != PRIO_DARWIN_THREAD) {
					zend_argument_value_error(3, &quot;must be one of PRIO_PGRP, PRIO_USER, PRIO_PROCESS or PRIO_DARWIN_THREAD&quot;);
					RETURN_THROWS();
				} else if (who == PRIO_DARWIN_THREAD &amp;&amp; pid != 0) {
					zend_argument_value_error(2, &quot;must be 0 (zero) if PRIO_DARWIN_THREAD is provided as second parameter&quot;);
					RETURN_THROWS();
				} else if (who == PRIO_DARWIN_THREAD &amp;&amp; pid == 0 &amp;&amp; (pri != 0 &amp;&amp; pri != PRIO_DARWIN_BG)) {
					zend_argument_value_error(1, &quot;must be either 0 (zero) or PRIO_DARWIN_BG, for mode PRIO_DARWIN_THREAD&quot;);
					RETURN_THROWS();
				} else {
					zend_argument_value_error(2, &quot;is not a valid process, process group, or user ID&quot;);
					RETURN_THROWS();
				}
#else
				zend_argument_value_error(3, &quot;must be one of PRIO_PGRP, PRIO_USER, or PRIO_PROCESS&quot;);
				RETURN_THROWS();
#endif
			case EPERM:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: A process was located, but neither its effective nor real user ID matched the effective user ID of the caller&quot;, errno);
				break;
			case EACCES:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: Only a super user may attempt to increase the process priority&quot;, errno);
				break;
			default:
				php_error_docref(NULL, E_WARNING, &quot;Unknown error %d has occurred&quot;, errno);
				break;
		}
		RETURN_FALSE;
	}

	RETURN_TRUE;
}
/* }}} */
#endif

/* {{{ Retrieve the error number set by the last pcntl function which failed. */
PHP_FUNCTION(pcntl_get_last_error)
{
	ZEND_PARSE_PARAMETERS_NONE();

	RETURN_LONG(PCNTL_G(last_error));
}
/* }}} */

/* {{{ Retrieve the system error message associated with the given errno. */
PHP_FUNCTION(pcntl_strerror)
{
	zend_long error;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(error)
	ZEND_PARSE_PARAMETERS_END();

	RETURN_STRING(strerror(error));
}
/* }}} */

/* Our custom signal handler that calls the appropriate php_function */
#ifdef HAVE_STRUCT_SIGINFO_T
static void pcntl_signal_handler(int signo, siginfo_t *siginfo, void *context)
#else
static void pcntl_signal_handler(int signo)
#endif
{
	struct php_pcntl_pending_signal *psig = PCNTL_G(spares);
	if (!psig) {
		/* oops, too many signals for us to track, so we&#039;ll forget about this one */
		return;
	}
	PCNTL_G(spares) = psig-&gt;next;

	psig-&gt;signo = signo;
	psig-&gt;next = NULL;

#ifdef HAVE_STRUCT_SIGINFO_T
	psig-&gt;siginfo = *siginfo;
#endif

	/* the head check is important, as the tick handler cannot atomically clear both
	 * the head and tail */
	if (PCNTL_G(head) &amp;&amp; PCNTL_G(tail)) {
		PCNTL_G(tail)-&gt;next = psig;
	} else {
		PCNTL_G(head) = psig;
	}
	PCNTL_G(tail) = psig;
	PCNTL_G(pending_signals) = 1;
	if (PCNTL_G(async_signals)) {
		zend_atomic_bool_store_ex(&amp;EG(vm_interrupt), true);
	}
}

void pcntl_signal_dispatch(void)
{
	zval params[2], *handle, retval;
	struct php_pcntl_pending_signal *queue, *next;
	sigset_t mask;
	sigset_t old_mask;

	if(!PCNTL_G(pending_signals)) {
		return;
	}

	/* Mask all signals */
	sigfillset(&amp;mask);
	sigprocmask(SIG_BLOCK, &amp;mask, &amp;old_mask);

	/* Bail if the queue is empty or if we are already playing the queue */
	if (!PCNTL_G(head) || PCNTL_G(processing_signal_queue)) {
		sigprocmask(SIG_SETMASK, &amp;old_mask, NULL);
		return;
	}

	/* Prevent switching fibers when handling signals */
	zend_fiber_switch_block();

	/* Prevent reentrant handler calls */
	PCNTL_G(processing_signal_queue) = 1;

	queue = PCNTL_G(head);
	PCNTL_G(head) = NULL; /* simple stores are atomic */

	/* Allocate */
	while (queue) {
		if ((handle = zend_hash_index_find(&amp;PCNTL_G(php_signal_table), queue-&gt;signo)) != NULL) {
			if (Z_TYPE_P(handle) != IS_LONG) {
				ZVAL_NULL(&amp;retval);
				ZVAL_LONG(&amp;params[0], queue-&gt;signo);
#ifdef HAVE_STRUCT_SIGINFO_T
				array_init(&amp;params[1]);
				pcntl_siginfo_to_zval(queue-&gt;signo, &amp;queue-&gt;siginfo, &amp;params[1]);
#else
				ZVAL_NULL(&amp;params[1]);
#endif

				/* Call php signal handler - Note that we do not report errors, and we ignore the return value */
				/* FIXME: this is probably broken when multiple signals are handled in this while loop (retval) */
				call_user_function(NULL, NULL, handle, &amp;retval, 2, params);
				zval_ptr_dtor(&amp;retval);
#ifdef HAVE_STRUCT_SIGINFO_T
				zval_ptr_dtor(&amp;params[1]);
#endif
			}
		}

		next = queue-&gt;next;
		queue-&gt;next = PCNTL_G(spares);
		PCNTL_G(spares) = queue;
		queue = next;
	}

	PCNTL_G(pending_signals) = 0;

	/* Re-enable queue */
	PCNTL_G(processing_signal_queue) = 0;

	/* Re-enable fiber switching */
	zend_fiber_switch_unblock();

	/* return signal mask to previous state */
	sigprocmask(SIG_SETMASK, &amp;old_mask, NULL);
}

static void pcntl_signal_dispatch_tick_function(int dummy_int, void *dummy_pointer)
{
	return pcntl_signal_dispatch();
}

/* {{{ Enable/disable asynchronous signal handling and return the old setting. */
PHP_FUNCTION(pcntl_async_signals)
{
	bool on, on_is_null = 1;

	ZEND_PARSE_PARAMETERS_START(0, 1)
		Z_PARAM_OPTIONAL
		Z_PARAM_BOOL_OR_NULL(on, on_is_null)
	ZEND_PARSE_PARAMETERS_END();

	if (on_is_null) {
		RETURN_BOOL(PCNTL_G(async_signals));
	}

	RETVAL_BOOL(PCNTL_G(async_signals));
	PCNTL_G(async_signals) = on;
}
/* }}} */

#ifdef HAVE_UNSHARE
/* {{{ disassociate parts of the process execution context */
PHP_FUNCTION(pcntl_unshare)
{
	zend_long flags;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(flags)
	ZEND_PARSE_PARAMETERS_END();

	if (unshare(flags) == -1) {
		PCNTL_G(last_error) = errno;
		switch (errno) {
#ifdef EINVAL
			case EINVAL:
				zend_argument_value_error(1, &quot;must be a combination of CLONE_* flags, or at least one flag is unsupported by the kernel&quot;);
				RETURN_THROWS();
				break;
#endif
#ifdef ENOMEM
			case ENOMEM:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: Insufficient memory for unshare&quot;, errno);
				break;
#endif
#ifdef EPERM
			case EPERM:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: No privilege to use these flags&quot;, errno);
				break;
#endif
#ifdef ENOSPC
			case ENOSPC:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: Reached the maximum nesting limit for one of the specified namespaces&quot;, errno);
				break;
#endif
#ifdef EUSERS
			case EUSERS:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: Reached the maximum nesting limit for the user namespace&quot;, errno);
				break;
#endif
			default:
				php_error_docref(NULL, E_WARNING, &quot;Unknown error %d has occurred&quot;, errno);
				break;
		}
		RETURN_FALSE;
	}

	RETURN_TRUE;
}
/* }}} */
#endif

#ifdef HAVE_RFORK
/* {{{ proto bool pcntl_rfork(int flags [, int signal])
   More control over the process creation is given over fork/vfork. */
PHP_FUNCTION(pcntl_rfork)
{
	zend_long flags;
	zend_long csignal = 0;
	pid_t pid;

	ZEND_PARSE_PARAMETERS_START(1, 2)
		Z_PARAM_LONG(flags)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG(csignal)
	ZEND_PARSE_PARAMETERS_END();

	/* This is a flag to use with great caution in general, preferably not within PHP */
	if ((flags &amp; RFMEM) != 0) {
		zend_argument_value_error(1, &quot;must not include RFMEM value, not allowed within this context&quot;);
		RETURN_THROWS();
	}

	if ((flags &amp; RFSIGSHARE) != 0) {
		zend_argument_value_error(1, &quot;must not include RFSIGSHARE value, not allowed within this context&quot;);
		RETURN_THROWS();
	}

	if ((flags &amp; (RFFDG | RFCFDG)) == (RFFDG | RFCFDG)) {
		zend_argument_value_error(1, &quot;must not include both RFFDG and RFCFDG, because these flags are mutually exclusive&quot;);
		RETURN_THROWS();
	}

	/* A new pid is required */
	if (!(flags &amp; (RFPROC))) {
		flags |= RFPROC;
	}

#ifdef RFTSIGZMB
	if ((flags &amp; RFTSIGZMB) != 0) {
		flags |= RFTSIGFLAGS(csignal);
	}
#endif

	pid = rfork(flags);

	if (pid == -1) {
		PCNTL_G(last_error) = errno;
		switch (errno) {
			case EAGAIN:
			php_error_docref(NULL, E_WARNING, &quot;Maximum process creations limit reached\n&quot;);
		break;

		default:
			php_error_docref(NULL, E_WARNING, &quot;Error %d&quot;, errno);
		}
	}

	RETURN_LONG((zend_long) pid);
}
#endif
/* }}} */

#ifdef HAVE_FORKX
/* {{{ proto bool pcntl_forkx(int flags)
   More elaborated version of fork with the following settings.
   FORK_WAITPID: forbid the parent process to wait for multiple pid but one only
   FORK_NOSIGCHLD: SIGCHLD signal ignored when the child terminates */
PHP_FUNCTION(pcntl_forkx)
{
	zend_long flags;
	pid_t pid;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(flags)
	ZEND_PARSE_PARAMETERS_END();

	if (flags &lt; FORK_NOSIGCHLD || flags &gt; FORK_WAITPID) {
		zend_argument_value_error(1, &quot;must be FORK_NOSIGCHLD or FORK_WAITPID&quot;);
		RETURN_THROWS();
	}

	pid = forkx(flags);

	if (pid == -1) {
		PCNTL_G(last_error) = errno;
		switch (errno) {
			case EAGAIN:
			php_error_docref(NULL, E_WARNING, &quot;Maximum process creations limit reached\n&quot;);
		break;
			case EPERM:
			php_error_docref(NULL, E_WARNING, &quot;Calling process not having the proper privileges\n&quot;);
		break;
			case ENOMEM:
			php_error_docref(NULL, E_WARNING, &quot;No swap space left\n&quot;);
		break;
		default:
			php_error_docref(NULL, E_WARNING, &quot;Error %d&quot;, errno);
		}
	}

	RETURN_LONG((zend_long) pid);
}
#endif
/* }}} */

#ifdef HAVE_PIDFD_OPEN
// The `pidfd_open` syscall is available since 5.3
// and `setns` since 3.0.
PHP_FUNCTION(pcntl_setns)
{
	zend_long pid, nstype = CLONE_NEWNET;
	bool pid_is_null = 1;
	int fd, ret;

	ZEND_PARSE_PARAMETERS_START(0, 2)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG_OR_NULL(pid, pid_is_null)
		Z_PARAM_LONG(nstype)
	ZEND_PARSE_PARAMETERS_END();

	pid = pid_is_null ? getpid() : pid;
	fd = syscall(SYS_pidfd_open, pid, 0);
	if (errno) {
		PCNTL_G(last_error) = errno;
		switch (errno) {
			case EINVAL:
			case ESRCH:
				zend_argument_value_error(1, &quot;is not a valid process (&quot; ZEND_LONG_FMT &quot;)&quot;, pid);
				RETURN_THROWS();

			case ENFILE:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: File descriptors per-process limit reached&quot;, errno);
				break;

			case ENODEV:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: Anonymous inode fs unsupported&quot;, errno);
				break;

			case ENOMEM:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: Insufficient memory for pidfd_open&quot;, errno);
				break;

			default:
			        php_error_docref(NULL, E_WARNING, &quot;Error %d&quot;, errno);
		}
		RETURN_FALSE;
	}
	ret = setns(fd, (int)nstype);
	close(fd);

	if (ret == -1) {
		PCNTL_G(last_error) = errno;
		switch (errno) {
			case ESRCH:
				zend_argument_value_error(1, &quot;process no longer available (&quot; ZEND_LONG_FMT &quot;)&quot;, pid);
				RETURN_THROWS();

			case EINVAL:
				zend_argument_value_error(2, &quot;is an invalid nstype (%d)&quot;, nstype);
				RETURN_THROWS();

			case EPERM:
				php_error_docref(NULL, E_WARNING, &quot;Error %d: No required capability for this process&quot;, errno);
				break;

			default:
			        php_error_docref(NULL, E_WARNING, &quot;Error %d&quot;, errno);
		}
		RETURN_FALSE;
	} else {
		RETURN_TRUE;
	}
}
#endif

#ifdef HAVE_SCHED_SETAFFINITY
PHP_FUNCTION(pcntl_getcpuaffinity)
{
	zend_long pid;
	bool pid_is_null = 1;
	cpu_set_t mask;

	ZEND_PARSE_PARAMETERS_START(0, 1)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG_OR_NULL(pid, pid_is_null)
	ZEND_PARSE_PARAMETERS_END();

	// 0 == getpid in this context, we&#039;re just saving a syscall
	pid = pid_is_null ? 0 : pid;

	PCNTL_CPU_ZERO(mask);

	if (sched_getaffinity(pid, PCNTL_CPUSET_SIZE(mask), PCNTL_CPUSET(mask)) != 0) {
		PCNTL_CPU_DESTROY(mask);
		PCNTL_G(last_error) = errno;
		switch (errno) {
			case ESRCH:
				zend_argument_value_error(1, &quot;invalid process (&quot; ZEND_LONG_FMT &quot;)&quot;, pid);
				RETURN_THROWS();
			case EPERM:
				php_error_docref(NULL, E_WARNING, &quot;Calling process not having the proper privileges&quot;);
				break;
			case EINVAL:
				zend_value_error(&quot;invalid cpu affinity mask size&quot;);
				RETURN_THROWS();
			default:
				php_error_docref(NULL, E_WARNING, &quot;Error %d&quot;, errno);
		}

		RETURN_FALSE;
	}

	zend_ulong maxcpus = (zend_ulong)sysconf(_SC_NPROCESSORS_CONF);
	array_init(return_value);

	for (zend_ulong i = 0; i &lt; maxcpus; i ++) {
		if (PCNTL_CPU_ISSET(i, mask)) {
			add_next_index_long(return_value, i);
		}
	}
	PCNTL_CPU_DESTROY(mask);
}

PHP_FUNCTION(pcntl_setcpuaffinity)
{
	zend_long pid;
	bool pid_is_null = 1;
	cpu_set_t mask;
	zval *hmask = NULL, *ncpu;

	ZEND_PARSE_PARAMETERS_START(0, 2)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG_OR_NULL(pid, pid_is_null)
		Z_PARAM_ARRAY(hmask)
	ZEND_PARSE_PARAMETERS_END();

	// TODO Why are the arguments optional?
	if (!hmask || zend_hash_num_elements(Z_ARRVAL_P(hmask)) == 0) {
		zend_argument_must_not_be_empty_error(2);
		RETURN_THROWS();
	}

	// 0 == getpid in this context, we&#039;re just saving a syscall
	pid = pid_is_null ? 0 : pid;
	zend_long maxcpus = sysconf(_SC_NPROCESSORS_CONF);
	PCNTL_CPU_ZERO(mask);

	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(hmask), ncpu) {
		ZVAL_DEREF(ncpu);
		zend_long cpu;
		if (Z_TYPE_P(ncpu) != IS_LONG) {
			if (Z_TYPE_P(ncpu) == IS_STRING) {
				zend_ulong tmp;
				if (!ZEND_HANDLE_NUMERIC(Z_STR_P(ncpu), tmp)) {
					zend_argument_value_error(2, &quot;cpu id invalid value (%s)&quot;, ZSTR_VAL(Z_STR_P(ncpu)));
					PCNTL_CPU_DESTROY(mask);
					RETURN_THROWS();
				}

				cpu = (zend_long)tmp;
			} else {
				zend_argument_type_error(2, &quot;value must be of type int|string, %s given&quot;, zend_zval_value_name(ncpu));
				PCNTL_CPU_DESTROY(mask);
				RETURN_THROWS();
			}
		} else {
			cpu = Z_LVAL_P(ncpu);
		}

		if (cpu &lt; 0 || cpu &gt;= maxcpus) {
			zend_argument_value_error(2, &quot;cpu id must be between 0 and &quot; ZEND_ULONG_FMT &quot; (&quot; ZEND_LONG_FMT &quot;)&quot;, maxcpus, cpu);
			RETURN_THROWS();
		}

		if (!PCNTL_CPU_ISSET(cpu, mask)) {
			PCNTL_CPU_SET(cpu, mask);
		}
	} ZEND_HASH_FOREACH_END();

	if (sched_setaffinity(pid, PCNTL_CPUSET_SIZE(mask), PCNTL_CPUSET(mask)) != 0) {
		PCNTL_CPU_DESTROY(mask);
		PCNTL_G(last_error) = errno;
		switch (errno) {
			case ESRCH:
				zend_argument_value_error(1, &quot;invalid process (&quot; ZEND_LONG_FMT &quot;)&quot;, pid);
				RETURN_THROWS();
			case EPERM:
				php_error_docref(NULL, E_WARNING, &quot;Calling process not having the proper privileges&quot;);
				break;
			case EINVAL:
				zend_argument_value_error(2, &quot;invalid cpu affinity mask size or unmapped cpu id(s)&quot;);
				RETURN_THROWS();
			default:
				php_error_docref(NULL, E_WARNING, &quot;Error %d&quot;, errno);
		}
		RETURN_FALSE;
	} else {
		PCNTL_CPU_DESTROY(mask);
		RETURN_TRUE;
	}
}
#endif

#if defined(HAVE_SCHED_GETCPU)
PHP_FUNCTION(pcntl_getcpu)
{
	ZEND_PARSE_PARAMETERS_NONE();

	RETURN_LONG(sched_getcpu());
}
#endif

#if defined(HAVE_PTHREAD_SET_QOS_CLASS_SELF_NP)
static qos_class_t qos_zval_to_lval(const zval *qos_obj)
{
	qos_class_t qos_class = QOS_CLASS_DEFAULT;
	zend_string *entry = Z_STR_P(zend_enum_fetch_case_name(Z_OBJ_P(qos_obj)));

	if (zend_string_equals_literal(entry, &quot;UserInteractive&quot;)) {
		qos_class = QOS_CLASS_USER_INTERACTIVE;
	} else if (zend_string_equals_literal(entry, &quot;UserInitiated&quot;)) {
		qos_class = QOS_CLASS_USER_INITIATED;
	} else if (zend_string_equals_literal(entry, &quot;Utility&quot;)) {
		qos_class = QOS_CLASS_UTILITY;
	} else if (zend_string_equals_literal(entry, &quot;Background&quot;)) {
		qos_class = QOS_CLASS_BACKGROUND;
	}

	return qos_class;
}

static zend_object *qos_lval_to_zval(qos_class_t qos_class)
{
	const char *entryname;
	switch (qos_class)
	{
	case QOS_CLASS_USER_INTERACTIVE:
		entryname = &quot;UserInteractive&quot;;
		break;
	case QOS_CLASS_USER_INITIATED:
		entryname = &quot;UserInitiated&quot;;
		break;
	case QOS_CLASS_UTILITY:
		entryname = &quot;Utility&quot;;
		break;
	case QOS_CLASS_BACKGROUND:
		entryname = &quot;Background&quot;;
		break;
	case QOS_CLASS_DEFAULT:
	default:
		entryname = &quot;Default&quot;;
		break;
	}

	return zend_enum_get_case_cstr(QosClass_ce, entryname);
}

PHP_FUNCTION(pcntl_getqos_class)
{
	qos_class_t qos_class;

	ZEND_PARSE_PARAMETERS_NONE();

	if (UNEXPECTED(pthread_get_qos_class_np(pthread_self(), &amp;qos_class, NULL) != 0))
	{
		// unlikely unless an external tool set the QOS class with a wrong value
		PCNTL_G(last_error) = errno;
		zend_throw_error(NULL, &quot;invalid QOS class %u&quot;, qos_class);
		RETURN_THROWS();
	}

	RETURN_OBJ_COPY(qos_lval_to_zval(qos_class));
}

PHP_FUNCTION(pcntl_setqos_class)
{
	zval *qos_obj;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_OBJECT_OF_CLASS(qos_obj, QosClass_ce)
	ZEND_PARSE_PARAMETERS_END();

	qos_class_t qos_class = qos_zval_to_lval(qos_obj);

	if (UNEXPECTED(pthread_set_qos_class_self_np((qos_class_t)qos_class, 0) != 0))
	{
		// unlikely, unless it is a new os issue, as we draw from the specified enum values
		PCNTL_G(last_error) = errno;
		zend_throw_error(NULL, &quot;pcntl_setqos_class failed&quot;);
		RETURN_THROWS();
	}
}
#endif

static void pcntl_interrupt_function(zend_execute_data *execute_data)
{
	pcntl_signal_dispatch();
	if (orig_interrupt_function) {
		orig_interrupt_function(execute_data);
	}
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fpcntl'>🔙 Back</a></p>