gnu-social/vendor/hoa/protocol/Wrapper.php

<?php

/**
 * Hoa
 *
 *
 * @license
 *
 * New BSD License
 *
 * Copyright © 2007-2017, Hoa community. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Hoa nor the names of its contributors may be
 *       used to endorse or promote products derived from this software without
 *       specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

namespace Hoa\Protocol
{

/**
 * Class \Hoa\Protocol\Wrapper.
 *
 * Stream wrapper for the `hoa://` protocol.
 *
 * @copyright  Copyright © 2007-2017 Hoa community
 * @license    New BSD License
 */
class Wrapper
{
    /**
     * Opened stream.
     *
     * @var resource
     */
    private $_stream     = null;

    /**
     * Stream name (filename).
     *
     * @var string
     */
    private $_streamName = null;

    /**
     * Stream context (given by the streamWrapper class).
     *
     * @var resource
     */
    public $context      = null;



    /**
     * Get the real path of the given URL.
     * Could return false if the path cannot be reached.
     *
     * @param   string  $path      Path (or URL).
     * @param   bool    $exists    If true, try to find the first that exists,
     * @return  mixed
     */
    public static function realPath($path, $exists = true)
    {
        return Node::getRoot()->resolve($path, $exists);
    }

    /**
     * Retrieve the underlying resource.
     *
     * @param   int     $castAs    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
     */
    public function stream_cast($castAs)
    {
        return false;
    }

    /**
     * Close a resource.
     * This method is called in response to fclose().
     * All resources that were locked, or allocated, by the wrapper should be
     * released.
     *
     * @return  void
     */
    public function stream_close()
    {
        if (true === @fclose($this->getStream())) {
            $this->_stream     = null;
            $this->_streamName = null;
        }

        return;
    }

    /**
     * Tests for end-of-file on a file pointer.
     * This method is called in response to feof().
     *
     * access   public
     * @return  bool
     */
    public function stream_eof()
    {
        return feof($this->getStream());
    }

    /**
     * Flush the output.
     * This method is called in respond to fflush().
     * If we have cached data in our stream but not yet stored it into the
     * underlying storage, we should do so now.
     *
     * @return  bool
     */
    public function stream_flush()
    {
        return fflush($this->getStream());
    }

    /**
     * Advisory file locking.
     * This method is called in response to flock(), when file_put_contents()
     * (when flags contains LOCK_EX), stream_set_blocking() and when closing the
     * stream (LOCK_UN).
     *
     * @param   int     $operation    Operation is one 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 we don't want flock() to
     *                                    block while locking (not supported on
     *                                    Windows).
     * @return  bool
     */
    public function stream_lock($operation)
    {
        return flock($this->getStream(), $operation);
    }

    /**
     * Change stream options.
     * This method is called to set metadata on the stream. It is called when
     * one of the following functions is called on a stream URL: touch, chmod,
     * chown or chgrp.
     *
     * @param   string    $path      The file path or URL to set metadata.
     * @param   int       $option    One of the following constant:
     *                                 * STREAM_META_TOUCH,
     *                                 * STREAM_META_OWNER_NAME,
     *                                 * STREAM_META_OWNER,
     *                                 * STREAM_META_GROUP_NAME,
     *                                 * STREAM_META_GROUP,
     *                                 * STREAM_META_ACCESS.
     * @param   mixed     $values    Arguments of touch, chmod, chown and chgrp.
     * @return  bool
     */
    public function stream_metadata($path, $option, $values)
    {
        $path = static::realPath($path, false);

        switch ($option) {
            case STREAM_META_TOUCH:
                $arity = count($values);

                if (0 === $arity) {
                    $out = touch($path);
                } elseif (1 === $arity) {
                    $out = touch($path, $values[0]);
                } else {
                    $out = touch($path, $values[0], $values[1]);
                }

                break;

            case STREAM_META_OWNER_NAME:
            case STREAM_META_OWNER:
                $out = chown($path, $values);

                break;

            case STREAM_META_GROUP_NAME:
            case STREAM_META_GROUP:
                $out = chgrp($path, $values);

                break;

            case STREAM_META_ACCESS:
                $out = chmod($path, $values);

                break;

            default:
                $out = false;
        }

        return $out;
    }

    /**
     * Open file or URL.
     * This method is called immediately after the wrapper is initialized (f.e.
     * by fopen() and file_get_contents()).
     *
     * @param   string  $path           Specifies the URL that was passed to the
     *                                  original function.
     * @param   string  $mode           The mode used to open the file, as
     *                                  detailed for fopen().
     * @param   int     $options        Holds additional flags set by the
     *                                  streams API. It can hold one or more of
     *                                  the following values OR'd together:
     *                                    * STREAM_USE_PATH, if path is relative,
     *                                      search for the resource using the
     *                                      include_path;
     *                                    * STREAM_REPORT_ERRORS, if this is
     *                                    set, you are responsible for raising
     *                                    errors using trigger_error during
     *                                    opening the stream. If this is not
     *                                    set, you should not raise any errors.
     * @param   string  &$openedPath    If the $path is opened successfully, and
     *                                  STREAM_USE_PATH is set in $options,
     *                                  $openedPath should be set to the full
     *                                  path of the file/resource that was
     *                                  actually opened.
     * @return  bool
     */
    public function stream_open($path, $mode, $options, &$openedPath)
    {
        $path = static::realPath($path, 'r' === $mode[0]);

        if (Protocol::NO_RESOLUTION === $path) {
            return false;
        }

        if (null === $this->context) {
            $openedPath = fopen($path, $mode, $options & STREAM_USE_PATH);
        } else {
            $openedPath = fopen(
                $path,
                $mode,
                $options & STREAM_USE_PATH,
                $this->context
            );
        }

        if (false === is_resource($openedPath)) {
            return false;
        }

        $this->_stream     = $openedPath;
        $this->_streamName = $path;

        return true;
    }

    /**
     * Read from stream.
     * This method is called in response to fread() and fgets().
     *
     * @param   int     $count    How many bytes of data from the current
     *                            position should be returned.
     * @return  string
     */
    public function stream_read($count)
    {
        return fread($this->getStream(), $count);
    }

    /**
     * Seek to specific location in a stream.
     * This method is called in response to fseek().
     * The read/write position of the stream should be updated according to the
     * $offset and $whence.
     *
     * @param   int     $offset    The stream offset to seek to.
     * @param   int     $whence    Possible values:
     *                               * SEEK_SET to set position equal to $offset
     *                                 bytes ;
     *                               * SEEK_CUR to set position to current
     *                                 location plus $offsete ;
     *                               * SEEK_END to set position to end-of-file
     *                                 plus $offset.
     * @return  bool
     */
    public function stream_seek($offset, $whence = SEEK_SET)
    {
        return 0 === fseek($this->getStream(), $offset, $whence);
    }

    /**
     * Retrieve information about a file resource.
     * This method is called in response to fstat().
     *
     * @return  array
     */
    public function stream_stat()
    {
        return fstat($this->getStream());
    }

    /**
     * Retrieve the current position of a stream.
     * This method is called in response to ftell().
     *
     * @return  int
     */
    public function stream_tell()
    {
        return ftell($this->getStream());
    }

    /**
     * Truncate a stream to a given length.
     *
     * @param   int     $size    Size.
     * @return  bool
     */
    public function stream_truncate($size)
    {
        return ftruncate($this->getStream(), $size);
    }

    /**
     * Write to stream.
     * This method is called in response to fwrite().
     *
     * @param   string  $data    Should be stored into the underlying stream.
     * @return  int
     */
    public function stream_write($data)
    {
        return fwrite($this->getStream(), $data);
    }

    /**
     * Close directory handle.
     * This method is called in to closedir().
     * Any resources which were locked, or allocated, during opening and use of
     * the directory stream should be released.
     *
     * @return  void
     */
    public function dir_closedir()
    {
        closedir($this->getStream());
        $this->_stream     = null;
        $this->_streamName = null;

        return;
    }

    /**
     * Open directory handle.
     * This method is called in response to opendir().
     *
     * @param   string  $path       Specifies the URL that was passed to opendir().
     * @param   int     $options    Whether or not to enforce safe_mode (0x04).
     *                              It is not used here.
     * @return  bool
     */
    public function dir_opendir($path, $options)
    {
        $path   = static::realPath($path);
        $handle = null;

        if (null === $this->context) {
            $handle = @opendir($path);
        } else {
            $handle = @opendir($path, $this->context);
        }

        if (false === $handle) {
            return false;
        }

        $this->_stream     = $handle;
        $this->_streamName = $path;

        return true;
    }

    /**
     * Read entry from directory handle.
     * This method is called in response to readdir().
     *
     * @return  mixed
     */
    public function dir_readdir()
    {
        return readdir($this->getStream());
    }

    /**
     * Rewind directory handle.
     * This method is called in response to rewinddir().
     * Should reset the output generated by self::dir_readdir, i.e. the next
     * call to self::dir_readdir should return the first entry in the location
     * returned by self::dir_opendir.
     *
     * @return  void
     */
    public function dir_rewinddir()
    {
        return rewinddir($this->getStream());
    }

    /**
     * Create a directory.
     * This method is called in response to mkdir().
     *
     * @param   string  $path       Directory which should be created.
     * @param   int     $mode       The value passed to mkdir().
     * @param   int     $options    A bitwise mask of values.
     * @return  bool
     */
    public function mkdir($path, $mode, $options)
    {
        if (null === $this->context) {
            return mkdir(
                static::realPath($path, false),
                $mode,
                $options | STREAM_MKDIR_RECURSIVE
            );
        }

        return mkdir(
            static::realPath($path, false),
            $mode,
            $options | STREAM_MKDIR_RECURSIVE,
            $this->context
        );
    }

    /**
     * Rename a file or directory.
     * This method is called in response to rename().
     * Should attempt to rename $from to $to.
     *
     * @param   string  $from    The URL to current file.
     * @param   string  $to      The URL which $from should be renamed to.
     * @return  bool
     */
    public function rename($from, $to)
    {
        if (null === $this->context) {
            return rename(static::realPath($from), static::realPath($to, false));
        }

        return rename(
            static::realPath($from),
            static::realPath($to, false),
            $this->context
        );
    }

    /**
     * Remove a directory.
     * This method is called in response to rmdir().
     *
     * @param   string  $path       The directory URL which should be removed.
     * @param   int     $options    A bitwise mask of values. It is not used
     *                              here.
     * @return  bool
     */
    public function rmdir($path, $options)
    {
        if (null === $this->context) {
            return rmdir(static::realPath($path));
        }

        return rmdir(static::realPath($path), $this->context);
    }

    /**
     * Delete a file.
     * This method is called in response to unlink().
     *
     * @param   string  $path    The file URL which should be deleted.
     * @return  bool
     */
    public function unlink($path)
    {
        if (null === $this->context) {
            return unlink(static::realPath($path));
        }

        return unlink(static::realPath($path), $this->context);
    }

    /**
     * Retrieve information about a file.
     * This method is called in response to all stat() related functions.
     *
     * @param   string  $path     The file URL which should be retrieve
     *                            information about.
     * @param   int     $flags    Holds additional flags set by the streams API.
     *                            It can hold one or more of the following
     *                            values OR'd together.
     *                            STREAM_URL_STAT_LINK: for resource with the
     *                            ability to link to other resource (such as an
     *                            HTTP location: forward, or a filesystem
     *                            symlink). This flag specified that only
     *                            information about the link itself should be
     *                            returned, not the resource pointed to by the
     *                            link. This flag is set in response to calls to
     *                            lstat(), is_link(), or filetype().
     *                            STREAM_URL_STAT_QUIET: if this flag is set,
     *                            our wrapper should not raise any errors. If
     *                            this flag is not set, we are responsible for
     *                            reporting errors using the trigger_error()
     *                            function during stating of the path.
     * @return  array
     */
    public function url_stat($path, $flags)
    {
        $path = static::realPath($path);

        if (Protocol::NO_RESOLUTION === $path) {
            if ($flags & STREAM_URL_STAT_QUIET) {
                return 0;
            } else {
                return trigger_error(
                    'Path ' . $path . ' cannot be resolved.',
                    E_WARNING
                );
            }
        }

        if ($flags & STREAM_URL_STAT_LINK) {
            return @lstat($path);
        }

        return @stat($path);
    }

    /**
     * Get stream resource.
     *
     * @return  resource
     */
    public function getStream()
    {
        return $this->_stream;
    }

    /**
     * Get stream name.
     *
     * @return  resource
     */
    public function getStreamName()
    {
        return $this->_streamName;
    }
}

/**
 * Register the `hoa://` protocol.
 */
stream_wrapper_register('hoa', Wrapper::class);

}

namespace
{

/**
 * Alias of `Hoa\Protocol::resolve` method.
 *
 * @param   string  $path      Path to resolve.
 * @param   bool    $exists    If `true`, try to find the first that exists,
 *                             else return the first solution.
 * @param   bool    $unfold    Return all solutions instead of one.
 * @return  mixed
 */
if (!function_exists('resolve')) {
    function resolve($path, $exists = true, $unfold = false)
    {
        return Hoa\Protocol::getInstance()->resolve($path, $exists, $unfold);
    }
}

}