Back to index

php5  5.3.10
Classes | Defines | Typedefs | Functions | Variables
userspace.c File Reference
#include "php.h"
#include "php_globals.h"
#include "ext/standard/file.h"
#include "ext/standard/flock_compat.h"

Go to the source code of this file.

Classes

struct  php_user_stream_wrapper
struct  _php_userstream_data

Defines

#define USERSTREAM_OPEN   "stream_open"
#define USERSTREAM_CLOSE   "stream_close"
#define USERSTREAM_READ   "stream_read"
#define USERSTREAM_WRITE   "stream_write"
#define USERSTREAM_FLUSH   "stream_flush"
#define USERSTREAM_SEEK   "stream_seek"
#define USERSTREAM_TELL   "stream_tell"
#define USERSTREAM_EOF   "stream_eof"
#define USERSTREAM_STAT   "stream_stat"
#define USERSTREAM_STATURL   "url_stat"
#define USERSTREAM_UNLINK   "unlink"
#define USERSTREAM_RENAME   "rename"
#define USERSTREAM_MKDIR   "mkdir"
#define USERSTREAM_RMDIR   "rmdir"
#define USERSTREAM_DIR_OPEN   "dir_opendir"
#define USERSTREAM_DIR_READ   "dir_readdir"
#define USERSTREAM_DIR_REWIND   "dir_rewinddir"
#define USERSTREAM_DIR_CLOSE   "dir_closedir"
#define USERSTREAM_LOCK   "stream_lock"
#define USERSTREAM_CAST   "stream_cast"
#define USERSTREAM_SET_OPTION   "stream_set_option"
#define STAT_PROP_ENTRY_EX(name, name2)
#define STAT_PROP_ENTRY(name)   STAT_PROP_ENTRY_EX(name,name)

Typedefs

typedef struct _php_userstream_data

Functions

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 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_unlink (php_stream_wrapper *wrapper, char *url, 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_rmdir (php_stream_wrapper *wrapper, char *url, int options, php_stream_context *context TSRMLS_DC)
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)
static void stream_wrapper_dtor (zend_rsrc_list_entry *rsrc TSRMLS_DC)
 PHP_MINIT_FUNCTION (user_streams)
 PHP_FUNCTION (stream_wrapper_register)
 PHP_FUNCTION (stream_wrapper_unregister)
 PHP_FUNCTION (stream_wrapper_restore)
