Back to index

php5  5.3.10
Defines | Functions | Variables
streams.c File Reference
#include "php.h"
#include "php_globals.h"
#include "php_network.h"
#include "php_open_temporary_file.h"
#include "ext/standard/file.h"
#include "ext/standard/basic_functions.h"
#include "ext/standard/php_string.h"
#include <stddef.h>
#include <fcntl.h>
#include "php_streams_int.h"

Go to the source code of this file.

Defines

#define _GNU_SOURCE

Functions

PHPAPI int php_file_le_stream (void)
PHPAPI int php_file_le_pstream (void)
PHPAPI int php_file_le_stream_filter (void)
PHPAPI HashTable_php_stream_get_url_stream_wrappers_hash (TSRMLS_D)
PHPAPI HashTablephp_stream_get_url_stream_wrappers_hash_global (void)
static int _php_stream_release_context (zend_rsrc_list_entry *le, void *pContext TSRMLS_DC)
static int forget_persistent_resource_id_numbers (zend_rsrc_list_entry *rsrc TSRMLS_DC)
 PHP_RSHUTDOWN_FUNCTION (streams)
PHPAPI int php_stream_from_persistent_id (const char *persistent_id, php_stream **stream TSRMLS_DC)
void php_stream_display_wrapper_errors (php_stream_wrapper *wrapper, const char *path, const char *caption TSRMLS_DC)
void php_stream_tidy_wrapper_error_log (php_stream_wrapper *wrapper TSRMLS_DC)
PHPAPI void php_stream_wrapper_log_error (php_stream_wrapper *wrapper, int options TSRMLS_DC, const char *fmt,...)
PHPAPI php_stream * _php_stream_alloc (php_stream_ops *ops, void *abstract, const char *persistent_id, const char *mode STREAMS_DC TSRMLS_DC)
static int _php_stream_free_persistent (zend_rsrc_list_entry *le, void *pStream TSRMLS_DC)
PHPAPI int _php_stream_free (php_stream *stream, int close_options TSRMLS_DC)
static void php_stream_fill_read_buffer (php_stream *stream, size_t size TSRMLS_DC)
PHPAPI size_t _php_stream_read (php_stream *stream, char *buf, size_t size TSRMLS_DC)
PHPAPI int _php_stream_eof (php_stream *stream TSRMLS_DC)
PHPAPI int _php_stream_putc (php_stream *stream, int c TSRMLS_DC)
PHPAPI int _php_stream_getc (php_stream *stream TSRMLS_DC)
PHPAPI int _php_stream_puts (php_stream *stream, char *buf TSRMLS_DC)
PHPAPI int _php_stream_stat (php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC)
PHPAPI char * php_stream_locate_eol (php_stream *stream, char *buf, size_t buf_len TSRMLS_DC)
PHPAPI char * _php_stream_get_line (php_stream *stream, char *buf, size_t maxlen, size_t *returned_len TSRMLS_DC)
PHPAPI char * php_stream_get_record (php_stream *stream, size_t maxlen, size_t *returned_len, char *delim, size_t delim_len TSRMLS_DC)
static size_t _php_stream_write_buffer (php_stream *stream, const char *buf, size_t count TSRMLS_DC)
static size_t _php_stream_write_filtered (php_stream *stream, const char *buf, size_t count, int flags TSRMLS_DC)
PHPAPI int _php_stream_flush (php_stream *stream, int closing TSRMLS_DC)
PHPAPI size_t _php_stream_write (php_stream *stream, const char *buf, size_t count TSRMLS_DC)
PHPAPI size_t _php_stream_printf (php_stream *stream TSRMLS_DC, const char *fmt,...)
PHPAPI off_t _php_stream_tell (php_stream *stream TSRMLS_DC)
PHPAPI int _php_stream_seek (php_stream *stream, off_t offset, int whence TSRMLS_DC)
PHPAPI int _php_stream_set_option (php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC)
PHPAPI int _php_stream_truncate_set_size (php_stream *stream, size_t newsize TSRMLS_DC)
PHPAPI size_t _php_stream_passthru (php_stream *stream STREAMS_DC TSRMLS_DC)
PHPAPI size_t _php_stream_copy_to_mem (php_stream *src, char **buf, size_t maxlen, int persistent STREAMS_DC TSRMLS_DC)
PHPAPI size_t _php_stream_copy_to_stream_ex (php_stream *src, php_stream *dest, size_t maxlen, size_t *len STREAMS_DC TSRMLS_DC)
ZEND_ATTRIBUTE_DEPRECATED
PHPAPI size_t 
_php_stream_copy_to_stream (php_stream *src, php_stream *dest, size_t maxlen STREAMS_DC TSRMLS_DC)
static void stream_resource_regular_dtor (zend_rsrc_list_entry *rsrc TSRMLS_DC)
static void stream_resource_persistent_dtor (zend_rsrc_list_entry *rsrc TSRMLS_DC)
void php_shutdown_stream_hashes (TSRMLS_D)
int php_init_stream_wrappers (int module_number TSRMLS_DC)
int php_shutdown_stream_wrappers (int module_number TSRMLS_DC)
static int php_stream_wrapper_scheme_validate (char *protocol, int protocol_len)
PHPAPI int php_register_url_stream_wrapper (char *protocol, php_stream_wrapper *wrapper TSRMLS_DC)
PHPAPI int php_unregister_url_stream_wrapper (char *protocol TSRMLS_DC)
static void clone_wrapper_hash (TSRMLS_D)
PHPAPI int php_register_url_stream_wrapper_volatile (char *protocol, php_stream_wrapper *wrapper TSRMLS_DC)
PHPAPI int php_unregister_url_stream_wrapper_volatile (char *protocol TSRMLS_DC)
PHPAPI php_stream_wrapper * php_stream_locate_url_wrapper (const char *path, char **path_for_open, int options TSRMLS_DC)
PHPAPI int _php_stream_mkdir (char *path, int mode, int options, php_stream_context *context TSRMLS_DC)
PHPAPI int _php_stream_rmdir (char *path, int options, php_stream_context *context TSRMLS_DC)
PHPAPI int _php_stream_stat_path (char *path, int flags, php_stream_statbuf *ssb, php_stream_context *context TSRMLS_DC)
PHPAPI php_stream * _php_stream_opendir (char *path, int options, php_stream_context *context STREAMS_DC TSRMLS_DC)
PHPAPI php_stream_dirent_php_stream_readdir (php_stream *dirstream, php_stream_dirent *ent TSRMLS_DC)
PHPAPI php_stream * _php_stream_open_wrapper_ex (char *path, char *mode, int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC)
PHPAPI php_stream_context * php_stream_context_set (php_stream *stream, php_stream_context *context)
PHPAPI void php_stream_notification_notify (php_stream_context *context, int notifycode, int severity, char *xmsg, int xcode, size_t bytes_sofar, size_t bytes_max, void *ptr TSRMLS_DC)
PHPAPI void php_stream_context_free (php_stream_context *context)
PHPAPI php_stream_context * php_stream_context_alloc (void)
PHPAPI php_stream_notifier * php_stream_notification_alloc (void)
PHPAPI void php_stream_notification_free (php_stream_notifier *notifier)
PHPAPI int php_stream_context_get_option (php_stream_context *context, const char *wrappername, const char *optionname, zval ***optionvalue)
PHPAPI int php_stream_context_set_option (php_stream_context *context, const char *wrappername, const char *optionname, zval *optionvalue)
PHPAPI int php_stream_context_get_link (php_stream_context *context, const char *hostent, php_stream **stream)
PHPAPI int php_stream_context_set_link (php_stream_context *context, const char *hostent, php_stream *stream)
PHPAPI int php_stream_context_del_link (php_stream_context *context, php_stream *stream)
PHPAPI int php_stream_dirent_alphasort (const char **a, const char **b)
PHPAPI int php_stream_dirent_alphasortr (const char **a, const char **b)
PHPAPI int _php_stream_scandir (char *dirname, char **namelist[], int flags, php_stream_context *context, int(*compare)(const char **a, const char **b) TSRMLS_DC)

Variables

static HashTable url_stream_wrappers_hash
static int le_stream = FAILURE
static int le_pstream = FAILURE
static int le_stream_filter = FAILURE

Define Documentation

#define _GNU_SOURCE

Definition at line 24 of file streams.c.


Function Documentation

PHPAPI php_stream* _php_stream_alloc ( php_stream_ops ops,
void *  abstract,
const char *  persistent_id,
const char *mode STREAMS_DC  TSRMLS_DC 
)

Definition at line 260 of file streams.c.

{
       php_stream *ret;

       ret = (php_stream*) pemalloc_rel_orig(sizeof(php_stream), persistent_id ? 1 : 0);

       memset(ret, 0, sizeof(php_stream));

       ret->readfilters.stream = ret;
       ret->writefilters.stream = ret;

#if STREAM_DEBUG
fprintf(stderr, "stream_alloc: %s:%p persistent=%s\n", ops->label, ret, persistent_id);
#endif

       ret->ops = ops;
       ret->abstract = abstract;
       ret->is_persistent = persistent_id ? 1 : 0;
       ret->chunk_size = FG(def_chunk_size);

#if ZEND_DEBUG
       ret->open_filename = __zend_orig_filename ? __zend_orig_filename : __zend_filename;
       ret->open_lineno = __zend_orig_lineno ? __zend_orig_lineno : __zend_lineno;
#endif

       if (FG(auto_detect_line_endings)) {
              ret->flags |= PHP_STREAM_FLAG_DETECT_EOL;
       }

       if (persistent_id) {
              zend_rsrc_list_entry le;

              Z_TYPE(le) = le_pstream;
              le.ptr = ret;
              le.refcount = 0;

              if (FAILURE == zend_hash_update(&EG(persistent_list), (char *)persistent_id,
                                   strlen(persistent_id) + 1,
                                   (void *)&le, sizeof(le), NULL)) {

                     pefree(ret, 1);
                     return NULL;
              }
       }

       ret->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ret, persistent_id ? le_pstream : le_stream);
       strlcpy(ret->mode, mode, sizeof(ret->mode));

       return ret;
}

Here is the call graph for this function:

