stream_wrappers.inc

Drupal stream wrapper interface.

Provides a Drupal interface and classes to implement PHP stream wrappers for public, private, and temporary files.

A stream wrapper is an abstraction of a file system that allows Drupal to use the same set of methods to access both local files and remote resources.

Note that PHP 5.2 fopen() only supports URIs of the form "scheme://target" despite the fact that according to RFC 3986 a URI's scheme component delimiter is in general just ":", not "://". Because of this PHP limitation and for consistency Drupal will only accept URIs of form "scheme://target".

See also

http://www.faqs.org/rfcs/rfc3986.html

http://bugs.php.net/bug.php?id=47070

File

includes/stream_wrappers.inc

View source
<?php


/**
 * @file
 * Drupal stream wrapper interface.
 *
 * Provides a Drupal interface and classes to implement PHP stream wrappers for
 * public, private, and temporary files.
 *
 * A stream wrapper is an abstraction of a file system that allows Drupal to
 * use the same set of methods to access both local files and remote resources.
 *
 * Note that PHP 5.2 fopen() only supports URIs of the form "scheme://target"
 * despite the fact that according to RFC 3986 a URI's scheme component
 * delimiter is in general just ":", not "://".  Because of this PHP limitation
 * and for consistency Drupal will only accept URIs of form "scheme://target".
 *
 * @see http://www.faqs.org/rfcs/rfc3986.html
 * @see http://bugs.php.net/bug.php?id=47070
 */

/**
 * Stream wrapper bit flags that are the basis for composite types.
 *
 * Note that 0x0002 is skipped, because it was the value of a constant that has
 * since been removed.
 */

/**
 * Stream wrapper bit flag -- a filter that matches all wrappers.
 */
define('STREAM_WRAPPERS_ALL', 0x0);

/**
 * Stream wrapper bit flag -- refers to a local file system location.
 */
define('STREAM_WRAPPERS_LOCAL', 0x1);

/**
 * Stream wrapper bit flag -- wrapper is readable (almost always true).
 */
define('STREAM_WRAPPERS_READ', 0x4);

/**
 * Stream wrapper bit flag -- wrapper is writeable.
 */
define('STREAM_WRAPPERS_WRITE', 0x8);

/**
 * Stream wrapper bit flag -- exposed in the UI and potentially web accessible.
 */
define('STREAM_WRAPPERS_VISIBLE', 0x10);

/**
 * Composite stream wrapper bit flags that are usually used as the types.
 */

/**
 * Stream wrapper type flag -- not visible in the UI or accessible via web,
 * but readable and writable. E.g. the temporary directory for uploads.
 */
define('STREAM_WRAPPERS_HIDDEN', STREAM_WRAPPERS_READ | STREAM_WRAPPERS_WRITE);

/**
 * Stream wrapper type flag -- hidden, readable and writeable using local files.
 */
define('STREAM_WRAPPERS_LOCAL_HIDDEN', STREAM_WRAPPERS_LOCAL | STREAM_WRAPPERS_HIDDEN);

/**
 * Stream wrapper type flag -- visible, readable and writeable.
 */
define('STREAM_WRAPPERS_WRITE_VISIBLE', STREAM_WRAPPERS_READ | STREAM_WRAPPERS_WRITE | STREAM_WRAPPERS_VISIBLE);

/**
 * Stream wrapper type flag -- visible and read-only.
 */
define('STREAM_WRAPPERS_READ_VISIBLE', STREAM_WRAPPERS_READ | STREAM_WRAPPERS_VISIBLE);

/**
 * Stream wrapper type flag -- the default when 'type' is omitted from
 * hook_stream_wrappers(). This does not include STREAM_WRAPPERS_LOCAL,
 * because PHP grants a greater trust level to local files (for example, they
 * can be used in an "include" statement, regardless of the "allow_url_include"
 * setting), so stream wrappers need to explicitly opt-in to this.
 */
define('STREAM_WRAPPERS_NORMAL', STREAM_WRAPPERS_WRITE_VISIBLE);

/**
 * Stream wrapper type flag -- visible, readable and writeable using local files.
 */
