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:  * ResponseHeaderBag is a container for Response HTTP headers.
 16:  *
 17:  * @author Fabien Potencier <fabien@symfony.com>
 18:  *
 19:  * @api
 20:  */
 21: class ResponseHeaderBag extends HeaderBag
 22: {
 23:     const COOKIES_FLAT           = 'flat';
 24:     const COOKIES_ARRAY          = 'array';
 25: 
 26:     const DISPOSITION_ATTACHMENT = 'attachment';
 27:     const DISPOSITION_INLINE     = 'inline';
 28: 
 29:     /**
 30:      * @var array
 31:      */
 32:     protected $computedCacheControl = array();
 33: 
 34:     /**
 35:      * @var array
 36:      */
 37:     protected $cookies              = array();
 38: 
 39:     /**
 40:      * @var array
 41:      */
 42:     protected $headerNames          = array();
 43: 
 44:     /**
 45:      * Constructor.
 46:      *
 47:      * @param array $headers An array of HTTP headers
 48:      *
 49:      * @api
 50:      */
 51:     public function __construct(array $headers = array())
 52:     {
 53:         parent::__construct($headers);
 54: 
 55:         if (!isset($this->headers['cache-control'])) {
 56:             $this->set('Cache-Control', '');
 57:         }
 58:     }
 59: 
 60:     /**
 61:      * {@inheritdoc}
 62:      */
 63:     public function __toString()
 64:     {
 65:         $cookies = '';
 66:         foreach ($this->getCookies() as $cookie) {
 67:             $cookies .= 'Set-Cookie: '.$cookie."\r\n";
 68:         }
 69: 
 70:         ksort($this->headerNames);
 71: 
 72:         return parent::__toString().$cookies;
 73:     }
 74: 
 75:     /**
 76:      * Returns the headers, with original capitalizations.
 77:      *
 78:      * @return array An array of headers
 79:      */
 80:     public function allPreserveCase()
 81:     {
 82:         return array_combine($this->headerNames, $this->headers);
 83:     }
 84: 
 85:     /**
 86:      * {@inheritdoc}
 87:      *
 88:      * @api
 89:      */
 90:     public function replace(array $headers = array())
 91:     {
 92:         $this->headerNames = array();
 93: 
 94:         parent::replace($headers);
 95: 
 96:         if (!isset($this->headers['cache-control'])) {
 97:             $this->set('Cache-Control', '');
 98:         }
 99:     }
100: 
101:     /**
102:      * {@inheritdoc}
103:      *
104:      * @api
105:      */
106:     public function set($key, $values, $replace = true)
107:     {
108:         parent::set($key, $values, $replace);
109: 
110:         $uniqueKey = strtr(strtolower($key), '_', '-');
111:         $this->headerNames[$uniqueKey] = $key;
112: 
113:         // ensure the cache-control header has sensible defaults
114:         if (in_array($uniqueKey, array('cache-control', 'etag', 'last-modified', 'expires'))) {
115:             $computed = $this->computeCacheControlValue();
116:             $this->headers['cache-control'] = array($computed);
117:             $this->headerNames['cache-control'] = 'Cache-Control';
118:             $this->computedCacheControl = $this->parseCacheControl($computed);
119:         }
120:     }
121: 
122:     /**
123:      * {@inheritdoc}
124:      *
125:      * @api
126:      */
127:     public function remove($key)
128:     {
129:         parent::remove($key);
130: 
131:         $uniqueKey = strtr(strtolower($key), '_', '-');
132:         unset($this->headerNames[$uniqueKey]);
133: 
134:         if ('cache-control' === $uniqueKey) {
135:             $this->computedCacheControl = array();
136:         }
137:     }
138: 
139:     /**
140:      * {@inheritdoc}
141:      */
142:     public function hasCacheControlDirective($key)
143:     {
144:         return array_key_exists($key, $this->computedCacheControl);
145:     }
146: 
147:     /**
148:      * {@inheritdoc}
149:      */
150:     public function getCacheControlDirective($key)
151:     {
152:         return array_key_exists($key, $this->computedCacheControl) ? $this->computedCacheControl[$key] : null;
153:     }
154: 
155:     /**
156:      * Sets a cookie.
157:      *
158:      * @param Cookie $cookie
159:      *
160:      * @api
161:      */
162:     public function setCookie(Cookie $cookie)
163:     {
164:         $this->cookies[$cookie->getDomain()][$cookie->getPath()][$cookie->getName()] = $cookie;
165:     }
166: 
167:     /**
168:      * Removes a cookie from the array, but does not unset it in the browser
169:      *
170:      * @param string $name
171:      * @param string $path
172:      * @param string $domain
173:      *
174:      * @api
175:      */
176:     public function removeCookie($name, $path = '/', $domain = null)
177:     {
178:         if (null === $path) {
179:             $path = '/';
180:         }
181: 
182:         unset($this->cookies[$domain][$path][$name]);
183: 
184:         if (empty($this->cookies[$domain][$path])) {
185:             unset($this->cookies[$domain][$path]);
186: 
187:             if (empty($this->cookies[$domain])) {
188:                 unset($this->cookies[$domain]);
189:             }
190:         }
191:     }
192: 
193:     /**
194:      * Returns an array with all cookies
195:      *
196:      * @param string $format
197:      *
198:      * @throws \InvalidArgumentException When the $format is invalid
199:      *
200:      * @return array
201:      *
202:      * @api
203:      */
204:     public function getCookies($format = self::COOKIES_FLAT)
205:     {
206:         if (!in_array($format, array(self::COOKIES_FLAT, self::COOKIES_ARRAY))) {
207:             throw new \InvalidArgumentException(sprintf('Format "%s" invalid (%s).', $format, implode(', ', array(self::COOKIES_FLAT, self::COOKIES_ARRAY))));
208:         }
209: 
210:         if (self::COOKIES_ARRAY === $format) {
211:             return $this->cookies;
212:         }
213: 
214:         $flattenedCookies = array();
215:         foreach ($this->cookies as $path) {
216:             foreach ($path as $cookies) {
217:                 foreach ($cookies as $cookie) {
218:                     $flattenedCookies[] = $cookie;
219:                 }
220:             }
221:         }
222: 
223:         return $flattenedCookies;
224:     }
225: 
226:     /**
227:      * Clears a cookie in the browser
228:      *
229:      * @param string $name
230:      * @param string $path
231:      * @param string $domain
232:      *
233:      * @api
234:      */
235:     public function clearCookie($name, $path = '/', $domain = null)
236:     {
237:         $this->setCookie(new Cookie($name, null, 1, $path, $domain));
238:     }
239: 
240:     /**
241:      * Generates a HTTP Content-Disposition field-value.
242:      *
243:      * @param string $disposition      One of "inline" or "attachment"
244:      * @param string $filename         A unicode string
245:      * @param string $filenameFallback A string containing only ASCII characters that
246:      *                                 is semantically equivalent to $filename. If the filename is already ASCII,
247:      *                                 it can be omitted, or just copied from $filename
248:      *
249:      * @return string A string suitable for use as a Content-Disposition field-value.
250:      *
251:      * @throws \InvalidArgumentException
252:      * @see RFC 6266
253:      */
254:     public function makeDisposition($disposition, $filename, $filenameFallback = '')
255:     {
256:         if (!in_array($disposition, array(self::DISPOSITION_ATTACHMENT, self::DISPOSITION_INLINE))) {
257:             throw new \InvalidArgumentException(sprintf('The disposition must be either "%s" or "%s".', self::DISPOSITION_ATTACHMENT, self::DISPOSITION_INLINE));
258:         }
259: 
260:         if ('' == $filenameFallback) {
261:             $filenameFallback = $filename;
262:         }
263: 
264:         // filenameFallback is not ASCII.
265:         if (!preg_match('/^[\x20-\x7e]*$/', $filenameFallback)) {
266:             throw new \InvalidArgumentException('The filename fallback must only contain ASCII characters.');
267:         }
268: 
269:         // percent characters aren't safe in fallback.
270:         if (false !== strpos($filenameFallback, '%')) {
271:             throw new \InvalidArgumentException('The filename fallback cannot contain the "%" character.');
272:         }
273: 
274:         // path separators aren't allowed in either.
275:         if (false !== strpos($filename, '/') || false !== strpos($filename, '\\') || false !== strpos($filenameFallback, '/') || false !== strpos($filenameFallback, '\\')) {
276:             throw new \InvalidArgumentException('The filename and the fallback cannot contain the "/" and "\\" characters.');
277:         }
278: 
279:         $output = sprintf('%s; filename="%s"', $disposition, str_replace('"', '\\"', $filenameFallback));
280: 
281:         if ($filename !== $filenameFallback) {
282:             $output .= sprintf("; filename*=utf-8''%s", rawurlencode($filename));
283:         }
284: 
285:         return $output;
286:     }
287: 
288:     /**
289:      * Returns the calculated value of the cache-control header.
290:      *
291:      * This considers several other headers and calculates or modifies the
292:      * cache-control header to a sensible, conservative value.
293:      *
294:      * @return string
295:      */
296:     protected function computeCacheControlValue()
297:     {
298:         if (!$this->cacheControl && !$this->has('ETag') && !$this->has('Last-Modified') && !$this->has('Expires')) {
299:             return 'no-cache';
300:         }
301: 
302:         if (!$this->cacheControl) {
303:             // conservative by default
304:             return 'private, must-revalidate';
305:         }
306: 
307:         $header = $this->getCacheControlHeader();
308:         if (isset($this->cacheControl['public']) || isset($this->cacheControl['private'])) {
309:             return $header;
310:         }
311: 
312:         // public if s-maxage is defined, private otherwise
313:         if (!isset($this->cacheControl['s-maxage'])) {
314:             return $header.', private';
315:         }
316: 
317:         return $header;
318:     }
319: }
320: