embedaddon/php/main/streams/userspace.c - diff

Return to userspace.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / main / streams

Diff for /embedaddon/php/main/streams/userspace.c between versions 1.1.1.1 and 1.1.1.4

version 1.1.1.1, 2012/02/21 23:48:05	version 1.1.1.4, 2014/06/15 20:04:01
Line 2	Line 2
+----------------------------------------------------------------------+	+----------------------------------------------------------------------+
\| PHP Version 5 \|	\| PHP Version 5 \|
+----------------------------------------------------------------------+	+----------------------------------------------------------------------+
\| Copyright (c) 1997-2012 The PHP Group \|	\| Copyright (c) 1997-2014 The PHP Group \|
+----------------------------------------------------------------------+	+----------------------------------------------------------------------+
\| This source file is subject to version 3.01 of the PHP license, \|	\| 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 \|	\| that is bundled with this package in the file LICENSE, and is \|
Line 26	Line 26
#ifdef HAVE_SYS_FILE_H	#ifdef HAVE_SYS_FILE_H
#include <sys/file.h>	#include <sys/file.h>
#endif	#endif
	#include <stddef.h>

	#if HAVE_UTIME
	# ifdef PHP_WIN32
	# include <sys/utime.h>
	# else
	# include <utime.h>
	# endif
	#endif

static int le_protocols;	static int le_protocols;

struct php_user_stream_wrapper {	struct php_user_stream_wrapper {
Line 42 static int user_wrapper_unlink(php_stream_wrapper *wra	Line 51 static int user_wrapper_unlink(php_stream_wrapper *wra
static int user_wrapper_rename(php_stream_wrapper wrapper, char url_from, char url_to, int options, php_stream_context context TSRMLS_DC);	static int user_wrapper_rename(php_stream_wrapper wrapper, char url_from, char url_to, int options, php_stream_context context TSRMLS_DC);
static int user_wrapper_mkdir(php_stream_wrapper wrapper, char url, int mode, int options, php_stream_context *context TSRMLS_DC);	static int user_wrapper_mkdir(php_stream_wrapper wrapper, char url, int mode, int options, php_stream_context *context TSRMLS_DC);
static int user_wrapper_rmdir(php_stream_wrapper wrapper, char url, int options, php_stream_context *context TSRMLS_DC);	static int user_wrapper_rmdir(php_stream_wrapper wrapper, char url, int options, php_stream_context *context TSRMLS_DC);
	static int user_wrapper_metadata(php_stream_wrapper wrapper, char url, int option, void value, php_stream_context context TSRMLS_DC);
static php_stream user_wrapper_opendir(php_stream_wrapper wrapper, char filename, char mode,	static php_stream user_wrapper_opendir(php_stream_wrapper wrapper, char filename, char mode,
int options, char *opened_path, php_stream_context context STREAMS_DC TSRMLS_DC);	int options, char *opened_path, php_stream_context context STREAMS_DC TSRMLS_DC);

Line 55 static php_stream_wrapper_ops user_stream_wops = {	Line 65 static php_stream_wrapper_ops user_stream_wops = {
user_wrapper_unlink,	user_wrapper_unlink,
user_wrapper_rename,	user_wrapper_rename,
user_wrapper_mkdir,	user_wrapper_mkdir,
user_wrapper_rmdir	user_wrapper_rmdir,
	user_wrapper_metadata
};	};


Line 77 PHP_MINIT_FUNCTION(user_streams)	Line 88 PHP_MINIT_FUNCTION(user_streams)

REGISTER_LONG_CONSTANT("STREAM_USE_PATH", USE_PATH, CONST_CS\|CONST_PERSISTENT);	REGISTER_LONG_CONSTANT("STREAM_USE_PATH", USE_PATH, CONST_CS\|CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("STREAM_IGNORE_URL", IGNORE_URL, CONST_CS\|CONST_PERSISTENT);	REGISTER_LONG_CONSTANT("STREAM_IGNORE_URL", IGNORE_URL, CONST_CS\|CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("STREAM_ENFORCE_SAFE_MODE", ENFORCE_SAFE_MODE, CONST_CS\|CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("STREAM_REPORT_ERRORS", REPORT_ERRORS, CONST_CS\|CONST_PERSISTENT);	REGISTER_LONG_CONSTANT("STREAM_REPORT_ERRORS", REPORT_ERRORS, CONST_CS\|CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("STREAM_MUST_SEEK", STREAM_MUST_SEEK, CONST_CS\|CONST_PERSISTENT);	REGISTER_LONG_CONSTANT("STREAM_MUST_SEEK", STREAM_MUST_SEEK, CONST_CS\|CONST_PERSISTENT);

Line 99 PHP_MINIT_FUNCTION(user_streams)	Line 109 PHP_MINIT_FUNCTION(user_streams)
REGISTER_LONG_CONSTANT("STREAM_CAST_AS_STREAM", PHP_STREAM_AS_STDIO, CONST_CS\|CONST_PERSISTENT);	REGISTER_LONG_CONSTANT("STREAM_CAST_AS_STREAM", PHP_STREAM_AS_STDIO, CONST_CS\|CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("STREAM_CAST_FOR_SELECT", PHP_STREAM_AS_FD_FOR_SELECT, CONST_CS\|CONST_PERSISTENT);	REGISTER_LONG_CONSTANT("STREAM_CAST_FOR_SELECT", PHP_STREAM_AS_FD_FOR_SELECT, CONST_CS\|CONST_PERSISTENT);

	REGISTER_LONG_CONSTANT("STREAM_META_TOUCH", PHP_STREAM_META_TOUCH, CONST_CS\|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("STREAM_META_OWNER", PHP_STREAM_META_OWNER, CONST_CS\|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("STREAM_META_OWNER_NAME", PHP_STREAM_META_OWNER_NAME, CONST_CS\|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("STREAM_META_GROUP", PHP_STREAM_META_GROUP, CONST_CS\|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("STREAM_META_GROUP_NAME", PHP_STREAM_META_GROUP_NAME, CONST_CS\|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("STREAM_META_ACCESS", PHP_STREAM_META_ACCESS, CONST_CS\|CONST_PERSISTENT);
return SUCCESS;	return SUCCESS;
}	}

Line 130 typedef struct _php_userstream_data php_userstream_dat	Line 146 typedef struct _php_userstream_data php_userstream_dat
#define USERSTREAM_LOCK "stream_lock"	#define USERSTREAM_LOCK "stream_lock"
#define USERSTREAM_CAST "stream_cast"	#define USERSTREAM_CAST "stream_cast"
#define USERSTREAM_SET_OPTION "stream_set_option"	#define USERSTREAM_SET_OPTION "stream_set_option"
	#define USERSTREAM_TRUNCATE "stream_truncate"
	#define USERSTREAM_METADATA "stream_metadata"

/* {{{ class should have methods like these:	/* {{{ class should have methods like these:

function stream_open($path, $mode, $options, &$opened_path)	function stream_open($path, $mode, $options, &$opened_path)
{	{
return true/false;	return true/false;
}	}

function stream_read($count)	function stream_read($count)
{	{
return false on error;	return false on error;
else return string;	else return string;
}	}

function stream_write($data)	function stream_write($data)
{	{
return false on error;	return false on error;
else return count written;	else return count written;
}	}

function stream_close()	function stream_close()
{	{
}	}

function stream_flush()	function stream_flush()
{	{
return true/false;	return true/false;
}	}

function stream_seek($offset, $whence)	function stream_seek($offset, $whence)
{	{
return true/false;	return true/false;
Line 255 typedef struct _php_userstream_data php_userstream_dat	Line 273 typedef struct _php_userstream_data php_userstream_dat
{	{
return true / false;	return true / false;
}	}

	function stream_truncate($new_size)
	{
	return true / false;
	}

}}} **/	}}} **/

static php_stream user_wrapper_opener(php_stream_wrapper wrapper, char filename, char mode, int options, char *opened_path, php_stream_context context STREAMS_DC TSRMLS_DC)	static zval user_stream_create_object(struct php_user_stream_wrapper uwrap, php_stream_context *context TSRMLS_DC)
{	{
struct php_user_stream_wrapper uwrap = (struct php_user_stream_wrapper)wrapper->abstract;	zval *object;
php_userstream_data_t *us;	/* create an instance of our class */
zval zfilename, zmode, zopened, zoptions, zretval = NULL, zfuncname;	ALLOC_ZVAL(object);
zval **args[4];	object_init_ex(object, uwrap->ce);
int call_result;	Z_SET_REFCOUNT_P(object, 1);
php_stream *stream = NULL;	Z_SET_ISREF_P(object);
zend_bool old_in_user_include;

/* Try to catch bad usage without preventing flexibility */	if (context) {
if (FG(user_stream_current_filename) != NULL && strcmp(filename, FG(user_stream_current_filename)) == 0) {	add_property_resource(object, "context", context->rsrc_id);
php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "infinite recursion prevented");	zend_list_addref(context->rsrc_id);
return NULL;	} else {
	add_property_null(object, "context");
}	}
FG(user_stream_current_filename) = filename;

/* if the user stream was registered as local and we are in include context,
we add allow_url_include restrictions to allow_url_fopen ones */
/* we need only is_url == 0 here since if is_url == 1 and remote wrappers
were restricted we wouldn't get here */
old_in_user_include = PG(in_user_include);
if(uwrap->wrapper.is_url == 0 &&
(options & STREAM_OPEN_FOR_INCLUDE) &&
!PG(allow_url_include)) {
PG(in_user_include) = 1;
}

us = emalloc(sizeof(*us));
us->wrapper = uwrap;

/* create an instance of our class */
ALLOC_ZVAL(us->object);
object_init_ex(us->object, uwrap->ce);
Z_SET_REFCOUNT_P(us->object, 1);
Z_SET_ISREF_P(us->object);

if (uwrap->ce->constructor) {	if (uwrap->ce->constructor) {
zend_fcall_info fci;	zend_fcall_info fci;
zend_fcall_info_cache fcc;	zend_fcall_info_cache fcc;
zval *retval_ptr;	zval *retval_ptr;

fci.size = sizeof(fci);	fci.size = sizeof(fci);
fci.function_table = &uwrap->ce->function_table;	fci.function_table = &uwrap->ce->function_table;
fci.function_name = NULL;	fci.function_name = NULL;
fci.symbol_table = NULL;	fci.symbol_table = NULL;
fci.object_ptr = us->object;	fci.object_ptr = object;
fci.retval_ptr_ptr = &retval_ptr;	fci.retval_ptr_ptr = &retval_ptr;
fci.param_count = 0;	fci.param_count = 0;
fci.params = NULL;	fci.params = NULL;
fci.no_separation = 1;	fci.no_separation = 1;

fcc.initialized = 1;	fcc.initialized = 1;
fcc.function_handler = uwrap->ce->constructor;	fcc.function_handler = uwrap->ce->constructor;
fcc.calling_scope = EG(scope);	fcc.calling_scope = EG(scope);
fcc.called_scope = Z_OBJCE_P(us->object);	fcc.called_scope = Z_OBJCE_P(object);
fcc.object_ptr = us->object;	fcc.object_ptr = object;

if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {	if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not execute %s::%s()", uwrap->ce->name, uwrap->ce->constructor->common.function_name);	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not execute %s::%s()", uwrap->ce->name, uwrap->ce->constructor->common.function_name);
zval_dtor(us->object);	zval_dtor(object);
FREE_ZVAL(us->object);	FREE_ZVAL(object);
efree(us);
FG(user_stream_current_filename) = NULL;
PG(in_user_include) = old_in_user_include;
return NULL;	return NULL;
} else {	} else {
if (retval_ptr) {	if (retval_ptr) {
Line 330 static php_stream *user_wrapper_opener(php_stream_wrap	Line 329 static php_stream *user_wrapper_opener(php_stream_wrap
}	}
}	}
}	}
	return object;
	}

if (context) {	static php_stream user_wrapper_opener(php_stream_wrapper wrapper, char filename, char mode, int options, char *opened_path, php_stream_context context STREAMS_DC TSRMLS_DC)
add_property_resource(us->object, "context", context->rsrc_id);	{
zend_list_addref(context->rsrc_id);	struct php_user_stream_wrapper uwrap = (struct php_user_stream_wrapper)wrapper->abstract;
} else {	php_userstream_data_t *us;
add_property_null(us->object, "context");	zval zfilename, zmode, zopened, zoptions, zretval = NULL, zfuncname;
	zval **args[4];
	int call_result;
	php_stream *stream = NULL;
	zend_bool old_in_user_include;

	/* Try to catch bad usage without preventing flexibility */
	if (FG(user_stream_current_filename) != NULL && strcmp(filename, FG(user_stream_current_filename)) == 0) {
	php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "infinite recursion prevented");
	return NULL;
}	}
	FG(user_stream_current_filename) = filename;

	/* if the user stream was registered as local and we are in include context,
	we add allow_url_include restrictions to allow_url_fopen ones */
	/* we need only is_url == 0 here since if is_url == 1 and remote wrappers
	were restricted we wouldn't get here */
	old_in_user_include = PG(in_user_include);
	if(uwrap->wrapper.is_url == 0 &&
	(options & STREAM_OPEN_FOR_INCLUDE) &&
	!PG(allow_url_include)) {
	PG(in_user_include) = 1;
	}

	us = emalloc(sizeof(*us));
	us->wrapper = uwrap;

	us->object = user_stream_create_object(uwrap, context TSRMLS_CC);
	if(us->object == NULL) {
	FG(user_stream_current_filename) = NULL;
	PG(in_user_include) = old_in_user_include;
	efree(us);
	return NULL;
	}

/* call it's stream_open method - set up params first */	/* call it's stream_open method - set up params first */
MAKE_STD_ZVAL(zfilename);	MAKE_STD_ZVAL(zfilename);
ZVAL_STRING(zfilename, filename, 1);	ZVAL_STRING(zfilename, filename, 1);
Line 359 static php_stream *user_wrapper_opener(php_stream_wrap	Line 392 static php_stream *user_wrapper_opener(php_stream_wrap

MAKE_STD_ZVAL(zfuncname);	MAKE_STD_ZVAL(zfuncname);
ZVAL_STRING(zfuncname, USERSTREAM_OPEN, 1);	ZVAL_STRING(zfuncname, USERSTREAM_OPEN, 1);

call_result = call_user_function_ex(NULL,	call_result = call_user_function_ex(NULL,
&us->object,	&us->object,
zfuncname,	zfuncname,
&zretval,	&zretval,
4, args,	4, args,
0, NULL TSRMLS_CC);	0, NULL TSRMLS_CC);

if (call_result == SUCCESS && zretval != NULL && zval_is_true(zretval)) {	if (call_result == SUCCESS && zretval != NULL && zval_is_true(zretval)) {
/* the stream is now open! */	/* the stream is now open! */
stream = php_stream_alloc_rel(&php_stream_userspace_ops, us, 0, mode);	stream = php_stream_alloc_rel(&php_stream_userspace_ops, us, 0, mode);
Line 383 static php_stream *user_wrapper_opener(php_stream_wrap	Line 416 static php_stream *user_wrapper_opener(php_stream_wrap
php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "\"%s::" USERSTREAM_OPEN "\" call failed",	php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "\"%s::" USERSTREAM_OPEN "\" call failed",
us->wrapper->classname);	us->wrapper->classname);
}	}

/* destroy everything else */	/* destroy everything else */
if (stream == NULL) {	if (stream == NULL) {
zval_ptr_dtor(&us->object);	zval_ptr_dtor(&us->object);
Line 391 static php_stream *user_wrapper_opener(php_stream_wrap	Line 424 static php_stream *user_wrapper_opener(php_stream_wrap
}	}
if (zretval)	if (zretval)
zval_ptr_dtor(&zretval);	zval_ptr_dtor(&zretval);

zval_ptr_dtor(&zfuncname);	zval_ptr_dtor(&zfuncname);
zval_ptr_dtor(&zopened);	zval_ptr_dtor(&zopened);
zval_ptr_dtor(&zoptions);	zval_ptr_dtor(&zoptions);
Line 399 static php_stream *user_wrapper_opener(php_stream_wrap	Line 432 static php_stream *user_wrapper_opener(php_stream_wrap
zval_ptr_dtor(&zfilename);	zval_ptr_dtor(&zfilename);

FG(user_stream_current_filename) = NULL;	FG(user_stream_current_filename) = NULL;

PG(in_user_include) = old_in_user_include;	PG(in_user_include) = old_in_user_include;
return stream;	return stream;
}	}
Line 410 static php_stream *user_wrapper_opendir(php_stream_wra	Line 443 static php_stream *user_wrapper_opendir(php_stream_wra
struct php_user_stream_wrapper uwrap = (struct php_user_stream_wrapper)wrapper->abstract;	struct php_user_stream_wrapper uwrap = (struct php_user_stream_wrapper)wrapper->abstract;
php_userstream_data_t *us;	php_userstream_data_t *us;
zval zfilename, zoptions, zretval = NULL, zfuncname;	zval zfilename, zoptions, zretval = NULL, zfuncname;
zval **args[2];	zval **args[2];
int call_result;	int call_result;
php_stream *stream = NULL;	php_stream *stream = NULL;

Line 420 static php_stream *user_wrapper_opendir(php_stream_wra	Line 453 static php_stream *user_wrapper_opendir(php_stream_wra
return NULL;	return NULL;
}	}
FG(user_stream_current_filename) = filename;	FG(user_stream_current_filename) = filename;

us = emalloc(sizeof(*us));	us = emalloc(sizeof(*us));
us->wrapper = uwrap;	us->wrapper = uwrap;

/* create an instance of our class */	us->object = user_stream_create_object(uwrap, context TSRMLS_CC);
ALLOC_ZVAL(us->object);	if(us->object == NULL) {
object_init_ex(us->object, uwrap->ce);	FG(user_stream_current_filename) = NULL;
Z_SET_REFCOUNT_P(us->object, 1);	efree(us);
Z_SET_ISREF_P(us->object);	return NULL;

if (context) {
add_property_resource(us->object, "context", context->rsrc_id);
zend_list_addref(context->rsrc_id);
} else {
add_property_null(us->object, "context");
}	}

/* call it's dir_open method - set up params first */	/* call it's dir_open method - set up params first */
MAKE_STD_ZVAL(zfilename);	MAKE_STD_ZVAL(zfilename);
ZVAL_STRING(zfilename, filename, 1);	ZVAL_STRING(zfilename, filename, 1);
Line 448 static php_stream *user_wrapper_opendir(php_stream_wra	Line 475 static php_stream *user_wrapper_opendir(php_stream_wra

MAKE_STD_ZVAL(zfuncname);	MAKE_STD_ZVAL(zfuncname);
ZVAL_STRING(zfuncname, USERSTREAM_DIR_OPEN, 1);	ZVAL_STRING(zfuncname, USERSTREAM_DIR_OPEN, 1);

call_result = call_user_function_ex(NULL,	call_result = call_user_function_ex(NULL,
&us->object,	&us->object,
zfuncname,	zfuncname,
&zretval,	&zretval,
2, args,	2, args,
0, NULL TSRMLS_CC);	0, NULL TSRMLS_CC);

if (call_result == SUCCESS && zretval != NULL && zval_is_true(zretval)) {	if (call_result == SUCCESS && zretval != NULL && zval_is_true(zretval)) {
/* the stream is now open! */	/* the stream is now open! */
stream = php_stream_alloc_rel(&php_stream_userspace_dir_ops, us, 0, mode);	stream = php_stream_alloc_rel(&php_stream_userspace_dir_ops, us, 0, mode);
Line 467 static php_stream *user_wrapper_opendir(php_stream_wra	Line 494 static php_stream *user_wrapper_opendir(php_stream_wra
php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "\"%s::" USERSTREAM_DIR_OPEN "\" call failed",	php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "\"%s::" USERSTREAM_DIR_OPEN "\" call failed",
us->wrapper->classname);	us->wrapper->classname);
}	}

/* destroy everything else */	/* destroy everything else */
if (stream == NULL) {	if (stream == NULL) {
zval_ptr_dtor(&us->object);	zval_ptr_dtor(&us->object);
Line 475 static php_stream *user_wrapper_opendir(php_stream_wra	Line 502 static php_stream *user_wrapper_opendir(php_stream_wra
}	}
if (zretval)	if (zretval)
zval_ptr_dtor(&zretval);	zval_ptr_dtor(&zretval);

zval_ptr_dtor(&zfuncname);	zval_ptr_dtor(&zfuncname);
zval_ptr_dtor(&zoptions);	zval_ptr_dtor(&zoptions);
zval_ptr_dtor(&zfilename);	zval_ptr_dtor(&zfilename);

FG(user_stream_current_filename) = NULL;	FG(user_stream_current_filename) = NULL;

return stream;	return stream;
}	}

Line 495 PHP_FUNCTION(stream_wrapper_register)	Line 522 PHP_FUNCTION(stream_wrapper_register)
struct php_user_stream_wrapper * uwrap;	struct php_user_stream_wrapper * uwrap;
int rsrc_id;	int rsrc_id;
long flags = 0;	long flags = 0;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss\|l", &protocol, &protocol_len, &classname, &classname_len, &flags) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss\|l", &protocol, &protocol_len, &classname, &classname_len, &flags) == FAILURE) {
RETURN_FALSE;	RETURN_FALSE;
}	}

uwrap = (struct php_user_stream_wrapper )ecalloc(1, sizeof(uwrap));	uwrap = (struct php_user_stream_wrapper )ecalloc(1, sizeof(uwrap));
uwrap->protoname = estrndup(protocol, protocol_len);	uwrap->protoname = estrndup(protocol, protocol_len);
uwrap->classname = estrndup(classname, classname_len);	uwrap->classname = estrndup(classname, classname_len);
Line 585 PHP_FUNCTION(stream_wrapper_restore)	Line 612 PHP_FUNCTION(stream_wrapper_restore)
if (php_register_url_stream_wrapper_volatile(protocol, wrapper TSRMLS_CC) == FAILURE) {	if (php_register_url_stream_wrapper_volatile(protocol, wrapper TSRMLS_CC) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to restore original %s:// wrapper", protocol);	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to restore original %s:// wrapper", protocol);
RETURN_FALSE;	RETURN_FALSE;
}	}

RETURN_TRUE;	RETURN_TRUE;
}	}
Line 633 static size_t php_userstreamop_write(php_stream *strea	Line 660 static size_t php_userstreamop_write(php_stream *strea
(long)(didwrite - count), (long)didwrite, (long)count);	(long)(didwrite - count), (long)didwrite, (long)count);
didwrite = count;	didwrite = count;
}	}

if (retval)	if (retval)
zval_ptr_dtor(&retval);	zval_ptr_dtor(&retval);

return didwrite;	return didwrite;
}	}

Line 721 static int php_userstreamop_close(php_stream *stream,	Line 748 static int php_userstreamop_close(php_stream *stream,
php_userstream_data_t us = (php_userstream_data_t )stream->abstract;	php_userstream_data_t us = (php_userstream_data_t )stream->abstract;

assert(us != NULL);	assert(us != NULL);

ZVAL_STRINGL(&func_name, USERSTREAM_CLOSE, sizeof(USERSTREAM_CLOSE)-1, 0);	ZVAL_STRINGL(&func_name, USERSTREAM_CLOSE, sizeof(USERSTREAM_CLOSE)-1, 0);

call_user_function_ex(NULL,	call_user_function_ex(NULL,
&us->object,	&us->object,
&func_name,	&func_name,
Line 732 static int php_userstreamop_close(php_stream *stream,	Line 759 static int php_userstreamop_close(php_stream *stream,

if (retval)	if (retval)
zval_ptr_dtor(&retval);	zval_ptr_dtor(&retval);

zval_ptr_dtor(&us->object);	zval_ptr_dtor(&us->object);

efree(us);	efree(us);

return 0;	return 0;
}	}

Line 750 static int php_userstreamop_flush(php_stream *stream T	Line 777 static int php_userstreamop_flush(php_stream *stream T
assert(us != NULL);	assert(us != NULL);

ZVAL_STRINGL(&func_name, USERSTREAM_FLUSH, sizeof(USERSTREAM_FLUSH)-1, 0);	ZVAL_STRINGL(&func_name, USERSTREAM_FLUSH, sizeof(USERSTREAM_FLUSH)-1, 0);

call_result = call_user_function_ex(NULL,	call_result = call_user_function_ex(NULL,
&us->object,	&us->object,
&func_name,	&func_name,
Line 761 static int php_userstreamop_flush(php_stream *stream T	Line 788 static int php_userstreamop_flush(php_stream *stream T
call_result = 0;	call_result = 0;
else	else
call_result = -1;	call_result = -1;

if (retval)	if (retval)
zval_ptr_dtor(&retval);	zval_ptr_dtor(&retval);

return call_result;	return call_result;
}	}

Line 803 static int php_userstreamop_seek(php_stream *stream, o	Line 830 static int php_userstreamop_seek(php_stream *stream, o
/* stream_seek is not implemented, so disable seeks for this stream */	/* stream_seek is not implemented, so disable seeks for this stream */
stream->flags \|= PHP_STREAM_FLAG_NO_SEEK;	stream->flags \|= PHP_STREAM_FLAG_NO_SEEK;
/* there should be no retval to clean up */	/* there should be no retval to clean up */

if (retval)	if (retval)
zval_ptr_dtor(&retval);	zval_ptr_dtor(&retval);

return -1;	return -1;
} else if (call_result == SUCCESS && retval != NULL && zval_is_true(retval)) {	} else if (call_result == SUCCESS && retval != NULL && zval_is_true(retval)) {
ret = 0;	ret = 0;
Line 890 static int statbuf_from_array(zval *array, php_stream_	Line 917 static int statbuf_from_array(zval *array, php_stream_
STAT_PROP_ENTRY(blocks);	STAT_PROP_ENTRY(blocks);
#endif	#endif

#undef STAT_PROP_ENTRY	#undef STAT_PROP_ENTRY
#undef STAT_PROP_ENTRY_EX	#undef STAT_PROP_ENTRY_EX
return SUCCESS;	return SUCCESS;
}	}

Line 921 static int php_userstreamop_stat(php_stream *stream, p	Line 948 static int php_userstreamop_stat(php_stream *stream, p
}	}
}	}

if (retval)	if (retval)
zval_ptr_dtor(&retval);	zval_ptr_dtor(&retval);

return ret;	return ret;
}	}

Line 933 static int php_userstreamop_set_option(php_stream *str	Line 960 static int php_userstreamop_set_option(php_stream *str
zval *retval = NULL;	zval *retval = NULL;
int call_result;	int call_result;
php_userstream_data_t us = (php_userstream_data_t )stream->abstract;	php_userstream_data_t us = (php_userstream_data_t )stream->abstract;
int ret = -1;	int ret = PHP_STREAM_OPTION_RETURN_NOTIMPL;
zval *zvalue = NULL;	zval *zvalue = NULL;
zval **args[3];	zval **args[3];

Line 971 static int php_userstreamop_set_option(php_stream *str	Line 998 static int php_userstreamop_set_option(php_stream *str
}	}

args[0] = &zvalue;	args[0] = &zvalue;

/* TODO wouldblock */	/* TODO wouldblock */
ZVAL_STRINGL(&func_name, USERSTREAM_LOCK, sizeof(USERSTREAM_LOCK)-1, 0);	ZVAL_STRINGL(&func_name, USERSTREAM_LOCK, sizeof(USERSTREAM_LOCK)-1, 0);

call_result = call_user_function_ex(NULL,	call_result = call_user_function_ex(NULL,
&us->object,	&us->object,
&func_name,	&func_name,
&retval,	&retval,
1, args, 0, NULL TSRMLS_CC);	1, args, 0, NULL TSRMLS_CC);

if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_BOOL) {	if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_BOOL) {
ret = !Z_LVAL_P(retval);	ret = !Z_LVAL_P(retval);
} else if (call_result == FAILURE) {	} else if (call_result == FAILURE) {
if (value == 0) {	if (value == 0) {
/* lock support test (TODO: more check) */	/* lock support test (TODO: more check) */
ret = 0;	ret = PHP_STREAM_OPTION_RETURN_OK;
} else {	} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_LOCK " is not implemented!",	php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_LOCK " is not implemented!",
us->wrapper->classname);	us->wrapper->classname);
	ret = PHP_STREAM_OPTION_RETURN_ERR;
}	}
}	}

break;	break;

	case PHP_STREAM_OPTION_TRUNCATE_API:
	ZVAL_STRINGL(&func_name, USERSTREAM_TRUNCATE, sizeof(USERSTREAM_TRUNCATE)-1, 0);

	switch (value) {
	case PHP_STREAM_TRUNCATE_SUPPORTED:
	if (zend_is_callable_ex(&func_name, us->object, IS_CALLABLE_CHECK_SILENT,
	NULL, NULL, NULL, NULL TSRMLS_CC))
	ret = PHP_STREAM_OPTION_RETURN_OK;
	else
	ret = PHP_STREAM_OPTION_RETURN_ERR;
	break;

	case PHP_STREAM_TRUNCATE_SET_SIZE: {
	ptrdiff_t new_size = (ptrdiff_t) ptrparam;
	if (new_size >= 0 && new_size <= (ptrdiff_t)LONG_MAX) {
	MAKE_STD_ZVAL(zvalue);
	ZVAL_LONG(zvalue, (long)new_size);
	args[0] = &zvalue;
	call_result = call_user_function_ex(NULL,
	&us->object,
	&func_name,
	&retval,
	1, args, 0, NULL TSRMLS_CC);
	if (call_result == SUCCESS && retval != NULL) {
	if (Z_TYPE_P(retval) == IS_BOOL) {
	ret = Z_LVAL_P(retval) ? PHP_STREAM_OPTION_RETURN_OK :
	PHP_STREAM_OPTION_RETURN_ERR;
	} else {
	php_error_docref(NULL TSRMLS_CC, E_WARNING,
	"%s::" USERSTREAM_TRUNCATE " did not return a boolean!",
	us->wrapper->classname);
	}
	} else {
	php_error_docref(NULL TSRMLS_CC, E_WARNING,
	"%s::" USERSTREAM_TRUNCATE " is not implemented!",
	us->wrapper->classname);
	}
	} else { /* bad new size */
	ret = PHP_STREAM_OPTION_RETURN_ERR;
	}
	break;
	}
	}
	break;

case PHP_STREAM_OPTION_READ_BUFFER:	case PHP_STREAM_OPTION_READ_BUFFER:
case PHP_STREAM_OPTION_WRITE_BUFFER:	case PHP_STREAM_OPTION_WRITE_BUFFER:
case PHP_STREAM_OPTION_READ_TIMEOUT:	case PHP_STREAM_OPTION_READ_TIMEOUT:
case PHP_STREAM_OPTION_BLOCKING: {	case PHP_STREAM_OPTION_BLOCKING: {
zval *zoption = NULL;	zval *zoption = NULL;
zval *zptrparam = NULL;	zval *zptrparam = NULL;

ZVAL_STRINGL(&func_name, USERSTREAM_SET_OPTION, sizeof(USERSTREAM_SET_OPTION)-1, 0);	ZVAL_STRINGL(&func_name, USERSTREAM_SET_OPTION, sizeof(USERSTREAM_SET_OPTION)-1, 0);

ALLOC_INIT_ZVAL(zoption);	ALLOC_INIT_ZVAL(zoption);
Line 1042 static int php_userstreamop_set_option(php_stream *str	Line 1115 static int php_userstreamop_set_option(php_stream *str
&func_name,	&func_name,
&retval,	&retval,
3, args, 0, NULL TSRMLS_CC);	3, args, 0, NULL TSRMLS_CC);

do {
if (call_result == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_SET_OPTION " is not implemented!",
us->wrapper->classname);
break;
}
if (retval && zend_is_true(retval)) {
ret = PHP_STREAM_OPTION_RETURN_OK;
}
} while (0);

	if (call_result == FAILURE) {
	php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_SET_OPTION " is not implemented!",
	us->wrapper->classname);
	ret = PHP_STREAM_OPTION_RETURN_ERR;
	} else if (retval && zend_is_true(retval)) {
	ret = PHP_STREAM_OPTION_RETURN_OK;
	} else {
	ret = PHP_STREAM_OPTION_RETURN_ERR;
	}

if (zoption) {	if (zoption) {
zval_ptr_dtor(&zoption);	zval_ptr_dtor(&zoption);
}	}
Line 1069 static int php_userstreamop_set_option(php_stream *str	Line 1141 static int php_userstreamop_set_option(php_stream *str
if (retval) {	if (retval) {
zval_ptr_dtor(&retval);	zval_ptr_dtor(&retval);
}	}



if (zvalue) {	if (zvalue) {
zval_ptr_dtor(&zvalue);	zval_ptr_dtor(&zvalue);
}	}
Line 1089 static int user_wrapper_unlink(php_stream_wrapper *wra	Line 1161 static int user_wrapper_unlink(php_stream_wrapper *wra
int ret = 0;	int ret = 0;

/* create an instance of our class */	/* create an instance of our class */
ALLOC_ZVAL(object);	object = user_stream_create_object(uwrap, context TSRMLS_CC);
object_init_ex(object, uwrap->ce);	if(object == NULL) {
Z_SET_REFCOUNT_P(object, 1);	return ret;
Z_SET_ISREF_P(object);

if (context) {
add_property_resource(object, "context", context->rsrc_id);
zend_list_addref(context->rsrc_id);
} else {
add_property_null(object, "context");
}	}

/* call the unlink method */	/* call the unlink method */
Line 1108 static int user_wrapper_unlink(php_stream_wrapper *wra	Line 1173 static int user_wrapper_unlink(php_stream_wrapper *wra

MAKE_STD_ZVAL(zfuncname);	MAKE_STD_ZVAL(zfuncname);
ZVAL_STRING(zfuncname, USERSTREAM_UNLINK, 1);	ZVAL_STRING(zfuncname, USERSTREAM_UNLINK, 1);

call_result = call_user_function_ex(NULL,	call_result = call_user_function_ex(NULL,
&object,	&object,
zfuncname,	zfuncname,
Line 1126 static int user_wrapper_unlink(php_stream_wrapper *wra	Line 1191 static int user_wrapper_unlink(php_stream_wrapper *wra
zval_ptr_dtor(&object);	zval_ptr_dtor(&object);
if (zretval)	if (zretval)
zval_ptr_dtor(&zretval);	zval_ptr_dtor(&zretval);

zval_ptr_dtor(&zfuncname);	zval_ptr_dtor(&zfuncname);
zval_ptr_dtor(&zfilename);	zval_ptr_dtor(&zfilename);

Line 1143 static int user_wrapper_rename(php_stream_wrapper *wra	Line 1208 static int user_wrapper_rename(php_stream_wrapper *wra
int ret = 0;	int ret = 0;

/* create an instance of our class */	/* create an instance of our class */
ALLOC_ZVAL(object);	object = user_stream_create_object(uwrap, context TSRMLS_CC);
object_init_ex(object, uwrap->ce);	if(object == NULL) {
Z_SET_REFCOUNT_P(object, 1);	return ret;
Z_SET_ISREF_P(object);

if (context) {
add_property_resource(object, "context", context->rsrc_id);
zend_list_addref(context->rsrc_id);
} else {
add_property_null(object, "context");
}	}

/* call the rename method */	/* call the rename method */
Line 1166 static int user_wrapper_rename(php_stream_wrapper *wra	Line 1224 static int user_wrapper_rename(php_stream_wrapper *wra

MAKE_STD_ZVAL(zfuncname);	MAKE_STD_ZVAL(zfuncname);
ZVAL_STRING(zfuncname, USERSTREAM_RENAME, 1);	ZVAL_STRING(zfuncname, USERSTREAM_RENAME, 1);

call_result = call_user_function_ex(NULL,	call_result = call_user_function_ex(NULL,
&object,	&object,
zfuncname,	zfuncname,
Line 1184 static int user_wrapper_rename(php_stream_wrapper *wra	Line 1242 static int user_wrapper_rename(php_stream_wrapper *wra
zval_ptr_dtor(&object);	zval_ptr_dtor(&object);
if (zretval)	if (zretval)
zval_ptr_dtor(&zretval);	zval_ptr_dtor(&zretval);

zval_ptr_dtor(&zfuncname);	zval_ptr_dtor(&zfuncname);
zval_ptr_dtor(&zold_name);	zval_ptr_dtor(&zold_name);
zval_ptr_dtor(&znew_name);	zval_ptr_dtor(&znew_name);
Line 1202 static int user_wrapper_mkdir(php_stream_wrapper *wrap	Line 1260 static int user_wrapper_mkdir(php_stream_wrapper *wrap
int ret = 0;	int ret = 0;

/* create an instance of our class */	/* create an instance of our class */
ALLOC_ZVAL(object);	object = user_stream_create_object(uwrap, context TSRMLS_CC);
object_init_ex(object, uwrap->ce);	if(object == NULL) {
Z_SET_REFCOUNT_P(object, 1);	return ret;
Z_SET_ISREF_P(object);

if (context) {
add_property_resource(object, "context", context->rsrc_id);
zend_list_addref(context->rsrc_id);
} else {
add_property_null(object, "context");
}	}

/* call the mkdir method */	/* call the mkdir method */
Line 1229 static int user_wrapper_mkdir(php_stream_wrapper *wrap	Line 1280 static int user_wrapper_mkdir(php_stream_wrapper *wrap

MAKE_STD_ZVAL(zfuncname);	MAKE_STD_ZVAL(zfuncname);
ZVAL_STRING(zfuncname, USERSTREAM_MKDIR, 1);	ZVAL_STRING(zfuncname, USERSTREAM_MKDIR, 1);

call_result = call_user_function_ex(NULL,	call_result = call_user_function_ex(NULL,
&object,	&object,
zfuncname,	zfuncname,
Line 1248 static int user_wrapper_mkdir(php_stream_wrapper *wrap	Line 1299 static int user_wrapper_mkdir(php_stream_wrapper *wrap
if (zretval) {	if (zretval) {
zval_ptr_dtor(&zretval);	zval_ptr_dtor(&zretval);
}	}

zval_ptr_dtor(&zfuncname);	zval_ptr_dtor(&zfuncname);
zval_ptr_dtor(&zfilename);	zval_ptr_dtor(&zfilename);
zval_ptr_dtor(&zmode);	zval_ptr_dtor(&zmode);
Line 1267 static int user_wrapper_rmdir(php_stream_wrapper *wrap	Line 1318 static int user_wrapper_rmdir(php_stream_wrapper *wrap
int ret = 0;	int ret = 0;

/* create an instance of our class */	/* create an instance of our class */
ALLOC_ZVAL(object);	object = user_stream_create_object(uwrap, context TSRMLS_CC);
object_init_ex(object, uwrap->ce);	if(object == NULL) {
Z_SET_REFCOUNT_P(object, 1);	return ret;
Z_SET_ISREF_P(object);

if (context) {
add_property_resource(object, "context", context->rsrc_id);
zend_list_addref(context->rsrc_id);
} else {
add_property_null(object, "context");
}	}

/* call the rmdir method */	/* call the rmdir method */
Line 1290 static int user_wrapper_rmdir(php_stream_wrapper *wrap	Line 1334 static int user_wrapper_rmdir(php_stream_wrapper *wrap

MAKE_STD_ZVAL(zfuncname);	MAKE_STD_ZVAL(zfuncname);
ZVAL_STRING(zfuncname, USERSTREAM_RMDIR, 1);	ZVAL_STRING(zfuncname, USERSTREAM_RMDIR, 1);

call_result = call_user_function_ex(NULL,	call_result = call_user_function_ex(NULL,
&object,	&object,
zfuncname,	zfuncname,
Line 1309 static int user_wrapper_rmdir(php_stream_wrapper *wrap	Line 1353 static int user_wrapper_rmdir(php_stream_wrapper *wrap
if (zretval) {	if (zretval) {
zval_ptr_dtor(&zretval);	zval_ptr_dtor(&zretval);
}	}

zval_ptr_dtor(&zfuncname);	zval_ptr_dtor(&zfuncname);
zval_ptr_dtor(&zfilename);	zval_ptr_dtor(&zfilename);
zval_ptr_dtor(&zoptions);	zval_ptr_dtor(&zoptions);
Line 1317 static int user_wrapper_rmdir(php_stream_wrapper *wrap	Line 1361 static int user_wrapper_rmdir(php_stream_wrapper *wrap
return ret;	return ret;
}	}

	static int user_wrapper_metadata(php_stream_wrapper wrapper, char url, int option, void value, php_stream_context context TSRMLS_DC)
	{
	struct php_user_stream_wrapper uwrap = (struct php_user_stream_wrapper)wrapper->abstract;
	zval zfilename, zoption, zvalue, zfuncname, *zretval;
	zval **args[3];
	int call_result;
	zval *object;
	int ret = 0;

	MAKE_STD_ZVAL(zvalue);
	switch(option) {
	case PHP_STREAM_META_TOUCH:
	array_init(zvalue);
	if(value) {
	struct utimbuf newtime = (struct utimbuf )value;
	add_index_long(zvalue, 0, newtime->modtime);
	add_index_long(zvalue, 1, newtime->actime);
	}
	break;
	case PHP_STREAM_META_GROUP:
	case PHP_STREAM_META_OWNER:
	case PHP_STREAM_META_ACCESS:
	ZVAL_LONG(zvalue, (long )value);
	break;
	case PHP_STREAM_META_GROUP_NAME:
	case PHP_STREAM_META_OWNER_NAME:
	ZVAL_STRING(zvalue, value, 1);
	break;
	default:
	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option %d for " USERSTREAM_METADATA, option);
	zval_ptr_dtor(&zvalue);
	return ret;
	}

	/* create an instance of our class */
	object = user_stream_create_object(uwrap, context TSRMLS_CC);
	if(object == NULL) {
	zval_ptr_dtor(&zvalue);
	return ret;
	}

	/* call the mkdir method */
	MAKE_STD_ZVAL(zfilename);
	ZVAL_STRING(zfilename, url, 1);
	args[0] = &zfilename;

	MAKE_STD_ZVAL(zoption);
	ZVAL_LONG(zoption, option);
	args[1] = &zoption;

	args[2] = &zvalue;

	MAKE_STD_ZVAL(zfuncname);
	ZVAL_STRING(zfuncname, USERSTREAM_METADATA, 1);

	call_result = call_user_function_ex(NULL,
	&object,
	zfuncname,
	&zretval,
	3, args,
	0, NULL TSRMLS_CC);

	if (call_result == SUCCESS && zretval && Z_TYPE_P(zretval) == IS_BOOL) {
	ret = Z_LVAL_P(zretval);
	} else if (call_result == FAILURE) {
	php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_METADATA " is not implemented!", uwrap->classname);
	}

	/* clean up */
	zval_ptr_dtor(&object);
	if (zretval) {
	zval_ptr_dtor(&zretval);
	}

	zval_ptr_dtor(&zfuncname);
	zval_ptr_dtor(&zfilename);
	zval_ptr_dtor(&zoption);
	zval_ptr_dtor(&zvalue);

	return ret;
	}


static int user_wrapper_stat_url(php_stream_wrapper wrapper, char url, int flags, php_stream_statbuf ssb, php_stream_context context TSRMLS_DC)	static int user_wrapper_stat_url(php_stream_wrapper wrapper, char url, int flags, php_stream_statbuf ssb, php_stream_context context TSRMLS_DC)
{	{
struct php_user_stream_wrapper uwrap = (struct php_user_stream_wrapper)wrapper->abstract;	struct php_user_stream_wrapper uwrap = (struct php_user_stream_wrapper)wrapper->abstract;
zval zfilename, zfuncname, zretval, zflags;	zval zfilename, zfuncname, zretval, zflags;
zval **args[2];	zval **args[2];
int call_result;	int call_result;
zval *object;	zval *object;
int ret = -1;	int ret = -1;

/* create an instance of our class */	/* create an instance of our class */
ALLOC_ZVAL(object);	object = user_stream_create_object(uwrap, context TSRMLS_CC);
object_init_ex(object, uwrap->ce);	if(object == NULL) {
Z_SET_REFCOUNT_P(object, 1);	return ret;
Z_SET_ISREF_P(object);

if (context) {
add_property_resource(object, "context", context->rsrc_id);
zend_list_addref(context->rsrc_id);
} else {
add_property_null(object, "context");
}	}

/* call it's stat_url method - set up params first */	/* call it's stat_url method - set up params first */
Line 1350 static int user_wrapper_stat_url(php_stream_wrapper *w	Line 1470 static int user_wrapper_stat_url(php_stream_wrapper *w

MAKE_STD_ZVAL(zfuncname);	MAKE_STD_ZVAL(zfuncname);
ZVAL_STRING(zfuncname, USERSTREAM_STATURL, 1);	ZVAL_STRING(zfuncname, USERSTREAM_STATURL, 1);

call_result = call_user_function_ex(NULL,	call_result = call_user_function_ex(NULL,
&object,	&object,
zfuncname,	zfuncname,
&zretval,	&zretval,
2, args,	2, args,
0, NULL TSRMLS_CC);	0, NULL TSRMLS_CC);

if (call_result == SUCCESS && zretval != NULL && Z_TYPE_P(zretval) == IS_ARRAY) {	if (call_result == SUCCESS && zretval != NULL && Z_TYPE_P(zretval) == IS_ARRAY) {
/* We got the info we needed */	/* We got the info we needed */
if (SUCCESS == statbuf_from_array(zretval, ssb TSRMLS_CC))	if (SUCCESS == statbuf_from_array(zretval, ssb TSRMLS_CC))
Line 1368 static int user_wrapper_stat_url(php_stream_wrapper *w	Line 1488 static int user_wrapper_stat_url(php_stream_wrapper *w
uwrap->classname);	uwrap->classname);
}	}
}	}

/* clean up */	/* clean up */
zval_ptr_dtor(&object);	zval_ptr_dtor(&object);
if (zretval)	if (zretval)
zval_ptr_dtor(&zretval);	zval_ptr_dtor(&zretval);

zval_ptr_dtor(&zfuncname);	zval_ptr_dtor(&zfuncname);
zval_ptr_dtor(&zfilename);	zval_ptr_dtor(&zfilename);
zval_ptr_dtor(&zflags);	zval_ptr_dtor(&zflags);

return ret;	return ret;

}	}
Line 1427 static int php_userstreamop_closedir(php_stream *strea	Line 1547 static int php_userstreamop_closedir(php_stream *strea
php_userstream_data_t us = (php_userstream_data_t )stream->abstract;	php_userstream_data_t us = (php_userstream_data_t )stream->abstract;

assert(us != NULL);	assert(us != NULL);

ZVAL_STRINGL(&func_name, USERSTREAM_DIR_CLOSE, sizeof(USERSTREAM_DIR_CLOSE)-1, 0);	ZVAL_STRINGL(&func_name, USERSTREAM_DIR_CLOSE, sizeof(USERSTREAM_DIR_CLOSE)-1, 0);

call_user_function_ex(NULL,	call_user_function_ex(NULL,
&us->object,	&us->object,
&func_name,	&func_name,
Line 1438 static int php_userstreamop_closedir(php_stream *strea	Line 1558 static int php_userstreamop_closedir(php_stream *strea

if (retval)	if (retval)
zval_ptr_dtor(&retval);	zval_ptr_dtor(&retval);

zval_ptr_dtor(&us->object);	zval_ptr_dtor(&us->object);

efree(us);	efree(us);

return 0;	return 0;
}	}

Line 1453 static int php_userstreamop_rewinddir(php_stream *stre	Line 1573 static int php_userstreamop_rewinddir(php_stream *stre
php_userstream_data_t us = (php_userstream_data_t )stream->abstract;	php_userstream_data_t us = (php_userstream_data_t )stream->abstract;

ZVAL_STRINGL(&func_name, USERSTREAM_DIR_REWIND, sizeof(USERSTREAM_DIR_REWIND)-1, 0);	ZVAL_STRINGL(&func_name, USERSTREAM_DIR_REWIND, sizeof(USERSTREAM_DIR_REWIND)-1, 0);

call_user_function_ex(NULL,	call_user_function_ex(NULL,
&us->object,	&us->object,
&func_name,	&func_name,
Line 1462 static int php_userstreamop_rewinddir(php_stream *stre	Line 1582 static int php_userstreamop_rewinddir(php_stream *stre

if (retval)	if (retval)
zval_ptr_dtor(&retval);	zval_ptr_dtor(&retval);

return 0;	return 0;

}	}
Line 1537 php_stream_ops php_stream_userspace_ops = {	Line 1657 php_stream_ops php_stream_userspace_ops = {
"user-space",	"user-space",
php_userstreamop_seek,	php_userstreamop_seek,
php_userstreamop_cast,	php_userstreamop_cast,
php_userstreamop_stat,	php_userstreamop_stat,
php_userstreamop_set_option,	php_userstreamop_set_option,
};	};

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1.1.1
changed lines
	Added in v.1.1.1.4