23966445012

Committed 03 Apr 2026 11:46PM UTC coverage: 98.989% (+0.02%) from 98.973%

Build # 23966445012

Build Type

push

github

Committed by

natanfelles

Commit Message

Update Request::getIp method

Coverage Stats

10 of 10 new or added lines in 1 file covered. (100.0%)

4 existing lines in 1 file now uncovered.

1664 of 1681 relevant lines covered (98.99%)

14.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.92

/src/Request.php

<?php declare(strict_types=1);
/*
 * This file is part of Aplus Framework HTTP Library.
 *
 * (c) Natan Felles <natanfelles@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace Framework\HTTP;

use BadMethodCallException;
use Framework\Helpers\ArraySimple;
use InvalidArgumentException;
use JetBrains\PhpStorm\ArrayShape;
use JetBrains\PhpStorm\Pure;
use LogicException;
use Override;
use RequestParseBodyException;
use RuntimeException;
use stdClass;
use UnexpectedValueException;

/**
 * Class Request.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Messages#HTTP_Requests
 *
 * @package http
 */
class Request extends Message implements RequestInterface
{
    /**
     * @var array<string,UploadedFile|array<mixed>>|null
     */
    protected ?array $files = null;
    /**
     * @var array<int,array<mixed>>|null
     */
    protected ?array $parsedBody = null;
    /**
     * @var array<string,mixed>|null
     */
    protected ?array $parseBodyOptions = null;
    /**
     * HTTP Authorization Header parsed.
     *
     * @var array<string,string|null>|null
     */
    protected ?array $auth = null;
    /**
     * @var string|null Basic or Digest
     */
    protected ?string $authType = null;
    protected string $host;
    protected int $port;
    /**
     * @var array<string,array<mixed>|null>
     */
    protected array $negotiation = [
        'ACCEPT' => null,
        'CHARSET' => null,
        'ENCODING' => null,
        'LANGUAGE' => null,
    ];
    protected URL | false | null $referrer = null;
    protected UserAgent | false | null $userAgent = null;
    protected bool $isAjax;
    /**
     * Tell if is an HTTPS connection.
     *
     * @var bool
     */
    protected bool $isSecure;
    protected int $jsonFlags = 0;
    protected string $ipKey = 'REMOTE_ADDR';

    /**
     * Request constructor.
     *
     * @param array<string> $allowedHosts set allowed hosts if your
     * server don't serve by Host header, as Nginx do
     *
     * @throws UnexpectedValueException if invalid Host
     */
    public function __construct(array $allowedHosts = [])
    {
        if ($allowedHosts) {
            $this->validateHost($allowedHosts);
        }
        $this->prepareStatusLine();
    }

    /**
     * @param string $method
     * @param array<int,mixed> $arguments
     *
     * @throws BadMethodCallException for method not allowed or method not found
     *
     * @return static
     */
    public function __call(string $method, array $arguments)
    {
        if ($method === 'setBody') {
            return $this->setBody(...$arguments);
        }
        if (\method_exists($this, $method)) {
            throw new BadMethodCallException("Method not allowed: {$method}");
        }
        throw new BadMethodCallException("Method not found: {$method}");
    }

    #[Override]
    public function __toString() : string
    {
        if ($this->parseContentType() === 'multipart/form-data') {
            $this->setBody($this->getMultipartBody());
        }
        return parent::__toString();
    }

    /**
     * NOTE: Created by comparing a request made with Firefox.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types#multipartform-data
     *
     * @return string
     */
    protected function getMultipartBody() : string
    {
        $bodyParts = [];
        /**
         * @var array<string,string> $parsedBody
         */
        $parsedBody = ArraySimple::convert($this->getParsedBody());
        foreach ($parsedBody as $field => $value) {
            $field = \htmlspecialchars($field, \ENT_QUOTES | \ENT_HTML5);
            $bodyParts[] = \implode("\r\n", [
                "Content-Disposition: form-data; name=\"{$field}\"",
                '',
                $value,
            ]);
        }
        /**
         * @var array<string,UploadedFile> $files
         */
        $files = ArraySimple::convert($this->getFiles());
        foreach ($files as $field => $file) {
            $field = \htmlspecialchars($field, \ENT_QUOTES | \ENT_HTML5);
            $field = \preg_replace('/\[\d+]/', '[]', $field);
            $filename = \htmlspecialchars($file->getFullPath(), \ENT_QUOTES | \ENT_HTML5);
            $contentType = $file->getClientType() ?: 'application/octet-stream';
            $getContentsOf = $file->isMoved() ? $file->getDestination() : $file->getTmpName();
            $data = '';
            if ($getContentsOf !== '') {
                $data = \file_get_contents($getContentsOf);
            }
            $bodyParts[] = \implode("\r\n", [
                "Content-Disposition: form-data; name=\"{$field}\"; filename=\"{$filename}\"",
                'Content-Type: ' . $contentType,
                '',
                $data,
            ]);
        }
        $boundary = '';
        $boundaryParts = \explode(';', $this->getContentType());
        foreach ($boundaryParts as $boundaryPart) {
            $boundaryPart = \trim($boundaryPart);
            if (\str_starts_with(\strtolower($boundaryPart), 'boundary=')) {
                $boundary = \substr($boundaryPart, \strlen('boundary='));
                break;
            }
        }
        foreach ($bodyParts as &$part) {
            $part = "--{$boundary}\r\n{$part}";
        }
        unset($part);
        $bodyParts[] = "--{$boundary}--";
        $bodyParts[] = '';
        $bodyParts = \implode("\r\n", $bodyParts);
        /**
         * Uncomment the code below to make a raw test.
         *
         * @see \Tests\HTTP\RequestTest::testToStringMultipart()
         */
        /*
        $serverLength = (string) $_SERVER['CONTENT_LENGTH'];
        $algoLength = (string) \strlen($bodyParts);
        \var_dump($serverLength, $algoLength);
        if ($serverLength !== $algoLength) {
            throw new \Exception(
                '$_SERVER CONTENT_LENGTH is ' . $serverLength
                . ', but the algorithm calculated ' . $algoLength
            );
        }
        */
        return $bodyParts;
    }

    /**
     * Check if Host header is allowed.
     *
     * @see https://expressionengine.com/blog/http-host-and-server-name-security-issues
     * @see http://nginx.org/en/docs/http/request_processing.html
     *
     * @param array<string> $allowedHosts
     */
    protected function validateHost(array $allowedHosts) : void
    {
        $host = $_SERVER['HTTP_HOST'] ?? null;
        if (!\in_array($host, $allowedHosts, true)) {
            throw new UnexpectedValueException('Invalid Host: ' . $host);
        }
    }

    protected function prepareStatusLine() : void
    {
        $this->setProtocol($_SERVER['SERVER_PROTOCOL']);
        $this->setMethod($_SERVER['REQUEST_METHOD']);
        $url = $this->isSecure() ? 'https' : 'http';
        $url .= '://' . $_SERVER['HTTP_HOST'];
        $url .= $_SERVER['REQUEST_URI'];
        $this->setUrl($url);
        $this->setHost($this->getUrl()->getHost());
    }

    public function getHeader(string $name) : ?string
    {
        $this->prepareHeaders();
        return $this->headers[\strtolower($name)] ?? null;
    }

    /**
     * @return array<string,string>
     */
    public function getHeaders() : array
    {
        $this->prepareHeaders();
        return $this->headers;
    }

    protected function prepareHeaders() : void
    {
        if (!empty($this->headers)) {
            return;
        }
        foreach ($_SERVER as $name => $value) {
            if (\str_starts_with($name, 'HTTP_')) {
                $name = \strtr(\substr($name, 5), ['_' => '-']);
                $this->setHeader($name, $value);
            }
        }
    }

    public function getCookie(string $name) : ?Cookie
    {
        $this->prepareCookies();
        return $this->cookies[$name] ?? null;
    }

    /**
     * Get all Cookies.
     *
     * @return array<string,Cookie>
     */
    public function getCookies() : array
    {
        $this->prepareCookies();
        return $this->cookies;
    }

    protected function prepareCookies() : void
    {
        if (!empty($this->cookies)) {
            return;
        }
        foreach ($_COOKIE as $name => $value) {
            $this->setCookie(new Cookie($name, $value));
        }
    }

    /**
     * @see https://www.php.net/manual/en/wrappers.php.php#wrappers.php.input
     *
     * @return string
     */
    public function getBody() : string
    {
        if (!isset($this->body)) {
            $this->body = (string) \file_get_contents('php://input');
        }
        return $this->body;
    }

    protected function prepareFiles() : void
    {
        if (isset($this->files)) {
            return;
        }
        $this->files = $this->getInputFiles();
    }

    /**
     * @param int $type
     * @param string|null $name
     * @param int|null $filter
     * @param array<int,int>|int $options
     *
     * @see https://www.php.net/manual/en/function.filter-var
     * @see https://www.php.net/manual/en/filter.filters.php
     *
     * @return mixed
     */
    protected function filterInput(
        int $type,
        ?string $name = null,
        ?int $filter = null,
        array | int $options = 0
    ) : mixed {
        $input = match ($type) {
            \INPUT_POST => $_POST,
            \INPUT_GET => $_GET,
            \INPUT_COOKIE => $_COOKIE,
            \INPUT_ENV => $_ENV,
            \INPUT_SERVER => $_SERVER,
            default => throw new InvalidArgumentException('Invalid input type: ' . $type)
        };
        if ($name !== null) {
            $input = \in_array($type, [\INPUT_POST, \INPUT_GET], true)
                ? ArraySimple::value($name, $input)
                : $input[$name] ?? null;
        }
        if ($filter !== null) {
            $input = \filter_var($input, $filter, $options);
        }
        return $input;
    }

    /**
     * Force an HTTPS connection on same URL.
     */
    public function forceHttps() : void
    {
        if (!$this->isSecure()) {
            \header(
                'Location: ' . $this->getUrl()->setScheme('https'),
                true,
                Status::MOVED_PERMANENTLY
            );
            if (!\defined('TESTING')) {
                // @codeCoverageIgnoreStart
                exit;
                // @codeCoverageIgnoreEnd
            }
        }
    }

    /**
     * Get the Authorization type.
     *
     * @return string|null Basic, Bearer, Digest or null for none
     */
    public function getAuthType() : ?string
    {
        if ($this->authType === null) {
            $auth = $_SERVER['HTTP_AUTHORIZATION'] ?? null;
            if ($auth) {
                $this->parseAuth($auth);
            }
        }
        return $this->authType;
    }

    /**
     * Get Basic authorization.
     *
     * @return array<string>|null Two keys: username and password
     */
    #[ArrayShape(['username' => 'string|null', 'password' => 'string|null'])]
    public function getBasicAuth() : ?array
    {
        return $this->getAuthType() === 'Basic'
            ? $this->auth
            : null;
    }

    /**
     * Get Bearer authorization.
     *
     * @return array<string>|null One key: token
     */
    #[ArrayShape(['token' => 'string|null'])]
    public function getBearerAuth() : ?array
    {
        return $this->getAuthType() === 'Bearer'
            ? $this->auth
            : null;
    }