define('STREAM_WRAPPERS_LOCAL_NORMAL', STREAM_WRAPPERS_LOCAL | STREAM_WRAPPERS_NORMAL);

/**
 * Generic PHP stream wrapper interface.
 *
 * @see http://www.php.net/manual/class.streamwrapper.php
 */
interface StreamWrapperInterface {
    public function stream_open($uri, $mode, $options, &$opened_url);
    public function stream_close();
    public function stream_lock($operation);
    public function stream_read($count);
    public function stream_write($data);
    public function stream_eof();
    public function stream_seek($offset, $whence);
    public function stream_flush();
    public function stream_tell();
    public function stream_stat();
    public function unlink($uri);
    public function rename($from_uri, $to_uri);
    public function mkdir($uri, $mode, $options);
    public function rmdir($uri, $options);
    public function url_stat($uri, $flags);
    public function dir_opendir($uri, $options);
    public function dir_readdir();
    public function dir_rewinddir();
    public function dir_closedir();

}

/**
 * Drupal stream wrapper extension.
 *
 * Extend the StreamWrapperInterface with methods expected by Drupal stream
 * wrapper classes.
 */
interface DrupalStreamWrapperInterface extends StreamWrapperInterface {
    
    /**
     * Set the absolute stream resource URI.
     *
     * This allows you to set the URI. Generally is only called by the factory
     * method.
     *
     * @param $uri
     *   A string containing the URI that should be used for this instance.
     */
    public function setUri($uri);
    
    /**
     * Returns the stream resource URI.
     *
     * @return
     *   Returns the current URI of the instance.
     */
    public function getUri();
    
    /**
     * Returns a web accessible URL for the resource.
     *
     * This function should return a URL that can be embedded in a web page
     * and accessed from a browser. For example, the external URL of
     * "youtube://xIpLd0WQKCY" might be
     * "http://www.youtube.com/watch?v=xIpLd0WQKCY".
     *
     * @return
     *   Returns a string containing a web accessible URL for the resource.
     */
    public function getExternalUrl();
    
    /**
     * Returns the MIME type of the resource.
     *
     * @param $uri
     *   The URI, path, or filename.
     * @param $mapping
     *   An optional map of extensions to their mimetypes, in the form:
     *    - 'mimetypes': a list of mimetypes, keyed by an identifier,
     *    - 'extensions': the mapping itself, an associative array in which
     *      the key is the extension and the value is the mimetype identifier.
     *
     * @return
     *   Returns a string containing the MIME type of the resource.
     */
    public static function getMimeType($uri, $mapping = NULL);
    
    /**
     * Changes permissions of the resource.
     *
     * PHP lacks this functionality and it is not part of the official stream
     * wrapper interface. This is a custom implementation for Drupal.
     *
     * @param $mode
     *   Integer value for the permissions. Consult PHP chmod() documentation
     *   for more information.
     *
     * @return
     *   Returns TRUE on success or FALSE on failure.
     */
    public function chmod($mode);
    
    /**
     * Returns canonical, absolute path of the resource.
     *
     * Implementation placeholder. PHP's realpath() does not support stream
     * wrappers. We provide this as a default so that individual wrappers may
     * implement their own solutions.
     *
     * @return
     *   Returns a string with absolute pathname on success (implemented
     *   by core wrappers), or FALSE on failure or if the registered
     *   wrapper does not provide an implementation.
     */
    public function realpath();
    
    /**
     * Gets the name of the directory from a given path.
     *
     * This method is usually accessed through drupal_dirname(), which wraps
     * around the normal PHP dirname() function, which does not support stream
     * wrappers.
     *
     * @param $uri
     *   An optional URI.
     *
     * @return
     *   A string containing the directory name, or FALSE if not applicable.
     *
     * @see drupal_dirname()
     */
    public function dirname($uri = NULL);

}

/**
 * Drupal stream wrapper base class for local files.
 *
 * This class provides a complete stream wrapper implementation. URIs such as
 * "public://example.txt" are expanded to a normal filesystem path such as
 * "sites/default/files/example.txt" and then PHP filesystem functions are
 * invoked.
 *
 * DrupalLocalStreamWrapper implementations need to implement at least the
 * getDirectoryPath() and getExternalUrl() methods.
 */
abstract class DrupalLocalStreamWrapper implements DrupalStreamWrapperInterface {
    
    /**
     * Stream context resource.
     *
     * @var Resource
     */
    public $context;
    
    /**
     * A generic resource handle.
     *
     * @var Resource
     */
    public $handle = NULL;
    
    /**
     * Instance URI (stream).
     *
     * A stream is referenced as "scheme://target".
     *
     * @var String
     */
    protected $uri;
    
    /**
     * Gets the path that the wrapper is responsible for.
     * @TODO: Review this method name in D8 per http://drupal.org/node/701358
     *
     * @return
     *   String specifying the path.
     */
    abstract function getDirectoryPath();
    
    /**
     * Base implementation of setUri().
     */
    function setUri($uri) {
        $this->uri = $uri;
    }
    
    /**
     * Base implementation of getUri().
     */
    function getUri() {
        return $this->uri;
    }
    
    /**
     * Returns the local writable target of the resource within the stream.
     *
     * This function should be used in place of calls to realpath() or similar
     * functions when attempting to determine the location of a file. While
     * functions like realpath() may return the location of a read-only file, this
     * method may return a URI or path suitable for writing that is completely
     * separate from the URI used for reading.
     *
     * @param $uri
     *   Optional URI.
     *
     * @return
     *   Returns a string representing a location suitable for writing of a file,
     *   or FALSE if unable to write to the file such as with read-only streams.
     */
    protected function getTarget($uri = NULL) {
        if (!isset($uri)) {
            $uri = $this->uri;
        }
        list($scheme, $target) = explode('://', $uri, 2);
        // Remove erroneous leading or trailing, forward-slashes and backslashes.
        return trim($target, '\\/');
    }
    
    /**
     * Base implementation of getMimeType().
     */
    static function getMimeType($uri, $mapping = NULL) {
        if (!isset($mapping)) {
            // The default file map, defined in file.mimetypes.inc is quite big.
            // We only load it when necessary.
            include_once DRUPAL_ROOT . '/includes/file.mimetypes.inc';
            $mapping = file_mimetype_mapping();
        }
        $extension = '';
        $file_parts = explode('.', drupal_basename($uri));
        // Remove the first part: a full filename should not match an extension.
        array_shift($file_parts);
        // Iterate over the file parts, trying to find a match.
        // For my.awesome.image.jpeg, we try:
        //   - jpeg
        //   - image.jpeg, and
        //   - awesome.image.jpeg
        while ($additional_part = array_pop($file_parts)) {
            $extension = strtolower($additional_part . ($extension ? '.' . $extension : ''));
            if (isset($mapping['extensions'][$extension])) {
                return $mapping['mimetypes'][$mapping['extensions'][$extension]];
            }
        }
        return 'application/octet-stream';
    }
    
    /**
     * Base implementation of chmod().
     */
    function chmod($mode) {
        $output = @chmod($this->getLocalPath(), $mode);
        // We are modifying the underlying file here, so we have to clear the stat
        // cache so that PHP understands that URI has changed too.
        clearstatcache();
        return $output;
    }
    
    /**
     * Base implementation of realpath().
     */
    function realpath() {
        return $this->getLocalPath();
    }
    
    /**
     * Returns the canonical absolute path of the URI, if possible.
     *
     * @param string $uri
     *   (optional) The stream wrapper URI to be converted to a canonical
     *   absolute path. This may point to a directory or another type of file.
     *
     * @return string|false
     *   If $uri is not set, returns the canonical absolute path of the URI
     *   previously set by the DrupalStreamWrapperInterface::setUri() function.
     *   If $uri is set and valid for this class, returns its canonical absolute
     *   path, as determined by the realpath() function. If $uri is set but not
     *   valid, returns FALSE.
     */
    protected function getLocalPath($uri = NULL) {
        if (!isset($uri)) {
            $uri = $this->uri;
        }
        $path = $this->getDirectoryPath() . '/' . $this->getTarget($uri);
        $realpath = realpath($path);
        if (!$realpath) {
            // This file does not yet exist.
            $realpath = realpath(dirname($path)) . '/' . drupal_basename($path);
        }
        $directory = realpath($this->getDirectoryPath());
        if (!$realpath || !$directory || strpos($realpath, $directory) !== 0) {
            return FALSE;
        }
        return $realpath;
    }
    
    /**
     * Support for fopen(), file_get_contents(), file_put_contents() etc.
     *
     * @param $uri
     *   A string containing the URI to the file to open.
     * @param $mode
     *   The file mode ("r", "wb" etc.).
     * @param $options
     *   A bit mask of STREAM_USE_PATH and STREAM_REPORT_ERRORS.
     * @param $opened_path
     *   A string containing the path actually opened.
     *
     * @return
     *   Returns TRUE if file was opened successfully.
     *
     * @see http://php.net/manual/streamwrapper.stream-open.php
     */
    public function stream_open($uri, $mode, $options, &$opened_path) {
        $this->uri = $uri;
        $path = $this->getLocalPath();
        if ($path === FALSE) {
            if ($options & STREAM_REPORT_ERRORS) {
                trigger_error('stream_open() filename cannot be empty', E_USER_WARNING);
            }
            return FALSE;
        }
        $this->handle = $options & STREAM_REPORT_ERRORS ? fopen($path, $mode) : @fopen($path, $mode);
        if ((bool) $this->handle && $options & STREAM_USE_PATH) {
            $opened_path = $path;
        }
        return (bool) $this->handle;
    }
    
    /**
     * Support for flock().
     *
     * @param $operation
     *   One of the following:
     *   - LOCK_SH to acquire a shared lock (reader).
     *   - LOCK_EX to acquire an exclusive lock (writer).
     *   - LOCK_UN to release a lock (shared or exclusive).
     *   - LOCK_NB if you don't want flock() to block while locking (not
     *     supported on Windows).
     *
     * @return
     *   Always returns TRUE at the present time.
     *
     * @see http://php.net/manual/streamwrapper.stream-lock.php
     */
    public function stream_lock($operation) {
        if (in_array($operation, array(
            LOCK_SH,
            LOCK_EX,
            LOCK_UN,
            LOCK_NB,
        ))) {
            return flock($this->handle, $operation);
        }
        return TRUE;
    }
    
    /**
     * Support for fread(), file_get_contents() etc.
     *
     * @param $count
     *   Maximum number of bytes to be read.
     *
     * @return
     *   The string that was read, or FALSE in case of an error.
     *
     * @see http://php.net/manual/streamwrapper.stream-read.php
     */
    public function stream_read($count) {
        return fread($this->handle, $count);
    }
    
    /**
     * Support for fwrite(), file_put_contents() etc.
     *
     * @param $data
     *   The string to be written.
     *
     * @return
     *   The number of bytes written (integer).
     *
     * @see http://php.net/manual/streamwrapper.stream-write.php
     */
    public function stream_write($data) {
        return fwrite($this->handle, $data);
    }
    
    /**
     * Support for feof().
     *
     * @return
     *   TRUE if end-of-file has been reached.
     *
     * @see http://php.net/manual/streamwrapper.stream-eof.php
     */
    public function stream_eof() {
        return feof($this->handle);
    }
    
    /**
     * Support for fseek().
     *
     * @param $offset
     *   The byte offset to got to.
     * @param $whence
     *   SEEK_SET, SEEK_CUR, or SEEK_END.
     *
     * @return
     *   TRUE on success.
     *
     * @see http://php.net/manual/streamwrapper.stream-seek.php
     */
    public function stream_seek($offset, $whence) {
        // fseek returns 0 on success and -1 on a failure.
        // stream_seek   1 on success and  0 on a failure.
        return !fseek($this->handle, $offset, $whence);
    }
    
    /**
     * Support for fflush().
     *
     * @return
     *   TRUE if data was successfully stored (or there was no data to store).
     *
     * @see http://php.net/manual/streamwrapper.stream-flush.php
     */
    public function stream_flush() {
        return fflush($this->handle);
    }
    
    /**
     * Support for ftell().
     *
     * @return
     *   The current offset in bytes from the beginning of file.
     *
     * @see http://php.net/manual/streamwrapper.stream-tell.php
     */
    public function stream_tell() {
        return ftell($this->handle);
    }
    
    /**
     * Support for fstat().
     *
     * @return
     *   An array with file status, or FALSE in case of an error - see fstat()
     *   for a description of this array.
     *
     * @see http://php.net/manual/streamwrapper.stream-stat.php
     */
    public function stream_stat() {
        return fstat($this->handle);
    }
    
    /**
     * Support for fclose().
     *
     * @return
     *   TRUE if stream was successfully closed.
     *
     * @see http://php.net/manual/streamwrapper.stream-close.php
     */
    public function stream_close() {
        return fclose($this->handle);
    }
    
    /**
     * Sets metadata on the stream.
     *
     * WARNING: Do not call this method directly! It will be called internally by
     * PHP itself when one of the following functions is called on a stream URL:
     *
     * @param string $uri
     *   A string containing the URI to the file to set metadata on.
     * @param int $option
     *   One of:
     *   - STREAM_META_TOUCH: The method was called in response to touch().
     *   - STREAM_META_OWNER_NAME: The method was called in response to chown()
     *     with string parameter.
     *   - STREAM_META_OWNER: The method was called in response to chown().
     *   - STREAM_META_GROUP_NAME: The method was called in response to chgrp().
     *   - STREAM_META_GROUP: The method was called in response to chgrp().
     *   - STREAM_META_ACCESS: The method was called in response to chmod().
     * @param mixed $value
     *   If option is:
     *   - STREAM_META_TOUCH: Array consisting of two arguments of the touch()
     *     function.
     *   - STREAM_META_OWNER_NAME or STREAM_META_GROUP_NAME: The name of the owner
     *     user/group as string.
     *   - STREAM_META_OWNER or STREAM_META_GROUP: The value of the owner
     *     user/group as integer.
     *   - STREAM_META_ACCESS: The argument of the chmod() as integer.
     *
     * @return bool
     *   Returns TRUE on success or FALSE on failure. If $option is not
     *   implemented, FALSE should be returned.
     *
     * @see touch()
     * @see chmod()
     * @see chown()
     * @see chgrp()
     * @link http://php.net/manual/streamwrapper.stream-metadata.php
     */
    public function stream_metadata($uri, $option, $value) {
        $target = $this->getLocalPath($uri);
        $return = FALSE;
        switch ($option) {
            case STREAM_META_TOUCH:
                if (!empty($value)) {
                    $return = touch($target, $value[0], $value[1]);
                }
                else {
                    $return = touch($target);
                }
                break;
            case STREAM_META_OWNER_NAME:
            case STREAM_META_OWNER:
                $return = chown($target, $value);
                break;
            case STREAM_META_GROUP_NAME:
            case STREAM_META_GROUP:
                $return = chgrp($target, $value);
                break;
            case STREAM_META_ACCESS:
                $return = chmod($target, $value);
                break;
        }
        if ($return) {
            // For convenience clear the file status cache of the underlying file,
            // since metadata operations are often followed by file status checks.
            clearstatcache(TRUE, $target);
        }
        return $return;
    }
    
    /**
     * Truncate stream.
     *
     * Will respond to truncation; e.g., through ftruncate().
     *
     * @param int $new_size
     *   The new size.
     *
     * @return bool
     *   TRUE on success, FALSE otherwise.
     */
    public function stream_truncate($new_size) {
        return ftruncate($this->handle, $new_size);
    }
    
    /**
     * Retrieve the underlying stream resource.
     *
     * This method is called in response to stream_select().
     *
     * @param int $cast_as
     *   Can be STREAM_CAST_FOR_SELECT when stream_select() is calling
     *   stream_cast() or STREAM_CAST_AS_STREAM when stream_cast() is called for
     *   other uses.
     *
     * @return resource|false
     *   The underlying stream resource or FALSE if stream_select() is not
     *   supported.
     *
     * @see stream_select()
     * @link http://php.net/manual/streamwrapper.stream-cast.php
     */
    public function stream_cast($cast_as) {
        return $this->handle ? $this->handle : FALSE;
    }
    