static size_t php_userstreamop_write (php_stream *stream, const char *buf, size_t count TSRMLS_DC)
static size_t php_userstreamop_read (php_stream *stream, char *buf, size_t count TSRMLS_DC)
static int php_userstreamop_close (php_stream *stream, int close_handle TSRMLS_DC)
static int php_userstreamop_flush (php_stream *stream TSRMLS_DC)
static int php_userstreamop_seek (php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
static int statbuf_from_array (zval *array, php_stream_statbuf *ssb TSRMLS_DC)
static int php_userstreamop_stat (php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC)
static int php_userstreamop_set_option (php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC)
static size_t php_userstreamop_readdir (php_stream *stream, char *buf, size_t count TSRMLS_DC)
static int php_userstreamop_closedir (php_stream *stream, int close_handle TSRMLS_DC)
static int php_userstreamop_rewinddir (php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
static int php_userstreamop_cast (php_stream *stream, int castas, void **retptr TSRMLS_DC)

Variables

static int le_protocols
static php_stream_wrapper_ops user_stream_wops
php_stream_ops php_stream_userspace_ops
php_stream_ops php_stream_userspace_dir_ops

Class Documentation

struct php_user_stream_wrapper

Definition at line 32 of file userspace.c.

Class Members
zend_class_entry * ce
char * classname
char * protoname
php_stream_wrapper wrapper
struct _php_userstream_data

Definition at line 105 of file userspace.c.

Collaboration diagram for _php_userstream_data:
Class Members
zval * object
struct php_user_stream_wrapper * wrapper

Define Documentation

#define STAT_PROP_ENTRY (   name)    STAT_PROP_ENTRY_EX(name,name)
#define STAT_PROP_ENTRY_EX (   name,
  name2 
)
Value:
if (SUCCESS == zend_hash_find(Z_ARRVAL_P(array), #name, sizeof(#name), (void**)&elem)) {     \
              SEPARATE_ZVAL(elem);                                                                                                                  \
              convert_to_long(*elem);                                                                   \
              ssb->sb.st_##name2 = Z_LVAL_PP(elem);                                                      \
       }
#define USERSTREAM_CAST   "stream_cast"

Definition at line 131 of file userspace.c.

#define USERSTREAM_CLOSE   "stream_close"

Definition at line 113 of file userspace.c.

#define USERSTREAM_DIR_CLOSE   "dir_closedir"

Definition at line 129 of file userspace.c.

#define USERSTREAM_DIR_OPEN   "dir_opendir"

Definition at line 126 of file userspace.c.

#define USERSTREAM_DIR_READ   "dir_readdir"

Definition at line 127 of file userspace.c.

#define USERSTREAM_DIR_REWIND   "dir_rewinddir"

Definition at line 128 of file userspace.c.

#define USERSTREAM_EOF   "stream_eof"

Definition at line 119 of file userspace.c.

#define USERSTREAM_FLUSH   "stream_flush"

Definition at line 116 of file userspace.c.

#define USERSTREAM_LOCK   "stream_lock"

Definition at line 130 of file userspace.c.

#define USERSTREAM_MKDIR   "mkdir"

Definition at line 124 of file userspace.c.

#define USERSTREAM_OPEN   "stream_open"

Definition at line 112 of file userspace.c.

#define USERSTREAM_READ   "stream_read"

Definition at line 114 of file userspace.c.

#define USERSTREAM_RENAME   "rename"

Definition at line 123 of file userspace.c.

#define USERSTREAM_RMDIR   "rmdir"

Definition at line 125 of file userspace.c.

#define USERSTREAM_SEEK   "stream_seek"

Definition at line 117 of file userspace.c.

#define USERSTREAM_SET_OPTION   "stream_set_option"

Definition at line 132 of file userspace.c.

#define USERSTREAM_STAT   "stream_stat"

Definition at line 120 of file userspace.c.

#define USERSTREAM_STATURL   "url_stat"

Definition at line 121 of file userspace.c.

#define USERSTREAM_TELL   "stream_tell"

Definition at line 118 of file userspace.c.

#define USERSTREAM_UNLINK   "unlink"

Definition at line 122 of file userspace.c.

#define USERSTREAM_WRITE   "stream_write"

Definition at line 115 of file userspace.c.


Typedef Documentation

typedef struct _php_userstream_data

Definition at line 109 of file userspace.c.


Function Documentation

PHP_FUNCTION ( stream_wrapper_register  )

Definition at line 491 of file userspace.c.

{
       char *protocol, *classname;
       int protocol_len, classname_len;
       struct php_user_stream_wrapper * uwrap;
       int rsrc_id;
       long flags = 0;
       
       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", &protocol, &protocol_len, &classname, &classname_len, &flags) == FAILURE) {
              RETURN_FALSE;
       }
       
       uwrap = (struct php_user_stream_wrapper *)ecalloc(1, sizeof(*uwrap));
       uwrap->protoname = estrndup(protocol, protocol_len);
       uwrap->classname = estrndup(classname, classname_len);
       uwrap->wrapper.wops = &user_stream_wops;
       uwrap->wrapper.abstract = uwrap;
       uwrap->wrapper.is_url = ((flags & PHP_STREAM_IS_URL) != 0);

       rsrc_id = ZEND_REGISTER_RESOURCE(NULL, uwrap, le_protocols);

       if (zend_lookup_class(uwrap->classname, classname_len, (zend_class_entry***)&uwrap->ce TSRMLS_CC) == SUCCESS) {
              uwrap->ce = *(zend_class_entry**)uwrap->ce;
              if (php_register_url_stream_wrapper_volatile(protocol, &uwrap->wrapper TSRMLS_CC) == SUCCESS) {
                     RETURN_TRUE;
              } else {
                     /* We failed.  But why? */
                     if (zend_hash_exists(php_stream_get_url_stream_wrappers_hash(), protocol, protocol_len + 1)) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Protocol %s:// is already defined.", protocol);
                     } else {
                            /* Hash doesn't exist so it must have been an invalid protocol scheme */
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid protocol scheme specified. Unable to register wrapper class %s to %s://", classname, protocol);
                     }
              }
       } else {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "class '%s' is undefined", classname);
       }

       zend_list_delete(rsrc_id);
       RETURN_FALSE;
}

Here is the call graph for this function:

PHP_FUNCTION ( stream_wrapper_unregister  )

Definition at line 536 of file userspace.c.

{
       char *protocol;
       int protocol_len;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &protocol, &protocol_len) == FAILURE) {
              RETURN_FALSE;
       }

       if (php_unregister_url_stream_wrapper_volatile(protocol TSRMLS_CC) == FAILURE) {
              /* We failed */
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to unregister protocol %s://", protocol);
              RETURN_FALSE;
       }

       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( stream_wrapper_restore  )

Definition at line 557 of file userspace.c.

{
       char *protocol;
       int protocol_len;
       php_stream_wrapper **wrapperpp = NULL, *wrapper;
       HashTable *global_wrapper_hash;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &protocol, &protocol_len) == FAILURE) {
              RETURN_FALSE;
       }

       global_wrapper_hash = php_stream_get_url_stream_wrappers_hash_global();
       if (php_stream_get_url_stream_wrappers_hash() == global_wrapper_hash) {
              php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s:// was never changed, nothing to restore", protocol);
              RETURN_TRUE;
       }

       if ((zend_hash_find(global_wrapper_hash, protocol, protocol_len + 1, (void**)&wrapperpp) == FAILURE) || !wrapperpp) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s:// never existed, nothing to restore", protocol);
              RETURN_FALSE;
       }

       /* next line might delete the pointer that wrapperpp points at, so deref it now */
       wrapper = *wrapperpp;

       /* A failure here could be okay given that the protocol might have been merely unregistered */
       php_unregister_url_stream_wrapper_volatile(protocol TSRMLS_CC);

       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);
              RETURN_FALSE;
       }      

       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_MINIT_FUNCTION ( user_streams  )

Definition at line 72 of file userspace.c.

