httprequest.php

См. документацию.

<?php

 
namespace Bitrix\Main;
 
use Bitrix\Main\Web\HttpHeaders;

class HttpRequest extends Request
{
    protected $queryString;
    protected $postData;
    protected $files;
    protected $cookies;
    protected $cookiesRaw;
    protected $jsonData;
    protected $headers;
    protected $httpHost;
    protected $acceptedLanguages;

    public function __construct(Server $server, array $queryString, array $postData, array $files, array $cookies, array $jsonData = [])
    {
        $request = array_merge($queryString, $postData);
        parent::__construct($server, $request);
 
        $this->queryString = new Type\ParameterDictionary($queryString);
        $this->postData = new Type\ParameterDictionary($postData);
        $this->files = new Type\ParameterDictionary($files);
        $this->cookiesRaw = new Type\ParameterDictionary($cookies);
        $this->cookies = new Type\ParameterDictionary($this->prepareCookie($cookies));
        $this->headers = $this->buildHttpHeaders($server);
        $this->jsonData = new Type\ParameterDictionary($jsonData);
    }
 
    private function buildHttpHeaders(Server $server)
    {
        $headers = new HttpHeaders();
        foreach ($this->fetchHeaders($server) as $headerName => $value)
        {
            try
            {
                $headers->add($headerName, $value);
            }
            catch (\InvalidArgumentException)
            {
                // ignore an invalid header
            }
        }
 
        return $headers;
    }

    public function addFilter(Type\IRequestFilter $filter)
    {
        parent::addFilter($filter);
 
        $filteredValues = $filter->filter([
            'get' => $this->queryString->values,
            'post' => $this->postData->values,
            'files' => $this->files->values,
            'cookie' => $this->cookiesRaw->values,
            'json' => $this->jsonData->values,
        ]);
 
        if (isset($filteredValues['get']))
        {
            $this->queryString->setValuesNoDemand($filteredValues['get']);
        }
        if (isset($filteredValues['post']))
        {
            $this->postData->setValuesNoDemand($filteredValues['post']);
        }
        if (isset($filteredValues['files']))
        {
            $this->files->setValuesNoDemand($filteredValues['files']);
        }
        if (isset($filteredValues['cookie']))
        {
            $this->cookiesRaw->setValuesNoDemand($filteredValues['cookie']);
            $this->cookies = new Type\ParameterDictionary($this->prepareCookie($filteredValues['cookie']));
        }
        if (isset($filteredValues['json']))
        {
            $this->jsonData->setValuesNoDemand($filteredValues['json']);
        }
 
        if (isset($filteredValues['get']) || isset($filteredValues['post']))
        {
            $this->setValuesNoDemand(array_merge($this->queryString->values, $this->postData->values));
        }
 
        // need to reinit
        $this->requestedPage = null;
        $this->requestedPageDirectory = null;
    }

    public function getQuery($name)
    {
        return $this->queryString->get($name);
    }

    public function getQueryList()
    {
        return $this->queryString;
    }

    public function getPost($name)
    {
        return $this->postData->get($name);
    }

    public function getPostList()
    {
        return $this->postData;
    }

    public function getFile($name)
    {
        return $this->files->get($name);
    }

    public function getFileList()
    {
        return $this->files;
    }

    public function getHeader($name)
    {
        return $this->headers->get($name);
    }

    public function getHeaders()
    {
        return $this->headers;
    }

    public function getCookie($name)
    {
        return $this->cookies->get($name);
    }

    public function getCookieList()
    {
        return $this->cookies;
    }
 
    public function getCookieRaw($name)
    {
        return $this->cookiesRaw->get($name);
    }
 
    public function getCookieRawList()
    {
        return $this->cookiesRaw;
    }
 
    public function getJsonList()
    {
        return $this->jsonData;
    }
 
    public function getRemoteAddress()
    {
        return $this->server->get('REMOTE_ADDR');
    }

    public function getUserAgent()
    {
        return $this->server->get('HTTP_USER_AGENT');
    }
 
    public function getRequestUri()
    {
        return $this->server->getRequestUri();
    }
 
    public function getRequestMethod()
    {
        return $this->server->getRequestMethod();
    }

    public function getServerPort()
    {
        return $this->server->getServerPort();
    }
 
    public function isPost()
    {
        return ($this->getRequestMethod() == 'POST');
    }
 
    public function getAcceptedLanguages()
    {
        if ($this->acceptedLanguages === null)
        {
            $this->acceptedLanguages = [];
 
            $acceptedLanguages = explode(',', $this->server->get('HTTP_ACCEPT_LANGUAGE'));
            foreach ($acceptedLanguages as $language)
            {
                $lang = explode(';', $language);
                $this->acceptedLanguages[] = $lang[0];
            }
        }
 
        return $this->acceptedLanguages;
    }

    public function getRequestedPage()
    {
        if ($this->requestedPage === null)
        {
            if (($uri = $this->getRequestUri()) == '')
            {
                $this->requestedPage = parent::getRequestedPage();
            }
            else
            {
                $parsedUri = new Web\Uri("http://" . $this->server->getHttpHost() . $uri);
                $this->requestedPage = static::normalize(static::decode($parsedUri->getPath()));
            }
        }
        return $this->requestedPage;
    }

    public function getDecodedUri()
    {
        $parsedUri = new Web\Uri("http://" . $this->server->getHttpHost() . $this->getRequestUri());
 
        $uri = static::decode($parsedUri->getPath());
 
        if (($query = $parsedUri->getQuery()) != '')
        {
            $uri .= "?" . $query;
        }
 
        return $uri;
    }
 
