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: use Symfony\Component\HttpFoundation\Session\SessionInterface;
  15: 
  16: /**
  17:  * Request represents an HTTP request.
  18:  *
  19:  * The methods dealing with URL accept / return a raw path (% encoded):
  20:  *   * getBasePath
  21:  *   * getBaseUrl
  22:  *   * getPathInfo
  23:  *   * getRequestUri
  24:  *   * getUri
  25:  *   * getUriForPath
  26:  *
  27:  * @author Fabien Potencier <fabien@symfony.com>
  28:  *
  29:  * @api
  30:  */
  31: class Request
  32: {
  33:     const HEADER_CLIENT_IP    = 'client_ip';
  34:     const HEADER_CLIENT_HOST  = 'client_host';
  35:     const HEADER_CLIENT_PROTO = 'client_proto';
  36:     const HEADER_CLIENT_PORT  = 'client_port';
  37: 
  38:     protected static $trustProxy = false;
  39: 
  40:     protected static $trustedProxies = array();
  41: 
  42:     /**
  43:      * Names for headers that can be trusted when
  44:      * using trusted proxies.
  45:      *
  46:      * The default names are non-standard, but widely used
  47:      * by popular reverse proxies (like Apache mod_proxy or Amazon EC2).
  48:      */
  49:     protected static $trustedHeaders = array(
  50:         self::HEADER_CLIENT_IP    => 'X_FORWARDED_FOR',
  51:         self::HEADER_CLIENT_HOST  => 'X_FORWARDED_HOST',
  52:         self::HEADER_CLIENT_PROTO => 'X_FORWARDED_PROTO',
  53:         self::HEADER_CLIENT_PORT  => 'X_FORWARDED_PORT',
  54:     );
  55: 
  56:     protected static $httpMethodParameterOverride = false;
  57: 
  58:     /**
  59:      * @var \Symfony\Component\HttpFoundation\ParameterBag
  60:      *
  61:      * @api
  62:      */
  63:     public $attributes;
  64: 
  65:     /**
  66:      * @var \Symfony\Component\HttpFoundation\ParameterBag
  67:      *
  68:      * @api
  69:      */
  70:     public $request;
  71: 
  72:     /**
  73:      * @var \Symfony\Component\HttpFoundation\ParameterBag
  74:      *
  75:      * @api
  76:      */
  77:     public $query;
  78: 
  79:     /**
  80:      * @var \Symfony\Component\HttpFoundation\ServerBag
  81:      *
  82:      * @api
  83:      */
  84:     public $server;
  85: 
  86:     /**
  87:      * @var \Symfony\Component\HttpFoundation\FileBag
  88:      *
  89:      * @api
  90:      */
  91:     public $files;
  92: 
  93:     /**
  94:      * @var \Symfony\Component\HttpFoundation\ParameterBag
  95:      *
  96:      * @api
  97:      */
  98:     public $cookies;
  99: 
 100:     /**
 101:      * @var \Symfony\Component\HttpFoundation\HeaderBag
 102:      *
 103:      * @api
 104:      */
 105:     public $headers;
 106: 
 107:     /**
 108:      * @var string
 109:      */
 110:     protected $content;
 111: 
 112:     /**
 113:      * @var array
 114:      */
 115:     protected $languages;
 116: 
 117:     /**
 118:      * @var array
 119:      */
 120:     protected $charsets;
 121: 
 122:     /**
 123:      * @var array
 124:      */
 125:     protected $acceptableContentTypes;
 126: 
 127:     /**
 128:      * @var string
 129:      */
 130:     protected $pathInfo;
 131: 
 132:     /**
 133:      * @var string
 134:      */
 135:     protected $requestUri;
 136: 
 137:     /**
 138:      * @var string
 139:      */
 140:     protected $baseUrl;
 141: 
 142:     /**
 143:      * @var string
 144:      */
 145:     protected $basePath;
 146: 
 147:     /**
 148:      * @var string
 149:      */
 150:     protected $method;
 151: 
 152:     /**
 153:      * @var string
 154:      */
 155:     protected $format;
 156: 
 157:     /**
 158:      * @var \Symfony\Component\HttpFoundation\Session\SessionInterface
 159:      */
 160:     protected $session;
 161: 
 162:     /**
 163:      * @var string
 164:      */
 165:     protected $locale;
 166: 
 167:     /**
 168:      * @var string
 169:      */
 170:     protected $defaultLocale = 'en';
 171: 
 172:     /**
 173:      * @var array
 174:      */
 175:     protected static $formats;
 176: 
 177:     /**
 178:      * Constructor.
 179:      *
 180:      * @param array  $query      The GET parameters
 181:      * @param array  $request    The POST parameters
 182:      * @param array  $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
 183:      * @param array  $cookies    The COOKIE parameters
 184:      * @param array  $files      The FILES parameters
 185:      * @param array  $server     The SERVER parameters
 186:      * @param string $content    The raw body data
 187:      *
 188:      * @api
 189:      */
 190:     public function __construct(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)
 191:     {
 192:         $this->initialize($query, $request, $attributes, $cookies, $files, $server, $content);
 193:     }
 194: 
 195:     /**
 196:      * Sets the parameters for this request.
 197:      *
 198:      * This method also re-initializes all properties.
 199:      *
 200:      * @param array  $query      The GET parameters
 201:      * @param array  $request    The POST parameters
 202:      * @param array  $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
 203:      * @param array  $cookies    The COOKIE parameters
 204:      * @param array  $files      The FILES parameters
 205:      * @param array  $server     The SERVER parameters
 206:      * @param string $content    The raw body data
 207:      *
 208:      * @api
 209:      */
 210:     public function initialize(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)
 211:     {
 212:         $this->request = new ParameterBag($request);
 213:         $this->query = new ParameterBag($query);
 214:         $this->attributes = new ParameterBag($attributes);
 215:         $this->cookies = new ParameterBag($cookies);
 216:         $this->files = new FileBag($files);
 217:         $this->server = new ServerBag($server);
 218:         $this->headers = new HeaderBag($this->server->getHeaders());
 219: 
 220:         $this->content = $content;
 221:         $this->languages = null;
 222:         $this->charsets = null;
 223:         $this->acceptableContentTypes = null;
 224:         $this->pathInfo = null;
 225:         $this->requestUri = null;
 226:         $this->baseUrl = null;
 227:         $this->basePath = null;
 228:         $this->method = null;
 229:         $this->format = null;
 230:     }
 231: 
 232:     /**
 233:      * Creates a new request with values from PHP's super globals.
 234:      *
 235:      * @return Request A new request
 236:      *
 237:      * @api
 238:      */
 239:     public static function createFromGlobals()
 240:     {
 241:         $request = new static($_GET, $_POST, array(), $_COOKIE, $_FILES, $_SERVER);
 242: 
 243:         if (0 === strpos($request->headers->get('CONTENT_TYPE'), 'application/x-www-form-urlencoded')
 244:             && in_array(strtoupper($request->server->get('REQUEST_METHOD', 'GET')), array('PUT', 'DELETE', 'PATCH'))
 245:         ) {
 246:             parse_str($request->getContent(), $data);
 247:             $request->request = new ParameterBag($data);
 248:         }
 249: 
 250:         return $request;
 251:     }
 252: 
 253:     /**
 254:      * Creates a Request based on a given URI and configuration.
 255:      *
 256:      * The information contained in the URI always take precedence
 257:      * over the other information (server and parameters).
 258:      *
 259:      * @param string $uri        The URI
 260:      * @param string $method     The HTTP method
 261:      * @param array  $parameters The query (GET) or request (POST) parameters
 262:      * @param array  $cookies    The request cookies ($_COOKIE)
 263:      * @param array  $files      The request files ($_FILES)
 264:      * @param array  $server     The server parameters ($_SERVER)
 265:      * @param string $content    The raw body data
 266:      *
 267:      * @return Request A Request instance
 268:      *
 269:      * @api
 270:      */
 271:     public static function create($uri, $method = 'GET', $parameters = array(), $cookies = array(), $files = array(), $server = array(), $content = null)
 272:     {
 273:         $server = array_replace(array(
 274:             'SERVER_NAME'          => 'localhost',
 275:             'SERVER_PORT'          => 80,
 276:             'HTTP_HOST'            => 'localhost',
 277:             'HTTP_USER_AGENT'      => 'Symfony/2.X',
 278:             'HTTP_ACCEPT'          => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
 279:             'HTTP_ACCEPT_LANGUAGE' => 'en-us,en;q=0.5',
 280:             'HTTP_ACCEPT_CHARSET'  => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
 281:             'REMOTE_ADDR'          => '127.0.0.1',
 282:             'SCRIPT_NAME'          => '',
 283:             'SCRIPT_FILENAME'      => '',
 284:             'SERVER_PROTOCOL'      => 'HTTP/1.1',
 285:             'REQUEST_TIME'         => time(),
 286:         ), $server);
 287: 
 288:         $server['PATH_INFO'] = '';
 289:         $server['REQUEST_METHOD'] = strtoupper($method);
 290: 
 291:         $components = parse_url($uri);
 292:         if (isset($components['host'])) {
 293:             $server['SERVER_NAME'] = $components['host'];
 294:             $server['HTTP_HOST'] = $components['host'];
 295:         }
 296: 
 297:         if (isset($components['scheme'])) {
 298:             if ('https' === $components['scheme']) {
 299:                 $server['HTTPS'] = 'on';
 300:                 $server['SERVER_PORT'] = 443;
 301:             } else {
 302:                 unset($server['HTTPS']);
 303:                 $server['SERVER_PORT'] = 80;
 304:             }
 305:         }
 306: 
 307:         if (isset($components['port'])) {
 308:             $server['SERVER_PORT'] = $components['port'];
 309:             $server['HTTP_HOST'] = $server['HTTP_HOST'].':'.$components['port'];
 310:         }
 311: 
 312:         if (isset($components['user'])) {
 313:             $server['PHP_AUTH_USER'] = $components['user'];
 314:         }
 315: 
 316:         if (isset($components['pass'])) {
 317:             $server['PHP_AUTH_PW'] = $components['pass'];
 318:         }
 319: 
 320:         if (!isset($components['path'])) {
 321:             $components['path'] = '/';
 322:         }
 323: 
 324:         switch (strtoupper($method)) {
 325:             case 'POST':
 326:             case 'PUT':
 327:             case 'DELETE':
 328:                 if (!isset($server['CONTENT_TYPE'])) {
 329:                     $server['CONTENT_TYPE'] = 'application/x-www-form-urlencoded';
 330:                 }
 331:             case 'PATCH':
 332:                 $request = $parameters;
 333:                 $query = array();
 334:                 break;
 335:             default:
 336:                 $request = array();
 337:                 $query = $parameters;
 338:                 break;
 339:         }
 340: 
 341:         if (isset($components['query'])) {
 342:             parse_str(html_entity_decode($components['query']), $qs);
 343:             $query = array_replace($qs, $query);
 344:         }
 345:         $queryString = http_build_query($query, '', '&');
 346: 
 347:         $server['REQUEST_URI'] = $components['path'].('' !== $queryString ? '?'.$queryString : '');
 348:         $server['QUERY_STRING'] = $queryString;
 349: 
 350:         return new static($query, $request, array(), $cookies, $files, $server, $content);
 351:     }
 352: 
 353:     /**
 354:      * Clones a request and overrides some of its parameters.
 355:      *
 356:      * @param array $query      The GET parameters
 357:      * @param array $request    The POST parameters
 358:      * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
 359:      * @param array $cookies    The COOKIE parameters
 360:      * @param array $files      The FILES parameters
 361:      * @param array $server     The SERVER parameters
 362:      *
 363:      * @return Request The duplicated request
 364:      *
 365:      * @api
 366:      */
 367:     public function duplicate(array $query = null, array $request = null, array $attributes = null, array $cookies = null, array $files = null, array $server = null)
 368:     {
 369:         $dup = clone $this;
 370:         if ($query !== null) {
 371:             $dup->query = new ParameterBag($query);
 372:         }
 373:         if ($request !== null) {
 374:             $dup->request = new ParameterBag($request);
 375:         }
 376:         if ($attributes !== null) {
 377:             $dup->attributes = new ParameterBag($attributes);
 378:         }
 379:         if ($cookies !== null) {
 380:             $dup->cookies = new ParameterBag($cookies);
 381:         }
 382:         if ($files !== null) {
 383:             $dup->files = new FileBag($files);
 384:         }
 385:         if ($server !== null) {
 386:             $dup->server = new ServerBag($server);
 387:             $dup->headers = new HeaderBag($dup->server->getHeaders());
 388:         }
 389:         $dup->languages = null;
 390:         $dup->charsets = null;
 391:         $dup->acceptableContentTypes = null;
 392:         $dup->pathInfo = null;
 393:         $dup->requestUri = null;
 394:         $dup->baseUrl = null;
 395:         $dup->basePath = null;
 396:         $dup->method = null;
 397:         $dup->format = null;
 398: 
 399:         return $dup;
 400:     }
 401: 
 402:     /**
 403:      * Clones the current request.
 404:      *
 405:      * Note that the session is not cloned as duplicated requests
 406:      * are most of the time sub-requests of the main one.
 407:      */
 408:     public function __clone()
 409:     {
 410:         $this->query      = clone $this->query;
 411:         $this->request    = clone $this->request;
 412:         $this->attributes = clone $this->attributes;
 413:         $this->cookies    = clone $this->cookies;
 414:         $this->files      = clone $this->files;
 415:         $this->server     = clone $this->server;
 416:         $this->headers    = clone $this->headers;
 417:     }
 418: 
 419:     /**
 420:      * Returns the request as a string.
 421:      *
 422:      * @return string The request
 423:      */
 424:     public function __toString()
 425:     {
 426:         return
 427:             sprintf('%s %s %s', $this->getMethod(), $this->getRequestUri(), $this->server->get('SERVER_PROTOCOL'))."\r\n".
 428:             $this->headers."\r\n".
 429:             $this->getContent();
 430:     }
 431: 
 432:     /**
 433:      * Overrides the PHP global variables according to this request instance.
 434:      *
 435:      * It overrides $_GET, $_POST, $_REQUEST, $_SERVER, $_COOKIE.
 436:      * $_FILES is never override, see rfc1867
 437:      *
 438:      * @api
 439:      */
 440:     public function overrideGlobals()
 441:     {
 442:         $_GET = $this->query->all();
 443:         $_POST = $this->request->all();
 444:         $_SERVER = $this->server->all();
 445:         $_COOKIE = $this->cookies->all();
 446: 
 447:         foreach ($this->headers->all() as $key => $value) {
 448:             $key = strtoupper(str_replace('-', '_', $key));
 449:             if (in_array($key, array('CONTENT_TYPE', 'CONTENT_LENGTH'))) {
 450:                 $_SERVER[$key] = implode(', ', $value);
 451:             } else {
 452:                 $_SERVER['HTTP_'.$key] = implode(', ', $value);
 453:             }
 454:         }
 455: 
 456:         $request = array('g' => $_GET, 'p' => $_POST, 'c' => $_COOKIE);
 457: 
 458:         $requestOrder = ini_get('request_order') ?: ini_get('variable_order');
 459:         $requestOrder = preg_replace('#[^cgp]#', '', strtolower($requestOrder)) ?: 'gp';
 460: 
 461:         $_REQUEST = array();
 462:         foreach (str_split($requestOrder) as $order) {
 463:             $_REQUEST = array_merge($_REQUEST, $request[$order]);
 464:         }
 465:     }
 466: 
 467:     /**
 468:      * Trusts $_SERVER entries coming from proxies.
 469:      *
 470:      * @deprecated Deprecated since version 2.0, to be removed in 2.3. Use setTrustedProxies instead.
 471:      */
 472:     public static function trustProxyData()
 473:     {
 474:         trigger_error('trustProxyData() is deprecated since version 2.0 and will be removed in 2.3. Use setTrustedProxies() instead.', E_USER_DEPRECATED);
 475: 
 476:         self::$trustProxy = true;
 477:     }
 478: 
 479:     /**
 480:      * Sets a list of trusted proxies.
 481:      *
 482:      * You should only list the reverse proxies that you manage directly.
 483:      *
 484:      * @param array $proxies A list of trusted proxies
 485:      *
 486:      * @api
 487:      */
 488:     public static function setTrustedProxies(array $proxies)
 489:     {
 490:         self::$trustedProxies = $proxies;
 491:         self::$trustProxy = $proxies ? true : false;
 492:     }
 493: 
 494:     /**
 495:      * Gets the list of trusted proxies.
 496:      *
 497:      * @return array An array of trusted proxies.
 498:      */
 499:     public static function getTrustedProxies()
 500:     {
 501:         return self::$trustedProxies;
 502:     }
 503: 
 504:     /**
 505:      * Sets the name for trusted headers.
 506:      *
 507:      * The following header keys are supported:
 508:      *
 509:      *  * Request::HEADER_CLIENT_IP:    defaults to X-Forwarded-For   (see getClientIp())
 510:      *  * Request::HEADER_CLIENT_HOST:  defaults to X-Forwarded-Host  (see getClientHost())
 511:      *  * Request::HEADER_CLIENT_PORT:  defaults to X-Forwarded-Port  (see getClientPort())
 512:      *  * Request::HEADER_CLIENT_PROTO: defaults to X-Forwarded-Proto (see getScheme() and isSecure())
 513:      *
 514:      * Setting an empty value allows to disable the trusted header for the given key.
 515:      *
 516:      * @param string $key   The header key
 517:      * @param string $value The header name
 518:      *
 519:      * @throws \InvalidArgumentException
 520:      */
 521:     public static function setTrustedHeaderName($key, $value)
 522:     {
 523:         if (!array_key_exists($key, self::$trustedHeaders)) {
 524:             throw new \InvalidArgumentException(sprintf('Unable to set the trusted header name for key "%s".', $key));
 525:         }
 526: 
 527:         self::$trustedHeaders[$key] = $value;
 528:     }
 529: 
 530:     /**
 531:      * Returns true if $_SERVER entries coming from proxies are trusted,
 532:      * false otherwise.
 533:      *
 534:      * @return boolean
 535:      *
 536:      * @deprecated Deprecated since version 2.2, to be removed in 2.3. Use getTrustedProxies instead.
 537:      */
 538:     public static function isProxyTrusted()
 539:     {
 540:         return self::$trustProxy;
 541:     }
 542: 
 543:     /**
 544:      * Normalizes a query string.
 545:      *
 546:      * It builds a normalized query string, where keys/value pairs are alphabetized,
 547:      * have consistent escaping and unneeded delimiters are removed.
 548:      *
 549:      * @param string $qs Query string
 550:      *
 551:      * @return string A normalized query string for the Request
 552:      */
 553:     public static function normalizeQueryString($qs)
 554:     {
 555:         if ('' == $qs) {
 556:             return '';
 557:         }
 558: 
 559:         $parts = array();
 560:         $order = array();
 561: 
 562:         foreach (explode('&', $qs) as $param) {
 563:             if ('' === $param || '=' === $param[0]) {
 564:                 // Ignore useless delimiters, e.g. "x=y&".
 565:                 // Also ignore pairs with empty key, even if there was a value, e.g. "=value", as such nameless values cannot be retrieved anyway.
 566:                 // PHP also does not include them when building _GET.
 567:                 continue;
 568:             }
 569: 
 570:             $keyValuePair = explode('=', $param, 2);
 571: 
 572:             // GET parameters, that are submitted from a HTML form, encode spaces as "+" by default (as defined in enctype application/x-www-form-urlencoded).
 573:             // PHP also converts "+" to spaces when filling the global _GET or when using the function parse_str. This is why we use urldecode and then normalize to
 574:             // RFC 3986 with rawurlencode.
 575:             $parts[] = isset($keyValuePair[1]) ?
 576:                 rawurlencode(urldecode($keyValuePair[0])).'='.rawurlencode(urldecode($keyValuePair[1])) :
 577:                 rawurlencode(urldecode($keyValuePair[0]));
 578:             $order[] = urldecode($keyValuePair[0]);
 579:         }
 580: 
 581:         array_multisort($order, SORT_ASC, $parts);
 582: 
 583:         return implode('&', $parts);
 584:     }
 585: 
 586:     /**
 587:      * Enables support for the _method request parameter to determine the intended HTTP method.
 588:      *
 589:      * Be warned that enabling this feature might lead to CSRF issues in your code.
 590:      * Check that you are using CSRF tokens when required.
 591:      *
 592:      * The HTTP method can only be overridden when the real HTTP method is POST.
 593:      */
 594:     public static function enableHttpMethodParameterOverride()
 595:     {
 596:         self::$httpMethodParameterOverride = true;
 597:     }
 598: 
 599:     /**
 600:      * Checks whether support for the _method request parameter is enabled.
 601:      *
 602:      * @return Boolean True when the _method request parameter is enabled, false otherwise
 603:      */
 604:     public static function getHttpMethodParameterOverride()
 605:     {
 606:         return self::$httpMethodParameterOverride;
 607:     }
 608: 
 609:     /**
 610:      * Gets a "parameter" value.
 611:      *
 612:      * This method is mainly useful for libraries that want to provide some flexibility.
 613:      *
 614:      * Order of precedence: GET, PATH, POST
 615:      *
 616:      * Avoid using this method in controllers:
 617:      *
 618:      *  * slow
 619:      *  * prefer to get from a "named" source
 620:      *
 621:      * It is better to explicitly get request parameters from the appropriate
 622:      * public property instead (query, attributes, request).
 623:      *
 624:      * @param string  $key     the key
 625:      * @param mixed   $default the default value
 626:      * @param Boolean $deep    is parameter deep in multidimensional array
 627:      *
 628:      * @return mixed
 629:      */
 630:     public function get($key, $default = null, $deep = false)
 631:     {
 632:         return $this->query->get($key, $this->attributes->get($key, $this->request->get($key, $default, $deep), $deep), $deep);
 633:     }
 634: 
 635:     /**
 636:      * Gets the Session.
 637:      *
 638:      * @return SessionInterface|null The session
 639:      *
 640:      * @api
 641:      */
 642:     public function getSession()
 643:     {
 644:         return $this->session;
 645:     }
 646: 
 647:     /**
 648:      * Whether the request contains a Session which was started in one of the
 649:      * previous requests.
 650:      *
 651:      * @return Boolean
 652:      *
 653:      * @api
 654:      */
 655:     public function hasPreviousSession()
 656:     {
 657:         // the check for $this->session avoids malicious users trying to fake a session cookie with proper name
 658:         return $this->hasSession() && $this->cookies->has($this->session->getName());
 659:     }
 660: 
 661:     /**
 662:      * Whether the request contains a Session object.
 663:      *
 664:      * This method does not give any information about the state of the session object,
 665:      * like whether the session is started or not. It is just a way to check if this Request
 666:      * is associated with a Session instance.
 667:      *
 668:      * @return Boolean true when the Request contains a Session object, false otherwise
 669:      *
 670:      * @api
 671:      */
 672:     public function hasSession()
 673:     {
 674:         return null !== $this->session;
 675:     }
 676: 
 677:     /**
 678:      * Sets the Session.
 679:      *
 680:      * @param SessionInterface $session The Session
 681:      *
 682:      * @api
 683:      */
 684:     public function setSession(SessionInterface $session)
 685:     {
 686:         $this->session = $session;
 687:     }
 688: 
 689:     /**
 690:      * Returns the client IP address.
 691:      *
 692:      * This method can read the client IP address from the "X-Forwarded-For" header
 693:      * when trusted proxies were set via "setTrustedProxies()". The "X-Forwarded-For"
 694:      * header value is a comma+space separated list of IP addresses, the left-most
 695:      * being the original client, and each successive proxy that passed the request
 696:      * adding the IP address where it received the request from.
 697:      *
 698:      * If your reverse proxy uses a different header name than "X-Forwarded-For",
 699:      * ("Client-Ip" for instance), configure it via "setTrustedHeaderName()" with
 700:      * the "client-ip" key.
 701:      *
 702:      * @return string The client IP address
 703:      *
 704:      * @see http://en.wikipedia.org/wiki/X-Forwarded-For
 705:      *
 706:      * @api
 707:      */
 708:     public function getClientIp()
 709:     {
 710:         $ip = $this->server->get('REMOTE_ADDR');
 711: 
 712:         if (!self::$trustProxy) {
 713:             return $ip;
 714:         }
 715: 
 716:         if (!self::$trustedHeaders[self::HEADER_CLIENT_IP] || !$this->headers->has(self::$trustedHeaders[self::HEADER_CLIENT_IP])) {
 717:             return $ip;
 718:         }
 719: 
 720:         $clientIps = array_map('trim', explode(',', $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_IP])));
 721:         $clientIps[] = $ip;
 722: 
 723:         $trustedProxies = self::$trustProxy && !self::$trustedProxies ? array($ip) : self::$trustedProxies;
 724:         $clientIps = array_diff($clientIps, $trustedProxies);
 725: 
 726:         return array_pop($clientIps);
 727:     }
 728: 
 729:     /**
 730:      * Returns current script name.
 731:      *
 732:      * @return string
 733:      *
 734:      * @api
 735:      */
 736:     public function getScriptName()
 737:     {
 738:         return $this->server->get('SCRIPT_NAME', $this->server->get('ORIG_SCRIPT_NAME', ''));
 739:     }
 740: 
 741:     /**
 742:      * Returns the path being requested relative to the executed script.
 743:      *
 744:      * The path info always starts with a /.
 745:      *
 746:      * Suppose this request is instantiated from /mysite on localhost:
 747:      *
 748:      *  * http://localhost/mysite              returns an empty string
 749:      *  * http://localhost/mysite/about        returns '/about'
 750:      *  * http://localhost/mysite/enco%20ded   returns '/enco%20ded'
 751:      *  * http://localhost/mysite/about?var=1  returns '/about'
 752:      *
 753:      * @return string The raw path (i.e. not urldecoded)
 754:      *
 755:      * @api
 756:      */
 757:     public function getPathInfo()
 758:     {
 759:         if (null === $this->pathInfo) {
 760:             $this->pathInfo = $this->preparePathInfo();
 761:         }
 762: 
 763:         return $this->pathInfo;
 764:     }
 765: 
 766:     /**
 767:      * Returns the root path from which this request is executed.
 768:      *
 769:      * Suppose that an index.php file instantiates this request object:
 770:      *
 771:      *  * http://localhost/index.php         returns an empty string
 772:      *  * http://localhost/index.php/page    returns an empty string
 773:      *  * http://localhost/web/index.php     returns '/web'
 774:      *  * http://localhost/we%20b/index.php  returns '/we%20b'
 775:      *
 776:      * @return string The raw path (i.e. not urldecoded)
 777:      *
 778:      * @api
 779:      */
 780:     public function getBasePath()
 781:     {
 782:         if (null === $this->basePath) {
 783:             $this->basePath = $this->prepareBasePath();
 784:         }
 785: 
 786:         return $this->basePath;
 787:     }
 788: 
 789:     /**
 790:      * Returns the root url from which this request is executed.
 791:      *
 792:      * The base URL never ends with a /.
 793:      *
 794:      * This is similar to getBasePath(), except that it also includes the
 795:      * script filename (e.g. index.php) if one exists.
 796:      *
 797:      * @return string The raw url (i.e. not urldecoded)
 798:      *
 799:      * @api
 800:      */
 801:     public function getBaseUrl()
 802:     {
 803:         if (null === $this->baseUrl) {
 804:             $this->baseUrl = $this->prepareBaseUrl();
 805:         }
 806: 
 807:         return $this->baseUrl;
 808:     }
 809: 
 810:     /**
 811:      * Gets the request's scheme.
 812:      *
 813:      * @return string
 814:      *
 815:      * @api
 816:      */
 817:     public function getScheme()
 818:     {
 819:         return $this->isSecure() ? 'https' : 'http';
 820:     }
 821: 
 822:     /**
 823:      * Returns the port on which the request is made.
 824:      *
 825:      * This method can read the client port from the "X-Forwarded-Port" header
 826:      * when trusted proxies were set via "setTrustedProxies()".
 827:      *
 828:      * The "X-Forwarded-Port" header must contain the client port.
 829:      *
 830:      * If your reverse proxy uses a different header name than "X-Forwarded-Port",
 831:      * configure it via "setTrustedHeaderName()" with the "client-port" key.
 832:      *
 833:      * @return string
 834:      *
 835:      * @api
 836:      */
 837:     public function getPort()
 838:     {
 839:         if (self::$trustProxy && self::$trustedHeaders[self::HEADER_CLIENT_PORT] && $port = $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_PORT])) {
 840:             return $port;
 841:         }
 842: 
 843:         return $this->server->get('SERVER_PORT');
 844:     }
 845: 
 846:     /**
 847:      * Returns the user.
 848:      *
 849:      * @return string|null
 850:      */
 851:     public function getUser()
 852:     {
 853:         return $this->server->get('PHP_AUTH_USER');
 854:     }
 855: 
 856:     /**
 857:      * Returns the password.
 858:      *
 859:      * @return string|null
 860:      */
 861:     public function getPassword()
 862:     {
 863:         return $this->server->get('PHP_AUTH_PW');
 864:     }
 865: 
 866:     /**
 867:      * Gets the user info.
 868:      *
 869:      * @return string A user name and, optionally, scheme-specific information about how to gain authorization to access the server
 870:      */
 871:     public function getUserInfo()
 872:     {
 873:         $userinfo = $this->getUser();
 874: 
 875:         $pass = $this->getPassword();
 876:         if ('' != $pass) {
 877:            $userinfo .= ":$pass";
 878:         }
 879: 
 880:         return $userinfo;
 881:     }
 882: 
 883:     /**
 884:      * Returns the HTTP host being requested.
 885:      *
 886:      * The port name will be appended to the host if it's non-standard.
 887:      *
 888:      * @return string
 889:      *
 890:      * @api
 891:      */
 892:     public function getHttpHost()
 893:     {
 894:         $scheme = $this->getScheme();
 895:         $port   = $this->getPort();
 896: 
 897:         if (('http' == $scheme && $port == 80) || ('https' == $scheme && $port == 443)) {
 898:             return $this->getHost();
 899:         }
 900: 
 901:         return $this->getHost().':'.$port;
 902:     }
 903: 
 904:     /**
 905:      * Returns the requested URI.
 906:      *
 907:      * @return string The raw URI (i.e. not urldecoded)
 908:      *
 909:      * @api
 910:      */
 911:     public function getRequestUri()
 912:     {
 913:         if (null === $this->requestUri) {
 914:             $this->requestUri = $this->prepareRequestUri();
 915:         }
 916: 
 917:         return $this->requestUri;
 918:     }
 919: 
 920:     /**
 921:      * Gets the scheme and HTTP host.
 922:      *
 923:      * If the URL was called with basic authentication, the user
 924:      * and the password are not added to the generated string.
 925:      *
 926:      * @return string The scheme and HTTP host
 927:      */
 928:     public function getSchemeAndHttpHost()
 929:     {
 930:         return $this->getScheme().'://'.$this->getHttpHost();
 931:     }
 932: 
 933:     /**
 934:      * Generates a normalized URI for the Request.
 935:      *
 936:      * @return string A normalized URI for the Request
 937:      *
 938:      * @see getQueryString()
 939:      *
 940:      * @api
 941:      */
 942:     public function getUri()
 943:     {
 944:         if (null !== $qs = $this->getQueryString()) {
 945:             $qs = '?'.$qs;
 946:         }
 947: 
 948:         return $this->getSchemeAndHttpHost().$this->getBaseUrl().$this->getPathInfo().$qs;
 949:     }
 950: 
 951:     /**
 952:      * Generates a normalized URI for the given path.
 953:      *
 954:      * @param string $path A path to use instead of the current one
 955:      *
 956:      * @return string The normalized URI for the path
 957:      *
 958:      * @api
 959:      */
 960:     public function getUriForPath($path)
 961:     {
 962:         return $this->getSchemeAndHttpHost().$this->getBaseUrl().$path;
 963:     }
 964: 
 965:     /**
 966:      * Generates the normalized query string for the Request.
 967:      *
 968:      * It builds a normalized query string, where keys/value pairs are alphabetized
 969:      * and have consistent escaping.
 970:      *
 971:      * @return string|null A normalized query string for the Request
 972:      *
 973:      * @api
 974:      */
 975:     public function getQueryString()
 976:     {
 977:         $qs = static::normalizeQueryString($this->server->get('QUERY_STRING'));
 978: 
 979:         return '' === $qs ? null : $qs;
 980:     }
 981: 
 982:     /**
 983:      * Checks whether the request is secure or not.
 984:      *
 985:      * This method can read the client port from the "X-Forwarded-Proto" header
 986:      * when trusted proxies were set via "setTrustedProxies()".
 987:      *
 988:      * The "X-Forwarded-Proto" header must contain the protocol: "https" or "http".
 989:      *
 990:      * If your reverse proxy uses a different header name than "X-Forwarded-Proto"
 991:      * ("SSL_HTTPS" for instance), configure it via "setTrustedHeaderName()" with
 992:      * the "client-proto" key.
 993:      *
 994:      * @return Boolean
 995:      *
 996:      * @api
 997:      */
 998:     public function isSecure()
 999:     {
1000:         if (self::$trustProxy && self::$trustedHeaders[self::HEADER_CLIENT_PROTO] && $proto = $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_PROTO])) {
1001:             return in_array(strtolower($proto), array('https', 'on', '1'));
1002:         }
1003: 
1004:         return 'on' == strtolower($this->server->get('HTTPS')) || 1 == $this->server->get('HTTPS');
1005:     }
1006: 
1007:     /**
1008:      * Returns the host name.
1009:      *
1010:      * This method can read the client port from the "X-Forwarded-Host" header
1011:      * when trusted proxies were set via "setTrustedProxies()".
1012:      *
1013:      * The "X-Forwarded-Host" header must contain the client host name.
1014:      *
1015:      * If your reverse proxy uses a different header name than "X-Forwarded-Host",
1016:      * configure it via "setTrustedHeaderName()" with the "client-host" key.
1017:      *
1018:      * @return string
1019:      *
1020:      * @throws \UnexpectedValueException when the host name is invalid
1021:      *
1022:      * @api
1023:      */
1024:     public function getHost()
1025:     {
1026:         if (self::$trustProxy && self::$trustedHeaders[self::HEADER_CLIENT_HOST] && $host = $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_HOST])) {
1027:             $elements = explode(',', $host);
1028: 
1029:             $host = $elements[count($elements) - 1];
1030:         } elseif (!$host = $this->headers->get('HOST')) {
1031:             if (!$host = $this->server->get('SERVER_NAME')) {
1032:                 $host = $this->server->get('SERVER_ADDR', '');
1033:             }
1034:         }
1035: 
1036:         // trim and remove port number from host
1037:         // host is lowercase as per RFC 952/2181
1038:         $host = strtolower(preg_replace('/:\d+$/', '', trim($host)));
1039: 
1040:         // as the host can come from the user (HTTP_HOST and depending on the configuration, SERVER_NAME too can come from the user)
1041:         // check that it does not contain forbidden characters (see RFC 952 and RFC 2181)
1042:         if ($host && !preg_match('/^\[?(?:[a-zA-Z0-9-:\]_]+\.?)+$/', $host)) {
1043:             throw new \UnexpectedValueException('Invalid Host');
1044:         }
1045: 
1046:         return $host;
1047:     }
1048: 
1049:     /**
1050:      * Sets the request method.
1051:      *
1052:      * @param string $method
1053:      *
1054:      * @api
1055:      */
1056:     public function setMethod($method)
1057:     {
1058:         $this->method = null;
1059:         $this->server->set('REQUEST_METHOD', $method);
1060:     }
1061: 
1062:     /**
1063:      * Gets the request "intended" method.
1064:      *
1065:      * If the X-HTTP-Method-Override header is set, and if the method is a POST,
1066:      * then it is used to determine the "real" intended HTTP method.
1067:      *
1068:      * The _method request parameter can also be used to determine the HTTP method,
1069:      * but only if enableHttpMethodParameterOverride() has been called.
1070:      *
1071:      * The method is always an uppercased string.
1072:      *
1073:      * @return string The request method
1074:      *
1075:      * @api
1076:      *
1077:      * @see getRealMethod
1078:      */
1079:     public function getMethod()
1080:     {
1081:         if (null === $this->method) {
1082:             $this->method = strtoupper($this->server->get('REQUEST_METHOD', 'GET'));
1083: 
1084:             if ('POST' === $this->method) {
1085:                 if ($method = $this->headers->get('X-HTTP-METHOD-OVERRIDE')) {
1086:                     $this->method = strtoupper($method);
1087:                 } elseif (self::$httpMethodParameterOverride) {
1088:                     $this->method = strtoupper($this->request->get('_method', $this->query->get('_method', 'POST')));
1089:                 }
1090:             }
1091:         }
1092: 
1093:         return $this->method;
1094:     }
1095: 
1096:     /**
1097:      * Gets the "real" request method.
1098:      *
1099:      * @return string The request method
1100:      *
1101:      * @see getMethod
1102:      */
1103:     public function getRealMethod()
1104:     {
1105:         return strtoupper($this->server->get('REQUEST_METHOD', 'GET'));
1106:     }
1107: 
1108:     /**
1109:      * Gets the mime type associated with the format.
1110:      *
1111:      * @param string $format The format
1112:      *
1113:      * @return string The associated mime type (null if not found)
1114:      *
1115:      * @api
1116:      */
1117:     public function getMimeType($format)
1118:     {
1119:         if (null === static::$formats) {
1120:             static::initializeFormats();
1121:         }
1122: 
1123:         return isset(static::$formats[$format]) ? static::$formats[$format][0] : null;
1124:     }
1125: 
1126:     /**
1127:      * Gets the format associated with the mime type.
1128:      *
1129:      * @param string $mimeType The associated mime type
1130:      *
1131:      * @return string|null The format (null if not found)
1132:      *
1133:      * @api
1134:      */
1135:     public function getFormat($mimeType)
1136:     {
1137:         if (false !== $pos = strpos($mimeType, ';')) {
1138:             $mimeType = substr($mimeType, 0, $pos);
1139:         }
1140: 
1141:         if (null === static::$formats) {
1142:             static::initializeFormats();
1143:         }
1144: 
1145:         foreach (static::$formats as $format => $mimeTypes) {
1146:             if (in_array($mimeType, (array) $mimeTypes)) {
1147:                 return $format;
1148:             }
1149:         }
1150: 
1151:         return null;
1152:     }
1153: 
1154:     /**
1155:      * Associates a format with mime types.
1156:      *
1157:      * @param string       $format    The format
1158:      * @param string|array $mimeTypes The associated mime types (the preferred one must be the first as it will be used as the content type)
1159:      *
1160:      * @api
1161:      */
1162:     public function setFormat($format, $mimeTypes)
1163:     {
1164:         if (null === static::$formats) {
1165:             static::initializeFormats();
1166:         }
1167: 
1168:         static::$formats[$format] = is_array($mimeTypes) ? $mimeTypes : array($mimeTypes);
1169:     }
1170: 
1171:     /**
1172:      * Gets the request format.
1173:      *
1174:      * Here is the process to determine the format:
1175:      *
1176:      *  * format defined by the user (with setRequestFormat())
1177:      *  * _format request parameter
1178:      *  * $default
1179:      *
1180:      * @param string $default The default format
1181:      *
1182:      * @return string The request format
1183:      *
1184:      * @api
1185:      */
1186:     public function getRequestFormat($default = 'html')
1187:     {
1188:         if (null === $this->format) {
1189:             $this->format = $this->get('_format', $default);
1190:         }
1191: 
1192:         return $this->format;
1193:     }
1194: 
1195:     /**
1196:      * Sets the request format.
1197:      *
1198:      * @param string $format The request format.
1199:      *
1200:      * @api
1201:      */
1202:     public function setRequestFormat($format)
1203:     {
1204:         $this->format = $format;
1205:     }
1206: 
1207:     /**
1208:      * Gets the format associated with the request.
1209:      *
1210:      * @return string|null The format (null if no content type is present)
1211:      *
1212:      * @api
1213:      */
1214:     public function getContentType()
1215:     {
1216:         return $this->getFormat($this->headers->get('CONTENT_TYPE'));
1217:     }
1218: 
1219:     /**
1220:      * Sets the default locale.
1221:      *
1222:      * @param string $locale
1223:      *
1224:      * @api
1225:      */
1226:     public function setDefaultLocale($locale)
1227:     {
1228:         $this->defaultLocale = $locale;
1229: 
1230:         if (null === $this->locale) {
1231:             $this->setPhpDefaultLocale($locale);
1232:         }
1233:     }
1234: 
1235:     /**
1236:      * Sets the locale.
1237:      *
1238:      * @param string $locale
1239:      *
1240:      * @api
1241:      */
1242:     public function setLocale($locale)
1243:     {
1244:         $this->setPhpDefaultLocale($this->locale = $locale);
1245:     }
1246: 
1247:     /**
1248:      * Get the locale.
1249:      *
1250:      * @return string
1251:      */
1252:     public function getLocale()
1253:     {
1254:         return null === $this->locale ? $this->defaultLocale : $this->locale;
1255:     }
1256: 
1257:     /**
1258:      * Checks if the request method is of specified type.
1259:      *
1260:      * @param string $method Uppercase request method (GET, POST etc).
1261:      *
1262:      * @return Boolean
1263:      */
1264:     public function isMethod($method)
1265:     {
1266:         return $this->getMethod() === strtoupper($method);
1267:     }
1268: 
1269:     /**
1270:      * Checks whether the method is safe or not.
1271:      *
1272:      * @return Boolean
1273:      *
1274:      * @api
1275:      */
1276:     public function isMethodSafe()
1277:     {
1278:         return in_array($this->getMethod(), array('GET', 'HEAD'));
1279:     }
1280: 
1281:     /**
1282:      * Returns the request body content.
1283:      *
1284:      * @param Boolean $asResource If true, a resource will be returned
1285:      *
1286:      * @return string|resource The request body content or a resource to read the body stream.
1287:      *
1288:      * @throws \LogicException
1289:      */
1290:     public function getContent($asResource = false)
1291:     {
1292:         if (false === $this->content || (true === $asResource && null !== $this->content)) {
1293:             throw new \LogicException('getContent() can only be called once when using the resource return type.');
1294:         }
1295: 
1296:         if (true === $asResource) {
1297:             $this->content = false;
1298: 
1299:             return fopen('php://input', 'rb');
1300:         }
1301: 
1302:         if (null === $this->content) {
1303:             $this->content = file_get_contents('php://input');
1304:         }
1305: 
1306:         return $this->content;
1307:     }
1308: 
1309:     /**
1310:      * Gets the Etags.
1311:      *
1312:      * @return array The entity tags
1313:      */
1314:     public function getETags()
1315:     {
1316:         return preg_split('/\s*,\s*/', $this->headers->get('if_none_match'), null, PREG_SPLIT_NO_EMPTY);
1317:     }
1318: 
1319:     /**
1320:      * @return Boolean
1321:      */
1322:     public function isNoCache()
1323:     {
1324:         return $this->headers->hasCacheControlDirective('no-cache') || 'no-cache' == $this->headers->get('Pragma');
1325:     }
1326: 
1327:     /**
1328:      * Returns the preferred language.
1329:      *
1330:      * @param array $locales An array of ordered available locales
1331:      *
1332:      * @return string|null The preferred locale
1333:      *
1334:      * @api
1335:      */
1336:     public function getPreferredLanguage(array $locales = null)
1337:     {
1338:         $preferredLanguages = $this->getLanguages();
1339: 
1340:         if (empty($locales)) {
1341:             return isset($preferredLanguages[0]) ? $preferredLanguages[0] : null;
1342:         }
1343: 
1344:         if (!$preferredLanguages) {
1345:             return $locales[0];
1346:         }
1347: 
1348:         $extendedPreferredLanguages = array();
1349:         foreach ($preferredLanguages as $language) {
1350:             $extendedPreferredLanguages[] = $language;
1351:             if (false !== $position = strpos($language, '_')) {
1352:                 $superLanguage = substr($language, 0, $position);
1353:                 if (!in_array($superLanguage, $preferredLanguages)) {
1354:                     $extendedPreferredLanguages[] = $superLanguage;
1355:                 }
1356:             }
1357:         }
1358: 
1359:         $preferredLanguages = array_values(array_intersect($extendedPreferredLanguages, $locales));
1360: 
1361:         return isset($preferredLanguages[0]) ? $preferredLanguages[0] : $locales[0];
1362:     }
1363: 
1364:     /**
1365:      * Gets a list of languages acceptable by the client browser.
1366:      *
1367:      * @return array Languages ordered in the user browser preferences
1368:      *
1369:      * @api
1370:      */
1371:     public function getLanguages()
1372:     {
1373:         if (null !== $this->languages) {
1374:             return $this->languages;
1375:         }
1376: 
1377:         $languages = AcceptHeader::fromString($this->headers->get('Accept-Language'))->all();
1378:         $this->languages = array();
1379:         foreach (array_keys($languages) as $lang) {
1380:             if (strstr($lang, '-')) {
1381:                 $codes = explode('-', $lang);
1382:                 if ($codes[0] == 'i') {
1383:                     // Language not listed in ISO 639 that are not variants
1384:                     // of any listed language, which can be registered with the
1385:                     // i-prefix, such as i-cherokee
1386:                     if (count($codes) > 1) {
1387:                         $lang = $codes[1];
1388:                     }
1389:                 } else {
1390:                     for ($i = 0, $max = count($codes); $i < $max; $i++) {
1391:                         if ($i == 0) {
1392:                             $lang = strtolower($codes[0]);
1393:                         } else {
1394:                             $lang .= '_'.strtoupper($codes[$i]);
1395:                         }
1396:                     }
1397:                 }
1398:             }
1399: 
1400:             $this->languages[] = $lang;
1401:         }
1402: 
1403:         return $this->languages;
1404:     }
1405: 
1406:     /**
1407:      * Gets a list of charsets acceptable by the client browser.
1408:      *
1409:      * @return array List of charsets in preferable order
1410:      *
1411:      * @api
1412:      */
1413:     public function getCharsets()
1414:     {
1415:         if (null !== $this->charsets) {
1416:             return $this->charsets;
1417:         }
1418: 
1419:         return $this->charsets = array_keys(AcceptHeader::fromString($this->headers->get('Accept-Charset'))->all());
1420:     }
1421: 
1422:     /**
1423:      * Gets a list of content types acceptable by the client browser
1424:      *
1425:      * @return array List of content types in preferable order
1426:      *
1427:      * @api
1428:      */
1429:     public function getAcceptableContentTypes()
1430:     {
1431:         if (null !== $this->acceptableContentTypes) {
1432:             return $this->acceptableContentTypes;
1433:         }
1434: 
1435:         return $this->acceptableContentTypes = array_keys(AcceptHeader::fromString($this->headers->get('Accept'))->all());
1436:     }
1437: 
1438:     /**
1439:      * Returns true if the request is a XMLHttpRequest.
1440:      *
1441:      * It works if your JavaScript library set an X-Requested-With HTTP header.
1442:      * It is known to work with common JavaScript frameworks:
1443:      * @link http://en.wikipedia.org/wiki/List_of_Ajax_frameworks#JavaScript
1444:      *
1445:      * @return Boolean true if the request is an XMLHttpRequest, false otherwise
1446:      *
1447:      * @api
1448:      */
1449:     public function isXmlHttpRequest()
1450:     {
1451:         return 'XMLHttpRequest' == $this->headers->get('X-Requested-With');
1452:     }
1453: 
1454:     /**
1455:      * Splits an Accept-* HTTP header.
1456:      *
1457:      * @param string $header Header to split
1458:      *
1459:      * @return array Array indexed by the values of the Accept-* header in preferred order
1460:      *
1461:      * @deprecated Deprecated since version 2.2, to be removed in 2.3.
1462:      */
1463:     public function splitHttpAcceptHeader($header)
1464:     {
1465:         trigger_error('splitHttpAcceptHeader() is deprecated since version 2.2 and will be removed in 2.3.', E_USER_DEPRECATED);
1466: 
1467:         $headers = array();
1468:         foreach (AcceptHeader::fromString($header)->all() as $item) {
1469:             $key = $item->getValue();
1470:             foreach ($item->getAttributes() as $name => $value) {
1471:                 $key .= sprintf(';%s=%s', $name, $value);
1472:             }
1473:             $headers[$key] = $item->getQuality();
1474:         }
1475: 
1476:         return $headers;
1477:     }
1478: 
1479:     /*
1480:      * The following methods are derived from code of the Zend Framework (1.10dev - 2010-01-24)
1481:      *
1482:      * Code subject to the new BSD license (http://framework.zend.com/license/new-bsd).
1483:      *
1484:      * Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
1485:      */
1486: 
1487:     protected function prepareRequestUri()
1488:     {
1489:         $requestUri = '';
1490: 
1491:         if ($this->headers->has('X_ORIGINAL_URL') && false !== stripos(PHP_OS, 'WIN')) {
1492:             // IIS with Microsoft Rewrite Module
1493:             $requestUri = $this->headers->get('X_ORIGINAL_URL');
1494:             $this->headers->remove('X_ORIGINAL_URL');
1495:         } elseif ($this->headers->has('X_REWRITE_URL') && false !== stripos(PHP_OS, 'WIN')) {
1496:             // IIS with ISAPI_Rewrite
1497:             $requestUri = $this->headers->get('X_REWRITE_URL');
1498:             $this->headers->remove('X_REWRITE_URL');
1499:         } elseif ($this->server->get('IIS_WasUrlRewritten') == '1' && $this->server->get('UNENCODED_URL') != '') {
1500:             // IIS7 with URL Rewrite: make sure we get the unencoded url (double slash problem)
1501:             $requestUri = $this->server->get('UNENCODED_URL');
1502:             $this->server->remove('UNENCODED_URL');
1503:             $this->server->remove('IIS_WasUrlRewritten');
1504:         } elseif ($this->server->has('REQUEST_URI')) {
1505:             $requestUri = $this->server->get('REQUEST_URI');
1506:             // HTTP proxy reqs setup request uri with scheme and host [and port] + the url path, only use url path
1507:             $schemeAndHttpHost = $this->getSchemeAndHttpHost();
1508:             if (strpos($requestUri, $schemeAndHttpHost) === 0) {
1509:                 $requestUri = substr($requestUri, strlen($schemeAndHttpHost));
1510:             }
1511:         } elseif ($this->server->has('ORIG_PATH_INFO')) {
1512:             // IIS 5.0, PHP as CGI
1513:             $requestUri = $this->server->get('ORIG_PATH_INFO');
1514:             if ('' != $this->server->get('QUERY_STRING')) {
1515:                 $requestUri .= '?'.$this->server->get('QUERY_STRING');
1516:             }
1517:             $this->server->remove('ORIG_PATH_INFO');
1518:         }
1519: 
1520:         // normalize the request URI to ease creating sub-requests from this request
1521:         $this->server->set('REQUEST_URI', $requestUri);
1522: 
1523:         return $requestUri;
1524:     }
1525: 
1526:     /**
1527:      * Prepares the base URL.
1528:      *
1529:      * @return string
1530:      */
1531:     protected function prepareBaseUrl()
1532:     {
1533:         $filename = basename($this->server->get('SCRIPT_FILENAME'));
1534: 
1535:         if (basename($this->server->get('SCRIPT_NAME')) === $filename) {
1536:             $baseUrl = $this->server->get('SCRIPT_NAME');
1537:         } elseif (basename($this->server->get('PHP_SELF')) === $filename) {
1538:             $baseUrl = $this->server->get('PHP_SELF');
1539:         } elseif (basename($this->server->get('ORIG_SCRIPT_NAME')) === $filename) {
1540:             $baseUrl = $this->server->get('ORIG_SCRIPT_NAME'); // 1and1 shared hosting compatibility
1541:         } else {
1542:             // Backtrack up the script_filename to find the portion matching
1543:             // php_self
1544:             $path    = $this->server->get('PHP_SELF', '');
1545:             $file    = $this->server->get('SCRIPT_FILENAME', '');
1546:             $segs    = explode('/', trim($file, '/'));
1547:             $segs    = array_reverse($segs);
1548:             $index   = 0;
1549:             $last    = count($segs);
1550:             $baseUrl = '';
1551:             do {
1552:                 $seg     = $segs[$index];
1553:                 $baseUrl = '/'.$seg.$baseUrl;
1554:                 ++$index;
1555:             } while (($last > $index) && (false !== ($pos = strpos($path, $baseUrl))) && (0 != $pos));
1556:         }
1557: 
1558:         // Does the baseUrl have anything in common with the request_uri?
1559:         $requestUri = $this->getRequestUri();
1560: 
1561:         if ($baseUrl && false !== $prefix = $this->getUrlencodedPrefix($requestUri, $baseUrl)) {
1562:             // full $baseUrl matches
1563:             return $prefix;
1564:         }
1565: 
1566:         if ($baseUrl && false !== $prefix = $this->getUrlencodedPrefix($requestUri, dirname($baseUrl))) {
1567:             // directory portion of $baseUrl matches
1568:             return rtrim($prefix, '/');
1569:         }
1570: 
1571:         $truncatedRequestUri = $requestUri;
1572:         if (($pos = strpos($requestUri, '?')) !== false) {
1573:             $truncatedRequestUri = substr($requestUri, 0, $pos);
1574:         }
1575: 
1576:         $basename = basename($baseUrl);
1577:         if (empty($basename) || !strpos(rawurldecode($truncatedRequestUri), $basename)) {
1578:             // no match whatsoever; set it blank
1579:             return '';
1580:         }
1581: 
1582:         // If using mod_rewrite or ISAPI_Rewrite strip the script filename
1583:         // out of baseUrl. $pos !== 0 makes sure it is not matching a value
1584:         // from PATH_INFO or QUERY_STRING
1585:         if ((strlen($requestUri) >= strlen($baseUrl)) && ((false !== ($pos = strpos($requestUri, $baseUrl))) && ($pos !== 0))) {
1586:             $baseUrl = substr($requestUri, 0, $pos + strlen($baseUrl));
1587:         }
1588: 
1589:         return rtrim($baseUrl, '/');
1590:     }
1591: 
1592:     /**
1593:      * Prepares the base path.
1594:      *
1595:      * @return string base path
1596:      */
1597:     protected function prepareBasePath()
1598:     {
1599:         $filename = basename($this->server->get('SCRIPT_FILENAME'));
1600:         $baseUrl = $this->getBaseUrl();
1601:         if (empty($baseUrl)) {
1602:             return '';
1603:         }
1604: 
1605:         if (basename($baseUrl) === $filename) {
1606:             $basePath = dirname($baseUrl);
1607:         } else {
1608:             $basePath = $baseUrl;
1609:         }
1610: 
1611:         if ('\\' === DIRECTORY_SEPARATOR) {
1612:             $basePath = str_replace('\\', '/', $basePath);
1613:         }
1614: 
1615:         return rtrim($basePath, '/');
1616:     }
1617: 
1618:     /**
1619:      * Prepares the path info.
1620:      *
1621:      * @return string path info
1622:      */
1623:     protected function preparePathInfo()
1624:     {
1625:         $baseUrl = $this->getBaseUrl();
1626: 
1627:         if (null === ($requestUri = $this->getRequestUri())) {
1628:             return '/';
1629:         }
1630: 
1631:         $pathInfo = '/';
1632: 
1633:         // Remove the query string from REQUEST_URI
1634:         if ($pos = strpos($requestUri, '?')) {
1635:             $requestUri = substr($requestUri, 0, $pos);
1636:         }
1637: 
1638:         if ((null !== $baseUrl) && (false === ($pathInfo = substr($requestUri, strlen($baseUrl))))) {
1639:             // If substr() returns false then PATH_INFO is set to an empty string
1640:             return '/';
1641:         } elseif (null === $baseUrl) {
1642:             return $requestUri;
1643:         }
1644: 
1645:         return (string) $pathInfo;
1646:     }
1647: 
1648:     /**
1649:      * Initializes HTTP request formats.
1650:      */
1651:     protected static function initializeFormats()
1652:     {
1653:         static::$formats = array(
1654:             'html' => array('text/html', 'application/xhtml+xml'),
1655:             'txt'  => array('text/plain'),
1656:             'js'   => array('application/javascript', 'application/x-javascript', 'text/javascript'),
1657:             'css'  => array('text/css'),
1658:             'json' => array('application/json', 'application/x-json'),
1659:             'xml'  => array('text/xml', 'application/xml', 'application/x-xml'),
1660:             'rdf'  => array('application/rdf+xml'),
1661:             'atom' => array('application/atom+xml'),
1662:             'rss'  => array('application/rss+xml'),
1663:         );
1664:     }
1665: 
1666:     /**
1667:      * Sets the default PHP locale.
1668:      *
1669:      * @param string $locale
1670:      */
1671:     private function setPhpDefaultLocale($locale)
1672:     {
1673:         // if either the class Locale doesn't exist, or an exception is thrown when
1674:         // setting the default locale, the intl module is not installed, and
1675:         // the call can be ignored:
1676:         try {
1677:             if (class_exists('Locale', false)) {
1678:                 \Locale::setDefault($locale);
1679:             }
1680:         } catch (\Exception $e) {
1681:         }
1682:     }
1683: 
1684:     /*
1685:      * Returns the prefix as encoded in the string when the string starts with
1686:      * the given prefix, false otherwise.
1687:      *
1688:      * @param string $string The urlencoded string
1689:      * @param string $prefix The prefix not encoded
1690:      *
1691:      * @return string|false The prefix as it is encoded in $string, or false
1692:      */
1693:     private function getUrlencodedPrefix($string, $prefix)
1694:     {
1695:         if (0 !== strpos(rawurldecode($string), $prefix)) {
1696:             return false;
1697:         }
1698: 
1699:         $len = strlen($prefix);
1700: 
1701:         if (preg_match("#^(%[[:xdigit:]]{2}|.){{$len}}#", $string, $match)) {
1702:             return $match[0];
1703:         }
1704: 
1705:         return false;
1706:     }
1707: }
1708: