Request.php

Go to the documentation of this file.

<?php
namespace ‪TYPO3\CMS\Core\Http;
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UriInterface;
 
class ‪Request extends ‪Message implements RequestInterface
{
    protected ‪$requestTarget;
 
    protected ‪$method;
 
    protected ‪$supportedMethods = [
        'CONNECT',
        'DELETE',
        'GET',
        'HEAD',
        'OPTIONS',
        'PATCH',
        'POST',
        'PUT',
        'TRACE',
        // WebDAV methods
        'COPY',
        'LOCK',
        'MKCOL',
        'MOVE',
        'PROPFIND',
        'PROPPATCH',
        'REPORT',
        'UNLOCK',
        // Custom methods
        'PURGE',
        'BAN'
    ];
 
    protected ‪$uri;
 
    public function ‪__construct(‪$uri = null, ‪$method = null, ‪$body = 'php://input', array ‪$headers = [])
    {
 
        // Build a streamable object for the body
        if (!is_string(‪$body) && !is_resource(‪$body) && !‪$body instanceof StreamInterface) {
            throw new \InvalidArgumentException('Body must be a string stream resource identifier, a stream resource, or a StreamInterface instance', 1436717271);
        }
 
        if (!‪$body instanceof StreamInterface) {
            ‪$body = new ‪Stream(‪$body);
        }
 
        if (is_string(‪$uri)) {
            ‪$uri = new ‪Uri(‪$uri);
        }
 
        if (!‪$uri instanceof UriInterface && ‪$uri !== null) {
            throw new \InvalidArgumentException('Invalid URI provided; must be null, a string, or a UriInterface instance', 1436717272);
        }
 
        $this->‪validateMethod(‪$method);
 
        $this->method = ‪$method;
        $this->uri    = ‪$uri;
        $this->body   = ‪$body;
        list($this->lowercasedHeaderNames, ‪$headers) = $this->‪filterHeaders(‪$headers);
        $this->‪assertHeaders(‪$headers);
        $this->headers = ‪$headers;
    }
 
    public function ‪getHeaders()
    {
        ‪$headers = parent::getHeaders();
        if (!$this->‪hasHeader('host') && ($this->uri && $this->uri->getHost())) {
            ‪$headers['host'] = [$this->‪getHostFromUri()];
        }
        return ‪$headers;
    }
 
    public function ‪getHeader($header)
    {
        if (!$this->‪hasHeader($header) && strtolower($header) === 'host' && ($this->uri && $this->uri->getHost())) {
            return [$this->‪getHostFromUri()];
        }
        return parent::getHeader($header);
    }
 
    protected function ‪getHostFromUri()
    {
        $host  = $this->uri->getHost();
        $host .= $this->uri->getPort() ? ':' . $this->uri->getPort() : '';
        return $host;
    }
 
    public function ‪getRequestTarget()
    {
        if ($this->requestTarget !== null) {
            return ‪$this->requestTarget;
        }
        if (!$this->uri) {
            return '/';
        }
        $target = $this->uri->getPath();
 
        if ($this->uri->getQuery()) {
            $target .= '?' . $this->uri->getQuery();
        }
 
        if (empty($target)) {
            $target = '/';
        }
        return $target;
    }
 
    public function ‪withRequestTarget(‪$requestTarget)
    {
        if (preg_match('#\s#', ‪$requestTarget)) {
            throw new \InvalidArgumentException('Invalid request target provided which contains whitespaces.', 1436717273);
        }
        $clonedObject = clone $this;
        $clonedObject->requestTarget = ‪$requestTarget;
        return $clonedObject;
    }
 
    public function ‪getMethod()
    {
        return !empty($this->method) ? $this->method : 'GET';
    }
 
    public function ‪withMethod(‪$method)
    {
        $clonedObject = clone $this;
        $clonedObject->method = ‪$method;
        return $clonedObject;
    }
 
    public function ‪getUri()
    {
        return ‪$this->uri;
    }
 
    public function ‪withUri(UriInterface ‪$uri, $preserveHost = false)
    {
        $clonedObject = clone $this;
        $clonedObject->uri = ‪$uri;
 
        if ($preserveHost) {
            return $clonedObject;
        }
 
        if (!‪$uri->getHost()) {
            return $clonedObject;
        }
 
        $host = ‪$uri->getHost();
 
        if (‪$uri->getPort()) {
            $host .= ':' . ‪$uri->getPort();
        }
 
        $clonedObject->lowercasedHeaderNames['host'] = 'Host';
        $clonedObject->headers['Host'] = [$host];
        return $clonedObject;
    }
 
    protected function ‪validateMethod(‪$method)
    {
        if (‪$method !== null) {
            if (!is_string(‪$method)) {
                $methodAsString = is_object(‪$method) ? get_class(‪$method) : gettype(‪$method);
                throw new \InvalidArgumentException('Unsupported HTTP method "' . $methodAsString . '".', 1436717274);
            }
            ‪$method = strtoupper(‪$method);
            if (!in_array(‪$method, $this->supportedMethods, true)) {
                throw new \InvalidArgumentException('Unsupported HTTP method "' . ‪$method . '".', 1436717275);
            }
        }
    }
}