    /**
     * Get Digest authorization.
     *
     * @return array<string>|null Nine keys: username, realm, nonce, uri,
     * response, opaque, qop, nc, cnonce
     */
    #[ArrayShape([
        'username' => 'string|null',
        'realm' => 'string|null',
        'nonce' => 'string|null',
        'uri' => 'string|null',
        'response' => 'string|null',
        'opaque' => 'string|null',
        'qop' => 'string|null',
        'nc' => 'string|null',
        'cnonce' => 'string|null',
    ])]
    public function getDigestAuth() : ?array
    {
        return $this->getAuthType() === 'Digest'
            ? $this->auth
            : null;
    }

    /**
     * @param string $authorization
     *
     * @return array<string,string|null>
     */
    protected function parseAuth(string $authorization) : array
    {
        $this->auth = [];
        [$type, $attributes] = \array_pad(\explode(' ', $authorization, 2), 2, null);
        if ($type === 'Basic') {
            $this->authType = $type;
            $this->auth = $this->parseBasicAuth($attributes);
        } elseif ($type === 'Bearer') {
            $this->authType = $type;
            $this->auth = $this->parseBearerAuth($attributes);
        } elseif ($type === 'Digest') {
            $this->authType = $type;
            $this->auth = $this->parseDigestAuth($attributes);
        }
        return $this->auth;
    }

    /**
     * @param string $attributes
     *
     * @return array<string,string|null>
     */
    #[ArrayShape(['username' => 'string|null', 'password' => 'string|null'])]
    #[Pure]
    protected function parseBasicAuth(string $attributes) : array
    {
        $data = [
            'username' => null,
            'password' => null,
        ];
        $attributes = \base64_decode($attributes);
        if ($attributes) {
            [
                $data['username'],
                $data['password'],
            ] = \array_pad(\explode(':', $attributes, 2), 2, null);
        }
        return $data;
    }

    /**
     * @param string $attributes
     *
     * @return array<string,string|null>
     */
    #[ArrayShape(['token' => 'string|null'])]
    #[Pure]
    protected function parseBearerAuth(string $attributes) : array
    {
        $data = [
            'token' => null,
        ];
        if ($attributes) {
            $data['token'] = $attributes;
        }
        return $data;
    }

    /**
     * @param string $attributes
     *
     * @return array<string,string|null>
     */
    #[ArrayShape([
        'username' => 'string|null',
        'realm' => 'string|null',
        'nonce' => 'string|null',
        'uri' => 'string|null',
        'response' => 'string|null',
        'opaque' => 'string|null',
        'qop' => 'string|null',
        'nc' => 'string|null',
        'cnonce' => 'string|null',
    ])]
    protected function parseDigestAuth(string $attributes) : array
    {
        $data = [
            'username' => null,
            'realm' => null,
            'nonce' => null,
            'uri' => null,
            'response' => null,
            'opaque' => null,
            'qop' => null,
            'nc' => null,
            'cnonce' => null,
        ];
        \preg_match_all(
            '#(username|realm|nonce|uri|response|opaque|qop|nc|cnonce)=(?:([\'"])([^\2]+?)\2|([^\s,]+))#',
            $attributes,
            $matches,
            \PREG_SET_ORDER
        );
        foreach ($matches as $match) {
            if (isset($match[3])) {
                $data[$match[1]] = $match[3] ?: $match[4] ?? '';
            }
        }
        return $data;
    }

    /**
     * Get the Parsed Body or part of it.
     *
     * @param string|null $name
     * @param int|null $filter
     * @param array<int,int>|int $filterOptions
     *
     * @throws RequestParseBodyException
     *
     * @return array<mixed>|mixed|string|null
     */
    public function getParsedBody(
        ?string $name = null,
        ?int $filter = null,
        array | int $filterOptions = 0
    ) : mixed {
        if ($this->isMethod(Method::POST)) {
            return $this->getPost($name, $filter, $filterOptions);
        }
        return $this->getFilteredParsedBody($name, $filter, $filterOptions);
    }

    /**
     * @param string|null $name
     * @param int|null $filter
     * @param array<int,int>|int $filterOptions
     *
     * @throws RequestParseBodyException
     *
     * @return array<mixed>|mixed|string|null
     */
    protected function getFilteredParsedBody(
        ?string $name = null,
        ?int $filter = null,
        array | int $filterOptions = 0
    ) : mixed {
        if (!$this->isParsedBody()) {
            $this->parseBody($this->getParseBodyOptions());
        }
        $variable = $name === null
            ? $this->parsedBody[0]
            : ArraySimple::value($name, $this->parsedBody[0]);
        return $filter === null
            ? $variable
            : \filter_var($variable, $filter, $filterOptions);
    }

    /**
     * @param array<string,mixed>|null $options
     *
     * @throws RequestParseBodyException
     * @throws LogicException
     *
     * @return static
     */
    public function parseBody(?array $options = null) : static
    {
        if ($this->isParsedBody()) {
            throw new LogicException('Parse error: the request body has already been parsed');
        }
        if (!$this->isForm()) {
            $this->parsedBody = [[], []];
            return $this;
        }
        $options ??= $this->getParseBodyOptions();
        $this->parsedBody = $this->requestParseBody($options);
        return $this;
    }

    /**
     * @param array<string,mixed>|null $options
     *
     * @throws RequestParseBodyException
     *
     * @return array<int,array<mixed>>
     */
    protected function requestParseBody(?array $options = null) : array
    {
        return \request_parse_body($options);
    }

    public function isParsedBody() : bool
    {
        return isset($this->parsedBody);
    }

    /**
     * @return array<string,mixed>|null
     */
    public function getParseBodyOptions() : ?array
    {
        return $this->parseBodyOptions;
    }

    /**
     * @param array<string,mixed>|null $options
     *
     * @see https://www.php.net/manual/en/function.request-parse-body.php#refsect1-function.request-parse-body-parameters
     */
    public function setParseBodyOptions(?array $options) : static
    {
        $this->parseBodyOptions = $options;
        return $this;
    }

    /**
     * Get the request body as JSON.
     *
     * @param bool|null $associative When true, JSON objects will be returned as
     * associative arrays; when false, JSON objects will be returned as objects.
     * When null, JSON objects will be returned as associative arrays or objects
     * depending on whether JSON_OBJECT_AS_ARRAY is set in the flags.
     * @param int|null $flags [optional] <p>
     *  Bitmask consisting of <b>JSON_BIGINT_AS_STRING</b>,
     *  <b>JSON_INVALID_UTF8_IGNORE</b>,
     *  <b>JSON_INVALID_UTF8_SUBSTITUTE</b>,
     *  <b>JSON_OBJECT_AS_ARRAY</b>,
     *  <b>JSON_THROW_ON_ERROR</b>.
     *  </p>
     *  <p>Default is none when null.</p>
     * @param int<1,max> $depth user specified recursion depth
     *
     * @see https://www.php.net/manual/en/function.json-decode.php
     * @see https://www.php.net/manual/en/json.constants.php
     *
     * @return array<string,mixed>|false|stdClass If option JSON_THROW_ON_ERROR
     * is not set, return false if json_decode fail. Otherwise, return a
     * stdClass instance, or an array if the $associative argument is passed as
     * true.
     */
    public function getJson(
        ?bool $associative = null,
        ?int $flags = null,
        int $depth = 512
    ) : array | false | stdClass {
        if ($flags === null) {
            $flags = $this->getJsonFlags();
        }
        $body = \json_decode($this->getBody(), $associative, $depth, $flags);
        if (\json_last_error() !== \JSON_ERROR_NONE) {
            return false;
        }
        return $body;
    }

    /**
     * @param string $type
     *
     * @return array<int,string>
     */
    protected function getNegotiableValues(string $type) : array
    {
        if ($this->negotiation[$type]) {
            return $this->negotiation[$type];
        }
        $header = $_SERVER['HTTP_ACCEPT' . ($type !== 'ACCEPT' ? '_' . $type : '')] ?? null;
        $this->negotiation[$type] = \array_keys(static::parseQualityValues(
            $header
        ));
        $this->negotiation[$type] = \array_map('\strtolower', $this->negotiation[$type]);
        return $this->negotiation[$type];
    }

    /**
     * @param string $type
     * @param array<int,string> $negotiable
     *
     * @return string
     */
    protected function negotiate(string $type, array $negotiable) : string
    {
        $negotiable = \array_map('\strtolower', $negotiable);
        foreach ($this->getNegotiableValues($type) as $item) {
            if (\in_array($item, $negotiable, true)) {
                return $item;
            }
        }
        return $negotiable[0];
    }

    /**
     * Get the mime types of the Accept header.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept
     *
     * @return array<int,string>
     */
    public function getAccepts() : array
    {
        return $this->getNegotiableValues('ACCEPT');
    }

    /**
     * Negotiate the Accept header.
     *
     * @param array<int,string> $negotiable Allowed mime types
     *
     * @return string The negotiated mime type
     */
    public function negotiateAccept(array $negotiable) : string
    {
        return $this->negotiate('ACCEPT', $negotiable);
    }

    /**
     * Get the Accept-Charset's.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Charset
     *
     * @return array<int,string>
     */
    public function getCharsets() : array
    {
        return $this->getNegotiableValues('CHARSET');
    }

    /**
     * Negotiate the Accept-Charset.
     *
     * @param array<int,string> $negotiable Allowed charsets
     *
     * @return string The negotiated charset
     */
    public function negotiateCharset(array $negotiable) : string
    {
        return $this->negotiate('CHARSET', $negotiable);
    }

    /**
     * Get the Accept-Encoding.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding
     *
     * @return array<int,string>
     */
    public function getEncodings() : array
    {
        return $this->getNegotiableValues('ENCODING');
    }

    /**
     * Negotiate the Accept-Encoding.
     *
     * @param array<int,string> $negotiable The allowed encodings
     *
     * @return string The negotiated encoding
     */
    public function negotiateEncoding(array $negotiable) : string
    {
        return $this->negotiate('ENCODING', $negotiable);
    }

    /**
     * Get the Accept-Language's.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Language
     *
     * @return array<int,string>
     */
    public function getLanguages() : array
    {
        return $this->getNegotiableValues('LANGUAGE');
    }

    /**
     * Negotiated the Accept-Language.
     *
     * @param array<int,string> $negotiable Allowed languages
     *
     * @return string The negotiated language
     */
    public function negotiateLanguage(array $negotiable) : string
    {
        return $this->negotiate('LANGUAGE', $negotiable);
    }

    /**
     * Get the Content-Type header value.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type
     *
     * @return string|null
     */
    #[Pure]
    public function getContentType() : ?string
    {
        return $_SERVER['HTTP_CONTENT_TYPE'] ?? null;
    }

    /**
     * @param string|null $name
     * @param int|null $filter
     * @param array<int,int>|int $filterOptions
     *
     * @return mixed
     */
    public function getEnv(
        ?string $name = null,
        ?int $filter = null,
        array | int $filterOptions = 0
    ) : mixed {
        return $this->filterInput(\INPUT_ENV, $name, $filter, $filterOptions);
    }

    /**
     * @return array<string,UploadedFile|array<mixed>>
     */
    public function getFiles() : array
    {
        $this->prepareFiles();
        return $this->files;
    }

    public function hasFiles() : bool
    {
        $this->prepareFiles();
        return !empty($this->files);
    }

    public function getFile(string $name) : ?UploadedFile
    {
        $this->prepareFiles();
        $file = ArraySimple::value($name, $this->files);
        return \is_array($file) ? null : $file;
    }

    /**
     * Get the URL GET queries.
     *
     * @param string|null $name
     * @param int|null $filter
     * @param array<int,int>|int $filterOptions
     *
     * @return mixed
     */
    public function getGet(
        ?string $name = null,
        ?int $filter = null,
        array | int $filterOptions = 0
    ) : mixed {
        return $this->filterInput(\INPUT_GET, $name, $filter, $filterOptions);
    }

    /**
     * @return string
     */
    #[Pure]
    public function getHost() : string
    {
        return $this->host;
    }

    /**
     * Get the X-Request-ID header.
     *
     * @return string|null
     */
    public function getId() : ?string
    {
        return $_SERVER['HTTP_X_REQUEST_ID'] ?? null;
    }

    /**
     * Get the connection IP.
     *
     * @param bool $validate True to validate the IP address, otherwise false
     *
     * @throws RuntimeException for invalid IP address
     *
     * @return string
     */
    public function getIp(bool $validate = true) : string
    {
        $key = $this->getIpKey();
        $ip = match($key) {
            'HTTP_FORWARDED' => $this->getIpFromHttpForwarded(),
            'HTTP_X_FORWARDED_FOR' => $this->getIpFromHttpXForwardedFor(),
            default => $_SERVER[$key]
        };
        if ($validate && !\filter_var($ip, \FILTER_VALIDATE_IP)) {
            throw new RuntimeException(
                "The value of {$key} is not a valid IP address"
            );
        }
        return $ip;
    }

    /**
     * Get IP from the X-Forwarded-For header.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For
     *
     * @return string The IP address
     */
    protected function getIpFromHttpXForwardedFor() : string
    {
        $ip = \explode(',', $_SERVER['HTTP_X_FORWARDED_FOR'], 2)[0];
        $ip = \trim($ip);
        return $ip;
    }

    /**
     * Get IP from the Forwarded header.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Forwarded
     *
     * @return string The IP address
     */
    protected function getIpFromHttpForwarded() : string
    {
        $directives = \strtolower($_SERVER['HTTP_FORWARDED']);
        $directives = \explode(',', $directives, 2)[0];
        $directives = \explode(';', $directives);
        foreach ($directives as $directive) {
            $directive = \trim($directive);
            if (!\str_starts_with($directive, 'for')) {
                continue;
            }
            $directive = \explode('=', $directive, 2)[1];
            $directive = \trim($directive);
            if (\str_starts_with($directive, '"')) {
                $directive = \substr($directive, 1, -1);
            }
            if (\str_starts_with($directive, '[')) {
                $pos = \strrpos($directive, ']');
                $directive = \substr($directive, 1, $pos - 1);
            }
            return $directive;
        }
        throw new RuntimeException(
            'The IP address could not be get from the Forwarded header'
        );
    }

    /**
     * Set the key used to get the IP address from the superglobal $_SERVER.
     *
     * @param string $ipKey
     *
     * @throws InvalidArgumentException for IP key not set in the $_SERVER var
     *
     * @return static
     */
    public function setIpKey(string $ipKey) : static
    {
        if (!isset($_SERVER[$ipKey])) {
            throw new InvalidArgumentException(
                'The IP Key "' . $ipKey . '" is not set in the $_SERVER'
            );
        }
        $this->ipKey = $ipKey;
        return $this;
    }

    /**
     * Get the key used to get the IP address from the superglobal $_SERVER.
     *
     * @return string
     */
    public function getIpKey() : string
    {
        return $this->ipKey;
    }

    #[Override]
    #[Pure]
    public function getMethod() : string
    {
        return parent::getMethod();
    }

    /**
     * @param string $method
     *
     * @throws InvalidArgumentException for invalid method
     *
     * @return bool
     */
    #[Override]
    public function isMethod(string $method) : bool
    {
        return parent::isMethod($method);
    }

    /**
     * Gets data from the last request, if it was redirected.
     *
     * @param string|null $key a key name or null to get all data
     *
     * @see Response::redirect()
     *
     * @throws LogicException if PHP Session is not active to get redirect data
     *
     * @return mixed an array containing all data, the key value or null
     * if the key was not found
     */
    public function getRedirectData(?string $key = null) : mixed
    {
        static $data;
        if ($data === null && \session_status() !== \PHP_SESSION_ACTIVE) {
            throw new LogicException('Session must be active to get redirect data');
        }
        if ($data === null) {
            $data = $_SESSION['$']['redirect_data'] ?? false;
            unset($_SESSION['$']['redirect_data']);
        }
        if ($key !== null && $data) {
            return ArraySimple::value($key, $data);
        }
        return $data === false ? null : $data;
    }

    /**
     * Get the URL port.
     *
     * @return int
     */
    public function getPort() : int
    {
        return $this->port ?? $_SERVER['SERVER_PORT'];
    }

    /**
     * Make an empty value according to the name type.
     *
     * @param string|null $name
     *
     * @return array<mixed>|null
     */
    protected function makeEmptyValue(?string $name) : ?array
    {
        return $name === null ? [] : null;
    }

    /**
     * Get POST data.
     *
     * @param string|null $name
     * @param int|null $filter
     * @param array<int,int>|int $filterOptions
     *
     * @throws RequestParseBodyException
     *
     * @return mixed
     */
    public function getPost(
        ?string $name = null,
        ?int $filter = null,
        array | int $filterOptions = 0
    ) : mixed {
        if ($this->isEnabledPostDataReading()) {
            return $this->filterInput(\INPUT_POST, $name, $filter, $filterOptions);
        }
        if ($this->isMethod(Method::POST)) {
            return $this->getFilteredParsedBody($name, $filter, $filterOptions);
        }
        return $this->makeEmptyValue($name);
    }

    /**
     * Get PATCH data.
     *
     * @param string|null $name
     * @param int|null $filter
     * @param array<int,int>|int $filterOptions
     *
     * @throws RequestParseBodyException
     *
     * @return mixed
     */
    public function getPatch(
        ?string $name = null,
        ?int $filter = null,
        array | int $filterOptions = 0
    ) : mixed {
        if ($this->isMethod(Method::PATCH)) {
            return $this->getFilteredParsedBody($name, $filter, $filterOptions);
        }
        return $this->makeEmptyValue($name);
    }

    /**
     * Get PUT data.
     *
     * @param string|null $name
     * @param int|null $filter
     * @param array<int,int>|int $filterOptions
     *
     * @throws RequestParseBodyException
     *
     * @return mixed
     */
    public function getPut(
        ?string $name = null,
        ?int $filter = null,
        array | int $filterOptions = 0
    ) : mixed {
        if ($this->isMethod(Method::PUT)) {
            return $this->getFilteredParsedBody($name, $filter, $filterOptions);
        }
        return $this->makeEmptyValue($name);
    }

    /**
     * Get the Referer header.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referer
     *
     * @return URL|null
     */
    public function getReferer() : ?URL
    {
        if ($this->referrer instanceof URL) {
            return $this->referrer;
        }
        if ($this->referrer === false) {
            return null;
        }
        $referer = $_SERVER['HTTP_REFERER'] ?? null;
        if ($referer === null) {
            $this->referrer = false;
            return null;
        }
        try {
            $this->referrer = new URL($referer);
        } catch (InvalidArgumentException) {
            $this->referrer = false;
        }
        return $this->getReferer();
    }

    /**
     * Get $_SERVER variables.
     *
     * @param string|null $name
     * @param int|null $filter
     * @param array<int,int>|int $filterOptions
     *
     * @return mixed
     */
    public function getServer(
        ?string $name = null,
        ?int $filter = null,
        array | int $filterOptions = 0
    ) : mixed {
        return $this->filterInput(\INPUT_SERVER, $name, $filter, $filterOptions);
    }

    /**
     * Gets the requested URL.
     *
     * @return URL
     */
    #[Override]
    #[Pure]
    public function getUrl() : URL
    {
        return parent::getUrl();
    }

    /**
     * Gets the User Agent client.
     *
     * @return UserAgent|null the UserAgent object or null if no user-agent
     * header was received
     */
    public function getUserAgent() : ?UserAgent
    {
        if ($this->userAgent instanceof UserAgent) {
            return $this->userAgent;
        }
        if ($this->userAgent === false) {
            return null;
        }
        $userAgent = $_SERVER['HTTP_USER_AGENT'] ?? null;
        isset($userAgent)
            ? $this->setUserAgent($userAgent)
            : $this->userAgent = false;
        return $this->getUserAgent();
    }

    /**
     * @param UserAgent|string $userAgent
     *
     * @return static
     */
    protected function setUserAgent(UserAgent | string $userAgent) : static
    {
        if (!$userAgent instanceof UserAgent) {
            $userAgent = new UserAgent($userAgent);
        }
        $this->userAgent = $userAgent;
        return $this;
    }

    /**
     * Check if is an AJAX Request based in the X-Requested-With Header.
     *
     * The X-Requested-With Header containing the "XMLHttpRequest" value is
     * used by various JavaScript libraries.
     *
     * @return bool
     */
    public function isAjax() : bool
    {
        if (isset($this->isAjax)) {
            return $this->isAjax;
        }
        $received = $_SERVER['HTTP_X_REQUESTED_WITH'] ?? null;
        return $this->isAjax = ($received
            && \strtolower($received) === 'xmlhttprequest');
    }

    /**
     * Say if a connection has HTTPS.
     *
     * @return bool
     */
    public function isSecure() : bool
    {
        if (isset($this->isSecure)) {
            return $this->isSecure;
        }
        $scheme = $_SERVER['REQUEST_SCHEME'] ?? '';
        $https = $_SERVER['HTTPS'] ?? '';
        return $this->isSecure = (
            \strtolower($scheme) === 'https' || \strtolower($https) === 'on'
        );
    }

    /**
     * Tells if the Content-Type header is application/x-www-form-urlencoded.
     *
     * @return bool
     */
    public function isFormUrlEncoded() : bool
    {
        return $this->parseContentType() === 'application/x-www-form-urlencoded';
    }

    /**
     * Tells if the Content-Type header is multipart/form-data.
     *
     * @return bool
     */
    public function isFormData() : bool
    {
        return $this->parseContentType() === 'multipart/form-data';
    }

    /**
     * Tells if the Content-Type header is application/x-www-form-urlencoded or
     * multipart/form-data.
     *
     * @return bool
     */
    public function isForm() : bool
    {
        return $this->isFormUrlEncoded() || $this->isFormData();
    }

    /**
     * Say if the request is a JSON call.
     *
     * @return bool
     */
    public function isJson() : bool
    {
        return $this->parseContentType() === 'application/json';
    }

    /**
     * Say if the request method is POST.
     *
     * @return bool
     */
    public function isPost() : bool
    {
        return $this->isMethod(Method::POST);
    }

    /**
     * @see https://php.watch/codex/enable_post_data_reading
     *
     * @return bool
     */
    protected function isEnabledPostDataReading() : bool
    {
        return \ini_get('enable_post_data_reading') === '1';
    }

    /**
     * @see https://www.sitepoint.com/community/t/-files-array-structure/2728/5
     *
     * @return array<string,UploadedFile|array<mixed>>
     */
    protected function getInputFiles() : array
    {
        if (!$this->isParsedBody() && !$this->isEnabledPostDataReading()) {
            $this->parseBody($this->getParseBodyOptions());
        }
        $files = $this->parsedBody[1] ?? $_FILES;
        if (empty($files)) {
            return [];
        }
        $makeObjects = static function (
            array $array,
            callable $makeObjects
        ) : UploadedFile | array {
            $return = [];
            foreach ($array as $k => $v) {
                if (\is_array($v)) {
                    $return[$k] = $makeObjects($v, $makeObjects);
                    continue;
                }
                return new UploadedFile($array);
            }
            return $return;
        };
        return $makeObjects(ArraySimple::files($files), $makeObjects); // @phpstan-ignore-line
    }

    /**
     * @param string $host
     *
     * @throws InvalidArgumentException for invalid host
     *
     * @return static
     */
    protected function setHost(string $host) : static
    {
        $filteredHost = 'http://' . $host;
        $filteredHost = \filter_var($filteredHost, \FILTER_VALIDATE_URL);
        if (!$filteredHost) {
            throw new InvalidArgumentException("Invalid host: {$host}");
        }
        $host = \parse_url($filteredHost);
        $this->host = $host['host']; // @phpstan-ignore-line
        if (isset($host['port'])) {
            $this->port = $host['port'];
        }
        return $this;
    }

    /**
     * Make a Response with the current Request.
     *
     * @return Response
     */
    public function makeResponse() : Response
    {
        return new Response($this);
    }
}

aplus-framework / http / 23966445012

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous