/*

+----------------------------------------------------------------------+

| 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 |

| [email protected] so we can mail you a copy immediately. |

+----------------------------------------------------------------------+

| Authors: Rasmus Lerdorf <[email protected]> |

| Stig Bakken <[email protected]> |

| Andi Gutmans <[email protected]> |

| Zeev Suraski <[email protected]> |

| PHP 4.0 patches by Thies C. Arntzen ([email protected]) |

| PHP streams by Wez Furlong ([email protected]) |

+----------------------------------------------------------------------+

*/

/* {{{ includes */

#include "php.h"

#include "php_globals.h"

#include "ext/standard/flock_compat.h"

#include "ext/standard/exec.h"

#include "ext/standard/php_filestat.h"

#include "php_open_temporary_file.h"

#include "ext/standard/basic_functions.h"

#include "php_ini.h"

#include "zend_smart_str.h"

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <wchar.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#ifdef PHP_WIN32

# include <io.h>

# define O_RDONLY _O_RDONLY

# include "win32/param.h"

# include "win32/winutil.h"

# include "win32/fnmatch.h"

# include "win32/ioutil.h"

#else

# if HAVE_SYS_PARAM_H

# include <sys/param.h>

# endif

# if HAVE_SYS_SELECT_H

# include <sys/select.h>

# endif

# include <sys/socket.h>

# include <netinet/in.h>

# include <netdb.h>

# if HAVE_ARPA_INET_H

# include <arpa/inet.h>

# endif

#endif

#include "ext/standard/head.h"

#include "php_string.h"

#include "file.h"

#ifdef HAVE_PWD_H

# ifdef PHP_WIN32

# include "win32/pwd.h"

# else

# include <pwd.h>

# endif

#endif

#ifdef HAVE_SYS_TIME_H

# include <sys/time.h>

#endif

#include "fsock.h"

#include "fopen_wrappers.h"

#include "streamsfuncs.h"

#include "php_globals.h"

#ifdef HAVE_SYS_FILE_H

# include <sys/file.h>

#endif

#if MISSING_FCLOSE_DECL

extern int fclose(FILE *);

#endif

#ifdef HAVE_SYS_MMAN_H

# include <sys/mman.h>

#endif

#include "scanf.h"

#include "zend_API.h"

#ifdef ZTS

int file_globals_id;

#else

php_file_globals file_globals;

#endif

#if defined(HAVE_FNMATCH) && !defined(PHP_WIN32)

# ifndef _GNU_SOURCE

# define _GNU_SOURCE

# endif

# include <fnmatch.h>

#endif

#include "file_arginfo.h"

/* }}} */

#define PHP_STREAM_TO_ZVAL(stream, arg) \

ZEND_ASSERT(Z_TYPE_P(arg) == IS_RESOURCE); \

php_stream_from_res(stream, Z_RES_P(arg));

/* {{{ ZTS-stuff / Globals / Prototypes */

/* sharing globals is *evil* */

static int le_stream_context = FAILURE;

PHPAPI int php_le_stream_context(void)

{

return le_stream_context;

}

/* }}} */

/* {{{ Module-Stuff */

static ZEND_RSRC_DTOR_FUNC(file_context_dtor)

{

php_stream_context *context = (php_stream_context*)res->ptr;

if (Z_TYPE(context->options) != IS_UNDEF) {

zval_ptr_dtor(&context->options);

ZVAL_UNDEF(&context->options);

}

php_stream_context_free(context);

}

static void file_globals_ctor(php_file_globals *file_globals_p)

{

memset(file_globals_p, 0, sizeof(php_file_globals));

file_globals_p->def_chunk_size = PHP_SOCK_CHUNK_SIZE;

}

static void file_globals_dtor(php_file_globals *file_globals_p)

{

#if defined(HAVE_GETHOSTBYNAME_R)

if (file_globals_p->tmp_host_buf) {

free(file_globals_p->tmp_host_buf);

}

#endif

}