    protected static function decode($url)
    {
        return rawurldecode($url);
    }

    public function getHttpHost()
    {
        if ($this->httpHost === null)
        {
            //scheme can be anything, it's used only for parsing
            $url = new Web\Uri("http://" . $this->server->getHttpHost());
            $host = $url->getHost();
            $host = trim($host, "\t\r\n\0 .");
 
            $this->httpHost = $host;
        }
 
        return $this->httpHost;
    }
 
    public function isHttps()
    {
        if ($this->server->get("SERVER_PORT") == 443)
        {
            return true;
        }
 
        $https = $this->server->get("HTTPS");
        if ($https != '' && strtolower($https) != "off")
        {
            //From the PHP manual: Set to a non-empty value if the script was queried through the HTTPS protocol.
            //Note that when using ISAPI with IIS, the value will be off if the request was not made through the HTTPS protocol.
            return true;
        }
 
        return (Config\Configuration::getValue("https_request") === true);
    }
 
    public function modifyByQueryString($queryString)
    {
        if ($queryString != '')
        {
            parse_str($queryString, $vars);
 
            $this->values += $vars;
            $this->queryString->values += $vars;
        }
    }

    protected function prepareCookie(array $cookies)
    {
        static $cookiePrefix = null;
        if ($cookiePrefix === null)
        {
            $cookiePrefix = Config\Option::get("main", "cookie_name", "BITRIX_SM") . "_";
        }
 
        $cookiePrefixLength = mb_strlen($cookiePrefix);
 
        $cookiesCrypter = new Web\CookiesCrypter();
        $cookiesNew = $cookiesToDecrypt = [];
        foreach ($cookies as $name => $value)
        {
            if (!str_starts_with($name, $cookiePrefix))
            {
                continue;
            }
 
            $name = mb_substr($name, $cookiePrefixLength);
            if (is_string($value) && $cookiesCrypter->shouldDecrypt($name, $value))
            {
                $cookiesToDecrypt[$name] = $value;
            }
            else
            {
                $cookiesNew[$name] = $value;
            }
        }
 
        foreach ($cookiesToDecrypt as $name => $value)
        {
            $cookiesNew[$name] = $cookiesCrypter->decrypt($name, $value, $cookiesNew);
        }
 
        return $cookiesNew;
    }
 
    private function fetchHeaders(Server $server)
    {
        $headers = [];
        foreach ($server as $name => $value)
        {
            if (str_starts_with($name, 'HTTP_'))
            {
                $headerName = substr($name, 5);
                $headers[$headerName] = $value;
            }
            elseif (in_array($name, ['CONTENT_TYPE', 'CONTENT_LENGTH'], true))
            {
                $headers[$name] = $value;
            }
        }
 
        return $this->normalizeHeaders($headers);
    }
 
    private function normalizeHeaders(array $headers)
    {
        $normalizedHeaders = [];
        foreach ($headers as $name => $value)
        {
            $headerName = strtolower(str_replace('_', '-', $name));
            $normalizedHeaders[$headerName] = $value;
        }
 
        return $normalizedHeaders;
    }
 
    protected static function normalize($path)
    {
        if (str_ends_with($path, "/"))
        {
            $path .= "index.php";
        }
 
        $path = IO\Path::normalize($path);
 
        return $path;
    }

    public function getScriptFile()
    {
        $scriptName = $this->getScriptName();
        if ($scriptName == "/bitrix/routing_index.php" || $scriptName == "/bitrix/urlrewrite.php" || $scriptName == "/404.php")
        {
            if (($v = $this->server->get("REAL_FILE_PATH")) != null)
            {
                $scriptName = $v;
            }
        }
        return $scriptName;
    }

    public static function getSystemParameters()
    {
        static $params = [
            "login",
            "login_form",
            "logout",
            "register",
            "forgot_password",
            "change_password",
            "confirm_registration",
            "confirm_code",
            "confirm_user_id",
            "bitrix_include_areas",
            "clear_cache",
            "show_page_exec_time",
            "show_include_exec_time",
            "show_sql_stat",
            "show_cache_stat",
            "show_link_stat",
            "sessid",
        ];
        return $params;
    }

    public static function getInput()
    {
        return file_get_contents("php://input");
    }

    public function getCookiesMode()
    {
        return $this->getCookie(HttpResponse::STORE_COOKIE_NAME);
    }
 
    public function isJson(): bool
    {
        $contentType = $this->headers->getContentType();
        if (!$contentType)
        {
            return false;
        }
        if ($contentType === 'application/json')
        {
            return true;
        }
 
        return str_contains($contentType, '+json');
    }

    public function decodeJson(): void
    {
        if ($this->isJson())
        {
            try
            {
                $json = Web\Json::decode(static::getInput());
                if (is_array($json))
                {
                    $this->jsonData = new Type\ParameterDictionary($json);
                }
            }
            catch (ArgumentException)
            {
            }
        }
    }
 
    public function decodeJsonStrict(): void
    {
        if (!$this->isJson())
        {
            throw new SystemException('Input is not valid JSON');
        }
        if (empty($this->jsonData->getValues()))
        {
            $json = Web\Json::decode(static::getInput());
            if (!is_array($json))
            {
                throw new SystemException('Decoded JSON is not an array');
            }
 
            $this->jsonData = new Type\ParameterDictionary($json);
        }
    }
}