httpheaders.php

<?php
 
namespace Bitrix\Main\Web;
 
use Bitrix\Main\Context;
use Bitrix\Main\Text\Encoding;
use IteratorAggregate;
use Traversable;
 
class HttpHeaders implements IteratorAggregate
{
    public const DEFAULT_HTTP_STATUS = 0;
 
    protected array $headers = [];
    protected string $version = '1.1';
    protected int $status;
    protected ?string $reasonPhrase = null;
 
    public function __construct(array $headers = null)
    {
        if ($headers !== null)
        {
            foreach ($headers as $header => $value)
            {
                $this->add($header, $value);
            }
        }
    }
 
    public function add($name, $value)
    {
        // compatibility
        $name = (string)$name;
 
        // PSR-7: The implementation SHOULD reject invalid values and SHOULD NOT make any attempt to automatically correct the provided values.
        if ($name == '' || !static::validateName($name))
        {
            throw new \InvalidArgumentException("Invalid header name '{$name}'.");
        }
 
        if (!is_array($value))
        {
            $value = [$value];
        }
 
        foreach ($value as $key => $val)
        {
            $value[$key] = (string)$val;
            if (!static::validateValue($value[$key]))
            {
                throw new \InvalidArgumentException("Invalid header value '{$value[$key]}'.");
            }
        }
 
        $nameLower = strtolower($name);
 
        if (!isset($this->headers[$nameLower]))
        {
            $this->headers[$nameLower] = [
                'name' => $name,
                'values' => [],
            ];
        }
        foreach ($value as $val)
        {
            $this->headers[$nameLower]['values'][] = $val;
        }
    }
 
    protected static function validateName(string $name): bool
    {
        return (!str_contains($name, "\0") && preg_match('/^[a-zA-Z0-9\'`#$%&*+.^_|~!-]+$/', $name));
    }
 
    protected static function validateValue(string $value): bool
    {
        return (!str_contains($value, "\0") && preg_match('/^[\x20\x09\x21-\x7E\x80-\xFF]*$/', $value));
    }
 
    public function set($name, $value)
    {
        $this->delete($name);
        $this->add($name, $value);
    }
 
    public function get($name, $returnArray = false)
    {
        $nameLower = strtolower($name);
 
        if (isset($this->headers[$nameLower]))
        {
            if ($returnArray)
            {
                return $this->headers[$nameLower]['values'];
            }
 
            return $this->headers[$nameLower]['values'][0];
        }
 
        return null;
    }
 
    public function delete($name)
    {
        $nameLower = strtolower($name);
 
        if (isset($this->headers[$nameLower]))
        {
            unset($this->headers[$nameLower]);
        }
    }
 
    public function has(string $name): bool
    {
        $nameLower = strtolower($name);
 
        return isset($this->headers[$nameLower]);
    }
 
    public function clear()
    {
        $this->headers = [];
    }
 
    public function toString()
    {
        $str = "";
        foreach ($this->headers as $header)
        {
            foreach ($header["values"] as $value)
            {
                $str .= $header["name"] . ": " . $value . "\r\n";
            }
        }
 
        return $str;
    }
 
    public function toArray()
    {
        return $this->headers;
    }
 
    public function getContentType()
    {
        $contentType = $this->get("Content-Type");
        if ($contentType !== null)
        {
            $parts = explode(";", $contentType);
 
            // RFC 2045 says: "The type, subtype, and parameter names are not case-sensitive."
            return strtolower(trim($parts[0]));
        }
 
        return null;
    }
 
    public function getContentTypeAttribute(string $attribute)
    {
        $contentType = $this->get('Content-Type');
        if ($contentType !== null)
        {
            $attribute = strtolower($attribute);
            $parts = explode(';', $contentType);
 
            foreach ($parts as $part)
            {
                $values = explode('=', $part);
                if (strtolower(trim($values[0])) == $attribute)
                {
                    return trim($values[1]);
                }
            }
        }
 
        return null;
    }
 
