httpresponse.php

<?php
 
namespace Bitrix\Main;
 
use Bitrix\Main\Web\HttpHeaders;
 
class HttpResponse extends Response
{
    public const STORE_COOKIE_NAME = 'STORE_COOKIES';
 
    protected $cookies = [];
    protected $headers;
    protected $lastModified;
 
    public function __construct()
    {
        parent::__construct();
 
        $this->setHeaders(new Web\HttpHeaders());
    }
 
    public function flush($text = '')
    {
        //clear all buffers - the response is responsible alone for its content
        while (@ob_end_clean())
        {
            ;
        }
 
        if (function_exists('fastcgi_finish_request'))
        {
            //php-fpm
            $this->writeHeaders();
            $this->writeBody($text);
 
            fastcgi_finish_request();
        }
        else
        {
            //apache handler
            ob_start();
 
            $this->writeBody($text);
 
            $size = ob_get_length();
 
            $this->addHeader('Content-Length', $size);
 
            $this->writeHeaders();
 
            ob_end_flush();
            @ob_flush();
            flush();
        }
    }
 
    public function addHeader($name, $value = '')
    {
        if (empty($name))
        {
            throw new ArgumentNullException('name');
        }
 
        $this->getHeaders()->add($name, $value);
 
        return $this;
    }
 
    public function setHeaders(Web\HttpHeaders $headers)
    {
        $this->headers = $headers;
 
        return $this;
    }
 
    public function addCookie(Web\Cookie $cookie, $replace = true, $checkExpires = true)
    {
        $key = $cookie->getName() . '.' . $cookie->getDomain() . '.' . $cookie->getPath();
        if ($replace || !isset($this->cookies[$key]))
        {
            if ($checkExpires && $cookie->getExpires() > 0)
            {
                //it's a persistent cookie; we should check if we're allowed to store persistent cookies
                static $askToStore = null;
                if ($askToStore === null)
                {
                    $askToStore = Config\Option::get('main', 'ask_to_store_cookies');
                }
                if ($askToStore === 'Y')
                {
                    if (Context::getCurrent()->getRequest()->getCookiesMode() !== 'Y')
                    {
                        //user declined to store cookies - we're using session cookies only
                        $cookie->setExpires(0);
                    }
                }
            }
 
            $this->cookies[$key] = $cookie;
        }
        return $this;
    }
 
    public function allowPersistentCookies($mode)
    {
        if ($mode === true)
        {
            //persistent cookie to remember
            $cookie = new Web\Cookie(self::STORE_COOKIE_NAME, 'Y');
        }
        else
        {
            //session cookie: we're not allowed to store persistent cookies
            $cookie = new Web\Cookie(self::STORE_COOKIE_NAME, 'N', 0);
        }
        $this->addCookie($cookie, true, false);
    }
 
    public function getCookies()
    {
        return $this->cookies;
    }
 
    public function getHeaders()
    {
        return $this->headers;
    }
 
    public function writeHeaders()
    {
        $this->flushStatus();
 
        if ($this->lastModified !== null)
        {
            $this->flushHeader(['Last-Modified', gmdate('D, d M Y H:i:s', $this->lastModified->getTimestamp()) . ' GMT']);
        }
 
        foreach ($this->getHeaders() as $name => $values)
        {
            if (is_array($values))
            {
                foreach ($values as $value)
                {
                    $this->flushHeader([$name, $value]);
                }
            }
            elseif ($values !== '')
            {
                $this->flushHeader([$name, $values]);
            }
            else
            {
                $this->flushHeader($name);
            }
        }
 
        $cookiesCrypter = new Web\CookiesCrypter();
        foreach ($this->cookies as $cookie)
        {
            if (!$cookiesCrypter->shouldEncrypt($cookie))
            {
                $this->setCookie($cookie);
            }
            else
            {
                foreach ($cookiesCrypter->encrypt($cookie) as $cryptoCookie)
                {
                    $this->setCookie($cryptoCookie);
                }
            }
        }
    }
 
    protected function flushStatus()
    {
        if (($status = $this->headers->getStatus()) > 0)
        {
            $reasonPhrase = $this->headers->getReasonPhrase();
            if ($reasonPhrase != '')
            {
                $status .= ' ' . $reasonPhrase;
            }
 
            $httpStatus = Config\Configuration::getValue('http_status');
            $cgiMode = (stristr(php_sapi_name(), 'cgi') !== false);
 
            if ($cgiMode && !$httpStatus)
            {
                header('Status: ' . $status);
            }
            else
            {
                header($this->getServerProtocol() . ' ' . $status);
            }
        }
    }
 
    protected function flushHeader($header)
    {
        if (is_array($header))
        {
            header($header[0] . ': ' . $header[1]);
        }
        else
        {
            header($header);
        }
 
        return $this;
    }
 
    protected function setCookie(Web\Cookie $cookie)
    {
        if ($cookie->getSpread() & Web\Cookie::SPREAD_DOMAIN)
        {
            $params = [
                'expires' => $cookie->getExpires(),
                'path' => $cookie->getPath(),
                'domain' => $cookie->getDomain(),
                'secure' => $cookie->getSecure(),
                'httponly' => $cookie->getHttpOnly(),
            ];
 
            if (($sameSite = $cookie->getSameSite()) !== null)
            {
                $params['samesite'] = $sameSite;
            }
 
            setcookie(
                $cookie->getName(),
                $cookie->getValue(),
                $params
            );
        }
 
        return $this;
    }
 
    public function setStatus($status)
    {
        if (preg_match('#^(\d+) *(.*)#', $status, $find))
        {
            $this->headers->setStatus((int)$find[1], trim($find[2]));
        }
 
        return $this;
    }
 
    public function getStatus()
    {
        return $this->getHeaders()->getStatus();
    }
 
    protected function getServerProtocol()
    {
        $context = Context::getCurrent();
        if ($context !== null)
        {
            $server = $context->getServer();
            if ($server !== null)
            {
                return $server->get('SERVER_PROTOCOL');
            }
        }
        return 'HTTP/1.0';
    }
 
    public function setLastModified(Type\DateTime $time)
    {
        if ($this->lastModified === null || $time->getTimestamp() > $this->lastModified->getTimestamp())
        {
            $this->lastModified = $time;
        }
 
        return $this;
    }
 
    final public function redirectTo($url): HttpResponse
    {
        $redirectResponse = new Engine\Response\Redirect($url);
 
        return $this->copyHeadersTo($redirectResponse);
    }
 
    public function copyHeadersTo(HttpResponse $response): HttpResponse
    {
        $httpHeaders = $response->getHeaders();
 
        foreach ($this->getHeaders() as $headerName => $values)
        {
            if ($this->shouldIgnoreHeaderToClone($headerName))
            {
                continue;
            }
 
            if ($httpHeaders->get($headerName))
            {
                continue;
            }
 
            $httpHeaders->add($headerName, $values);
        }
 
        foreach ($this->getCookies() as $cookie)
        {
            $response->addCookie($cookie, false);
        }
 
        $status = $this->getStatus();
        if ($status !== HttpHeaders::DEFAULT_HTTP_STATUS)
        {
            $response->setStatus($status);
        }
 
        return $response;
    }
 
    private function shouldIgnoreHeaderToClone($headerName)
    {
        return in_array(strtolower($headerName), [
            'content-encoding',
            'content-length',
            'content-type',
        ], true);
    }
}