    /**
     * Change stream options.
     *
     * This method is called to set options on the stream.
     *
     * Since Windows systems do not allow it and it is not needed for most use
     * cases anyway, this method is not supported on local files and will trigger
     * an error and return false. If needed, custom subclasses can provide
     * OS-specific implementations for advanced use cases.
     *
     * @param int $option
     *   One of:
     *   - STREAM_OPTION_BLOCKING: The method was called in response to
     *     stream_set_blocking().
     *   - STREAM_OPTION_READ_TIMEOUT: The method was called in response to
     *     stream_set_timeout().
     *   - STREAM_OPTION_WRITE_BUFFER: The method was called in response to
     *     stream_set_write_buffer().
     * @param int $arg1
     *   If option is:
     *   - STREAM_OPTION_BLOCKING: The requested blocking mode:
     *     - 1 means blocking.
     *     - 0 means not blocking.
     *   - STREAM_OPTION_READ_TIMEOUT: The timeout in seconds.
     *   - STREAM_OPTION_WRITE_BUFFER: The buffer mode, STREAM_BUFFER_NONE or
     *     STREAM_BUFFER_FULL.
     * @param int $arg2
     *   If option is:
     *   - STREAM_OPTION_BLOCKING: This option is not set.
     *   - STREAM_OPTION_READ_TIMEOUT: The timeout in microseconds.
     *   - STREAM_OPTION_WRITE_BUFFER: The requested buffer size.
     *
     * @return bool
     *   TRUE on success, FALSE otherwise. If $option is not implemented, FALSE
     *   should be returned.
     */
    public function stream_set_option($option, $arg1, $arg2) {
        trigger_error('stream_set_option() not supported for local file based stream wrappers', E_USER_WARNING);
        return FALSE;
    }
    
    /**
     * Support for unlink().
     *
     * @param $uri
     *   A string containing the URI to the resource to delete.
     *
     * @return
     *   TRUE if resource was successfully deleted.
     *
     * @see http://php.net/manual/streamwrapper.unlink.php
     */
    public function unlink($uri) {
        $this->uri = $uri;
        return drupal_unlink($this->getLocalPath());
    }
    
    /**
     * Support for rename().
     *
     * @param $from_uri,
     *   The URI to the file to rename.
     * @param $to_uri
     *   The new URI for file.
     *
     * @return
     *   TRUE if file was successfully renamed.
     *
     * @see http://php.net/manual/streamwrapper.rename.php
     */
    public function rename($from_uri, $to_uri) {
        return rename($this->getLocalPath($from_uri), $this->getLocalPath($to_uri));
    }
    
    /**
     * Gets the name of the directory from a given path.
     *
     * This method is usually accessed through drupal_dirname(), which wraps
     * around the PHP dirname() function because it does not support stream
     * wrappers.
     *
     * @param $uri
     *   A URI or path.
     *
     * @return
     *   A string containing the directory name.
     *
     * @see drupal_dirname()
     */
    public function dirname($uri = NULL) {
        list($scheme, $target) = explode('://', $uri, 2);
        $target = $this->getTarget($uri);
        $dirname = dirname($target);
        if ($dirname == '.') {
            $dirname = '';
        }
        return $scheme . '://' . $dirname;
    }
    
    /**
     * Support for mkdir().
     *
     * @param $uri
     *   A string containing the URI to the directory to create.
     * @param $mode
     *   Permission flags - see mkdir().
     * @param $options
     *   A bit mask of STREAM_REPORT_ERRORS and STREAM_MKDIR_RECURSIVE.
     *
     * @return
     *   TRUE if directory was successfully created.
     *
     * @see http://php.net/manual/streamwrapper.mkdir.php
     */
    public function mkdir($uri, $mode, $options) {
        $this->uri = $uri;
        $recursive = (bool) ($options & STREAM_MKDIR_RECURSIVE);
        if ($recursive) {
            // $this->getLocalPath() fails if $uri has multiple levels of directories
            // that do not yet exist.
            $localpath = $this->getDirectoryPath() . '/' . $this->getTarget($uri);
        }
        else {
            $localpath = $this->getLocalPath($uri);
        }
        if ($options & STREAM_REPORT_ERRORS) {
            return drupal_mkdir($localpath, $mode, $recursive);
        }
        else {
            return @drupal_mkdir($localpath, $mode, $recursive);
        }
    }
    