static PHP_INI_MH(OnUpdateAutoDetectLineEndings)

{

if (zend_ini_parse_bool(new_value)) {

zend_error(E_DEPRECATED, "auto_detect_line_endings is deprecated");

}

return OnUpdateBool(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);

}

PHP_INI_BEGIN()

STD_PHP_INI_ENTRY("user_agent", NULL, PHP_INI_ALL, OnUpdateString, user_agent, php_file_globals, file_globals)

STD_PHP_INI_ENTRY("from", NULL, PHP_INI_ALL, OnUpdateString, from_address, php_file_globals, file_globals)

STD_PHP_INI_ENTRY("default_socket_timeout", "60", PHP_INI_ALL, OnUpdateLong, default_socket_timeout, php_file_globals, file_globals)

STD_PHP_INI_BOOLEAN("auto_detect_line_endings", "0", PHP_INI_ALL, OnUpdateAutoDetectLineEndings, auto_detect_line_endings, php_file_globals, file_globals)

PHP_INI_END()

PHP_MINIT_FUNCTION(file)

{

le_stream_context = zend_register_list_destructors_ex(file_context_dtor, NULL, "stream-context", module_number);

#ifdef ZTS

ts_allocate_id(&file_globals_id, sizeof(php_file_globals), (ts_allocate_ctor) file_globals_ctor, (ts_allocate_dtor) file_globals_dtor);

#else

file_globals_ctor(&file_globals);

#endif

REGISTER_INI_ENTRIES();

register_file_symbols(module_number);

return SUCCESS;

}

/* }}} */

PHP_MSHUTDOWN_FUNCTION(file) /* {{{ */

{

#ifndef ZTS

file_globals_dtor(&file_globals);

#endif

return SUCCESS;

}

/* }}} */

PHPAPI void php_flock_common(php_stream *stream, zend_long operation,

uint32_t operation_arg_num, zval *wouldblock, zval *return_value)

{

int flock_values[] = { LOCK_SH, LOCK_EX, LOCK_UN };

int act;

act = operation & PHP_LOCK_UN;

if (act < 1 || act > 3) {

zend_argument_value_error(operation_arg_num, "must be one of LOCK_SH, LOCK_EX, or LOCK_UN");

RETURN_THROWS();

}

if (wouldblock) {

ZEND_TRY_ASSIGN_REF_LONG(wouldblock, 0);

}

/* flock_values contains all possible actions if (operation & PHP_LOCK_NB) we won't block on the lock */

act = flock_values[act - 1] | (operation & PHP_LOCK_NB ? LOCK_NB : 0);

if (php_stream_lock(stream, act)) {

if (operation && errno == EWOULDBLOCK && wouldblock) {

ZEND_TRY_ASSIGN_REF_LONG(wouldblock, 1);

}

RETURN_FALSE;

}

RETURN_TRUE;

}

/* {{{ Portable file locking */

PHP_FUNCTION(flock)

{

zval *res, *wouldblock = NULL;

php_stream *stream;

zend_long operation = 0;

ZEND_PARSE_PARAMETERS_START(2, 3)

Z_PARAM_RESOURCE(res)

Z_PARAM_LONG(operation)

Z_PARAM_OPTIONAL

Z_PARAM_ZVAL(wouldblock)

ZEND_PARSE_PARAMETERS_END();

PHP_STREAM_TO_ZVAL(stream, res);

php_flock_common(stream, operation, 2, wouldblock, return_value);

}

/* }}} */

#define PHP_META_UNSAFE ".\\+*?[^]$() "

/* {{{ Extracts all meta tag content attributes from a file and returns an array */

PHP_FUNCTION(get_meta_tags)

{

char *filename;

size_t filename_len;

bool use_include_path = 0;

int in_tag = 0, done = 0;

int looking_for_val = 0, have_name = 0, have_content = 0;

int saw_name = 0, saw_content = 0;

char *name = NULL, *value = NULL, *temp = NULL;

php_meta_tags_token tok, tok_last;

php_meta_tags_data md;

/* Initialize our structure */

memset(&md, 0, sizeof(md));

/* Parse arguments */

ZEND_PARSE_PARAMETERS_START(1, 2)

Z_PARAM_PATH(filename, filename_len)

Z_PARAM_OPTIONAL

Z_PARAM_BOOL(use_include_path)

ZEND_PARSE_PARAMETERS_END();

md.stream = php_stream_open_wrapper(filename, "rb",

(use_include_path ? USE_PATH : 0) | REPORT_ERRORS,

NULL);

if (!md.stream) {

RETURN_FALSE;

}

array_init(return_value);

tok_last = TOK_EOF;

while (!done && (tok = php_next_meta_token(&md)) != TOK_EOF) {

if (tok == TOK_ID) {

if (tok_last == TOK_OPENTAG) {

md.in_meta = !strcasecmp("meta", md.token_data);

} else if (tok_last == TOK_SLASH && in_tag) {

if (strcasecmp("head", md.token_data) == 0) {

/* We are done here! */

done = 1;

}

} else if (tok_last == TOK_EQUAL && looking_for_val) {

if (saw_name) {

if (name) efree(name);

/* Get the NAME attr (Single word attr, non-quoted) */

temp = name = estrndup(md.token_data, md.token_len);

while (temp && *temp) {

if (strchr(PHP_META_UNSAFE, *temp)) {

*temp = '_';

}

temp++;

}

have_name = 1;

} else if (saw_content) {

if (value) efree(value);

value = estrndup(md.token_data, md.token_len);

have_content = 1;

}

looking_for_val = 0;

} else {

if (md.in_meta) {

if (strcasecmp("name", md.token_data) == 0) {

saw_name = 1;

saw_content = 0;

looking_for_val = 1;

} else if (strcasecmp("content", md.token_data) == 0) {

saw_name = 0;

saw_content = 1;

looking_for_val = 1;

}

}

}

} else if (tok == TOK_STRING && tok_last == TOK_EQUAL && looking_for_val) {

if (saw_name) {

if (name) efree(name);

/* Get the NAME attr (Quoted single/double) */

temp = name = estrndup(md.token_data, md.token_len);

while (temp && *temp) {

if (strchr(PHP_META_UNSAFE, *temp)) {

*temp = '_';

}

temp++;

}

have_name = 1;

} else if (saw_content) {

if (value) efree(value);

value = estrndup(md.token_data, md.token_len);

have_content = 1;

}

looking_for_val = 0;

} else if (tok == TOK_OPENTAG) {

if (looking_for_val) {

looking_for_val = 0;

have_name = saw_name = 0;

have_content = saw_content = 0;

}

in_tag = 1;

} else if (tok == TOK_CLOSETAG) {

if (have_name) {

/* For BC */

zend_str_tolower(name, strlen(name));

if (have_content) {

add_assoc_string(return_value, name, value);

} else {

add_assoc_string(return_value, name, "");

}

efree(name);

if (value) efree(value);

} else if (have_content) {

efree(value);

}

name = value = NULL;

/* Reset all of our flags */

in_tag = looking_for_val = 0;

have_name = saw_name = 0;

have_content = saw_content = 0;

md.in_meta = 0;

}

tok_last = tok;

if (md.token_data)

efree(md.token_data);

md.token_data = NULL;

}

if (value) efree(value);

if (name) efree(name);

php_stream_close(md.stream);

}

/* }}} */

/* {{{ Read the entire file into a string */

PHP_FUNCTION(file_get_contents)

{

char *filename;

size_t filename_len;

bool use_include_path = 0;

php_stream *stream;

zend_long offset = 0;

zend_long maxlen;

bool maxlen_is_null = 1;

zval *zcontext = NULL;

php_stream_context *context = NULL;

zend_string *contents;

/* Parse arguments */

ZEND_PARSE_PARAMETERS_START(1, 5)

Z_PARAM_PATH(filename, filename_len)

Z_PARAM_OPTIONAL

Z_PARAM_BOOL(use_include_path)

Z_PARAM_RESOURCE_OR_NULL(zcontext)

Z_PARAM_LONG(offset)

Z_PARAM_LONG_OR_NULL(maxlen, maxlen_is_null)

ZEND_PARSE_PARAMETERS_END();

if (maxlen_is_null) {

maxlen = (ssize_t) PHP_STREAM_COPY_ALL;

} else if (maxlen < 0) {

zend_argument_value_error(5, "must be greater than or equal to 0");

RETURN_THROWS();

}

context = php_stream_context_from_zval(zcontext, 0);

stream = php_stream_open_wrapper_ex(filename, "rb",

(use_include_path ? USE_PATH : 0) | REPORT_ERRORS,

NULL, context);

if (!stream) {

RETURN_FALSE;

}

/* disabling the read buffer allows doing the whole transfer

in just one read() system call */

if (php_stream_is(stream, PHP_STREAM_IS_STDIO)) {

php_stream_set_option(stream, PHP_STREAM_OPTION_READ_BUFFER, PHP_STREAM_BUFFER_NONE, NULL);

}

if (offset != 0 && php_stream_seek(stream, offset, ((offset > 0) ? SEEK_SET : SEEK_END)) < 0) {

php_error_docref(NULL, E_WARNING, "Failed to seek to position " ZEND_LONG_FMT " in the stream", offset);

php_stream_close(stream);

RETURN_FALSE;

}

if ((contents = php_stream_copy_to_mem(stream, maxlen, 0)) != NULL) {

RETVAL_STR(contents);

} else {

RETVAL_EMPTY_STRING();

}

php_stream_close(stream);

}

/* }}} */

/* {{{ Write/Create a file with contents data and return the number of bytes written */

PHP_FUNCTION(file_put_contents)

{

php_stream *stream;

char *filename;

size_t filename_len;

zval *data;

ssize_t numbytes = 0;

zend_long flags = 0;

zval *zcontext = NULL;

php_stream_context *context = NULL;

php_stream *srcstream = NULL;

char mode[3] = "wb";

ZEND_PARSE_PARAMETERS_START(2, 4)

Z_PARAM_PATH(filename, filename_len)

Z_PARAM_ZVAL(data)

Z_PARAM_OPTIONAL

Z_PARAM_LONG(flags)

Z_PARAM_RESOURCE_OR_NULL(zcontext)

ZEND_PARSE_PARAMETERS_END();

if (Z_TYPE_P(data) == IS_RESOURCE) {

php_stream_from_zval(srcstream, data);

}

context = php_stream_context_from_zval(zcontext, flags & PHP_FILE_NO_DEFAULT_CONTEXT);

if (flags & PHP_FILE_APPEND) {

mode[0] = 'a';

} else if (flags & LOCK_EX) {

/* check to make sure we are dealing with a regular file */

if (php_memnstr(filename, "://", sizeof("://") - 1, filename + filename_len)) {

if (strncasecmp(filename, "file://", sizeof("file://") - 1)) {

php_error_docref(NULL, E_WARNING, "Exclusive locks may only be set for regular files");

RETURN_FALSE;

}

}

mode[0] = 'c';

}

mode[2] = '\0';

stream = php_stream_open_wrapper_ex(filename, mode, ((flags & PHP_FILE_USE_INCLUDE_PATH) ? USE_PATH : 0) | REPORT_ERRORS, NULL, context);

if (stream == NULL) {

RETURN_FALSE;

}

if ((flags & LOCK_EX) && (!php_stream_supports_lock(stream) || php_stream_lock(stream, LOCK_EX))) {

php_stream_close(stream);

php_error_docref(NULL, E_WARNING, "Exclusive locks are not supported for this stream");

RETURN_FALSE;

}

if (mode[0] == 'c') {

php_stream_truncate_set_size(stream, 0);

}

switch (Z_TYPE_P(data)) {

case IS_RESOURCE: {

size_t len;

if (php_stream_copy_to_stream_ex(srcstream, stream, PHP_STREAM_COPY_ALL, &len) != SUCCESS) {

numbytes = -1;

} else {

if (len > ZEND_LONG_MAX) {

php_error_docref(NULL, E_WARNING, "content truncated from %zu to " ZEND_LONG_FMT " bytes", len, ZEND_LONG_MAX);

len = ZEND_LONG_MAX;

}

numbytes = len;

}

break;

}

case IS_NULL:

case IS_LONG:

case IS_DOUBLE:

case IS_FALSE:

case IS_TRUE:

convert_to_string(data);

ZEND_FALLTHROUGH;

case IS_STRING:

if (Z_STRLEN_P(data)) {

numbytes = php_stream_write(stream, Z_STRVAL_P(data), Z_STRLEN_P(data));

if (numbytes != -1 && numbytes != Z_STRLEN_P(data)) {

php_error_docref(NULL, E_WARNING, "Only %zd of %zd bytes written, possibly out of free disk space", numbytes, Z_STRLEN_P(data));

numbytes = -1;

}

}

break;

case IS_ARRAY:

if (zend_hash_num_elements(Z_ARRVAL_P(data))) {

ssize_t bytes_written;

zval *tmp;

ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(data), tmp) {

zend_string *t;

zend_string *str = zval_get_tmp_string(tmp, &t);

if (ZSTR_LEN(str)) {

numbytes += ZSTR_LEN(str);

bytes_written = php_stream_write(stream, ZSTR_VAL(str), ZSTR_LEN(str));

if (bytes_written != ZSTR_LEN(str)) {

php_error_docref(NULL, E_WARNING, "Failed to write %zd bytes to %s", ZSTR_LEN(str), filename);

zend_tmp_string_release(t);

numbytes = -1;

break;

}

}

zend_tmp_string_release(t);

} ZEND_HASH_FOREACH_END();

}

break;

case IS_OBJECT:

if (Z_OBJ_HT_P(data) != NULL) {

zval out;

if (zend_std_cast_object_tostring(Z_OBJ_P(data), &out, IS_STRING) == SUCCESS) {

numbytes = php_stream_write(stream, Z_STRVAL(out), Z_STRLEN(out));

if (numbytes != -1 && numbytes != Z_STRLEN(out)) {

php_error_docref(NULL, E_WARNING, "Only %zd of %zd bytes written, possibly out of free disk space", numbytes, Z_STRLEN(out));

numbytes = -1;

}

zval_ptr_dtor_str(&out);

break;

}

}

ZEND_FALLTHROUGH;

default:

numbytes = -1;

break;

}

php_stream_close(stream);

if (numbytes < 0) {

RETURN_FALSE;

}

RETURN_LONG(numbytes);

}

/* }}} */

#define PHP_FILE_BUF_SIZE 80

/* {{{ Read entire file into an array */

PHP_FUNCTION(file)

{

char *filename;

size_t filename_len;

char *p, *s, *e;

int i = 0;

char eol_marker = '\n';

zend_long flags = 0;

bool use_include_path;

bool include_new_line;

bool skip_blank_lines;

php_stream *stream;

zval *zcontext = NULL;

php_stream_context *context = NULL;

zend_string *target_buf;

/* Parse arguments */

ZEND_PARSE_PARAMETERS_START(1, 3)

Z_PARAM_PATH(filename, filename_len)

Z_PARAM_OPTIONAL

Z_PARAM_LONG(flags)

Z_PARAM_RESOURCE_OR_NULL(zcontext)

ZEND_PARSE_PARAMETERS_END();

if (flags < 0 || flags > (PHP_FILE_USE_INCLUDE_PATH | PHP_FILE_IGNORE_NEW_LINES | PHP_FILE_SKIP_EMPTY_LINES | PHP_FILE_NO_DEFAULT_CONTEXT)) {

zend_argument_value_error(2, "must be a valid flag value");

RETURN_THROWS();

}

use_include_path = flags & PHP_FILE_USE_INCLUDE_PATH;

include_new_line = !(flags & PHP_FILE_IGNORE_NEW_LINES);

skip_blank_lines = flags & PHP_FILE_SKIP_EMPTY_LINES;

context = php_stream_context_from_zval(zcontext, flags & PHP_FILE_NO_DEFAULT_CONTEXT);

stream = php_stream_open_wrapper_ex(filename, "rb", (use_include_path ? USE_PATH : 0) | REPORT_ERRORS, NULL, context);

if (!stream) {

RETURN_FALSE;

}

/* Initialize return array */

array_init(return_value);

if ((target_buf = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0)) != NULL) {

s = ZSTR_VAL(target_buf);

e = ZSTR_VAL(target_buf) + ZSTR_LEN(target_buf);

if (!(p = (char*)php_stream_locate_eol(stream, target_buf))) {

p = e;

goto parse_eol;

}

if (stream->flags & PHP_STREAM_FLAG_EOL_MAC) {

eol_marker = '\r';

}

/* for performance reasons the code is duplicated, so that the if (include_new_line)

* will not need to be done for every single line in the file. */

if (include_new_line) {

do {

p++;

parse_eol:

add_index_stringl(return_value, i++, s, p-s);

s = p;

} while ((p = memchr(p, eol_marker, (e-p))));

} else {

do {

int windows_eol = 0;

if (p != ZSTR_VAL(target_buf) && eol_marker == '\n' && *(p - 1) == '\r') {

windows_eol++;

}

if (skip_blank_lines && !(p-s-windows_eol)) {

s = ++p;

continue;

}

add_index_stringl(return_value, i++, s, p-s-windows_eol);

s = ++p;

} while ((p = memchr(p, eol_marker, (e-p))));

}

/* handle any left overs of files without new lines */

if (s != e) {

p = e;

goto parse_eol;

}

}

if (target_buf) {

zend_string_free(target_buf);

}

php_stream_close(stream);

}

/* }}} */

/* {{{ Create a unique filename in a directory */

PHP_FUNCTION(tempnam)

{

char *dir, *prefix;

size_t dir_len, prefix_len;

zend_string *opened_path;

int fd;

zend_string *p;

ZEND_PARSE_PARAMETERS_START(2, 2)

Z_PARAM_PATH(dir, dir_len)

Z_PARAM_PATH(prefix, prefix_len)

ZEND_PARSE_PARAMETERS_END();

p = php_basename(prefix, prefix_len, NULL, 0);

if (ZSTR_LEN(p) > 64) {

ZSTR_VAL(p)[63] = '\0';

}

RETVAL_FALSE;

if ((fd = php_open_temporary_fd_ex(dir, ZSTR_VAL(p), &opened_path, PHP_TMP_FILE_OPEN_BASEDIR_CHECK_ALWAYS)) >= 0) {

close(fd);

RETVAL_STR(opened_path);

}

zend_string_release_ex(p, 0);

}

/* }}} */

/* {{{ Create a temporary file that will be deleted automatically after use */

PHP_FUNCTION(tmpfile)

{

php_stream *stream;

ZEND_PARSE_PARAMETERS_NONE();

stream = php_stream_fopen_tmpfile();

if (stream) {

php_stream_to_zval(stream, return_value);

} else {

RETURN_FALSE;

}

}

/* }}} */

/* {{{ Open a file or a URL and return a file pointer */

PHP_FUNCTION(fopen)

{

char *filename, *mode;

size_t filename_len, mode_len;

bool use_include_path = 0;

zval *zcontext = NULL;

php_stream *stream;

php_stream_context *context = NULL;

ZEND_PARSE_PARAMETERS_START(2, 4)

Z_PARAM_PATH(filename, filename_len)

Z_PARAM_STRING(mode, mode_len)

Z_PARAM_OPTIONAL

Z_PARAM_BOOL(use_include_path)

Z_PARAM_RESOURCE_OR_NULL(zcontext)

ZEND_PARSE_PARAMETERS_END();

context = php_stream_context_from_zval(zcontext, 0);

stream = php_stream_open_wrapper_ex(filename, mode, (use_include_path ? USE_PATH : 0) | REPORT_ERRORS, NULL, context);

if (stream == NULL) {

RETURN_FALSE;

}

php_stream_to_zval(stream, return_value);

}

/* }}} */

/* {{{ Close an open file pointer */

PHPAPI PHP_FUNCTION(fclose)

{

zval *res;

php_stream *stream;

ZEND_PARSE_PARAMETERS_START(1, 1)

Z_PARAM_RESOURCE(res)

ZEND_PARSE_PARAMETERS_END();

PHP_STREAM_TO_ZVAL(stream, res);

if ((stream->flags & PHP_STREAM_FLAG_NO_FCLOSE) != 0) {

php_error_docref(NULL, E_WARNING, ZEND_LONG_FMT " is not a valid stream resource", stream->res->handle);

RETURN_FALSE;

}

php_stream_free(stream,

PHP_STREAM_FREE_KEEP_RSRC |

(stream->is_persistent ? PHP_STREAM_FREE_CLOSE_PERSISTENT : PHP_STREAM_FREE_CLOSE));

RETURN_TRUE;

}

/* }}} */

/* {{{ Execute a command and open either a read or a write pipe to it */

PHP_FUNCTION(popen)

{

char *command, *mode;

size_t command_len, mode_len;

FILE *fp;

php_stream *stream;

char *posix_mode;

ZEND_PARSE_PARAMETERS_START(2, 2)

Z_PARAM_PATH(command, command_len)

Z_PARAM_STRING(mode, mode_len)

ZEND_PARSE_PARAMETERS_END();

posix_mode = estrndup(mode, mode_len);

#ifndef PHP_WIN32

{

char *z = memchr(posix_mode, 'b', mode_len);

if (z) {

memmove(z, z + 1, mode_len - (z - posix_mode));

mode_len--;

}

}

#endif

/* Musl only partially validates the mode. Manually check it to ensure consistent behavior. */

if (mode_len > 2 ||

(mode_len == 1 && (*posix_mode != 'r' && *posix_mode != 'w')) ||

(mode_len == 2 && (memcmp(posix_mode, "rb", 2) && memcmp(posix_mode, "wb", 2)))

) {

zend_argument_value_error(2, "must be one of \"r\", \"rb\", \"w\", or \"wb\"");

efree(posix_mode);

RETURN_THROWS();

}

fp = VCWD_POPEN(command, posix_mode);

if (!fp) {

php_error_docref2(NULL, command, posix_mode, E_WARNING, "%s", strerror(errno));

efree(posix_mode);

RETURN_FALSE;

}

stream = php_stream_fopen_from_pipe(fp, mode);

if (stream == NULL) {

php_error_docref2(NULL, command, mode, E_WARNING, "%s", strerror(errno));

RETVAL_FALSE;

} else {

php_stream_to_zval(stream, return_value);

}

efree(posix_mode);

}

/* }}} */

/* {{{ Close a file pointer opened by popen() */

PHP_FUNCTION(pclose)

{

zval *res;

php_stream *stream;

ZEND_PARSE_PARAMETERS_START(1, 1)

Z_PARAM_RESOURCE(res)

ZEND_PARSE_PARAMETERS_END();

PHP_STREAM_TO_ZVAL(stream, res);

FG(pclose_wait) = 1;

zend_list_close(stream->res);

FG(pclose_wait) = 0;

RETURN_LONG(FG(pclose_ret));

}

/* }}} */

/* {{{ Test for end-of-file on a file pointer */

PHPAPI PHP_FUNCTION(feof)

{

zval *res;

php_stream *stream;

ZEND_PARSE_PARAMETERS_START(1, 1)

Z_PARAM_RESOURCE(res)

ZEND_PARSE_PARAMETERS_END();

PHP_STREAM_TO_ZVAL(stream, res);

if (php_stream_eof(stream)) {

RETURN_TRUE;

} else {

RETURN_FALSE;

}

}

/* }}} */

/* {{{ Get a line from file pointer */

PHPAPI PHP_FUNCTION(fgets)

{

zval *res;

zend_long len = 1024;

bool len_is_null = 1;

char *buf = NULL;

size_t line_len = 0;

zend_string *str;

php_stream *stream;

ZEND_PARSE_PARAMETERS_START(1, 2)

Z_PARAM_RESOURCE(res)

Z_PARAM_OPTIONAL

Z_PARAM_LONG_OR_NULL(len, len_is_null)

ZEND_PARSE_PARAMETERS_END();

PHP_STREAM_TO_ZVAL(stream, res);

if (len_is_null) {

/* ask streams to give us a buffer of an appropriate size */

buf = php_stream_get_line(stream, NULL, 0, &line_len);

if (buf == NULL) {

RETURN_FALSE;

}

// TODO: avoid reallocation ???

RETVAL_STRINGL(buf, line_len);

efree(buf);

} else {

if (len <= 0) {

zend_argument_value_error(2, "must be greater than 0");

RETURN_THROWS();

}

str = zend_string_alloc(len, 0);

if (php_stream_get_line(stream, ZSTR_VAL(str), len, &line_len) == NULL) {

zend_string_efree(str);

RETURN_FALSE;

}

/* resize buffer if it's much larger than the result.

* Only needed if the user requested a buffer size. */

if (line_len < (size_t)len / 2) {

str = zend_string_truncate(str, line_len, 0);

} else {

ZSTR_LEN(str) = line_len;

}

RETURN_NEW_STR(str);

}

}

/* }}} */

/* {{{ Get a character from file pointer */

PHPAPI PHP_FUNCTION(fgetc)

{

zval *res;

php_stream *stream;

ZEND_PARSE_PARAMETERS_START(1, 1)

Z_PARAM_RESOURCE(res)

ZEND_PARSE_PARAMETERS_END();

PHP_STREAM_TO_ZVAL(stream, res);

int result = php_stream_getc(stream);

if (result == EOF) {

RETVAL_FALSE;

} else {

RETURN_CHAR(result);

}

}

/* }}} */

/* {{{ Implements a mostly ANSI compatible fscanf() */

PHP_FUNCTION(fscanf)

{

int result, argc = 0;

size_t format_len;

zval *args = NULL;

zval *file_handle;

char *buf, *format;

size_t len;

void *what;

ZEND_PARSE_PARAMETERS_START(2, -1)

Z_PARAM_RESOURCE(file_handle)

Z_PARAM_STRING(format, format_len)

Z_PARAM_VARIADIC('*', args, argc)

ZEND_PARSE_PARAMETERS_END();

what = zend_fetch_resource2(Z_RES_P(file_handle), "File-Handle", php_file_le_stream(), php_file_le_pstream());

/* we can't do a ZEND_VERIFY_RESOURCE(what), otherwise we end up

* with a leak if we have an invalid filehandle. This needs changing

* if the code behind ZEND_VERIFY_RESOURCE changed. - cc */

if (!what) {

RETURN_THROWS();

}

buf = php_stream_get_line((php_stream *) what, NULL, 0, &len);

if (buf == NULL) {

RETURN_FALSE;

}

result = php_sscanf_internal(buf, format, argc, args, 0, return_value);

efree(buf);

if (SCAN_ERROR_WRONG_PARAM_COUNT == result) {

WRONG_PARAM_COUNT;

}

}

/* }}} */