PHPAPI size_t _php_stream_copy_to_mem ( php_stream *  src,
char **  buf,
size_t  maxlen,
int persistent STREAMS_DC  TSRMLS_DC 
)

Definition at line 1282 of file streams.c.

{
       size_t ret = 0;
       char *ptr;
       size_t len = 0, max_len;
       int step = CHUNK_SIZE;
       int min_room = CHUNK_SIZE / 4;
       php_stream_statbuf ssbuf;

       if (maxlen == 0) {
              return 0;
       }

       if (maxlen == PHP_STREAM_COPY_ALL) {
              maxlen = 0;
       }

       if (maxlen > 0) {
              ptr = *buf = pemalloc_rel_orig(maxlen + 1, persistent);
              while ((len < maxlen) && !php_stream_eof(src)) {
                     ret = php_stream_read(src, ptr, maxlen - len);
                     if (!ret) {
                            break;
                     }
                     len += ret;
                     ptr += ret;
              }
              *ptr = '\0';
              return len;
       }

       /* avoid many reallocs by allocating a good sized chunk to begin with, if
        * we can.  Note that the stream may be filtered, in which case the stat
        * result may be inaccurate, as the filter may inflate or deflate the
        * number of bytes that we can read.  In order to avoid an upsize followed
        * by a downsize of the buffer, overestimate by the step size (which is
        * 2K).  */
       if (php_stream_stat(src, &ssbuf) == 0 && ssbuf.sb.st_size > 0) {
              max_len = ssbuf.sb.st_size + step;
       } else {
              max_len = step;
       }

       ptr = *buf = pemalloc_rel_orig(max_len, persistent);

       while((ret = php_stream_read(src, ptr, max_len - len))) {
              len += ret;
              if (len + min_room >= max_len) {
                     *buf = perealloc_rel_orig(*buf, max_len + step, persistent);
                     max_len += step;
                     ptr = *buf + len;
              } else {
                     ptr += ret;
              }
       }
       if (len) {
              *buf = perealloc_rel_orig(*buf, len + 1, persistent);
              (*buf)[len] = '\0';
       } else {
              pefree(*buf, persistent);
              *buf = NULL;
       }
       return len;
}

Here is the call graph for this function:

ZEND_ATTRIBUTE_DEPRECATED PHPAPI size_t _php_stream_copy_to_stream ( php_stream *  src,
php_stream *  dest,
size_t maxlen STREAMS_DC  TSRMLS_DC 
)

Definition at line 1456 of file streams.c.

{
       size_t len;
       int ret = _php_stream_copy_to_stream_ex(src, dest, maxlen, &len STREAMS_REL_CC TSRMLS_CC);
       if (ret == SUCCESS && len == 0 && maxlen != 0) {
              return 1;
       }
       return len;
}

Here is the call graph for this function:

PHPAPI size_t _php_stream_copy_to_stream_ex ( php_stream *  src,
php_stream *  dest,
size_t  maxlen,
size_t *len STREAMS_DC  TSRMLS_DC 
)

Definition at line 1348 of file streams.c.

{
       char buf[CHUNK_SIZE];
       size_t readchunk;
       size_t haveread = 0;
       size_t didread;
       size_t dummy;
       php_stream_statbuf ssbuf;

       if (!len) {
              len = &dummy;
       }

       if (maxlen == 0) {
              *len = 0;
              return SUCCESS;
       }

       if (maxlen == PHP_STREAM_COPY_ALL) {
              maxlen = 0;
       }

       if (php_stream_stat(src, &ssbuf) == 0) {
              if (ssbuf.sb.st_size == 0
#ifdef S_ISREG
                     && S_ISREG(ssbuf.sb.st_mode)
#endif
              ) {
                     *len = 0;
                     return SUCCESS;
              }
       }

       if (php_stream_mmap_possible(src)) {
              char *p;
              size_t mapped;

              p = php_stream_mmap_range(src, php_stream_tell(src), maxlen, PHP_STREAM_MAP_MODE_SHARED_READONLY, &mapped);

              if (p) {
                     mapped = php_stream_write(dest, p, mapped);

                     php_stream_mmap_unmap_ex(src, mapped);

                     *len = mapped;

                     /* we've got at least 1 byte to read.
                      * less than 1 is an error */

                     if (mapped > 0) {
                            return SUCCESS;
                     }
                     return FAILURE;
              }
       }

       while(1) {
              readchunk = sizeof(buf);

              if (maxlen && (maxlen - haveread) < readchunk) {
                     readchunk = maxlen - haveread;
              }

              didread = php_stream_read(src, buf, readchunk);

              if (didread) {
                     /* extra paranoid */
                     size_t didwrite, towrite;
                     char *writeptr;

                     towrite = didread;
                     writeptr = buf;
                     haveread += didread;

                     while(towrite) {
                            didwrite = php_stream_write(dest, writeptr, towrite);
                            if (didwrite == 0) {
                                   *len = haveread - (didread - towrite);
                                   return FAILURE;
                            }

                            towrite -= didwrite;
                            writeptr += didwrite;
                     }
              } else {
                     break;
              }

              if (maxlen - haveread == 0) {
                     break;
              }
       }

       *len = haveread;

       /* we've got at least 1 byte to read.
        * less than 1 is an error */

       if (haveread > 0 || src->eof) {
              return SUCCESS;
       }
       return FAILURE;
}

Here is the caller graph for this function:

PHPAPI int _php_stream_eof ( php_stream *stream  TSRMLS_DC)

Definition at line 677 of file streams.c.

{
       /* if there is data in the buffer, it's not EOF */
       if (stream->writepos - stream->readpos > 0) {
              return 0;
       }

       /* use the configured timeout when checking eof */
       if (!stream->eof && PHP_STREAM_OPTION_RETURN_ERR ==
                     php_stream_set_option(stream, PHP_STREAM_OPTION_CHECK_LIVENESS,
                     0, NULL)) {
              stream->eof = 1;
       }

       return stream->eof;
}
PHPAPI int _php_stream_flush ( php_stream *  stream,
int closing  TSRMLS_DC 
)

Definition at line 1082 of file streams.c.

{
       int ret = 0;

       if (stream->writefilters.head) {
              _php_stream_write_filtered(stream, NULL, 0, closing ? PSFS_FLAG_FLUSH_CLOSE : PSFS_FLAG_FLUSH_INC  TSRMLS_CC);
       }

       if (stream->ops->flush) {
              ret = stream->ops->flush(stream TSRMLS_CC);
       }

       return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int _php_stream_free ( php_stream *  stream,
int close_options  TSRMLS_DC 
)

Definition at line 317 of file streams.c.

{
       int ret = 1;
       int remove_rsrc = 1;
       int preserve_handle = close_options & PHP_STREAM_FREE_PRESERVE_HANDLE ? 1 : 0;
       int release_cast = 1;
       php_stream_context *context = stream->context;

       if (stream->flags & PHP_STREAM_FLAG_NO_CLOSE) {
              preserve_handle = 1;
       }

#if STREAM_DEBUG
fprintf(stderr, "stream_free: %s:%p[%s] in_free=%d opts=%08x\n", stream->ops->label, stream, stream->orig_path, stream->in_free, close_options);
#endif

       /* recursion protection */
       if (stream->in_free) {
              return 1;
       }

       stream->in_free++;

       /* if we are releasing the stream only (and preserving the underlying handle),
        * we need to do things a little differently.
        * We are only ever called like this when the stream is cast to a FILE*
        * for include (or other similar) purposes.
        * */
       if (preserve_handle) {
              if (stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FOPENCOOKIE) {
                     /* If the stream was fopencookied, we must NOT touch anything
                      * here, as the cookied stream relies on it all.
                      * Instead, mark the stream as OK to auto-clean */
                     php_stream_auto_cleanup(stream);
                     stream->in_free--;
                     return 0;
              }
              /* otherwise, make sure that we don't close the FILE* from a cast */
              release_cast = 0;
       }

#if STREAM_DEBUG
fprintf(stderr, "stream_free: %s:%p[%s] preserve_handle=%d release_cast=%d remove_rsrc=%d\n",
              stream->ops->label, stream, stream->orig_path, preserve_handle, release_cast, remove_rsrc);
#endif

       /* make sure everything is saved */
       _php_stream_flush(stream, 1 TSRMLS_CC);

       /* If not called from the resource dtor, remove the stream from the resource list. */
       if ((close_options & PHP_STREAM_FREE_RSRC_DTOR) == 0 && remove_rsrc) {
              /* zend_list_delete actually only decreases the refcount; if we're
               * releasing the stream, we want to actually delete the resource from
               * the resource list, otherwise the resource will point to invalid memory.
               * In any case, let's always completely delete it from the resource list,
               * not only when PHP_STREAM_FREE_RELEASE_STREAM is set */
              while (zend_list_delete(stream->rsrc_id) == SUCCESS) {}
       }

       /* Remove stream from any context link list */
       if (stream->context && stream->context->links) {
              php_stream_context_del_link(stream->context, stream);
       }

       if (close_options & PHP_STREAM_FREE_CALL_DTOR) {
              if (release_cast && stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FOPENCOOKIE) {
                     /* calling fclose on an fopencookied stream will ultimately
                            call this very same function.  If we were called via fclose,
                            the cookie_closer unsets the fclose_stdiocast flags, so
                            we can be sure that we only reach here when PHP code calls
                            php_stream_free.
                            Lets let the cookie code clean it all up.
                      */
                     stream->in_free = 0;
                     return fclose(stream->stdiocast);
              }

              ret = stream->ops->close(stream, preserve_handle ? 0 : 1 TSRMLS_CC);
              stream->abstract = NULL;

              /* tidy up any FILE* that might have been fdopened */
              if (release_cast && stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FDOPEN && stream->stdiocast) {
                     fclose(stream->stdiocast);
                     stream->stdiocast = NULL;
                     stream->fclose_stdiocast = PHP_STREAM_FCLOSE_NONE;
              }
       }

       if (close_options & PHP_STREAM_FREE_RELEASE_STREAM) {
              while (stream->readfilters.head) {
                     php_stream_filter_remove(stream->readfilters.head, 1 TSRMLS_CC);
              }
              while (stream->writefilters.head) {
                     php_stream_filter_remove(stream->writefilters.head, 1 TSRMLS_CC);
              }

              if (stream->wrapper && stream->wrapper->wops && stream->wrapper->wops->stream_closer) {
                     stream->wrapper->wops->stream_closer(stream->wrapper, stream TSRMLS_CC);
                     stream->wrapper = NULL;
              }

              if (stream->wrapperdata) {
                     zval_ptr_dtor(&stream->wrapperdata);
                     stream->wrapperdata = NULL;
              }

              if (stream->readbuf) {
                     pefree(stream->readbuf, stream->is_persistent);
                     stream->readbuf = NULL;
              }

              if (stream->is_persistent && (close_options & PHP_STREAM_FREE_PERSISTENT)) {
                     /* we don't work with *stream but need its value for comparison */
                     zend_hash_apply_with_argument(&EG(persistent_list), (apply_func_arg_t) _php_stream_free_persistent, stream TSRMLS_CC);
              }
#if ZEND_DEBUG
              if ((close_options & PHP_STREAM_FREE_RSRC_DTOR) && (stream->__exposed == 0) && (EG(error_reporting) & E_WARNING)) {
                     /* it leaked: Lets deliberately NOT pefree it so that the memory manager shows it
                      * as leaked; it will log a warning, but lets help it out and display what kind
                      * of stream it was. */
                     char *leakinfo;
                     spprintf(&leakinfo, 0, __FILE__ "(%d) : Stream of type '%s' %p (path:%s) was not closed\n", __LINE__, stream->ops->label, stream, stream->orig_path);

                     if (stream->orig_path) {
                            pefree(stream->orig_path, stream->is_persistent);
                            stream->orig_path = NULL;
                     }

# if defined(PHP_WIN32)
                     OutputDebugString(leakinfo);
# else
                     fprintf(stderr, "%s", leakinfo);
# endif
                     efree(leakinfo);
              } else {
                     if (stream->orig_path) {
                            pefree(stream->orig_path, stream->is_persistent);
                            stream->orig_path = NULL;
                     }

                     pefree(stream, stream->is_persistent);
              }
#else
              if (stream->orig_path) {
                     pefree(stream->orig_path, stream->is_persistent);
                     stream->orig_path = NULL;
              }

              pefree(stream, stream->is_persistent);
#endif
       }

       if (context) {
              zend_list_delete(context->rsrc_id);
       }

       return ret;
}

Here is the call graph for this function:

static int _php_stream_free_persistent ( zend_rsrc_list_entry le,
void *pStream  TSRMLS_DC 
) [static]

Definition at line 312 of file streams.c.

{
       return le->ptr == pStream;
}

Here is the caller graph for this function:

PHPAPI char* _php_stream_get_line ( php_stream *  stream,
char *  buf,
size_t  maxlen,
size_t *returned_len  TSRMLS_DC 
)

Definition at line 788 of file streams.c.

{
       size_t avail = 0;
       size_t current_buf_size = 0;
       size_t total_copied = 0;
       int grow_mode = 0;
       char *bufstart = buf;

       if (buf == NULL) {
              grow_mode = 1;
       } else if (maxlen == 0) {
              return NULL;
       }

       /*
        * If the underlying stream operations block when no new data is readable,
        * we need to take extra precautions.
        *
        * If there is buffered data available, we check for a EOL. If it exists,
        * we pass the data immediately back to the caller. This saves a call
        * to the read implementation and will not block where blocking
        * is not necessary at all.
        *
        * If the stream buffer contains more data than the caller requested,
        * we can also avoid that costly step and simply return that data.
        */

       for (;;) {
              avail = stream->writepos - stream->readpos;

              if (avail > 0) {
                     size_t cpysz = 0;
                     char *readptr;
                     char *eol;
                     int done = 0;

                     readptr = stream->readbuf + stream->readpos;
                     eol = php_stream_locate_eol(stream, NULL, 0 TSRMLS_CC);

                     if (eol) {
                            cpysz = eol - readptr + 1;
                            done = 1;
                     } else {
                            cpysz = avail;
                     }

                     if (grow_mode) {
                            /* allow room for a NUL. If this realloc is really a realloc
                             * (ie: second time around), we get an extra byte. In most
                             * cases, with the default chunk size of 8K, we will only
                             * incur that overhead once.  When people have lines longer
                             * than 8K, we waste 1 byte per additional 8K or so.
                             * That seems acceptable to me, to avoid making this code
                             * hard to follow */
                            bufstart = erealloc(bufstart, current_buf_size + cpysz + 1);
                            current_buf_size += cpysz + 1;
                            buf = bufstart + total_copied;
                     } else {
                            if (cpysz >= maxlen - 1) {
                                   cpysz = maxlen - 1;
                                   done = 1;
                            }
                     }

                     memcpy(buf, readptr, cpysz);

                     stream->position += cpysz;
                     stream->readpos += cpysz;
                     buf += cpysz;
                     maxlen -= cpysz;
                     total_copied += cpysz;

                     if (done) {
                            break;
                     }
              } else if (stream->eof) {
                     break;
              } else {
                     /* XXX: Should be fine to always read chunk_size */
                     size_t toread;

                     if (grow_mode) {
                            toread = stream->chunk_size;
                     } else {
                            toread = maxlen - 1;
                            if (toread > stream->chunk_size) {
                                   toread = stream->chunk_size;
                            }
                     }

                     php_stream_fill_read_buffer(stream, toread TSRMLS_CC);

                     if (stream->writepos - stream->readpos == 0) {
                            break;
                     }
              }
       }

       if (total_copied == 0) {
              if (grow_mode) {
                     assert(bufstart == NULL);
              }
              return NULL;
       }

       buf[0] = '\0';
       if (returned_len) {
              *returned_len = total_copied;
       }

       return bufstart;
}

Here is the call graph for this function:

Definition at line 58 of file streams.c.

{
       return (FG(stream_wrappers) ? FG(stream_wrappers) : &url_stream_wrappers_hash);
}
PHPAPI int _php_stream_getc ( php_stream *stream  TSRMLS_DC)

Definition at line 704 of file streams.c.

{
       char buf;

       if (php_stream_read(stream, &buf, 1) > 0) {
              return buf & 0xff;
       }
       return EOF;
}
PHPAPI int _php_stream_mkdir ( char *  path,
int  mode,
int  options,
php_stream_context *context  TSRMLS_DC 
)

Definition at line 1739 of file streams.c.

{
       php_stream_wrapper *wrapper = NULL;

       wrapper = php_stream_locate_url_wrapper(path, NULL, ENFORCE_SAFE_MODE TSRMLS_CC);
       if (!wrapper || !wrapper->wops || !wrapper->wops->stream_mkdir) {
              return 0;
       }

       return wrapper->wops->stream_mkdir(wrapper, path, mode, options, context TSRMLS_CC);
}

Here is the call graph for this function:

PHPAPI php_stream* _php_stream_open_wrapper_ex ( char *  path,
char *  mode,
int  options,
char **  opened_path,
php_stream_context *context STREAMS_DC  TSRMLS_DC 
)

Definition at line 1862 of file streams.c.

{
       php_stream *stream = NULL;
       php_stream_wrapper *wrapper = NULL;
       char *path_to_open;
       int persistent = options & STREAM_OPEN_PERSISTENT;
       char *resolved_path = NULL;
       char *copy_of_path = NULL;


       if (opened_path) {
              *opened_path = NULL;
       }

       if (!path || !*path) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Filename cannot be empty");
              return NULL;
       }

       if (options & USE_PATH) {
              resolved_path = zend_resolve_path(path, strlen(path) TSRMLS_CC);
              if (resolved_path) {
                     path = resolved_path;
                     /* we've found this file, don't re-check include_path or run realpath */
                     options |= STREAM_ASSUME_REALPATH;
                     options &= ~USE_PATH;
              }
       }

       path_to_open = path;

       wrapper = php_stream_locate_url_wrapper(path, &path_to_open, options TSRMLS_CC);
       if (options & STREAM_USE_URL && (!wrapper || !wrapper->is_url)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "This function may only be used against URLs");
              if (resolved_path) {
                     efree(resolved_path);
              }
              return NULL;
       }

       if (wrapper) {
              if (!wrapper->wops->stream_opener) {
                     php_stream_wrapper_log_error(wrapper, options ^ REPORT_ERRORS TSRMLS_CC,
                                   "wrapper does not support stream open");
              } else {
                     stream = wrapper->wops->stream_opener(wrapper,
                            path_to_open, mode, options ^ REPORT_ERRORS,
                            opened_path, context STREAMS_REL_CC TSRMLS_CC);
              }

              /* if the caller asked for a persistent stream but the wrapper did not
               * return one, force an error here */
              if (stream && (options & STREAM_OPEN_PERSISTENT) && !stream->is_persistent) {
                     php_stream_wrapper_log_error(wrapper, options ^ REPORT_ERRORS TSRMLS_CC,
                                   "wrapper does not support persistent streams");
                     php_stream_close(stream);
                     stream = NULL;
              }

              if (stream) {
                     stream->wrapper = wrapper;
              }
       }

       if (stream) {
              if (opened_path && !*opened_path && resolved_path) {
                     *opened_path = resolved_path;
                     resolved_path = NULL;
              }
              if (stream->orig_path) {
                     pefree(stream->orig_path, persistent);
              }
              copy_of_path = pestrdup(path, persistent);
              stream->orig_path = copy_of_path;
#if ZEND_DEBUG
              stream->open_filename = __zend_orig_filename ? __zend_orig_filename : __zend_filename;
              stream->open_lineno = __zend_orig_lineno ? __zend_orig_lineno : __zend_lineno;
#endif
       }

       if (stream != NULL && (options & STREAM_MUST_SEEK)) {
              php_stream *newstream;

              switch(php_stream_make_seekable_rel(stream, &newstream,
                                   (options & STREAM_WILL_CAST)
                                          ? PHP_STREAM_PREFER_STDIO : PHP_STREAM_NO_PREFERENCE)) {
                     case PHP_STREAM_UNCHANGED:
                            if (resolved_path) {
                                   efree(resolved_path);
                            }
                            return stream;
                     case PHP_STREAM_RELEASED:
                            if (newstream->orig_path) {
                                   pefree(newstream->orig_path, persistent);
                            }
                            newstream->orig_path = pestrdup(path, persistent);
                            if (resolved_path) {
                                   efree(resolved_path);
                            }
                            return newstream;
                     default:
                            php_stream_close(stream);
                            stream = NULL;
                            if (options & REPORT_ERRORS) {
                                   char *tmp = estrdup(path);
                                   php_strip_url_passwd(tmp);
                                   php_error_docref1(NULL TSRMLS_CC, tmp, E_WARNING, "could not make seekable - %s",
                                                 tmp);
                                   efree(tmp);

                                   options ^= REPORT_ERRORS;
                            }
              }
       }

       if (stream && stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0 && strchr(mode, 'a') && stream->position == 0) {
              off_t newpos = 0;

              /* if opened for append, we need to revise our idea of the initial file position */
              if (0 == stream->ops->seek(stream, 0, SEEK_CUR, &newpos TSRMLS_CC)) {
                     stream->position = newpos;
              }
       }

       if (stream == NULL && (options & REPORT_ERRORS)) {
              php_stream_display_wrapper_errors(wrapper, path, "failed to open stream" TSRMLS_CC);
              if (opened_path && *opened_path) {
                     efree(*opened_path);
                     *opened_path = NULL;
              }
       }
       php_stream_tidy_wrapper_error_log(wrapper TSRMLS_CC);
