vendor/symfony/http-foundation/ResponseHeaderBag.php line 187

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\HttpFoundation;
  14. /**
  15.  * ResponseHeaderBag is a container for Response HTTP headers.
  16.  *
  17.  * @author Fabien Potencier <fabien@symfony.com>
  18.  */
  19. class ResponseHeaderBag extends HeaderBag
  20. {
  21.     public const COOKIES_FLAT = 'flat';
  22.     public const COOKIES_ARRAY = 'array';
  24.     public const DISPOSITION_ATTACHMENT = 'attachment';
  25.     public const DISPOSITION_INLINE = 'inline';
  27.     protected $computedCacheControl = [];
  28.     protected $cookies = [];
  29.     protected $headerNames = [];
  31.     public function __construct(array $headers = [])
  32.     {
  33.         parent::__construct($headers);
  35.         if (!isset($this->headers['cache-control'])) {
  36.             $this->set('Cache-Control', '');
  37.         }
  39.         /* RFC2616 - 14.18 says all Responses need to have a Date */
  40.         if (!isset($this->headers['date'])) {
  41.             $this->initDate();
  42.         }
  43.     }
  45.     /**
  46.      * Returns the headers, with original capitalizations.
  47.      */
  48.     public function allPreserveCase(): array
  49.     {
  50.         $headers = [];
  51.         foreach ($this->all() as $name => $value) {
  52.             $headers[$this->headerNames[$name] ?? $name] = $value;
  53.         }
  55.         return $headers;
  56.     }
  58.     public function allPreserveCaseWithoutCookies()
  59.     {
  60.         $headers = $this->allPreserveCase();
  61.         if (isset($this->headerNames['set-cookie'])) {
  62.             unset($headers[$this->headerNames['set-cookie']]);
  63.         }
  65.         return $headers;
  66.     }
  68.     /**
  69.      * {@inheritdoc}
  70.      */
  71.     public function replace(array $headers = [])
  72.     {
  73.         $this->headerNames = [];
  75.         parent::replace($headers);
  77.         if (!isset($this->headers['cache-control'])) {
  78.             $this->set('Cache-Control', '');
  79.         }
  81.         if (!isset($this->headers['date'])) {
  82.             $this->initDate();
  83.         }
  84.     }
  86.     /**
  87.      * {@inheritdoc}
  88.      */
  89.     public function all(string $key = null): array
  90.     {
  91.         $headers = parent::all();
  93.         if (null !== $key) {
  94.             $key = strtr($key, self::UPPER, self::LOWER);
  96.             return 'set-cookie' !== $key ? $headers[$key] ?? [] : array_map('strval', $this->getCookies());
  97.         }
  99.         foreach ($this->getCookies() as $cookie) {
  100.             $headers['set-cookie'][] = (string) $cookie;
  101.         }
  103.         return $headers;
  104.     }
  106.     /**
  107.      * {@inheritdoc}
  108.      */
  109.     public function set(string $key, string|array|null $values, bool $replace = true)
  110.     {
  111.         $uniqueKey = strtr($key, self::UPPER, self::LOWER);
  113.         if ('set-cookie' === $uniqueKey) {
  114.             if ($replace) {
  115.                 $this->cookies = [];
  116.             }
  117.             foreach ((array) $values as $cookie) {
  118.                 $this->setCookie(Cookie::fromString($cookie));
  119.             }
  120.             $this->headerNames[$uniqueKey] = $key;
  122.             return;
  123.         }
  125.         $this->headerNames[$uniqueKey] = $key;
  127.         parent::set($key, $values, $replace);
  129.         // ensure the cache-control header has sensible defaults
  130.         if (\in_array($uniqueKey, ['cache-control', 'etag', 'last-modified', 'expires'], true) && '' !== $computed = $this->computeCacheControlValue()) {
  131.             $this->headers['cache-control'] = [$computed];
  132.             $this->headerNames['cache-control'] = 'Cache-Control';
  133.             $this->computedCacheControl = $this->parseCacheControl($computed);
  134.         }
  135.     }
  137.     /**
  138.      * {@inheritdoc}
  139.      */
  140.     public function remove(string $key)
  141.     {
  142.         $uniqueKey = strtr($key, self::UPPER, self::LOWER);
  143.         unset($this->headerNames[$uniqueKey]);
  145.         if ('set-cookie' === $uniqueKey) {
  146.             $this->cookies = [];
  148.             return;
  149.         }
  151.         parent::remove($key);
  153.         if ('cache-control' === $uniqueKey) {
  154.             $this->computedCacheControl = [];
  155.         }
  157.         if ('date' === $uniqueKey) {
  158.             $this->initDate();
  159.         }
  160.     }
  162.     /**
  163.      * {@inheritdoc}
  164.      */
  165.     public function hasCacheControlDirective(string $key): bool
  166.     {
  167.         return \array_key_exists($key, $this->computedCacheControl);
  168.     }
  170.     /**
  171.      * {@inheritdoc}
  172.      */
  173.     public function getCacheControlDirective(string $key): bool|string|null
  174.     {
  175.         return $this->computedCacheControl[$key] ?? null;
  176.     }
  178.     public function setCookie(Cookie $cookie)
  179.     {
  180.         $this->cookies[$cookie->getDomain()][$cookie->getPath()][$cookie->getName()] = $cookie;
  181.         $this->headerNames['set-cookie'] = 'Set-Cookie';
  182.     }
  184.     /**
  185.      * Removes a cookie from the array, but does not unset it in the browser.
  186.      */
  187.     public function removeCookie(string $name, ?string $path = '/', string $domain = null)
  188.     {
  189.         if (null === $path) {
  190.             $path = '/';
  191.         }
  193.         unset($this->cookies[$domain][$path][$name]);
  195.         if (empty($this->cookies[$domain][$path])) {
  196.             unset($this->cookies[$domain][$path]);
  198.             if (empty($this->cookies[$domain])) {
  199.                 unset($this->cookies[$domain]);
  200.             }
  201.         }
  203.         if (empty($this->cookies)) {
  204.             unset($this->headerNames['set-cookie']);
  205.         }
  206.     }
  208.     /**
  209.      * Returns an array with all cookies.
  210.      *
  211.      * @return Cookie[]
  212.      *
  213.      * @throws \InvalidArgumentException When the $format is invalid
  214.      */
  215.     public function getCookies(string $format = self::COOKIES_FLAT): array
  216.     {
  217.         if (!\in_array($format, [self::COOKIES_FLAT, self::COOKIES_ARRAY])) {
  218.             throw new \InvalidArgumentException(sprintf('Format "%s" invalid (%s).', $format, implode(', ', [self::COOKIES_FLAT, self::COOKIES_ARRAY])));
  219.         }
  221.         if (self::COOKIES_ARRAY === $format) {
  222.             return $this->cookies;
  223.         }
  225.         $flattenedCookies = [];
  226.         foreach ($this->cookies as $path) {
  227.             foreach ($path as $cookies) {
  228.                 foreach ($cookies as $cookie) {
  229.                     $flattenedCookies[] = $cookie;
  230.                 }
  231.             }
  232.         }
  234.         return $flattenedCookies;
  235.     }
  237.     /**
  238.      * Clears a cookie in the browser.
  239.      */
  240.     public function clearCookie(string $name, ?string $path = '/', string $domain = null, bool $secure = false, bool $httpOnly = true, string $sameSite = null)
  241.     {
  242.         $this->setCookie(new Cookie($name, null, 1, $path, $domain, $secure, $httpOnly, false, $sameSite));
  243.     }
  245.     /**
  246.      * @see HeaderUtils::makeDisposition()
  247.      */
  248.     public function makeDisposition(string $disposition, string $filename, string $filenameFallback = '')
  249.     {
  250.         return HeaderUtils::makeDisposition($disposition, $filename, $filenameFallback);
  251.     }
  253.     /**
  254.      * Returns the calculated value of the cache-control header.
  255.      *
  256.      * This considers several other headers and calculates or modifies the
  257.      * cache-control header to a sensible, conservative value.
  258.      */
  259.     protected function computeCacheControlValue(): string
  260.     {
  261.         if (!$this->cacheControl) {
  262.             if ($this->has('Last-Modified') || $this->has('Expires')) {
  263.                 return 'private, must-revalidate'; // allows for heuristic expiration (RFC 7234 Section 4.2.2) in the case of "Last-Modified"
  264.             }
  266.             // conservative by default
  267.             return 'no-cache, private';
  268.         }
  270.         $header = $this->getCacheControlHeader();
  271.         if (isset($this->cacheControl['public']) || isset($this->cacheControl['private'])) {
  272.             return $header;
  273.         }
  275.         // public if s-maxage is defined, private otherwise
  276.         if (!isset($this->cacheControl['s-maxage'])) {
  277.             return $header.', private';
  278.         }
  280.         return $header;
  281.     }
  283.     private function initDate(): void
  284.     {
  285.         $this->set('Date', gmdate('D, d M Y H:i:s').' GMT');
  286.     }
  287. }