Shell Bypass 403 GE-C666C

Ghost Exploiter Team Official

Directory >> /var/www/html/back/vendor/react/stream/src/

File / Folder	Size	Action
.	-
ClockInterface.php	0.546KB	edt ren
CompositeStream-2026012...	1.828KB	edt ren
CompositeStream.php	1.828KB	edt ren
DuplexResourceStream-20...	7.397KB	edt ren
DuplexResourceStream.php	7.397KB	edt ren
DuplexStreamInterface-2...	1.685KB	edt ren
DuplexStreamInterface.php	1.685KB	edt ren
ReadableResourceStream-...	5.99KB	edt ren
ReadableResourceStream.php	5.99KB	edt ren
ReadableStreamInterface...	13.902KB	edt ren
ReadableStreamInterface...	13.902KB	edt ren
ThroughStream.php	5.116KB	edt ren
Util-20260128105544.php	2.227KB	edt ren
Util.php	2.227KB	edt ren
WritableResourceStream-...	5.431KB	edt ren
WritableResourceStream.php	5.431KB	edt ren
WritableStreamInterface...	14.398KB	edt ren
WritableStreamInterface...	14.398KB	edt ren
auth.php	3.935KB	edt ren
composer.json	0KB	edt ren
console.php	0KB	edt ren
debugbar.php	13.946KB	edt ren

<?php

namespace React\Stream;

use Evenement\EventEmitter;
use React\EventLoop\Loop;
use React\EventLoop\LoopInterface;
use InvalidArgumentException;

final class DuplexResourceStream extends EventEmitter implements DuplexStreamInterface
{
    private $stream;

/** @var LoopInterface */
    private $loop;

/**
     * Controls the maximum buffer size in bytes to read at once from the stream.
     *
     * This can be a positive number which means that up to X bytes will be read
     * at once from the underlying stream resource. Note that the actual number
     * of bytes read may be lower if the stream resource has less than X bytes
     * currently available.
     *
     * This can be `-1` which means read everything available from the
     * underlying stream resource.
     * This should read until the stream resource is not readable anymore
     * (i.e. underlying buffer drained), note that this does not neccessarily
     * mean it reached EOF.
     *
     * @var int
     */
    private $bufferSize;
    private $buffer;

private $readable = true;
    private $writable = true;
    private $closing = false;
    private $listening = false;

/**
     * @param resource $stream
     * @param ?LoopInterface $loop
     * @param ?int $readChunkSize
     * @param ?WritableStreamInterface $buffer
     */
    public function __construct($stream, $loop = null, $readChunkSize = null, $buffer = null)
    {
        if (!\is_resource($stream) || \get_resource_type($stream) !== "stream") {
             throw new InvalidArgumentException('First parameter must be a valid stream resource');
        }

// ensure resource is opened for reading and wrting (fopen mode must contain "+")
        $meta = \stream_get_meta_data($stream);
        if (isset($meta['mode']) && $meta['mode'] !== '' && \strpos($meta['mode'], '+') === false) {
            throw new InvalidArgumentException('Given stream resource is not opened in read and write mode');
        }

// this class relies on non-blocking I/O in order to not interrupt the event loop
        // e.g. pipes on Windows do not support this: https://bugs.php.net/bug.php?id=47918
        if ($buffer !== null && !$buffer instanceof WritableResourceStream && \stream_set_blocking($stream, false) !== true) {
            throw new \RuntimeException('Unable to set stream resource to non-blocking mode');
        }

if ($loop !== null && !$loop instanceof LoopInterface) { // manual type check to support legacy PHP < 7.1
            throw new \InvalidArgumentException('Argument #2 ($loop) expected null|React\EventLoop\LoopInterface');
        }
        if ($buffer !== null && !$buffer instanceof WritableStreamInterface) { // manual type check to support legacy PHP < 7.1
            throw new \InvalidArgumentException('Argument #4 ($buffer) expected null|React\Stream\WritableStreamInterface');
        }

// Use unbuffered read operations on the underlying stream resource.
        // Reading chunks from the stream may otherwise leave unread bytes in
        // PHP's stream buffers which some event loop implementations do not
        // trigger events on (edge triggered).
        // This does not affect the default event loop implementation (level
        // triggered), so we can ignore platforms not supporting this (HHVM).
        // Pipe streams (such as STDIN) do not seem to require this and legacy
        // PHP versions cause SEGFAULTs on unbuffered pipe streams, so skip this.
        if (\function_exists('stream_set_read_buffer') && !$this->isLegacyPipe($stream)) {
            \stream_set_read_buffer($stream, 0);
        }

if ($buffer === null) {
            $buffer = new WritableResourceStream($stream, $loop);
        }

$this->stream = $stream;
        $this->loop = $loop ?: Loop::get();
        $this->bufferSize = ($readChunkSize === null) ? 65536 : (int)$readChunkSize;
        $this->buffer = $buffer;

$that = $this;

$this->buffer->on('error', function ($error) use ($that) {
            $that->emit('error', array($error));
        });

$this->buffer->on('close', array($this, 'close'));

$this->buffer->on('drain', function () use ($that) {
            $that->emit('drain');
        });

$this->resume();
    }

public function isReadable()
    {
        return $this->readable;
    }

public function isWritable()
    {
        return $this->writable;
    }

public function pause()
    {
        if ($this->listening) {
            $this->loop->removeReadStream($this->stream);
            $this->listening = false;
        }
    }

public function resume()
    {
        if (!$this->listening && $this->readable) {
            $this->loop->addReadStream($this->stream, array($this, 'handleData'));
            $this->listening = true;
        }
    }

public function write($data)
    {
        if (!$this->writable) {
            return false;
        }

return $this->buffer->write($data);
    }

public function close()
    {
        if (!$this->writable && !$this->closing) {
            return;
        }

$this->closing = false;

$this->readable = false;
        $this->writable = false;

$this->emit('close');
        $this->pause();
        $this->buffer->close();
        $this->removeAllListeners();

if (\is_resource($this->stream)) {
            \fclose($this->stream);
        }
    }

public function end($data = null)
    {
        if (!$this->writable) {
            return;
        }

$this->closing = true;

$this->readable = false;
        $this->writable = false;
        $this->pause();

$this->buffer->end($data);
    }

public function pipe(WritableStreamInterface $dest, array $options = array())
    {
        return Util::pipe($this, $dest, $options);
    }

/** @internal */
    public function handleData($stream)
    {
        $error = null;
        \set_error_handler(function ($errno, $errstr, $errfile, $errline) use (&$error) {
            $error = new \ErrorException(
                $errstr,
                0,
                $errno,
                $errfile,
                $errline
            );
        });

$data = \stream_get_contents($stream, $this->bufferSize);

\restore_error_handler();

if ($error !== null) {
            $this->emit('error', array(new \RuntimeException('Unable to read from stream: ' . $error->getMessage(), 0, $error)));
            $this->close();
            return;
        }

if ($data !== '') {
            $this->emit('data', array($data));
        } elseif (\feof($this->stream)) {
            // no data read => we reached the end and close the stream
            $this->emit('end');
            $this->close();
        }
    }

/**
     * Returns whether this is a pipe resource in a legacy environment
     *
     * This works around a legacy PHP bug (#61019) that was fixed in PHP 5.4.28+
     * and PHP 5.5.12+ and newer.
     *
     * @param resource $resource
     * @return bool
     * @link https://github.com/reactphp/child-process/issues/40
     *
     * @codeCoverageIgnore
     */
    private function isLegacyPipe($resource)
    {
        if (\PHP_VERSION_ID < 50428 || (\PHP_VERSION_ID >= 50500 && \PHP_VERSION_ID < 50512)) {
            $meta = \stream_get_meta_data($resource);

if (isset($meta['stream_type']) && $meta['stream_type'] === 'STDIO') {
                return true;
            }
        }
        return false;
    }
}