    /**
     * Support for rmdir().
     *
     * @param $uri
     *   A string containing the URI to the directory to delete.
     * @param $options
     *   A bit mask of STREAM_REPORT_ERRORS.
     *
     * @return
     *   TRUE if directory was successfully removed.
     *
     * @see http://php.net/manual/streamwrapper.rmdir.php
     */
    public function rmdir($uri, $options) {
        $this->uri = $uri;
        if ($options & STREAM_REPORT_ERRORS) {
            return drupal_rmdir($this->getLocalPath());
        }
        else {
            return @drupal_rmdir($this->getLocalPath());
        }
    }
    
    /**
     * Support for stat().
     *
     * @param $uri
     *   A string containing the URI to get information about.
     * @param $flags
     *   A bit mask of STREAM_URL_STAT_LINK and STREAM_URL_STAT_QUIET.
     *
     * @return
     *   An array with file status, or FALSE in case of an error - see fstat()
     *   for a description of this array.
     *
     * @see http://php.net/manual/streamwrapper.url-stat.php
     */
    public function url_stat($uri, $flags) {
        $this->uri = $uri;
        $path = $this->getLocalPath();
        // Suppress warnings if requested or if the file or directory does not
        // exist. This is consistent with PHP's plain filesystem stream wrapper.
        if ($flags & STREAM_URL_STAT_QUIET || !file_exists($path)) {
            return @stat($path);
        }
        else {
            return stat($path);
        }
    }
    
    /**
     * Support for opendir().
     *
     * @param $uri
     *   A string containing the URI to the directory to open.
     * @param $options
     *   Unknown (parameter is not documented in PHP Manual).
     *
     * @return
     *   TRUE on success.
     *
     * @see http://php.net/manual/streamwrapper.dir-opendir.php
     */
    public function dir_opendir($uri, $options) {
        $this->uri = $uri;
        $this->handle = opendir($this->getLocalPath());
        return (bool) $this->handle;
    }
    
    /**
     * Support for readdir().
     *
     * @return
     *   The next filename, or FALSE if there are no more files in the directory.
     *
     * @see http://php.net/manual/streamwrapper.dir-readdir.php
     */
    public function dir_readdir() {
        return readdir($this->handle);
    }
    
    /**
     * Support for rewinddir().
     *
     * @return
     *   TRUE on success.
     *
     * @see http://php.net/manual/streamwrapper.dir-rewinddir.php
     */
    public function dir_rewinddir() {
        rewinddir($this->handle);
        // We do not really have a way to signal a failure as rewinddir() does not
        // have a return value and there is no way to read a directory handler
        // without advancing to the next file.
        return TRUE;
    }
    
    /**
     * Support for closedir().
     *
     * @return
     *   TRUE on success.
     *
     * @see http://php.net/manual/streamwrapper.dir-closedir.php
     */
    public function dir_closedir() {
        closedir($this->handle);
        // We do not really have a way to signal a failure as closedir() does not
        // have a return value.
        return TRUE;
    }

}

/**
 * Drupal public (public://) stream wrapper class.
 *
 * Provides support for storing publicly accessible files with the Drupal file
 * interface.
 */
class DrupalPublicStreamWrapper extends DrupalLocalStreamWrapper {
    
    /**
     * Implements abstract public function getDirectoryPath()
     */
    public function getDirectoryPath() {
        return variable_get('file_public_path', conf_path() . '/files');
    }
    
    /**
     * Overrides getExternalUrl().
     *
     * Return the HTML URI of a public file.
     */
    function getExternalUrl() {
        $path = str_replace('\\', '/', $this->getTarget());
        return $GLOBALS['base_url'] . '/' . self::getDirectoryPath() . '/' . drupal_encode_path($path);
    }
    
    /**
     * {@inheritdoc}
     */
    protected function getLocalPath($uri = NULL) {
        $path = parent::getLocalPath($uri);
        if (variable_get('sa_core_2022_012_override', FALSE)) {
            return $path;
        }
        $private_path = variable_get('file_private_path', FALSE);
        if ($private_path) {
            $private_path = realpath($private_path);
            if ($private_path && strpos($path, $private_path) === 0) {
                return FALSE;
            }
        }
        return $path;
    }

}

/**
 * Drupal private (private://) stream wrapper class.
 *
 * Provides support for storing privately accessible files with the Drupal file
 * interface.
 */
class DrupalPrivateStreamWrapper extends DrupalLocalStreamWrapper {
    
    /**
     * Implements abstract public function getDirectoryPath()
     */
    public function getDirectoryPath() {
        return variable_get('file_private_path', '');
    }
    
    /**
     * Overrides getExternalUrl().
     *
     * Return the HTML URI of a private file.
     */
    function getExternalUrl() {
        $path = str_replace('\\', '/', $this->getTarget());
        return url('system/files/' . $path, array(
            'absolute' => TRUE,
        ));
    }

}

/**
 * Drupal temporary (temporary://) stream wrapper class.
 *
 * Provides support for storing temporarily accessible files with the Drupal
 * file interface.
 *
 * Extends DrupalPublicStreamWrapper.
 */
class DrupalTemporaryStreamWrapper extends DrupalLocalStreamWrapper {
    
    /**
     * Implements abstract public function getDirectoryPath()
     */
    public function getDirectoryPath() {
        return variable_get('file_temporary_path', file_directory_temp());
    }
    
    /**
     * Overrides getExternalUrl().
     */
    public function getExternalUrl() {
        $path = str_replace('\\', '/', $this->getTarget());
        return url('system/temporary/' . $path, array(
            'absolute' => TRUE,
        ));
    }

}

Constants

Title Deprecated Summary
STREAM_WRAPPERS_ALL Stream wrapper bit flag -- a filter that matches all wrappers.
STREAM_WRAPPERS_HIDDEN Stream wrapper type flag -- not visible in the UI or accessible via web, but readable and writable. E.g. the temporary directory for uploads.
STREAM_WRAPPERS_LOCAL Stream wrapper bit flag -- refers to a local file system location.
STREAM_WRAPPERS_LOCAL_HIDDEN Stream wrapper type flag -- hidden, readable and writeable using local files.
STREAM_WRAPPERS_LOCAL_NORMAL Stream wrapper type flag -- visible, readable and writeable using local files.
STREAM_WRAPPERS_NORMAL Stream wrapper type flag -- the default when 'type' is omitted from hook_stream_wrappers(). This does not include STREAM_WRAPPERS_LOCAL, because PHP grants a greater trust level to local files (for example, they can be used in an…
STREAM_WRAPPERS_READ Stream wrapper bit flag -- wrapper is readable (almost always true).
STREAM_WRAPPERS_READ_VISIBLE Stream wrapper type flag -- visible and read-only.
STREAM_WRAPPERS_VISIBLE Stream wrapper bit flag -- exposed in the UI and potentially web accessible.
STREAM_WRAPPERS_WRITE Stream wrapper bit flag -- wrapper is writeable.
STREAM_WRAPPERS_WRITE_VISIBLE Stream wrapper type flag -- visible, readable and writeable.

Classes

Title Deprecated Summary
DrupalLocalStreamWrapper Drupal stream wrapper base class for local files.
DrupalPrivateStreamWrapper Drupal private (private://) stream wrapper class.
DrupalPublicStreamWrapper Drupal public (public://) stream wrapper class.
DrupalTemporaryStreamWrapper Drupal temporary (temporary://) stream wrapper class.

Interfaces

Title Deprecated Summary
DrupalStreamWrapperInterface Drupal stream wrapper extension.
StreamWrapperInterface Generic PHP stream wrapper interface.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.