{
       le_protocols = zend_register_list_destructors_ex(stream_wrapper_dtor, NULL, "stream factory", 0);
       if (le_protocols == FAILURE)
              return FAILURE;

       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_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_MUST_SEEK",                     STREAM_MUST_SEEK, CONST_CS|CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("STREAM_URL_STAT_LINK",          PHP_STREAM_URL_STAT_LINK,          CONST_CS|CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("STREAM_URL_STAT_QUIET",  PHP_STREAM_URL_STAT_QUIET,         CONST_CS|CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("STREAM_MKDIR_RECURSIVE", PHP_STREAM_MKDIR_RECURSIVE,        CONST_CS|CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("STREAM_IS_URL",   PHP_STREAM_IS_URL,          CONST_CS|CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("STREAM_OPTION_BLOCKING", PHP_STREAM_OPTION_BLOCKING,        CONST_CS|CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("STREAM_OPTION_READ_TIMEOUT",    PHP_STREAM_OPTION_READ_TIMEOUT,           CONST_CS|CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("STREAM_OPTION_READ_BUFFER",     PHP_STREAM_OPTION_READ_BUFFER,            CONST_CS|CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("STREAM_OPTION_WRITE_BUFFER",    PHP_STREAM_OPTION_WRITE_BUFFER,           CONST_CS|CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("STREAM_BUFFER_NONE",            PHP_STREAM_BUFFER_NONE,                   CONST_CS|CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("STREAM_BUFFER_LINE",            PHP_STREAM_BUFFER_LINE,                   CONST_CS|CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("STREAM_BUFFER_FULL",            PHP_STREAM_BUFFER_FULL,                   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);

       return SUCCESS;
}

Here is the call graph for this function:

static int php_userstreamop_cast ( php_stream *  stream,
int  castas,
void **retptr  TSRMLS_DC 
) [static]

Definition at line 1470 of file userspace.c.

{
       php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
       zval func_name;
       zval *retval = NULL;
       zval *zcastas = NULL;
       zval **args[1];
       php_stream * intstream = NULL;
       int call_result;
       int ret = FAILURE;

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

       ALLOC_INIT_ZVAL(zcastas);
       switch(castas) {
       case PHP_STREAM_AS_FD_FOR_SELECT:
              ZVAL_LONG(zcastas, PHP_STREAM_AS_FD_FOR_SELECT);
              break;
       default:
              ZVAL_LONG(zcastas, PHP_STREAM_AS_STDIO);
              break;
       }
       args[0] = &zcastas;

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

       do {
              if (call_result == FAILURE) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_CAST " is not implemented!",
                                   us->wrapper->classname);
                     break;
              }
              if (retval == NULL || !zend_is_true(retval)) {
                     break;
              }
              php_stream_from_zval_no_verify(intstream, &retval);
              if (!intstream) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_CAST " must return a stream resource",
                                   us->wrapper->classname);
                     break;
              }
              if (intstream == stream) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_CAST " must not return itself",
                                   us->wrapper->classname);
                     intstream = NULL;
                     break;
              }
              ret = php_stream_cast(intstream, castas, retptr, 1);
       } while (0);

       if (retval) {
              zval_ptr_dtor(&retval);
       }
       if (zcastas) {
              zval_ptr_dtor(&zcastas);
       }

       return ret;
}

Here is the call graph for this function:

static int php_userstreamop_close ( php_stream *  stream,
int close_handle  TSRMLS_DC 
) [static]

Definition at line 717 of file userspace.c.

{
       zval func_name;
       zval *retval = NULL;
       php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;

       assert(us != NULL);
       
       ZVAL_STRINGL(&func_name, USERSTREAM_CLOSE, sizeof(USERSTREAM_CLOSE)-1, 0);
       
       call_user_function_ex(NULL,
                     &us->object,
                     &func_name,
                     &retval,
                     0, NULL, 0, NULL TSRMLS_CC);

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

       efree(us);
       
       return 0;
}

Here is the call graph for this function:

static int php_userstreamop_closedir ( php_stream *  stream,
int close_handle  TSRMLS_DC 
) [static]

Definition at line 1423 of file userspace.c.

{
       zval func_name;
       zval *retval = NULL;
       php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;

       assert(us != NULL);
       
       ZVAL_STRINGL(&func_name, USERSTREAM_DIR_CLOSE, sizeof(USERSTREAM_DIR_CLOSE)-1, 0);
       
       call_user_function_ex(NULL,
                     &us->object,
                     &func_name,
                     &retval,
                     0, NULL, 0, NULL TSRMLS_CC);

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

       efree(us);
       
       return 0;
}

Here is the call graph for this function:

static int php_userstreamop_flush ( php_stream *stream  TSRMLS_DC) [static]

Definition at line 743 of file userspace.c.

{
       zval func_name;
       zval *retval = NULL;
       int call_result;
       php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;

       assert(us != NULL);

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

       if (call_result == SUCCESS && retval != NULL && zval_is_true(retval))
              call_result = 0;
       else
              call_result = -1;
       
       if (retval)
              zval_ptr_dtor(&retval);
       
       return call_result;
}

Here is the call graph for this function:

static size_t php_userstreamop_read ( php_stream *  stream,
char *  buf,
size_t count  TSRMLS_DC 
) [static]

Definition at line 643 of file userspace.c.

{
       zval func_name;
       zval *retval = NULL;
       zval **args[1];
       int call_result;
       size_t didread = 0;
       php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
       zval *zcount;

       assert(us != NULL);

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

       MAKE_STD_ZVAL(zcount);
       ZVAL_LONG(zcount, count);
       args[0] = &zcount;

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

       if (call_result == SUCCESS && retval != NULL) {
              convert_to_string(retval);
              didread = Z_STRLEN_P(retval);
              if (didread > count) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_READ " - read %ld bytes more data than requested (%ld read, %ld max) - excess data will be lost",
                                   us->wrapper->classname, (long)(didread - count), (long)didread, (long)count);
                     didread = count;
              }
              if (didread > 0)
                     memcpy(buf, Z_STRVAL_P(retval), didread);
       } else if (call_result == FAILURE) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_READ " is not implemented!",
                            us->wrapper->classname);
       }
       zval_ptr_dtor(&zcount);

       if (retval) {
              zval_ptr_dtor(&retval);
              retval = NULL;
       }

       /* since the user stream has no way of setting the eof flag directly, we need to ask it if we hit eof */

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

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

       if (call_result == SUCCESS && retval != NULL && zval_is_true(retval)) {
              stream->eof = 1;
       } else if (call_result == FAILURE) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING,
                            "%s::" USERSTREAM_EOF " is not implemented! Assuming EOF",
                            us->wrapper->classname);

              stream->eof = 1;
       }

       if (retval) {
              zval_ptr_dtor(&retval);
              retval = NULL;
       }

       return didread;
}

Here is the call graph for this function:

static size_t php_userstreamop_readdir ( php_stream *  stream,
char *  buf,
size_t count  TSRMLS_DC 
) [static]

Definition at line 1385 of file userspace.c.

{
       zval func_name;
       zval *retval = NULL;
       int call_result;
       size_t didread = 0;
       php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
       php_stream_dirent *ent = (php_stream_dirent*)buf;

       /* avoid problems if someone mis-uses the stream */
       if (count != sizeof(php_stream_dirent))
              return 0;

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

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

       if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) != IS_BOOL) {
              convert_to_string(retval);
              PHP_STRLCPY(ent->d_name, Z_STRVAL_P(retval), sizeof(ent->d_name), Z_STRLEN_P(retval));

              didread = sizeof(php_stream_dirent);
       } else if (call_result == FAILURE) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_DIR_READ " is not implemented!",
                            us->wrapper->classname);
       }

       if (retval)
              zval_ptr_dtor(&retval);

       return didread;
}

Here is the call graph for this function:

static int php_userstreamop_rewinddir ( php_stream *  stream,
off_t  offset,
int  whence,
off_t *newoffs  TSRMLS_DC 
) [static]

Definition at line 1449 of file userspace.c.

{
       zval func_name;
       zval *retval = NULL;
       php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;

       ZVAL_STRINGL(&func_name, USERSTREAM_DIR_REWIND, sizeof(USERSTREAM_DIR_REWIND)-1, 0);
       
       call_user_function_ex(NULL,
                     &us->object,
                     &func_name,
                     &retval,
                     0, NULL, 0, NULL TSRMLS_CC);

       if (retval)
              zval_ptr_dtor(&retval);
       
       return 0;

}

Here is the call graph for this function:

static int php_userstreamop_seek ( php_stream *  stream,
off_t  offset,
int  whence,
off_t *newoffs  TSRMLS_DC 
) [static]

Definition at line 771 of file userspace.c.

{
       zval func_name;
       zval *retval = NULL;
       int call_result, ret;
       php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
       zval **args[2];
       zval *zoffs, *zwhence;

       assert(us != NULL);

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

       MAKE_STD_ZVAL(zoffs);
       ZVAL_LONG(zoffs, offset);
       args[0] = &zoffs;

       MAKE_STD_ZVAL(zwhence);
       ZVAL_LONG(zwhence, whence);
       args[1] = &zwhence;

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

       zval_ptr_dtor(&zoffs);
       zval_ptr_dtor(&zwhence);

       if (call_result == FAILURE) {
              /* stream_seek is not implemented, so disable seeks for this stream */
              stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
              /* there should be no retval to clean up */
              
              if (retval) 
                     zval_ptr_dtor(&retval);
              
              return -1;
       } else if (call_result == SUCCESS && retval != NULL && zval_is_true(retval)) {
              ret = 0;
       } else {
              ret = -1;
       }

       if (retval) {
              zval_ptr_dtor(&retval);
              retval = NULL;
       }

       if (ret) {
              return ret;
       }

       /* now determine where we are */
       ZVAL_STRINGL(&func_name, USERSTREAM_TELL, sizeof(USERSTREAM_TELL)-1, 0);

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

       if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_LONG) {
              *newoffs = Z_LVAL_P(retval);
              ret = 0;
       } else if (call_result == FAILURE) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_TELL " is not implemented!", us->wrapper->classname);
              ret = -1;
       } else {
              ret = -1;
       }

       if (retval) {
              zval_ptr_dtor(&retval);
       }
       return ret;
}

Here is the call graph for this function:

static int php_userstreamop_set_option ( php_stream *  stream,
int  option,
int  value,
void *ptrparam  TSRMLS_DC 
) [static]

Definition at line 931 of file userspace.c.

                                                                                                            {
       zval func_name;
       zval *retval = NULL;
       int call_result;
       php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
       int ret = -1;
       zval *zvalue = NULL;
       zval **args[3];

       switch (option) {
       case PHP_STREAM_OPTION_CHECK_LIVENESS:
              ZVAL_STRINGL(&func_name, USERSTREAM_EOF, sizeof(USERSTREAM_EOF)-1, 0);
              call_result = call_user_function_ex(NULL, &us->object, &func_name, &retval, 0, NULL, 0, NULL TSRMLS_CC);
              if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_BOOL) {
                     ret = zval_is_true(retval) ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
              } else {
                     ret = PHP_STREAM_OPTION_RETURN_ERR;
                     php_error_docref(NULL TSRMLS_CC, E_WARNING,
                                   "%s::" USERSTREAM_EOF " is not implemented! Assuming EOF",
                                   us->wrapper->classname);
              }
              break;

       case PHP_STREAM_OPTION_LOCKING:
              MAKE_STD_ZVAL(zvalue);
              ZVAL_LONG(zvalue, 0);

              if (value & LOCK_NB) {
                     Z_LVAL_P(zvalue) |= PHP_LOCK_NB;
              }
              switch(value & ~LOCK_NB) {
              case LOCK_SH:
                     Z_LVAL_P(zvalue) |= PHP_LOCK_SH;
                     break;
              case LOCK_EX:
                     Z_LVAL_P(zvalue) |= PHP_LOCK_EX;
                     break;
              case LOCK_UN:
                     Z_LVAL_P(zvalue) |= PHP_LOCK_UN;
                     break;
              }

              args[0] = &zvalue;
              
              /* TODO wouldblock */
              ZVAL_STRINGL(&func_name, USERSTREAM_LOCK, sizeof(USERSTREAM_LOCK)-1, 0);
              
              call_result = call_user_function_ex(NULL,
                                                                             &us->object,
                                                                             &func_name,
                                                                             &retval,
                                                                             1, args, 0, NULL TSRMLS_CC);
              
              if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_BOOL) {
                     ret = !Z_LVAL_P(retval);
              } else if (call_result == FAILURE) {
                     if (value == 0) { 
                            /* lock support test (TODO: more check) */
                            ret = 0;
                     } else {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_LOCK " is not implemented!", 
                                                         us->wrapper->classname);
                     }
              }

              break;
       
       case PHP_STREAM_OPTION_READ_BUFFER:
       case PHP_STREAM_OPTION_WRITE_BUFFER:
       case PHP_STREAM_OPTION_READ_TIMEOUT:
       case PHP_STREAM_OPTION_BLOCKING: {
              zval *zoption = NULL;
              zval *zptrparam = NULL;
              
              ZVAL_STRINGL(&func_name, USERSTREAM_SET_OPTION, sizeof(USERSTREAM_SET_OPTION)-1, 0);

              ALLOC_INIT_ZVAL(zoption);
              ZVAL_LONG(zoption, option);

              ALLOC_INIT_ZVAL(zvalue);
              ALLOC_INIT_ZVAL(zptrparam);

              args[0] = &zoption;
              args[1] = &zvalue;
              args[2] = &zptrparam;

              switch(option) {
              case PHP_STREAM_OPTION_READ_BUFFER:
              case PHP_STREAM_OPTION_WRITE_BUFFER:
                     ZVAL_LONG(zvalue, value);
                     if (ptrparam) {
                            ZVAL_LONG(zptrparam, *(long *)ptrparam);
                     } else {
                            ZVAL_LONG(zptrparam, BUFSIZ);
                     }
                     break;
              case PHP_STREAM_OPTION_READ_TIMEOUT: {
                     struct timeval tv = *(struct timeval*)ptrparam;
                     ZVAL_LONG(zvalue, tv.tv_sec);
                     ZVAL_LONG(zptrparam, tv.tv_usec);
                     break;
                     }
              case PHP_STREAM_OPTION_BLOCKING:
                     ZVAL_LONG(zvalue, value);
                     break;
              default:
                     break;
              }

              call_result = call_user_function_ex(NULL,
                     &us->object,
                     &func_name,
                     &retval,
                     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 (zoption) {
                     zval_ptr_dtor(&zoption);
              }
              if (zptrparam) {
                     zval_ptr_dtor(&zptrparam);
              }

              break;
              }
       }

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

       if (zvalue) {
              zval_ptr_dtor(&zvalue);
       }

       return ret;
}

Here is the call graph for this function:

static int php_userstreamop_stat ( php_stream *  stream,
php_stream_statbuf *ssb  TSRMLS_DC 
) [static]

Definition at line 898 of file userspace.c.

{
       zval func_name;
       zval *retval = NULL;
       int call_result;
       php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
       int ret = -1;

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

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

       if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_ARRAY) {
              if (SUCCESS == statbuf_from_array(retval, ssb TSRMLS_CC))
                     ret = 0;
       } else {
              if (call_result == FAILURE) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_STAT " is not implemented!",
                                   us->wrapper->classname);
              }
       }

       if (retval) 
              zval_ptr_dtor(&retval);
       
       return ret;
}

Here is the call graph for this function:

static size_t php_userstreamop_write ( php_stream *  stream,
const char *  buf,
size_t count  TSRMLS_DC 
) [static]

Definition at line 594 of file userspace.c.

{
       zval func_name;
       zval *retval = NULL;
       int call_result;
       php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
       zval **args[1];
       zval *zbufptr;
       size_t didwrite = 0;

       assert(us != NULL);

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

       MAKE_STD_ZVAL(zbufptr);
       ZVAL_STRINGL(zbufptr, (char*)buf, count, 1);;
       args[0] = &zbufptr;

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

       didwrite = 0;
       if (call_result == SUCCESS && retval != NULL) {
              convert_to_long(retval);
              didwrite = Z_LVAL_P(retval);
       } else if (call_result == FAILURE) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_WRITE " is not implemented!",
                            us->wrapper->classname);
       }

       /* don't allow strange buffer overruns due to bogus return */
       if (didwrite > count) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_WRITE " wrote %ld bytes more data than requested (%ld written, %ld max)",
                            us->wrapper->classname,
                            (long)(didwrite - count), (long)didwrite, (long)count);
              didwrite = count;
       }
       
       if (retval)
              zval_ptr_dtor(&retval);
       
       return didwrite;
}

Here is the call graph for this function:

static int statbuf_from_array ( zval *  array,
php_stream_statbuf *ssb  TSRMLS_DC 
) [static]

Definition at line 853 of file userspace.c.

{
       zval **elem;

#define STAT_PROP_ENTRY_EX(name, name2)                        \
       if (SUCCESS == zend_hash_find(Z_ARRVAL_P(array), #name, sizeof(#name), (void**)&elem)) {     \
              SEPARATE_ZVAL(elem);                                                                                                                  \
              convert_to_long(*elem);                                                                   \
              ssb->sb.st_##name2 = Z_LVAL_PP(elem);                                                      \
       }

#define STAT_PROP_ENTRY(name) STAT_PROP_ENTRY_EX(name,name)

       memset(ssb, 0, sizeof(php_stream_statbuf));
       STAT_PROP_ENTRY(dev);
       STAT_PROP_ENTRY(ino);
       STAT_PROP_ENTRY(mode);
       STAT_PROP_ENTRY(nlink);
       STAT_PROP_ENTRY(uid);
       STAT_PROP_ENTRY(gid);
#if HAVE_ST_RDEV
       STAT_PROP_ENTRY(rdev);
#endif
       STAT_PROP_ENTRY(size);
#ifdef NETWARE
       STAT_PROP_ENTRY_EX(atime, atime.tv_sec);
       STAT_PROP_ENTRY_EX(mtime, mtime.tv_sec);
       STAT_PROP_ENTRY_EX(ctime, ctime.tv_sec);
#else
       STAT_PROP_ENTRY(atime);
       STAT_PROP_ENTRY(mtime);
       STAT_PROP_ENTRY(ctime);
#endif
#ifdef HAVE_ST_BLKSIZE
       STAT_PROP_ENTRY(blksize);
#endif
#ifdef HAVE_ST_BLOCKS
       STAT_PROP_ENTRY(blocks);
#endif

#undef STAT_PROP_ENTRY      
#undef STAT_PROP_ENTRY_EX   
       return SUCCESS;
}

Here is the caller graph for this function:

static void stream_wrapper_dtor ( zend_rsrc_list_entry *rsrc  TSRMLS_DC) [static]

Definition at line 62 of file userspace.c.

{
       struct php_user_stream_wrapper * uwrap = (struct php_user_stream_wrapper*)rsrc->ptr;

       efree(uwrap->protoname);
       efree(uwrap->classname);
       efree(uwrap);
}

Here is the caller graph for this function:

static int user_wrapper_mkdir ( php_stream_wrapper *  wrapper,
char *  url,
int  mode,
int  options,
php_stream_context *context  TSRMLS_DC 
) [static]

Definition at line 1195 of file userspace.c.

{
       struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
       zval *zfilename, *zmode, *zoptions, *zfuncname, *zretval;
       zval **args[3];
       int call_result;
       zval *object;
       int ret = 0;

       /* create an instance of our class */
       ALLOC_ZVAL(object);
       object_init_ex(object, uwrap->ce);
       Z_SET_REFCOUNT_P(object, 1);
       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 */
       MAKE_STD_ZVAL(zfilename);
       ZVAL_STRING(zfilename, url, 1);
       args[0] = &zfilename;

       MAKE_STD_ZVAL(zmode);
       ZVAL_LONG(zmode, mode);
       args[1] = &zmode;

       MAKE_STD_ZVAL(zoptions);
       ZVAL_LONG(zoptions, options);
       args[2] = &zoptions;

       MAKE_STD_ZVAL(zfuncname);
       ZVAL_STRING(zfuncname, USERSTREAM_MKDIR, 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_MKDIR " 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(&zmode);
       zval_ptr_dtor(&zoptions);

       return ret;
}

Here is the call graph for this function:

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 
) [static]

Definition at line 407 of file userspace.c.

{
       struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
       php_userstream_data_t *us;
       zval *zfilename, *zoptions, *zretval = NULL, *zfuncname;
       zval **args[2];      
       int call_result;
       php_stream *stream = NULL;

       /* 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;
       
       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 (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 */
       MAKE_STD_ZVAL(zfilename);
       ZVAL_STRING(zfilename, filename, 1);
       args[0] = &zfilename;

       MAKE_STD_ZVAL(zoptions);
       ZVAL_LONG(zoptions, options);
       args[1] = &zoptions;

       MAKE_STD_ZVAL(zfuncname);
       ZVAL_STRING(zfuncname, USERSTREAM_DIR_OPEN, 1);
       
       call_result = call_user_function_ex(NULL,
                     &us->object,
                     zfuncname,
                     &zretval,
                     2, args,
                     0, NULL       TSRMLS_CC);
       
       if (call_result == SUCCESS && zretval != NULL && zval_is_true(zretval)) {
              /* the stream is now open! */
              stream = php_stream_alloc_rel(&php_stream_userspace_dir_ops, us, 0, mode);

              /* set wrapper data to be a reference to our object */
              stream->wrapperdata = us->object;
              zval_add_ref(&stream->wrapperdata);
       } else {
              php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "\"%s::" USERSTREAM_DIR_OPEN "\" call failed",
                     us->wrapper->classname);
       }
       
       /* destroy everything else */
       if (stream == NULL) {
              zval_ptr_dtor(&us->object);
              efree(us);
       }
       if (zretval)
              zval_ptr_dtor(&zretval);
       
       zval_ptr_dtor(&zfuncname);
       zval_ptr_dtor(&zoptions);
       zval_ptr_dtor(&zfilename);

       FG(user_stream_current_filename) = NULL;
              
       return stream;
}

Here is the call graph for this function:

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]

Definition at line 261 of file userspace.c.

{
       struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
       php_userstream_data_t *us;
       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; 

       /* 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) {
              zend_fcall_info fci;
              zend_fcall_info_cache fcc;
              zval *retval_ptr;
              
              fci.size = sizeof(fci);
              fci.function_table = &uwrap->ce->function_table;
              fci.function_name = NULL;
              fci.symbol_table = NULL;
              fci.object_ptr = us->object;
              fci.retval_ptr_ptr = &retval_ptr;
              fci.param_count = 0;
              fci.params = NULL;
              fci.no_separation = 1;
              
              fcc.initialized = 1;
              fcc.function_handler = uwrap->ce->constructor;
              fcc.calling_scope = EG(scope);
              fcc.called_scope = Z_OBJCE_P(us->object);
              fcc.object_ptr = us->object;

              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);
                     zval_dtor(us->object);
                     FREE_ZVAL(us->object);
                     efree(us);
                     FG(user_stream_current_filename) = NULL;
                     PG(in_user_include) = old_in_user_include;
                     return NULL;
              } else {
                     if (retval_ptr) {
                            zval_ptr_dtor(&retval_ptr);
                     }
              }
       }

       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 stream_open method - set up params first */
       MAKE_STD_ZVAL(zfilename);
       ZVAL_STRING(zfilename, filename, 1);
       args[0] = &zfilename;

       MAKE_STD_ZVAL(zmode);
       ZVAL_STRING(zmode, mode, 1);
       args[1] = &zmode;

       MAKE_STD_ZVAL(zoptions);
       ZVAL_LONG(zoptions, options);
       args[2] = &zoptions;

       MAKE_STD_ZVAL(zopened);
       Z_SET_REFCOUNT_P(zopened, 1);
       Z_SET_ISREF_P(zopened);
       ZVAL_NULL(zopened);
       args[3] = &zopened;

       MAKE_STD_ZVAL(zfuncname);
       ZVAL_STRING(zfuncname, USERSTREAM_OPEN, 1);
       
       call_result = call_user_function_ex(NULL,
                     &us->object,
                     zfuncname,
                     &zretval,
                     4, args,
                     0, NULL       TSRMLS_CC);
       
       if (call_result == SUCCESS && zretval != NULL && zval_is_true(zretval)) {
              /* the stream is now open! */
              stream = php_stream_alloc_rel(&php_stream_userspace_ops, us, 0, mode);

              /* if the opened path is set, copy it out */
              if (Z_TYPE_P(zopened) == IS_STRING && opened_path) {
                     *opened_path = estrndup(Z_STRVAL_P(zopened), Z_STRLEN_P(zopened));
              }

              /* set wrapper data to be a reference to our object */
              stream->wrapperdata = us->object;
              zval_add_ref(&stream->wrapperdata);
       } else {
              php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "\"%s::" USERSTREAM_OPEN "\" call failed",
                     us->wrapper->classname);
       }
       
       /* destroy everything else */
       if (stream == NULL) {
              zval_ptr_dtor(&us->object);
              efree(us);
       }
       if (zretval)
              zval_ptr_dtor(&zretval);
       
       zval_ptr_dtor(&zfuncname);
       zval_ptr_dtor(&zopened);
       zval_ptr_dtor(&zoptions);
       zval_ptr_dtor(&zmode);
       zval_ptr_dtor(&zfilename);

       FG(user_stream_current_filename) = NULL;
              
       PG(in_user_include) = old_in_user_include;
       return stream;
}