#if ZEND_DEBUG
       if (stream == NULL && copy_of_path != NULL) {
              pefree(copy_of_path, persistent);
       }
#endif
       if (resolved_path) {
              efree(resolved_path);
       }
       return stream;
}

Here is the call graph for this function:

PHPAPI php_stream* _php_stream_opendir ( char *  path,
int  options,
php_stream_context *context STREAMS_DC  TSRMLS_DC 
)

Definition at line 1813 of file streams.c.

{
       php_stream *stream = NULL;
       php_stream_wrapper *wrapper = NULL;
       char *path_to_open;

       if (!path || !*path) {
              return NULL;
       }

       path_to_open = path;

       wrapper = php_stream_locate_url_wrapper(path, &path_to_open, options TSRMLS_CC);

       if (wrapper && wrapper->wops->dir_opener) {
              stream = wrapper->wops->dir_opener(wrapper,
                            path_to_open, "r", options ^ REPORT_ERRORS, NULL,
                            context STREAMS_REL_CC TSRMLS_CC);

              if (stream) {
                     stream->wrapper = wrapper;
                     stream->flags |= PHP_STREAM_FLAG_NO_BUFFER | PHP_STREAM_FLAG_IS_DIR;
              }
       } else if (wrapper) {
              php_stream_wrapper_log_error(wrapper, options ^ REPORT_ERRORS TSRMLS_CC, "not implemented");
       }
       if (stream == NULL && (options & REPORT_ERRORS)) {
              php_stream_display_wrapper_errors(wrapper, path, "failed to open dir" TSRMLS_CC);
       }
       php_stream_tidy_wrapper_error_log(wrapper TSRMLS_CC);

       return stream;
}

Here is the call graph for this function:

PHPAPI size_t _php_stream_passthru ( php_stream *stream STREAMS_DC  TSRMLS_DC)

Definition at line 1252 of file streams.c.

{
       size_t bcount = 0;
       char buf[8192];
       int b;

       if (php_stream_mmap_possible(stream)) {
              char *p;
              size_t mapped;

              p = php_stream_mmap_range(stream, php_stream_tell(stream), PHP_STREAM_MMAP_ALL, PHP_STREAM_MAP_MODE_SHARED_READONLY, &mapped);

              if (p) {
                     PHPWRITE(p, mapped);

                     php_stream_mmap_unmap_ex(stream, mapped);

                     return mapped;
              }
       }

       while ((b = php_stream_read(stream, buf, sizeof(buf))) > 0) {
              PHPWRITE(buf, b);
              bcount += b;
       }

       return bcount;
}
PHPAPI size_t _php_stream_printf ( php_stream *stream  TSRMLS_DC,
const char *  fmt,
  ... 
)

Definition at line 1110 of file streams.c.

{
       size_t count;
       char *buf;
       va_list ap;

       va_start(ap, fmt);
       count = vspprintf(&buf, 0, fmt, ap);
       va_end(ap);

       if (!buf) {
              return 0; /* error condition */
       }

       count = php_stream_write(stream, buf, count);
       efree(buf);

       return count;
}

Here is the call graph for this function:

PHPAPI int _php_stream_putc ( php_stream *  stream,
int TSRMLS_DC 
)

Definition at line 694 of file streams.c.

{
       unsigned char buf = c;

       if (php_stream_write(stream, &buf, 1) > 0) {
              return 1;
       }
       return EOF;
}
PHPAPI int _php_stream_puts ( php_stream *  stream,
char *buf  TSRMLS_DC 
)

Definition at line 714 of file streams.c.

{
       int len;
       char newline[2] = "\n"; /* is this OK for Win? */
       len = strlen(buf);

       if (len > 0 && php_stream_write(stream, buf, len) && php_stream_write(stream, newline, 1)) {
              return 1;
       }
       return 0;
}
PHPAPI size_t _php_stream_read ( php_stream *  stream,
char *  buf,
size_t size  TSRMLS_DC 
)

Definition at line 611 of file streams.c.

{
       size_t toread = 0, didread = 0;

       while (size > 0) {

              /* take from the read buffer first.
               * It is possible that a buffered stream was switched to non-buffered, so we
               * drain the remainder of the buffer before using the "raw" read mode for
               * the excess */
              if (stream->writepos > stream->readpos) {

                     toread = stream->writepos - stream->readpos;
                     if (toread > size) {
                            toread = size;
                     }

                     memcpy(buf, stream->readbuf + stream->readpos, toread);
                     stream->readpos += toread;
                     size -= toread;
                     buf += toread;
                     didread += toread;
              }

              /* ignore eof here; the underlying state might have changed */
              if (size == 0) {
                     break;
              }

              if (!stream->readfilters.head && (stream->flags & PHP_STREAM_FLAG_NO_BUFFER || stream->chunk_size == 1)) {
                     toread = stream->ops->read(stream, buf, size TSRMLS_CC);
              } else {
                     php_stream_fill_read_buffer(stream, size TSRMLS_CC);

                     toread = stream->writepos - stream->readpos;
                     if (toread > size) {
                            toread = size;
                     }

                     if (toread > 0) {
                            memcpy(buf, stream->readbuf + stream->readpos, toread);
                            stream->readpos += toread;
                     }
              }
              if (toread > 0) {
                     didread += toread;
                     buf += toread;
                     size -= toread;
              } else {
                     /* EOF, or temporary end of data (for non-blocking mode). */
                     break;
              }

              /* just break anyway, to avoid greedy read */
              if (stream->wrapper != &php_plain_files_wrapper) {
                     break;
              }
       }

       if (didread > 0) {
              stream->position += didread;
       }

       return didread;
}

Here is the call graph for this function:

PHPAPI php_stream_dirent* _php_stream_readdir ( php_stream *  dirstream,
php_stream_dirent *ent  TSRMLS_DC 
)

Definition at line 1850 of file streams.c.

{

       if (sizeof(php_stream_dirent) == php_stream_read(dirstream, (char*)ent, sizeof(php_stream_dirent))) {
              return ent;
       }

       return NULL;
}
static int _php_stream_release_context ( zend_rsrc_list_entry le,
void *pContext  TSRMLS_DC 
) [static]

Definition at line 68 of file streams.c.

{
       if (le->ptr == pContext) {
              return --le->refcount == 0;
       }
       return 0;
}

Here is the caller graph for this function:

PHPAPI int _php_stream_rmdir ( char *  path,
int  options,
php_stream_context *context  TSRMLS_DC 
)

Definition at line 1754 of file streams.c.

{
       php_stream_wrapper *wrapper = NULL;

       wrapper = php_stream_locate_url_wrapper(path, NULL, ENFORCE_SAFE_MODE TSRMLS_CC);
       if (!wrapper || !wrapper->wops || !wrapper->wops->stream_rmdir) {
              return 0;
       }

       return wrapper->wops->stream_rmdir(wrapper, path, options, context TSRMLS_CC);
}

Here is the call graph for this function:

PHPAPI int _php_stream_scandir ( char *  dirname,
char **  namelist[],
int  flags,
php_stream_context *  context,
int(*)(const char **a, const char **b) TSRMLS_DC  compare 
)

Definition at line 2188 of file streams.c.

{
       php_stream *stream;
       php_stream_dirent sdp;
       char **vector = NULL;
       int vector_size = 0;
       int nfiles = 0;

       if (!namelist) {
              return FAILURE;
       }

       stream = php_stream_opendir(dirname, ENFORCE_SAFE_MODE | REPORT_ERRORS, context);
       if (!stream) {
              return FAILURE;
       }

       while (php_stream_readdir(stream, &sdp)) {
              if (nfiles == vector_size) {
                     if (vector_size == 0) {
                            vector_size = 10;
                     } else {
                            vector_size *= 2;
                     }
                     vector = (char **) erealloc(vector, vector_size * sizeof(char *));
              }

              vector[nfiles] = estrdup(sdp.d_name);

              nfiles++;
       }
       php_stream_closedir(stream);

       *namelist = vector;

       if (compare) {
              qsort(*namelist, nfiles, sizeof(char *), (int(*)(const void *, const void *))compare);
       }
       return nfiles;
}

Here is the call graph for this function:

PHPAPI int _php_stream_seek ( php_stream *  stream,
off_t  offset,
int whence  TSRMLS_DC 
)

Definition at line 1135 of file streams.c.

{
       if (stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FOPENCOOKIE) {
              /* flush to commit data written to the fopencookie FILE* */
              fflush(stream->stdiocast);
       }

       /* handle the case where we are in the buffer */
       if ((stream->flags & PHP_STREAM_FLAG_NO_BUFFER) == 0) {
              switch(whence) {
                     case SEEK_CUR:
                            if (offset > 0 && offset <= stream->writepos - stream->readpos) {
                                   stream->readpos += offset; /* if offset = ..., then readpos = writepos */
                                   stream->position += offset;
                                   stream->eof = 0;
                                   return 0;
                            }
                            break;
                     case SEEK_SET:
                            if (offset > stream->position &&
                                          offset <= stream->position + stream->writepos - stream->readpos) {
                                   stream->readpos += offset - stream->position;
                                   stream->position = offset;
                                   stream->eof = 0;
                                   return 0;
                            }
                            break;
              }
       }


       if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) {
              int ret;

              if (stream->writefilters.head) {
                     _php_stream_flush(stream, 0 TSRMLS_CC);
              }

              switch(whence) {
                     case SEEK_CUR:
                            offset = stream->position + offset;
                            whence = SEEK_SET;
                            break;
              }
              ret = stream->ops->seek(stream, offset, whence, &stream->position TSRMLS_CC);

              if (((stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) || ret == 0) {
                     if (ret == 0) {
                            stream->eof = 0;
                     }

                     /* invalidate the buffer contents */
                     stream->readpos = stream->writepos = 0;

                     return ret;
              }
              /* else the stream has decided that it can't support seeking after all;
               * fall through to attempt emulation */
       }

       /* emulate forward moving seeks with reads */
       if (whence == SEEK_CUR && offset >= 0) {
              char tmp[1024];
              size_t didread;
              while(offset > 0) {
                     if ((didread = php_stream_read(stream, tmp, MIN(offset, sizeof(tmp)))) == 0) {
                            return -1;
                     }
                     offset -= didread;
              }
              stream->eof = 0;
              return 0;
       }

       php_error_docref(NULL TSRMLS_CC, E_WARNING, "stream does not support seeking");

       return -1;
}

Here is the call graph for this function:

PHPAPI int _php_stream_set_option ( php_stream *  stream,
int  option,
int  value,
void *ptrparam  TSRMLS_DC 
)

Definition at line 1214 of file streams.c.

{
       int ret = PHP_STREAM_OPTION_RETURN_NOTIMPL;

       if (stream->ops->set_option) {
              ret = stream->ops->set_option(stream, option, value, ptrparam TSRMLS_CC);
       }

       if (ret == PHP_STREAM_OPTION_RETURN_NOTIMPL) {
              switch(option) {
                     case PHP_STREAM_OPTION_SET_CHUNK_SIZE:
                            ret = stream->chunk_size;
                            stream->chunk_size = value;
                            return ret;

                     case PHP_STREAM_OPTION_READ_BUFFER:
                            /* try to match the buffer mode as best we can */
                            if (value == PHP_STREAM_BUFFER_NONE) {
                                   stream->flags |= PHP_STREAM_FLAG_NO_BUFFER;
                            } else if (stream->flags & PHP_STREAM_FLAG_NO_BUFFER) {
                                   stream->flags ^= PHP_STREAM_FLAG_NO_BUFFER;
                            }
                            ret = PHP_STREAM_OPTION_RETURN_OK;
                            break;

                     default:
                            ;
              }
       }

       return ret;
}
PHPAPI int _php_stream_stat ( php_stream *  stream,
php_stream_statbuf *ssb  TSRMLS_DC 
)

Definition at line 726 of file streams.c.

{
       memset(ssb, 0, sizeof(*ssb));

       /* if the stream was wrapped, allow the wrapper to stat it */
       if (stream->wrapper && stream->wrapper->wops->stream_stat != NULL) {
              return stream->wrapper->wops->stream_stat(stream->wrapper, stream, ssb TSRMLS_CC);
       }

       /* if the stream doesn't directly support stat-ing, return with failure.
        * We could try and emulate this by casting to a FD and fstat-ing it,
        * but since the fd might not represent the actual underlying content
        * this would give bogus results. */
       if (stream->ops->stat == NULL) {
              return -1;
       }

       return (stream->ops->stat)(stream, ssb TSRMLS_CC);
}
PHPAPI int _php_stream_stat_path ( char *  path,
int  flags,
php_stream_statbuf ssb,
php_stream_context *context  TSRMLS_DC 
)

Definition at line 1768 of file streams.c.

{
       php_stream_wrapper *wrapper = NULL;
       char *path_to_open = path;
       int ret;

       /* Try to hit the cache first */
       if (flags & PHP_STREAM_URL_STAT_LINK) {
              if (BG(CurrentLStatFile) && strcmp(path, BG(CurrentLStatFile)) == 0) {
                     memcpy(ssb, &BG(lssb), sizeof(php_stream_statbuf));
                     return 0;
              }
       } else {
              if (BG(CurrentStatFile) && strcmp(path, BG(CurrentStatFile)) == 0) {
                     memcpy(ssb, &BG(ssb), sizeof(php_stream_statbuf));
                     return 0;
              }
       }

       wrapper = php_stream_locate_url_wrapper(path, &path_to_open, ENFORCE_SAFE_MODE TSRMLS_CC);
       if (wrapper && wrapper->wops->url_stat) {
              ret = wrapper->wops->url_stat(wrapper, path_to_open, flags, ssb, context TSRMLS_CC);
              if (ret == 0) {
                     /* Drop into cache */
                     if (flags & PHP_STREAM_URL_STAT_LINK) {
                            if (BG(CurrentLStatFile)) {
                                   efree(BG(CurrentLStatFile));
                            }
                            BG(CurrentLStatFile) = estrdup(path);
                            memcpy(&BG(lssb), ssb, sizeof(php_stream_statbuf));
                     } else {
                            if (BG(CurrentStatFile)) {
                                   efree(BG(CurrentStatFile));
                            }
                            BG(CurrentStatFile) = estrdup(path);
                            memcpy(&BG(ssb), ssb, sizeof(php_stream_statbuf));
                     }
              }
              return ret;
       }
       return -1;
}

Here is the call graph for this function:

PHPAPI off_t _php_stream_tell ( php_stream *stream  TSRMLS_DC)

Definition at line 1130 of file streams.c.

{
       return stream->position;
}
PHPAPI int _php_stream_truncate_set_size ( php_stream *  stream,
size_t newsize  TSRMLS_DC 
)
PHPAPI size_t _php_stream_write ( php_stream *  stream,
const char *  buf,
size_t count  TSRMLS_DC 
)

Definition at line 1097 of file streams.c.

{
       if (buf == NULL || count == 0 || stream->ops->write == NULL) {
              return 0;
       }

       if (stream->writefilters.head) {
              return _php_stream_write_filtered(stream, buf, count, PSFS_FLAG_NORMAL TSRMLS_CC);
       } else {
              return _php_stream_write_buffer(stream, buf, count TSRMLS_CC);
       }
}

Here is the call graph for this function:

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

Definition at line 976 of file streams.c.

{
       size_t didwrite = 0, towrite, justwrote;

       /* if we have a seekable stream we need to ensure that data is written at the
        * current stream->position. This means invalidating the read buffer and then
        * performing a low-level seek */
       if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0 && stream->readpos != stream->writepos) {
              stream->readpos = stream->writepos = 0;

              stream->ops->seek(stream, stream->position, SEEK_SET, &stream->position TSRMLS_CC);
       }


       while (count > 0) {
              towrite = count;
              if (towrite > stream->chunk_size)
                     towrite = stream->chunk_size;

              justwrote = stream->ops->write(stream, buf, towrite TSRMLS_CC);

              /* convert justwrote to an integer, since normally it is unsigned */
              if ((int)justwrote > 0) {
                     buf += justwrote;
                     count -= justwrote;
                     didwrite += justwrote;

                     /* Only screw with the buffer if we can seek, otherwise we lose data
                      * buffered from fifos and sockets */
                     if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) {
                            stream->position += justwrote;
                     }
              } else {
                     break;
              }
       }
       return didwrite;

}

Here is the caller graph for this function:

static size_t _php_stream_write_filtered ( php_stream *  stream,
const char *  buf,
size_t  count,
int flags  TSRMLS_DC 
) [static]

Definition at line 1021 of file streams.c.

{
       size_t consumed = 0;
       php_stream_bucket *bucket;
       php_stream_bucket_brigade brig_in = { NULL, NULL }, brig_out = { NULL, NULL };
       php_stream_bucket_brigade *brig_inp = &brig_in, *brig_outp = &brig_out, *brig_swap;
       php_stream_filter_status_t status = PSFS_ERR_FATAL;
       php_stream_filter *filter;

       if (buf) {
              bucket = php_stream_bucket_new(stream, (char *)buf, count, 0, 0 TSRMLS_CC);
              php_stream_bucket_append(&brig_in, bucket TSRMLS_CC);
       }

       for (filter = stream->writefilters.head; filter; filter = filter->next) {
              /* for our return value, we are interested in the number of bytes consumed from
               * the first filter in the chain */
              status = filter->fops->filter(stream, filter, brig_inp, brig_outp,
                            filter == stream->writefilters.head ? &consumed : NULL, flags TSRMLS_CC);

              if (status != PSFS_PASS_ON) {
                     break;
              }
              /* brig_out becomes brig_in.
               * brig_in will always be empty here, as the filter MUST attach any un-consumed buckets
               * to its own brigade */
              brig_swap = brig_inp;
              brig_inp = brig_outp;
              brig_outp = brig_swap;
              memset(brig_outp, 0, sizeof(*brig_outp));
       }

       switch (status) {
              case PSFS_PASS_ON:
                     /* filter chain generated some output; push it through to the
                      * underlying stream */
                     while (brig_inp->head) {
                            bucket = brig_inp->head;
                            _php_stream_write_buffer(stream, bucket->buf, bucket->buflen TSRMLS_CC);
                            /* Potential error situation - eg: no space on device. Perhaps we should keep this brigade
                             * hanging around and try to write it later.
                             * At the moment, we just drop it on the floor
                             * */

                            php_stream_bucket_unlink(bucket TSRMLS_CC);
                            php_stream_bucket_delref(bucket TSRMLS_CC);
                     }
                     break;
              case PSFS_FEED_ME:
                     /* need more data before we can push data through to the stream */
                     break;

              case PSFS_ERR_FATAL:
                     /* some fatal error.  Theoretically, the stream is borked, so all
                      * further writes should fail. */
                     break;
       }

       return consumed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void clone_wrapper_hash ( TSRMLS_D  ) [static]

Definition at line 1568 of file streams.c.

{
       php_stream_wrapper *tmp;

       ALLOC_HASHTABLE(FG(stream_wrappers));
       zend_hash_init(FG(stream_wrappers), zend_hash_num_elements(&url_stream_wrappers_hash), NULL, NULL, 1);
       zend_hash_copy(FG(stream_wrappers), &url_stream_wrappers_hash, NULL, &tmp, sizeof(tmp));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int forget_persistent_resource_id_numbers ( zend_rsrc_list_entry *rsrc  TSRMLS_DC) [static]

Definition at line 76 of file streams.c.

{
       php_stream *stream;

       if (Z_TYPE_P(rsrc) != le_pstream) {
              return 0;
       }

       stream = (php_stream*)rsrc->ptr;

#if STREAM_DEBUG
fprintf(stderr, "forget_persistent: %s:%p\n", stream->ops->label, stream);
#endif

       stream->rsrc_id = FAILURE;

       if (stream->context) {
              zend_hash_apply_with_argument(&EG(regular_list),
                            (apply_func_arg_t) _php_stream_release_context,
                            stream->context TSRMLS_CC);
              stream->context = NULL;
       }

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 48 of file streams.c.

{
       return le_pstream;
}

Here is the caller graph for this function:

Definition at line 43 of file streams.c.

{
       return le_stream;
}

Here is the caller graph for this function:

Definition at line 53 of file streams.c.

{
       return le_stream_filter;
}

Here is the caller graph for this function:

int php_init_stream_wrappers ( int module_number  TSRMLS_DC)

Definition at line 1497 of file streams.c.

{
       le_stream = zend_register_list_destructors_ex(stream_resource_regular_dtor, NULL, "stream", module_number);
       le_pstream = zend_register_list_destructors_ex(NULL, stream_resource_persistent_dtor, "persistent stream", module_number);

       /* Filters are cleaned up by the streams they're attached to */
       le_stream_filter = zend_register_list_destructors_ex(NULL, NULL, "stream filter", module_number);

       return (
                     zend_hash_init(&url_stream_wrappers_hash, 0, NULL, NULL, 1) == SUCCESS
                     &&
                     zend_hash_init(php_get_stream_filters_hash_global(), 0, NULL, NULL, 1) == SUCCESS
                     &&
                     zend_hash_init(php_stream_xport_get_hash(), 0, NULL, NULL, 1) == SUCCESS
                     &&
                     php_stream_xport_register("tcp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
                     &&
                     php_stream_xport_register("udp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
#if defined(AF_UNIX) && !(defined(PHP_WIN32) || defined(__riscos__) || defined(NETWARE))
                     &&
                     php_stream_xport_register("unix", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
                     &&
                     php_stream_xport_register("udg", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
#endif
              ) ? SUCCESS : FAILURE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_register_url_stream_wrapper ( char *  protocol,
php_stream_wrapper *wrapper  TSRMLS_DC 
)

Definition at line 1552 of file streams.c.

{
       int protocol_len = strlen(protocol);

       if (php_stream_wrapper_scheme_validate(protocol, protocol_len) == FAILURE) {
              return FAILURE;
       }

       return zend_hash_add(&url_stream_wrappers_hash, protocol, protocol_len + 1, &wrapper, sizeof(wrapper), NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_register_url_stream_wrapper_volatile ( char *  protocol,
php_stream_wrapper *wrapper  TSRMLS_DC 
)

Definition at line 1578 of file streams.c.

{
       int protocol_len = strlen(protocol);

       if (php_stream_wrapper_scheme_validate(protocol, protocol_len) == FAILURE) {
              return FAILURE;
       }

       if (!FG(stream_wrappers)) {
              clone_wrapper_hash(TSRMLS_C);
       }

       return zend_hash_add(FG(stream_wrappers), protocol, protocol_len + 1, &wrapper, sizeof(wrapper), NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHP_RSHUTDOWN_FUNCTION ( streams  )

Definition at line 102 of file streams.c.

Here is the call graph for this function:

Definition at line 1482 of file streams.c.

{
       if (FG(stream_wrappers)) {
              zend_hash_destroy(FG(stream_wrappers));
              efree(FG(stream_wrappers));
              FG(stream_wrappers) = NULL;
       }

       if (FG(stream_filters)) {
              zend_hash_destroy(FG(stream_filters));
              efree(FG(stream_filters));
              FG(stream_filters) = NULL;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int php_shutdown_stream_wrappers ( int module_number  TSRMLS_DC)

Definition at line 1524 of file streams.c.

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI php_stream_context* php_stream_context_alloc ( void  )

Definition at line 2049 of file streams.c.

{
       php_stream_context *context;

       context = ecalloc(1, sizeof(php_stream_context));
       context->notifier = NULL;
       MAKE_STD_ZVAL(context->options);
       array_init(context->options);

       context->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, context, php_le_stream_context());
       return context;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_stream_context_del_link ( php_stream_context *  context,
php_stream *  stream 
)

Definition at line 2141 of file streams.c.

{
       php_stream **pstream;
       char *hostent;
       int ret = SUCCESS;

       if (!context || !context->links || !stream) {
              return FAILURE;
       }

       for(zend_hash_internal_pointer_reset(Z_ARRVAL_P(context->links));
              SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(context->links), (void**)&pstream);
              zend_hash_move_forward(Z_ARRVAL_P(context->links))) {
              if (*pstream == stream) {
                     if (SUCCESS == zend_hash_get_current_key(Z_ARRVAL_P(context->links), &hostent, NULL, 0)) {
                            if (FAILURE == zend_hash_del(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1)) {
                                   ret = FAILURE;
                            }
                     } else {
                            ret = FAILURE;
                     }
              }
       }

       return ret;
}

Here is the caller graph for this function:

PHPAPI void php_stream_context_free ( php_stream_context *  context)

Definition at line 2032 of file streams.c.

{
       if (context->options) {
              zval_ptr_dtor(&context->options);
              context->options = NULL;
       }
       if (context->notifier) {
              php_stream_notification_free(context->notifier);
              context->notifier = NULL;
       }
       if (context->links) {
              zval_ptr_dtor(&context->links);
              context->links = NULL;
       }
       efree(context);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_stream_context_get_link ( php_stream_context *  context,
const char *  hostent,
php_stream **  stream 
)

Definition at line 2109 of file streams.c.

{
       php_stream **pstream;

       if (!stream || !hostent || !context || !(context->links)) {
              return FAILURE;
       }
       if (SUCCESS == zend_hash_find(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1, (void**)&pstream)) {
              *stream = *pstream;
              return SUCCESS;
       }
       return FAILURE;
}

Here is the call graph for this function:

PHPAPI int php_stream_context_get_option ( php_stream_context *  context,
const char *  wrappername,
const char *  optionname,
zval ***  optionvalue 
)

Definition at line 2075 of file streams.c.

{
       zval **wrapperhash;

       if (FAILURE == zend_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) {
              return FAILURE;
       }
       return zend_hash_find(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)optionvalue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI php_stream_context* php_stream_context_set ( php_stream *  stream,
php_stream_context *  context 
)

Definition at line 2008 of file streams.c.

{
       php_stream_context *oldcontext = stream->context;
       TSRMLS_FETCH();

       stream->context = context;

       if (context) {
              zend_list_addref(context->rsrc_id);
       }
       if (oldcontext) {
              zend_list_delete(oldcontext->rsrc_id);
       }

       return oldcontext;
}

Here is the caller graph for this function:

PHPAPI int php_stream_context_set_link ( php_stream_context *  context,
const char *  hostent,
php_stream *  stream 
)

Definition at line 2124 of file streams.c.

{
       if (!context) {
              return FAILURE;
       }
       if (!context->links) {
              ALLOC_INIT_ZVAL(context->links);
              array_init(context->links);
       }
       if (!stream) {
              /* Delete any entry for <hostent> */
              return zend_hash_del(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1);
       }
       return zend_hash_update(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1, (void**)&stream, sizeof(php_stream *), NULL);
}
PHPAPI int php_stream_context_set_option ( php_stream_context *  context,
const char *  wrappername,
const char *  optionname,
zval *  optionvalue 
)

Definition at line 2086 of file streams.c.

{
       zval **wrapperhash;
       zval *category, *copied_val;

       ALLOC_INIT_ZVAL(copied_val);
       *copied_val = *optionvalue;
       zval_copy_ctor(copied_val);
       INIT_PZVAL(copied_val);

       if (FAILURE == zend_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) {
              MAKE_STD_ZVAL(category);
              array_init(category);
              if (FAILURE == zend_hash_update(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&category, sizeof(zval *), NULL)) {
                     return FAILURE;
              }

              wrapperhash = &category;
       }
       return zend_hash_update(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)&copied_val, sizeof(zval *), NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_stream_dirent_alphasort ( const char **  a,
const char **  b 
)

Definition at line 2172 of file streams.c.

{
       return strcoll(*a, *b);
}

Here is the caller graph for this function:

PHPAPI int php_stream_dirent_alphasortr ( const char **  a,
const char **  b 
)

Definition at line 2180 of file streams.c.

{
       return strcoll(*b, *a);
}

Here is the caller graph for this function:

void php_stream_display_wrapper_errors ( php_stream_wrapper *  wrapper,
const char *  path,
const char *caption  TSRMLS_DC 
)

Definition at line 152 of file streams.c.

{
       char *tmp = estrdup(path);
       char *msg;
       int free_msg = 0;
       php_stream_wrapper orig_wrapper;

       if (wrapper) {
              if (wrapper->err_count > 0) {
                     int i;
                     size_t l;
                     int brlen;
                     char *br;

                     if (PG(html_errors)) {
                            brlen = 7;
                            br = "<br />\n";
                     } else {
                            brlen = 1;
                            br = "\n";
                     }

                     for (i = 0, l = 0; i < wrapper->err_count; i++) {
                            l += strlen(wrapper->err_stack[i]);
                            if (i < wrapper->err_count - 1) {
                                   l += brlen;
                            }
                     }
                     msg = emalloc(l + 1);
                     msg[0] = '\0';
                     for (i = 0; i < wrapper->err_count; i++) {
                            strcat(msg, wrapper->err_stack[i]);
                            if (i < wrapper->err_count - 1) {
                                   strcat(msg, br);
                            }
                     }

                     free_msg = 1;
              } else {
                     if (wrapper == &php_plain_files_wrapper) {
                            msg = strerror(errno);
                     } else {
                            msg = "operation failed";
                     }
              }
       } else {
              msg = "no suitable wrapper could be found";
       }

       php_strip_url_passwd(tmp);
       if (wrapper) {
              /* see bug #52935 */
              orig_wrapper = *wrapper;
              wrapper->err_stack = NULL;
              wrapper->err_count = 0;
       }
       php_error_docref1(NULL TSRMLS_CC, tmp, E_WARNING, "%s: %s", caption, msg);
       if (wrapper) {
              *wrapper = orig_wrapper;
       }
       efree(tmp);
       if (free_msg) {
              efree(msg);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void php_stream_fill_read_buffer ( php_stream *  stream,
size_t size  TSRMLS_DC 
) [static]

Definition at line 479 of file streams.c.

{
       /* allocate/fill the buffer */

       if (stream->readfilters.head) {
              char *chunk_buf;
              int err_flag = 0;
              php_stream_bucket_brigade brig_in = { NULL, NULL }, brig_out = { NULL, NULL };
              php_stream_bucket_brigade *brig_inp = &brig_in, *brig_outp = &brig_out, *brig_swap;

              /* Invalidate the existing cache, otherwise reads can fail, see note in
                 main/streams/filter.c::_php_stream_filter_append */
              stream->writepos = stream->readpos = 0;

              /* allocate a buffer for reading chunks */
              chunk_buf = emalloc(stream->chunk_size);

              while (!stream->eof && !err_flag && (stream->writepos - stream->readpos < (off_t)size)) {
                     size_t justread = 0;
                     int flags;
                     php_stream_bucket *bucket;
                     php_stream_filter_status_t status = PSFS_ERR_FATAL;
                     php_stream_filter *filter;

                     /* read a chunk into a bucket */
                     justread = stream->ops->read(stream, chunk_buf, stream->chunk_size TSRMLS_CC);
                     if (justread && justread != (size_t)-1) {
                            bucket = php_stream_bucket_new(stream, chunk_buf, justread, 0, 0 TSRMLS_CC);

                            /* after this call, bucket is owned by the brigade */
                            php_stream_bucket_append(brig_inp, bucket TSRMLS_CC);

                            flags = PSFS_FLAG_NORMAL;
                     } else {
                            flags = stream->eof ? PSFS_FLAG_FLUSH_CLOSE : PSFS_FLAG_FLUSH_INC;
                     }

                     /* wind the handle... */
                     for (filter = stream->readfilters.head; filter; filter = filter->next) {
                            status = filter->fops->filter(stream, filter, brig_inp, brig_outp, NULL, flags TSRMLS_CC);

                            if (status != PSFS_PASS_ON) {
                                   break;
                            }

                            /* brig_out becomes brig_in.
                             * brig_in will always be empty here, as the filter MUST attach any un-consumed buckets
                             * to its own brigade */
                            brig_swap = brig_inp;
                            brig_inp = brig_outp;
                            brig_outp = brig_swap;
                            memset(brig_outp, 0, sizeof(*brig_outp));
                     }

                     switch (status) {
                            case PSFS_PASS_ON:
                                   /* we get here when the last filter in the chain has data to pass on.
                                    * in this situation, we are passing the brig_in brigade into the
                                    * stream read buffer */
                                   while (brig_inp->head) {
                                          bucket = brig_inp->head;
                                          /* grow buffer to hold this bucket
                                           * TODO: this can fail for persistent streams */
                                          if (stream->readbuflen - stream->writepos < bucket->buflen) {
                                                 stream->readbuflen += bucket->buflen;
                                                 stream->readbuf = perealloc(stream->readbuf, stream->readbuflen,
                                                               stream->is_persistent);
                                          }
                                          memcpy(stream->readbuf + stream->writepos, bucket->buf, bucket->buflen);
                                          stream->writepos += bucket->buflen;

                                          php_stream_bucket_unlink(bucket TSRMLS_CC);
                                          php_stream_bucket_delref(bucket TSRMLS_CC);
                                   }
                                   break;

                            case PSFS_FEED_ME:
                                   /* when a filter needs feeding, there is no brig_out to deal with.
                                    * we simply continue the loop; if the caller needs more data,
                                    * we will read again, otherwise out job is done here */
                                   if (justread == 0) {
                                          /* there is no data */
                                          err_flag = 1;
                                          break;
                                   }
                                   continue;

                            case PSFS_ERR_FATAL:
                                   /* some fatal error. Theoretically, the stream is borked, so all
                                    * further reads should fail. */
                                   err_flag = 1;
                                   break;
                     }

                     if (justread == 0 || justread == (size_t)-1) {
                            break;
                     }
              }

              efree(chunk_buf);

       } else {
              /* is there enough data in the buffer ? */
              if (stream->writepos - stream->readpos < (off_t)size) {
                     size_t justread = 0;

                     /* reduce buffer memory consumption if possible, to avoid a realloc */
                     if (stream->readbuf && stream->readbuflen - stream->writepos < stream->chunk_size) {
                            memmove(stream->readbuf, stream->readbuf + stream->readpos, stream->readbuflen - stream->readpos);
                            stream->writepos -= stream->readpos;
                            stream->readpos = 0;
                     }

                     /* grow the buffer if required
                      * TODO: this can fail for persistent streams */
                     if (stream->readbuflen - stream->writepos < stream->chunk_size) {
                            stream->readbuflen += stream->chunk_size;
                            stream->readbuf = perealloc(stream->readbuf, stream->readbuflen,
                                          stream->is_persistent);
                     }

                     justread = stream->ops->read(stream, stream->readbuf + stream->writepos,
                                   stream->readbuflen - stream->writepos
                                   TSRMLS_CC);

                     if (justread != (size_t)-1) {
                            stream->writepos += justread;
                     }
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI int php_stream_from_persistent_id ( const char *  persistent_id,
php_stream **stream  TSRMLS_DC 
)

Definition at line 108 of file streams.c.

{
       zend_rsrc_list_entry *le;

       if (zend_hash_find(&EG(persistent_list), (char*)persistent_id, strlen(persistent_id)+1, (void*) &le) == SUCCESS) {
              if (Z_TYPE_P(le) == le_pstream) {
                     if (stream) {
                            HashPosition pos;
                            zend_rsrc_list_entry *regentry;
                            ulong index = -1; /* intentional */

                            /* see if this persistent resource already has been loaded to the
                             * regular list; allowing the same resource in several entries in the
                             * regular list causes trouble (see bug #54623) */
                            zend_hash_internal_pointer_reset_ex(&EG(regular_list), &pos);
                            while (zend_hash_get_current_data_ex(&EG(regular_list),
                                          (void **)&regentry, &pos) == SUCCESS) {
                                   if (regentry->ptr == le->ptr) {
                                          zend_hash_get_current_key_ex(&EG(regular_list), NULL, NULL,
                                                 &index, 0, &pos);
                                          break;
                                   }
                                   zend_hash_move_forward_ex(&EG(regular_list), &pos);
                            }
                            
                            *stream = (php_stream*)le->ptr;
                            if (index == -1) { /* not found in regular list */
                                   le->refcount++;
                                   (*stream)->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, *stream, le_pstream);
                            } else {
                                   regentry->refcount++;
                                   (*stream)->rsrc_id = index;
                            }
                     }
                     return PHP_STREAM_PERSISTENT_SUCCESS;
              }
              return PHP_STREAM_PERSISTENT_FAILURE;
       }
       return PHP_STREAM_PERSISTENT_NOT_EXIST;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI char* php_stream_get_record ( php_stream *  stream,
size_t  maxlen,
size_t returned_len,
char *  delim,
size_t delim_len  TSRMLS_DC 
)

Definition at line 902 of file streams.c.

{
       char *e, *buf;
       size_t toread, len;
       int skip = 0;

       len = stream->writepos - stream->readpos;

       /* make sure the stream read buffer has maxlen bytes */
       while (len < maxlen) {

              size_t just_read;
              toread = MIN(maxlen - len, stream->chunk_size);

              php_stream_fill_read_buffer(stream, len + toread TSRMLS_CC);

              just_read = (stream->writepos - stream->readpos) - len;
              len += just_read;

              /* Assume the stream is temporarily or permanently out of data */
              if (just_read == 0) {
                     break;
              }
       }

       if (delim_len == 0 || !delim) {
              toread = maxlen;
       } else {
              size_t seek_len;

              /* set the maximum number of bytes we're allowed to read from buffer */
              seek_len = stream->writepos - stream->readpos;
              if (seek_len > maxlen) {
                     seek_len = maxlen;
              }

              if (delim_len == 1) {
                     e = memchr(stream->readbuf + stream->readpos, *delim, seek_len);
              } else {
                     e = php_memnstr(stream->readbuf + stream->readpos, delim, delim_len, (stream->readbuf + stream->readpos + seek_len));
              }

              if (!e) {
                     /* return with error if the delimiter string was not found, we
                      * could not completely fill the read buffer with maxlen bytes
                      * and we don't know we've reached end of file. Added with
                      * non-blocking streams in mind, where this situation is frequent */
                     if (seek_len < maxlen && !stream->eof) {
                            return NULL;
                     }
                     toread = maxlen;
              } else {
                     toread = e - (char *) stream->readbuf - stream->readpos;
                     /* we found the delimiter, so advance the read pointer past it */
                     skip = 1;
              }
       }

       if (toread > maxlen && maxlen > 0) {
              toread = maxlen;
       }

       buf = emalloc(toread + 1);
       *returned_len = php_stream_read(stream, buf, toread);

       if (skip) {
              stream->readpos += delim_len;
              stream->position += delim_len;
       }
       buf[*returned_len] = '\0';
       return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 63 of file streams.c.

Here is the caller graph for this function:

PHPAPI char* php_stream_locate_eol ( php_stream *  stream,
char *  buf,
size_t buf_len  TSRMLS_DC 
)

Definition at line 746 of file streams.c.

{
       size_t avail;
       char *cr, *lf, *eol = NULL;
       char *readptr;

       if (!buf) {
              readptr = stream->readbuf + stream->readpos;
              avail = stream->writepos - stream->readpos;
       } else {
              readptr = buf;
              avail = buf_len;
       }

       /* Look for EOL */
       if (stream->flags & PHP_STREAM_FLAG_DETECT_EOL) {
              cr = memchr(readptr, '\r', avail);
              lf = memchr(readptr, '\n', avail);

              if (cr && lf != cr + 1 && !(lf && lf < cr)) {
                     /* mac */
                     stream->flags ^= PHP_STREAM_FLAG_DETECT_EOL;
                     stream->flags |= PHP_STREAM_FLAG_EOL_MAC;
                     eol = cr;
              } else if ((cr && lf && cr == lf - 1) || (lf)) {
                     /* dos or unix endings */
                     stream->flags ^= PHP_STREAM_FLAG_DETECT_EOL;
                     eol = lf;
              }
       } else if (stream->flags & PHP_STREAM_FLAG_EOL_MAC) {
              eol = memchr(readptr, '\r', avail);
       } else {
              /* unix (and dos) line endings */
              eol = memchr(readptr, '\n', avail);
       }

       return eol;
}

Here is the caller graph for this function:

PHPAPI php_stream_wrapper* php_stream_locate_url_wrapper ( const char *  path,
char **  path_for_open,
int options  TSRMLS_DC 
)

Definition at line 1604 of file streams.c.

{
       HashTable *wrapper_hash = (FG(stream_wrappers) ? FG(stream_wrappers) : &url_stream_wrappers_hash);
       php_stream_wrapper **wrapperpp = NULL;
       const char *p, *protocol = NULL;
       int n = 0;

       if (path_for_open) {
              *path_for_open = (char*)path;
       }

       if (options & IGNORE_URL) {
              return (options & STREAM_LOCATE_WRAPPERS_ONLY) ? NULL : &php_plain_files_wrapper;
       }

       for (p = path; isalnum((int)*p) || *p == '+' || *p == '-' || *p == '.'; p++) {
              n++;
       }

       if ((*p == ':') && (n > 1) && (!strncmp("//", p+1, 2) || (n == 4 && !memcmp("data:", path, 5)))) {
              protocol = path;
       } else if (n == 5 && strncasecmp(path, "zlib:", 5) == 0) {
              /* BC with older php scripts and zlib wrapper */
              protocol = "compress.zlib";
              n = 13;
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Use of \"zlib:\" wrapper is deprecated; please use \"compress.zlib://\" instead");
       }

       if (protocol) {
              char *tmp = estrndup(protocol, n);
              if (FAILURE == zend_hash_find(wrapper_hash, (char*)tmp, n + 1, (void**)&wrapperpp)) {
                     php_strtolower(tmp, n);
                     if (FAILURE == zend_hash_find(wrapper_hash, (char*)tmp, n + 1, (void**)&wrapperpp)) {
                            char wrapper_name[32];

                            if (n >= sizeof(wrapper_name)) {
                                   n = sizeof(wrapper_name) - 1;
                            }
                            PHP_STRLCPY(wrapper_name, protocol, sizeof(wrapper_name), n);

                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find the wrapper \"%s\" - did you forget to enable it when you configured PHP?", wrapper_name);

                            wrapperpp = NULL;
                            protocol = NULL;
                     }
              }
              efree(tmp);
       }
       /* TODO: curl based streams probably support file:// properly */
       if (!protocol || !strncasecmp(protocol, "file", n))     {
              /* fall back on regular file access */
              php_stream_wrapper *plain_files_wrapper = &php_plain_files_wrapper;

              if (protocol) {
                     int localhost = 0;

                     if (!strncasecmp(path, "file://localhost/", 17)) {
                            localhost = 1;
                     }

#ifdef PHP_WIN32
                     if (localhost == 0 && path[n+3] != '\0' && path[n+3] != '/' && path[n+4] != ':')    {
#else
                     if (localhost == 0 && path[n+3] != '\0' && path[n+3] != '/') {
#endif
                            if (options & REPORT_ERRORS) {
                                   php_error_docref(NULL TSRMLS_CC, E_WARNING, "remote host file access not supported, %s", path);
                            }
                            return NULL;
                     }

                     if (path_for_open) {
                            /* skip past protocol and :/, but handle windows correctly */
                            *path_for_open = (char*)path + n + 1;
                            if (localhost == 1) {
                                   (*path_for_open) += 11;
                            }
                            while (*(++*path_for_open)=='/');
#ifdef PHP_WIN32
                            if (*(*path_for_open + 1) != ':')
#endif
                                   (*path_for_open)--;
                     }
              }

              if (options & STREAM_LOCATE_WRAPPERS_ONLY) {
                     return NULL;
              }

              if (FG(stream_wrappers)) {
              /* The file:// wrapper may have been disabled/overridden */

                     if (wrapperpp) {
                            /* It was found so go ahead and provide it */
                            return *wrapperpp;
                     }

                     /* Check again, the original check might have not known the protocol name */
                     if (zend_hash_find(wrapper_hash, "file", sizeof("file"), (void**)&wrapperpp) == SUCCESS) {
                            return *wrapperpp;
                     }

                     if (options & REPORT_ERRORS) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "file:// wrapper is disabled in the server configuration");
                     }
                     return NULL;
              }

              return plain_files_wrapper;
       }

       if (wrapperpp && (*wrapperpp)->is_url &&
        (options & STREAM_DISABLE_URL_PROTECTION) == 0 &&
           (!PG(allow_url_fopen) ||
            (((options & STREAM_OPEN_FOR_INCLUDE) ||
              PG(in_user_include)) && !PG(allow_url_include)))) {
              if (options & REPORT_ERRORS) {
                     /* protocol[n] probably isn't '\0' */
                     char *protocol_dup = estrndup(protocol, n);
                     if (!PG(allow_url_fopen)) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s:// wrapper is disabled in the server configuration by allow_url_fopen=0", protocol_dup);
                     } else {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s:// wrapper is disabled in the server configuration by allow_url_include=0", protocol_dup);
                     }
                     efree(protocol_dup);
              }
              return NULL;
       }

       return *wrapperpp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI php_stream_notifier* php_stream_notification_alloc ( void  )

Definition at line 2062 of file streams.c.

{
       return ecalloc(1, sizeof(php_stream_notifier));
}

Here is the caller graph for this function:

PHPAPI void php_stream_notification_free ( php_stream_notifier *  notifier)

Definition at line 2067 of file streams.c.

{
       if (notifier->dtor) {
              notifier->dtor(notifier);
       }
       efree(notifier);
}

Here is the caller graph for this function:

PHPAPI void php_stream_notification_notify ( php_stream_context *  context,
int  notifycode,
int  severity,
char *  xmsg,
int  xcode,
size_t  bytes_sofar,
size_t  bytes_max,
void *ptr  TSRMLS_DC 
)

Definition at line 2025 of file streams.c.

{
       if (context && context->notifier)
              context->notifier->func(context, notifycode, severity, xmsg, xcode, bytes_sofar, bytes_max, ptr TSRMLS_CC);
}
void php_stream_tidy_wrapper_error_log ( php_stream_wrapper *wrapper  TSRMLS_DC)

Definition at line 218 of file streams.c.

{
       if (wrapper) {
              /* tidy up the error stack */
              int i;

              for (i = 0; i < wrapper->err_count; i++) {
                     efree(wrapper->err_stack[i]);
              }
              if (wrapper->err_stack) {
                     efree(wrapper->err_stack);
              }
              wrapper->err_stack = NULL;
              wrapper->err_count = 0;
       }
}

Here is the caller graph for this function:

PHPAPI void php_stream_wrapper_log_error ( php_stream_wrapper *  wrapper,
int options  TSRMLS_DC,
const char *  fmt,
  ... 
)

Definition at line 235 of file streams.c.

{
       va_list args;
       char *buffer = NULL;

       va_start(args, fmt);
       vspprintf(&buffer, 0, fmt, args);
       va_end(args);

       if (options & REPORT_ERRORS || wrapper == NULL) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", buffer);
              efree(buffer);
       } else {
              /* append to stack */
              wrapper->err_stack = erealloc(wrapper->err_stack, (wrapper->err_count + 1) * sizeof(char *));
              if (wrapper->err_stack) {
                     wrapper->err_stack[wrapper->err_count++] = buffer;
              }
       }
}

Here is the call graph for this function:

static int php_stream_wrapper_scheme_validate ( char *  protocol,
int  protocol_len 
) [inline, static]

Definition at line 1535 of file streams.c.

{
       int i;

       for(i = 0; i < protocol_len; i++) {
              if (!isalnum((int)protocol[i]) &&
                     protocol[i] != '+' &&
                     protocol[i] != '-' &&
                     protocol[i] != '.') {
                     return FAILURE;
              }
       }

       return SUCCESS;
}

Here is the caller graph for this function:

PHPAPI int php_unregister_url_stream_wrapper ( char *protocol  TSRMLS_DC)

Definition at line 1563 of file streams.c.

{
       return zend_hash_del(&url_stream_wrappers_hash, protocol, strlen(protocol) + 1);
}

Here is the caller graph for this function:

PHPAPI int php_unregister_url_stream_wrapper_volatile ( char *protocol  TSRMLS_DC)

Definition at line 1593 of file streams.c.

{
       if (!FG(stream_wrappers)) {
              clone_wrapper_hash(TSRMLS_C);
       }

       return zend_hash_del(FG(stream_wrappers), protocol, strlen(protocol) + 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1476 of file streams.c.

{
       php_stream *stream = (php_stream*)rsrc->ptr;
       FG(pclose_ret) = php_stream_free(stream, PHP_STREAM_FREE_CLOSE | PHP_STREAM_FREE_RSRC_DTOR);
}

Here is the caller graph for this function:

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

Definition at line 1469 of file streams.c.

{
       php_stream *stream = (php_stream*)rsrc->ptr;
       /* set the return value for pclose */
       FG(pclose_ret) = php_stream_free(stream, PHP_STREAM_FREE_CLOSE | PHP_STREAM_FREE_RSRC_DTOR);
}

Here is the caller graph for this function:


Variable Documentation

int le_pstream = FAILURE [static]

Definition at line 40 of file streams.c.

int le_stream = FAILURE [static]

Definition at line 39 of file streams.c.

Definition at line 41 of file streams.c.

Definition at line 38 of file streams.c.