[Summary view] [Print] [Text view]

   1  <?php
   2  
   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   */
  11  
  12  namespace Symfony\Component\HttpFoundation;
  13  
  14  /**
  15   * HeaderBag is a container for HTTP headers.
  16   *
  17   * @author Fabien Potencier <fabien@symfony.com>
  18   */
  19  class HeaderBag implements \IteratorAggregate, \Countable
  20  {
  21      protected $headers = [];
  22      protected $cacheControl = [];
  23  
  24      /**
  25       * @param array $headers An array of HTTP headers
  26       */
  27      public function __construct(array $headers = [])
  28      {
  29          foreach ($headers as $key => $values) {
  30              $this->set($key, $values);
  31          }
  32      }
  33  
  34      /**
  35       * Returns the headers as a string.
  36       *
  37       * @return string The headers
  38       */
  39      public function __toString()
  40      {
  41          if (!$headers = $this->all()) {
  42              return '';
  43          }
  44  
  45          ksort($headers);
  46          $max = max(array_map('strlen', array_keys($headers))) + 1;
  47          $content = '';
  48          foreach ($headers as $name => $values) {
  49              $name = implode('-', array_map('ucfirst', explode('-', $name)));
  50              foreach ($values as $value) {
  51                  $content .= sprintf("%-{$max}s %s\r\n", $name.':', $value);
  52              }
  53          }
  54  
  55          return $content;
  56      }
  57  
  58      /**
  59       * Returns the headers.
  60       *
  61       * @return array An array of headers
  62       */
  63      public function all()
  64      {
  65          return $this->headers;
  66      }
  67  
  68      /**
  69       * Returns the parameter keys.
  70       *
  71       * @return array An array of parameter keys
  72       */
  73      public function keys()
  74      {
  75          return array_keys($this->all());
  76      }
  77  
  78      /**
  79       * Replaces the current HTTP headers by a new set.
  80       *
  81       * @param array $headers An array of HTTP headers
  82       */
  83      public function replace(array $headers = [])
  84      {
  85          $this->headers = [];
  86          $this->add($headers);
  87      }
  88  
  89      /**
  90       * Adds new headers the current HTTP headers set.
  91       *
  92       * @param array $headers An array of HTTP headers
  93       */
  94      public function add(array $headers)
  95      {
  96          foreach ($headers as $key => $values) {
  97              $this->set($key, $values);
  98          }
  99      }
 100  
 101      /**
 102       * Returns a header value by name.
 103       *
 104       * @param string      $key     The header name
 105       * @param string|null $default The default value
 106       * @param bool        $first   Whether to return the first value or all header values
 107       *
 108       * @return string|string[]|null The first header value or default value if $first is true, an array of values otherwise
 109       */
 110      public function get($key, $default = null, $first = true)
 111      {
 112          $key = str_replace('_', '-', strtolower($key));
 113          $headers = $this->all();
 114  
 115          if (!\array_key_exists($key, $headers)) {
 116              if (null === $default) {
 117                  return $first ? null : [];
 118              }
 119  
 120              return $first ? $default : [$default];
 121          }
 122  
 123          if ($first) {
 124              if (!$headers[$key]) {
 125                  return $default;
 126              }
 127  
 128              if (null === $headers[$key][0]) {
 129                  return null;
 130              }
 131  
 132              return (string) $headers[$key][0];
 133          }
 134  
 135          return $headers[$key];
 136      }
 137  
 138      /**
 139       * Sets a header by name.
 140       *
 141       * @param string          $key     The key
 142       * @param string|string[] $values  The value or an array of values
 143       * @param bool            $replace Whether to replace the actual value or not (true by default)
 144       */
 145      public function set($key, $values, $replace = true)
 146      {
 147          $key = str_replace('_', '-', strtolower($key));
 148  
 149          if (\is_array($values)) {
 150              $values = array_values($values);
 151  
 152              if (true === $replace || !isset($this->headers[$key])) {
 153                  $this->headers[$key] = $values;
 154              } else {
 155                  $this->headers[$key] = array_merge($this->headers[$key], $values);
 156              }
 157          } else {
 158              if (true === $replace || !isset($this->headers[$key])) {
 159                  $this->headers[$key] = [$values];
 160              } else {
 161                  $this->headers[$key][] = $values;
 162              }
 163          }
 164  
 165          if ('cache-control' === $key) {
 166              $this->cacheControl = $this->parseCacheControl(implode(', ', $this->headers[$key]));
 167          }
 168      }
 169  
 170      /**
 171       * Returns true if the HTTP header is defined.
 172       *
 173       * @param string $key The HTTP header
 174       *
 175       * @return bool true if the parameter exists, false otherwise
 176       */
 177      public function has($key)
 178      {
 179          return \array_key_exists(str_replace('_', '-', strtolower($key)), $this->all());
 180      }
 181  
 182      /**
 183       * Returns true if the given HTTP header contains the given value.
 184       *
 185       * @param string $key   The HTTP header name
 186       * @param string $value The HTTP value
 187       *
 188       * @return bool true if the value is contained in the header, false otherwise
 189       */
 190      public function contains($key, $value)
 191      {
 192          return \in_array($value, $this->get($key, null, false));
 193      }
 194  
 195      /**
 196       * Removes a header.
 197       *
 198       * @param string $key The HTTP header name
 199       */
 200      public function remove($key)
 201      {
 202          $key = str_replace('_', '-', strtolower($key));
 203  
 204          unset($this->headers[$key]);
 205  
 206          if ('cache-control' === $key) {
 207              $this->cacheControl = [];
 208          }
 209      }
 210  
 211      /**
 212       * Returns the HTTP header value converted to a date.
 213       *
 214       * @param string    $key     The parameter key
 215       * @param \DateTime $default The default value
 216       *
 217       * @return \DateTime|null The parsed DateTime or the default value if the header does not exist
 218       *
 219       * @throws \RuntimeException When the HTTP header is not parseable
 220       */
 221      public function getDate($key, \DateTime $default = null)
 222      {
 223          if (null === $value = $this->get($key)) {
 224              return $default;
 225          }
 226  
 227          if (false === $date = \DateTime::createFromFormat(\DATE_RFC2822, $value)) {
 228              throw new \RuntimeException(sprintf('The "%s" HTTP header is not parseable (%s).', $key, $value));
 229          }
 230  
 231          return $date;
 232      }
 233  
 234      /**
 235       * Adds a custom Cache-Control directive.
 236       *
 237       * @param string $key   The Cache-Control directive name
 238       * @param mixed  $value The Cache-Control directive value
 239       */
 240      public function addCacheControlDirective($key, $value = true)
 241      {
 242          $this->cacheControl[$key] = $value;
 243  
 244          $this->set('Cache-Control', $this->getCacheControlHeader());
 245      }
 246  
 247      /**
 248       * Returns true if the Cache-Control directive is defined.
 249       *
 250       * @param string $key The Cache-Control directive
 251       *
 252       * @return bool true if the directive exists, false otherwise
 253       */
 254      public function hasCacheControlDirective($key)
 255      {
 256          return \array_key_exists($key, $this->cacheControl);
 257      }
 258  
 259      /**
 260       * Returns a Cache-Control directive value by name.
 261       *
 262       * @param string $key The directive name
 263       *
 264       * @return mixed|null The directive value if defined, null otherwise
 265       */
 266      public function getCacheControlDirective($key)
 267      {
 268          return \array_key_exists($key, $this->cacheControl) ? $this->cacheControl[$key] : null;
 269      }
 270  
 271      /**
 272       * Removes a Cache-Control directive.
 273       *
 274       * @param string $key The Cache-Control directive
 275       */
 276      public function removeCacheControlDirective($key)
 277      {
 278          unset($this->cacheControl[$key]);
 279  
 280          $this->set('Cache-Control', $this->getCacheControlHeader());
 281      }
 282  
 283      /**
 284       * Returns an iterator for headers.
 285       *
 286       * @return \ArrayIterator An \ArrayIterator instance
 287       */
 288      public function getIterator()
 289      {
 290          return new \ArrayIterator($this->headers);
 291      }
 292  
 293      /**
 294       * Returns the number of headers.
 295       *
 296       * @return int The number of headers
 297       */
 298      public function count()
 299      {
 300          return \count($this->headers);
 301      }
 302  
 303      protected function getCacheControlHeader()
 304      {
 305          $parts = [];
 306          ksort($this->cacheControl);
 307          foreach ($this->cacheControl as $key => $value) {
 308              if (true === $value) {
 309                  $parts[] = $key;
 310              } else {
 311                  if (preg_match('#[^a-zA-Z0-9._-]#', $value)) {
 312                      $value = '"'.$value.'"';
 313                  }
 314  
 315                  $parts[] = "$key=$value";
 316              }
 317          }
 318  
 319          return implode(', ', $parts);
 320      }
 321  
 322      /**
 323       * Parses a Cache-Control HTTP header.
 324       *
 325       * @param string $header The value of the Cache-Control HTTP header
 326       *
 327       * @return array An array representing the attribute values
 328       */
 329      protected function parseCacheControl($header)
 330      {
 331          $cacheControl = [];
 332          preg_match_all('#([a-zA-Z][a-zA-Z_-]*)\s*(?:=(?:"([^"]*)"|([^ \t",;]*)))?#', $header, $matches, \PREG_SET_ORDER);
 333          foreach ($matches as $match) {
 334              $cacheControl[strtolower($match[1])] = isset($match[3]) ? $match[3] : (isset($match[2]) ? $match[2] : true);
 335          }
 336  
 337          return $cacheControl;
 338      }
 339  }