Here is the call graph for this function:

static int user_wrapper_rename ( php_stream_wrapper *  wrapper,
char *  url_from,
char *  url_to,
int  options,
php_stream_context *context  TSRMLS_DC 
) [static]

Definition at line 1136 of file userspace.c.

{
       struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
       zval *zold_name, *znew_name, *zfuncname, *zretval;
       zval **args[2];
       int call_result;
       zval *object;
       int ret = 0;

       /* create an instance of our class */
       ALLOC_ZVAL(object);
       object_init_ex(object, uwrap->ce);
       Z_SET_REFCOUNT_P(object, 1);
       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 */
       MAKE_STD_ZVAL(zold_name);
       ZVAL_STRING(zold_name, url_from, 1);
       args[0] = &zold_name;

       MAKE_STD_ZVAL(znew_name);
       ZVAL_STRING(znew_name, url_to, 1);
       args[1] = &znew_name;

       MAKE_STD_ZVAL(zfuncname);
       ZVAL_STRING(zfuncname, USERSTREAM_RENAME, 1);
       
       call_result = call_user_function_ex(NULL,
                     &object,
                     zfuncname,
                     &zretval,
                     2, 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_RENAME " is not implemented!", uwrap->classname);
       }

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

       return ret;
}

Here is the call graph for this function:

static int user_wrapper_rmdir ( php_stream_wrapper *  wrapper,
char *  url,
int  options,
php_stream_context *context  TSRMLS_DC 
) [static]

Definition at line 1260 of file userspace.c.

{
       struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
       zval *zfilename, *zoptions, *zfuncname, *zretval;
       zval **args[3];
       int call_result;
       zval *object;
       int ret = 0;

       /* create an instance of our class */
       ALLOC_ZVAL(object);
       object_init_ex(object, uwrap->ce);
       Z_SET_REFCOUNT_P(object, 1);
       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 */
       MAKE_STD_ZVAL(zfilename);
       ZVAL_STRING(zfilename, url, 1);
       args[0] = &zfilename;

       MAKE_STD_ZVAL(zoptions);
       ZVAL_LONG(zoptions, options);
       args[1] = &zoptions;

       MAKE_STD_ZVAL(zfuncname);
       ZVAL_STRING(zfuncname, USERSTREAM_RMDIR, 1);
       
       call_result = call_user_function_ex(NULL,
                     &object,
                     zfuncname,
                     &zretval,
                     2, 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_RMDIR " 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(&zoptions);

       return ret;
}

Here is the call graph for this function:

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]

Definition at line 1320 of file userspace.c.

{
       struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
       zval *zfilename, *zfuncname, *zretval, *zflags;
       zval **args[2];      
       int call_result;
       zval *object;
       int ret = -1;

       /* create an instance of our class */
       ALLOC_ZVAL(object);
       object_init_ex(object, uwrap->ce);
       Z_SET_REFCOUNT_P(object, 1);
       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 */
       MAKE_STD_ZVAL(zfilename);
       ZVAL_STRING(zfilename, url, 1);
       args[0] = &zfilename;

       MAKE_STD_ZVAL(zflags);
       ZVAL_LONG(zflags, flags);
       args[1] = &zflags;

       MAKE_STD_ZVAL(zfuncname);
       ZVAL_STRING(zfuncname, USERSTREAM_STATURL, 1);
       
       call_result = call_user_function_ex(NULL,
                     &object,
                     zfuncname,
                     &zretval,
                     2, args,
                     0, NULL       TSRMLS_CC);
       
       if (call_result == SUCCESS && zretval != NULL && Z_TYPE_P(zretval) == IS_ARRAY) {
              /* We got the info we needed */
              if (SUCCESS == statbuf_from_array(zretval, ssb TSRMLS_CC))
                     ret = 0;
       } else {
              if (call_result == FAILURE) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_STATURL " 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(&zflags);
              
       return ret;

}

Here is the call graph for this function:

static int user_wrapper_unlink ( php_stream_wrapper *  wrapper,
char *  url,
int  options,
php_stream_context *context  TSRMLS_DC 
) [static]

Definition at line 1082 of file userspace.c.

{
       struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
       zval *zfilename, *zfuncname, *zretval;
       zval **args[1];
       int call_result;
       zval *object;
       int ret = 0;

       /* create an instance of our class */
       ALLOC_ZVAL(object);
       object_init_ex(object, uwrap->ce);
       Z_SET_REFCOUNT_P(object, 1);
       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 */
       MAKE_STD_ZVAL(zfilename);
       ZVAL_STRING(zfilename, url, 1);
       args[0] = &zfilename;

       MAKE_STD_ZVAL(zfuncname);
       ZVAL_STRING(zfuncname, USERSTREAM_UNLINK, 1);
       
       call_result = call_user_function_ex(NULL,
                     &object,
                     zfuncname,
                     &zretval,
                     1, 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_UNLINK " 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);

       return ret;
}

Here is the call graph for this function:


Variable Documentation

int le_protocols [static]

Definition at line 30 of file userspace.c.

Initial value:

Definition at line 1544 of file userspace.c.