    public function getBoundary()
    {
        return $this->getContentTypeAttribute('boundary');
    }
 
    public function getCharset()
    {
        return $this->getContentTypeAttribute('charset');
    }
 
    public function getContentDisposition()
    {
        $contentDisposition = $this->get("Content-Disposition");
        if ($contentDisposition !== null)
        {
            $parts = explode(";", $contentDisposition);
 
            return trim($parts[0]);
        }
 
        return null;
    }
 
    public function getFilename()
    {
        $contentDisposition = $this->get('Content-Disposition');
        if ($contentDisposition !== null)
        {
            $filename = null;
            $encoding = null;
 
            $contentElements = explode(';', $contentDisposition);
            foreach ($contentElements as $contentElement)
            {
                $contentElement = trim($contentElement);
                if (preg_match('/^filename\*=(.+)\'(.+)?\'(.+)$/', $contentElement, $matches))
                {
                    $filename = $matches[3];
                    $encoding = $matches[1];
                    break;
                }
                elseif (preg_match('/^filename="(.+)"$/', $contentElement, $matches))
                {
                    $filename = $matches[1];
                }
                elseif (preg_match('/^filename=(.+)$/', $contentElement, $matches))
                {
                    $filename = $matches[1];
                }
            }
 
            if ($filename <> '')
            {
                $filename = urldecode($filename);
 
                if ($encoding <> '')
                {
                    $charset = Context::getCurrent()->getCulture()->getCharset();
                    $filename = Encoding::convertEncoding($filename, $encoding, $charset);
                }
            }
 
            return $filename;
        }
 
        return null;
    }
 
    public function getIterator(): Traversable
    {
        $toIterate = [];
        foreach ($this->headers as $header)
        {
            $toIterate[$header['name']] = $header['values'];
        }
 
        return new \ArrayIterator($toIterate);
    }
 
    public function getCookies(): HttpCookies
    {
        $cookies = new HttpCookies();
 
        if ($this->has('set-cookie'))
        {
            foreach ($this->get('set-cookie', true) as $value)
            {
                $cookies->addFromString($value);
            }
        }
 
        return $cookies;
    }
 
    public function getHeaders(): array
    {
        return iterator_to_array($this->getIterator());
    }
 
    public static function createFromString(string $response): HttpHeaders
    {
        $headers = new static();
 
        $headerName = null;
        foreach (explode("\n", $response) as $k => $header)
        {
            if ($k == 0)
            {
                $headers->parseStatus($header);
            }
            elseif (preg_match("/^[ \\t]/", $header))
            {
                if ($headerName !== null)
                {
                    try
                    {
                        $headers->add($headerName, trim($header));
                    }
                    catch (\InvalidArgumentException)
                    {
                        // ignore an invalid header
                    }
                }
            }
            elseif (str_contains($header, ':'))
            {
                [$headerName, $headerValue] = explode(':', $header, 2);
                try
                {
                    $headers->add($headerName, trim($headerValue));
                }
                catch (\InvalidArgumentException)
                {
                    // ignore an invalid header
                }
            }
        }
 
        return $headers;
    }
 
    public function parseStatus(string $status): HttpHeaders
    {
        if (preg_match('#^HTTP/(\S+) (\d+) *(.*)#', $status, $find))
        {
            $this->version = $find[1];
            $this->setStatus((int)$find[2], trim($find[3]));
        }
 
        return $this;
    }
 
    public function setStatus(int $status, ?string $reasonPhrase = null): HttpHeaders
    {
        $this->status = $status;
        $this->reasonPhrase = $reasonPhrase;
 
        return $this;
    }
 
    public function getStatus(): int
    {
        return $this->status ?? self::DEFAULT_HTTP_STATUS;
    }
 
    public function setVersion(string $version): HttpHeaders
    {
        $this->version = $version;
 
        return $this;
    }
 
    public function getVersion(): ?string
    {
        return $this->version;
    }
 
    public function getReasonPhrase(): string
    {
        return $this->reasonPhrase ?? '';
    }
}