2010-02-17 13:53:18 +00:00
< ? php
/*
2010-04-07 01:51:29 +01:00
* This file is part of the Symfony package .
2010-02-17 13:53:18 +00:00
*
2011-03-06 11:40:06 +00:00
* ( c ) Fabien Potencier < fabien @ symfony . com >
2010-02-17 13:53:18 +00:00
*
* For the full copyright and license information , please view the LICENSE
* file that was distributed with this source code .
*/
2011-01-15 13:29:43 +00:00
namespace Symfony\Component\HttpFoundation ;
2012-02-08 23:15:47 +00:00
use Symfony\Component\HttpFoundation\Session\SessionInterface ;
2011-12-08 05:50:01 +00:00
2010-02-17 13:53:18 +00:00
/**
2010-05-03 10:40:23 +01:00
* Request represents an HTTP request .
2010-02-17 13:53:18 +00:00
*
2012-03-19 14:59:52 +00:00
* The methods dealing with URL accept / return a raw path ( % encoded ) :
* * getBasePath
* * getBaseUrl
* * getPathInfo
* * getRequestUri
* * getUri
* * getUriForPath
*
2011-03-06 11:40:06 +00:00
* @ author Fabien Potencier < fabien @ symfony . com >
2011-07-20 09:06:02 +01:00
*
* @ api
2010-02-17 13:53:18 +00:00
*/
2010-04-24 08:38:58 +01:00
class Request
2010-02-17 13:53:18 +00:00
{
2012-12-29 13:43:44 +00:00
const HEADER_CLIENT_IP = 'client_ip' ;
const HEADER_CLIENT_HOST = 'client_host' ;
2012-11-28 10:53:55 +00:00
const HEADER_CLIENT_PROTO = 'client_proto' ;
2012-12-29 13:43:44 +00:00
const HEADER_CLIENT_PORT = 'client_port' ;
2012-11-28 10:53:55 +00:00
2012-11-29 11:31:26 +00:00
protected static $trustProxy = false ;
2012-11-27 21:21:23 +00:00
protected static $trustedProxies = array ();
2011-07-05 18:38:29 +01:00
2012-11-28 07:25:47 +00:00
/**
* Names for headers that can be trusted when
* using trusted proxies .
*
* The default names are non - standard , but widely used
* by popular reverse proxies ( like Apache mod_proxy or Amazon EC2 ) .
*/
protected static $trustedHeaders = array (
2012-11-28 10:53:55 +00:00
self :: HEADER_CLIENT_IP => 'X_FORWARDED_FOR' ,
self :: HEADER_CLIENT_HOST => 'X_FORWARDED_HOST' ,
self :: HEADER_CLIENT_PROTO => 'X_FORWARDED_PROTO' ,
self :: HEADER_CLIENT_PORT => 'X_FORWARDED_PORT' ,
2012-11-28 07:25:47 +00:00
);
2011-07-05 18:38:29 +01:00
2012-11-28 09:31:19 +00:00
protected static $httpMethodParameterOverride = false ;
2010-07-21 21:49:49 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ var \Symfony\Component\HttpFoundation\ParameterBag
2011-07-20 09:06:02 +01:00
*
* @ api
2010-07-21 21:49:49 +01:00
*/
public $attributes ;
2010-07-10 13:46:25 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ var \Symfony\Component\HttpFoundation\ParameterBag
2011-07-20 09:06:02 +01:00
*
* @ api
2010-07-10 13:46:25 +01:00
*/
2010-05-06 12:25:53 +01:00
public $request ;
2010-07-10 13:46:25 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ var \Symfony\Component\HttpFoundation\ParameterBag
2011-07-20 09:06:02 +01:00
*
* @ api
2010-07-10 13:46:25 +01:00
*/
2010-05-06 12:25:53 +01:00
public $query ;
2010-07-10 13:46:25 +01:00
/**
2011-09-27 08:49:25 +01:00
* @ var \Symfony\Component\HttpFoundation\ServerBag
2011-07-20 09:06:02 +01:00
*
* @ api
2010-07-10 13:46:25 +01:00
*/
2010-05-06 12:25:53 +01:00
public $server ;
2010-07-10 13:46:25 +01:00
/**
2011-09-27 08:49:25 +01:00
* @ var \Symfony\Component\HttpFoundation\FileBag
2011-07-20 09:06:02 +01:00
*
* @ api
2010-07-10 13:46:25 +01:00
*/
2010-05-06 12:25:53 +01:00
public $files ;
2010-07-10 13:46:25 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ var \Symfony\Component\HttpFoundation\ParameterBag
2011-07-20 09:06:02 +01:00
*
* @ api
2010-07-10 13:46:25 +01:00
*/
2010-05-06 12:25:53 +01:00
public $cookies ;
2010-07-10 13:46:25 +01:00
/**
2010-08-20 22:09:55 +01:00
* @ var \Symfony\Component\HttpFoundation\HeaderBag
2011-07-20 09:06:02 +01:00
*
* @ api
2010-07-10 13:46:25 +01:00
*/
2010-05-06 12:25:53 +01:00
public $headers ;
2011-11-02 15:42:51 +00:00
/**
* @ var string
*/
2010-12-12 08:05:03 +00:00
protected $content ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
2012-06-25 17:21:41 +01:00
* @ var array
2011-11-02 15:42:51 +00:00
*/
2010-05-06 12:25:53 +01:00
protected $languages ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
2012-06-25 17:21:41 +01:00
* @ var array
2011-11-02 15:42:51 +00:00
*/
2010-05-06 12:25:53 +01:00
protected $charsets ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
2012-06-25 17:21:41 +01:00
* @ var array
2011-11-02 15:42:51 +00:00
*/
2010-05-06 12:25:53 +01:00
protected $acceptableContentTypes ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
* @ var string
*/
2010-05-06 12:25:53 +01:00
protected $pathInfo ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
* @ var string
*/
2010-05-06 12:25:53 +01:00
protected $requestUri ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
* @ var string
*/
2010-05-06 12:25:53 +01:00
protected $baseUrl ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
* @ var string
*/
2010-05-06 12:25:53 +01:00
protected $basePath ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
* @ var string
*/
2010-05-06 12:25:53 +01:00
protected $method ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
* @ var string
*/
2010-05-06 12:25:53 +01:00
protected $format ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
2012-02-08 23:15:47 +00:00
* @ var \Symfony\Component\HttpFoundation\Session\SessionInterface
2011-11-02 15:42:51 +00:00
*/
2010-07-09 08:26:22 +01:00
protected $session ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
* @ var string
*/
2011-10-05 10:09:51 +01:00
protected $locale ;
2011-12-18 13:33:54 +00:00
2011-11-02 15:42:51 +00:00
/**
* @ var string
*/
2011-10-05 10:09:51 +01:00
protected $defaultLocale = 'en' ;
2010-05-06 12:25:53 +01:00
2011-11-02 15:42:51 +00:00
/**
2012-06-25 17:21:41 +01:00
* @ var array
2011-11-02 15:42:51 +00:00
*/
2012-07-09 13:50:58 +01:00
protected static $formats ;
2010-05-06 12:25:53 +01:00
/**
* Constructor .
*
2011-02-04 11:37:52 +00:00
* @ param array $query The GET parameters
* @ param array $request The POST parameters
* @ param array $attributes The request attributes ( parameters parsed from the PATH_INFO , ... )
* @ param array $cookies The COOKIE parameters
* @ param array $files The FILES parameters
* @ param array $server The SERVER parameters
* @ param string $content The raw body data
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
2011-02-04 11:37:52 +00:00
public function __construct ( array $query = array (), array $request = array (), array $attributes = array (), array $cookies = array (), array $files = array (), array $server = array (), $content = null )
2010-05-06 12:25:53 +01:00
{
2011-02-04 11:37:52 +00:00
$this -> initialize ( $query , $request , $attributes , $cookies , $files , $server , $content );
2010-05-06 12:25:53 +01:00
}
/**
* Sets the parameters for this request .
*
* This method also re - initializes all properties .
*
2011-02-04 11:37:52 +00:00
* @ param array $query The GET parameters
* @ param array $request The POST parameters
* @ param array $attributes The request attributes ( parameters parsed from the PATH_INFO , ... )
* @ param array $cookies The COOKIE parameters
* @ param array $files The FILES parameters
* @ param array $server The SERVER parameters
* @ param string $content The raw body data
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
2011-02-04 11:37:52 +00:00
public function initialize ( array $query = array (), array $request = array (), array $attributes = array (), array $cookies = array (), array $files = array (), array $server = array (), $content = null )
2010-05-06 12:25:53 +01:00
{
2011-01-27 03:22:24 +00:00
$this -> request = new ParameterBag ( $request );
$this -> query = new ParameterBag ( $query );
$this -> attributes = new ParameterBag ( $attributes );
$this -> cookies = new ParameterBag ( $cookies );
$this -> files = new FileBag ( $files );
$this -> server = new ServerBag ( $server );
2011-01-22 17:34:18 +00:00
$this -> headers = new HeaderBag ( $this -> server -> getHeaders ());
2010-05-06 12:25:53 +01:00
2011-02-04 11:37:52 +00:00
$this -> content = $content ;
2010-05-06 12:25:53 +01:00
$this -> languages = null ;
$this -> charsets = null ;
$this -> acceptableContentTypes = null ;
$this -> pathInfo = null ;
$this -> requestUri = null ;
$this -> baseUrl = null ;
$this -> basePath = null ;
$this -> method = null ;
$this -> format = null ;
}
2011-01-27 20:20:08 +00:00
/**
* Creates a new request with values from PHP ' s super globals .
*
* @ return Request A new request
2011-07-20 09:06:02 +01:00
*
* @ api
2011-01-27 20:20:08 +00:00
*/
2012-07-09 13:50:58 +01:00
public static function createFromGlobals ()
2011-01-27 20:20:08 +00:00
{
2011-05-11 09:30:57 +01:00
$request = new static ( $_GET , $_POST , array (), $_COOKIE , $_FILES , $_SERVER );
2012-10-09 09:56:57 +01:00
if ( 0 === strpos ( $request -> headers -> get ( 'CONTENT_TYPE' ), 'application/x-www-form-urlencoded' )
2011-08-07 11:07:28 +01:00
&& in_array ( strtoupper ( $request -> server -> get ( 'REQUEST_METHOD' , 'GET' )), array ( 'PUT' , 'DELETE' , 'PATCH' ))
2011-05-11 09:30:57 +01:00
) {
2011-05-12 22:21:13 +01:00
parse_str ( $request -> getContent (), $data );
2011-05-11 09:30:57 +01:00
$request -> request = new ParameterBag ( $data );
}
return $request ;
2011-01-27 20:20:08 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Creates a Request based on a given URI and configuration .
*
2013-02-06 15:42:45 +00:00
* The information contained in the URI always take precedence
* over the other information ( server and parameters ) .
*
2010-05-06 12:25:53 +01:00
* @ param string $uri The URI
* @ param string $method The HTTP method
2012-07-04 03:13:21 +01:00
* @ param array $parameters The query ( GET ) or request ( POST ) parameters
2010-05-06 12:25:53 +01:00
* @ param array $cookies The request cookies ( $_COOKIE )
* @ param array $files The request files ( $_FILES )
* @ param array $server The server parameters ( $_SERVER )
2011-02-04 11:37:52 +00:00
* @ param string $content The raw body data
2010-05-06 12:25:53 +01:00
*
* @ return Request A Request instance
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
2012-07-09 13:50:58 +01:00
public static function create ( $uri , $method = 'GET' , $parameters = array (), $cookies = array (), $files = array (), $server = array (), $content = null )
2010-05-06 12:25:53 +01:00
{
2013-02-06 15:42:45 +00:00
$server = array_replace ( array (
2010-05-06 12:25:53 +01:00
'SERVER_NAME' => 'localhost' ,
'SERVER_PORT' => 80 ,
'HTTP_HOST' => 'localhost' ,
2010-09-01 12:56:06 +01:00
'HTTP_USER_AGENT' => 'Symfony/2.X' ,
2010-05-06 12:25:53 +01:00
'HTTP_ACCEPT' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8' ,
'HTTP_ACCEPT_LANGUAGE' => 'en-us,en;q=0.5' ,
'HTTP_ACCEPT_CHARSET' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7' ,
'REMOTE_ADDR' => '127.0.0.1' ,
'SCRIPT_NAME' => '' ,
'SCRIPT_FILENAME' => '' ,
2011-05-15 11:33:06 +01:00
'SERVER_PROTOCOL' => 'HTTP/1.1' ,
2011-06-25 11:44:24 +01:00
'REQUEST_TIME' => time (),
2013-02-06 15:42:45 +00:00
), $server );
$server [ 'PATH_INFO' ] = '' ;
$server [ 'REQUEST_METHOD' ] = strtoupper ( $method );
2010-05-06 12:25:53 +01:00
2010-12-06 00:32:42 +00:00
$components = parse_url ( $uri );
if ( isset ( $components [ 'host' ])) {
2013-02-06 15:42:45 +00:00
$server [ 'SERVER_NAME' ] = $components [ 'host' ];
$server [ 'HTTP_HOST' ] = $components [ 'host' ];
2010-12-06 00:32:42 +00:00
}
2010-12-07 21:51:45 +00:00
if ( isset ( $components [ 'scheme' ])) {
if ( 'https' === $components [ 'scheme' ]) {
2013-02-06 15:42:45 +00:00
$server [ 'HTTPS' ] = 'on' ;
$server [ 'SERVER_PORT' ] = 443 ;
} else {
unset ( $server [ 'HTTPS' ]);
$server [ 'SERVER_PORT' ] = 80 ;
2010-12-07 21:51:45 +00:00
}
}
2010-12-06 00:32:42 +00:00
if ( isset ( $components [ 'port' ])) {
2013-02-06 15:42:45 +00:00
$server [ 'SERVER_PORT' ] = $components [ 'port' ];
$server [ 'HTTP_HOST' ] = $server [ 'HTTP_HOST' ] . ':' . $components [ 'port' ];
2010-12-06 00:32:42 +00:00
}
2011-07-27 07:27:46 +01:00
2011-09-12 12:01:04 +01:00
if ( isset ( $components [ 'user' ])) {
2013-02-06 15:42:45 +00:00
$server [ 'PHP_AUTH_USER' ] = $components [ 'user' ];
2011-09-12 12:01:04 +01:00
}
if ( isset ( $components [ 'pass' ])) {
2013-02-06 15:42:45 +00:00
$server [ 'PHP_AUTH_PW' ] = $components [ 'pass' ];
2011-09-12 12:01:04 +01:00
}
2011-07-19 09:54:21 +01:00
if ( ! isset ( $components [ 'path' ])) {
2012-10-11 14:19:35 +01:00
$components [ 'path' ] = '/' ;
2011-07-19 09:54:21 +01:00
}
2010-12-06 00:32:42 +00:00
2011-08-07 12:01:39 +01:00
switch ( strtoupper ( $method )) {
case 'POST' :
case 'PUT' :
case 'DELETE' :
2013-02-08 15:29:55 +00:00
if ( ! isset ( $server [ 'CONTENT_TYPE' ])) {
$server [ 'CONTENT_TYPE' ] = 'application/x-www-form-urlencoded' ;
}
2011-08-07 12:01:39 +01:00
case 'PATCH' :
$request = $parameters ;
$query = array ();
break ;
default :
$request = array ();
$query = $parameters ;
break ;
2010-05-06 12:25:53 +01:00
}
2010-02-17 13:53:18 +00:00
2012-02-11 23:26:10 +00:00
if ( isset ( $components [ 'query' ])) {
2012-07-04 03:13:21 +01:00
parse_str ( html_entity_decode ( $components [ 'query' ]), $qs );
$query = array_replace ( $qs , $query );
2010-05-06 12:25:53 +01:00
}
2012-07-04 03:13:21 +01:00
$queryString = http_build_query ( $query , '' , '&' );
2010-02-17 13:53:18 +00:00
2013-02-06 15:42:45 +00:00
$server [ 'REQUEST_URI' ] = $components [ 'path' ] . ( '' !== $queryString ? '?' . $queryString : '' );
$server [ 'QUERY_STRING' ] = $queryString ;
2010-05-06 12:25:53 +01:00
2011-02-04 11:37:52 +00:00
return new static ( $query , $request , array (), $cookies , $files , $server , $content );
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Clones a request and overrides some of its parameters .
*
2010-07-21 21:49:49 +01:00
* @ param array $query The GET parameters
* @ param array $request The POST parameters
* @ param array $attributes The request attributes ( parameters parsed from the PATH_INFO , ... )
* @ param array $cookies The COOKIE parameters
* @ param array $files The FILES parameters
* @ param array $server The SERVER parameters
2011-07-20 09:06:02 +01:00
*
2012-06-25 17:21:41 +01:00
* @ return Request The duplicated request
*
2011-07-20 09:06:02 +01:00
* @ api
2010-05-06 12:25:53 +01:00
*/
2010-07-21 21:49:49 +01:00
public function duplicate ( array $query = null , array $request = null , array $attributes = null , array $cookies = null , array $files = null , array $server = null )
2010-05-06 12:25:53 +01:00
{
$dup = clone $this ;
2011-02-08 10:14:38 +00:00
if ( $query !== null ) {
2011-06-08 09:35:47 +01:00
$dup -> query = new ParameterBag ( $query );
2011-02-08 10:14:38 +00:00
}
if ( $request !== null ) {
2011-06-08 09:35:47 +01:00
$dup -> request = new ParameterBag ( $request );
2011-02-08 10:14:38 +00:00
}
if ( $attributes !== null ) {
2011-06-08 09:35:47 +01:00
$dup -> attributes = new ParameterBag ( $attributes );
2011-02-08 10:14:38 +00:00
}
if ( $cookies !== null ) {
2011-06-08 09:35:47 +01:00
$dup -> cookies = new ParameterBag ( $cookies );
2011-02-08 10:14:38 +00:00
}
if ( $files !== null ) {
2011-06-08 09:35:47 +01:00
$dup -> files = new FileBag ( $files );
2011-02-08 10:14:38 +00:00
}
if ( $server !== null ) {
2011-06-08 09:35:47 +01:00
$dup -> server = new ServerBag ( $server );
$dup -> headers = new HeaderBag ( $dup -> server -> getHeaders ());
2011-02-08 10:14:38 +00:00
}
2011-09-08 12:28:21 +01:00
$dup -> languages = null ;
$dup -> charsets = null ;
$dup -> acceptableContentTypes = null ;
$dup -> pathInfo = null ;
$dup -> requestUri = null ;
$dup -> baseUrl = null ;
$dup -> basePath = null ;
$dup -> method = null ;
$dup -> format = null ;
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
return $dup ;
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
2010-11-09 10:08:30 +00:00
/**
* Clones the current request .
*
* Note that the session is not cloned as duplicated requests
* are most of the time sub - requests of the main one .
*/
2010-05-06 12:25:53 +01:00
public function __clone ()
2010-02-17 13:53:18 +00:00
{
2010-07-21 21:49:49 +01:00
$this -> query = clone $this -> query ;
$this -> request = clone $this -> request ;
$this -> attributes = clone $this -> attributes ;
$this -> cookies = clone $this -> cookies ;
$this -> files = clone $this -> files ;
$this -> server = clone $this -> server ;
$this -> headers = clone $this -> headers ;
2010-02-17 13:53:18 +00:00
}
2011-05-15 11:33:06 +01:00
/**
* Returns the request as a string .
*
* @ return string The request
*/
public function __toString ()
{
2011-05-15 11:38:12 +01:00
return
sprintf ( '%s %s %s' , $this -> getMethod (), $this -> getRequestUri (), $this -> server -> get ( 'SERVER_PROTOCOL' )) . " \r \n " .
$this -> headers . " \r \n " .
$this -> getContent ();
2011-05-15 11:33:06 +01:00
}
2010-05-24 13:02:58 +01:00
/**
* Overrides the PHP global variables according to this request instance .
*
2012-03-11 11:02:08 +00:00
* It overrides $_GET , $_POST , $_REQUEST , $_SERVER , $_COOKIE .
* $_FILES is never override , see rfc1867
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-24 13:02:58 +01:00
*/
public function overrideGlobals ()
{
$_GET = $this -> query -> all ();
$_POST = $this -> request -> all ();
$_SERVER = $this -> server -> all ();
2010-12-03 19:19:45 +00:00
$_COOKIE = $this -> cookies -> all ();
2010-05-24 13:02:58 +01:00
2010-07-28 13:20:46 +01:00
foreach ( $this -> headers -> all () as $key => $value ) {
2011-06-08 10:04:41 +01:00
$key = strtoupper ( str_replace ( '-' , '_' , $key ));
if ( in_array ( $key , array ( 'CONTENT_TYPE' , 'CONTENT_LENGTH' ))) {
$_SERVER [ $key ] = implode ( ', ' , $value );
} else {
$_SERVER [ 'HTTP_' . $key ] = implode ( ', ' , $value );
}
2010-07-28 13:20:46 +01:00
}
2012-03-11 11:02:08 +00:00
$request = array ( 'g' => $_GET , 'p' => $_POST , 'c' => $_COOKIE );
2012-06-28 23:35:09 +01:00
$requestOrder = ini_get ( 'request_order' ) ? : ini_get ( 'variable_order' );
2012-06-28 16:48:35 +01:00
$requestOrder = preg_replace ( '#[^cgp]#' , '' , strtolower ( $requestOrder )) ? : 'gp' ;
2012-03-11 11:02:08 +00:00
$_REQUEST = array ();
2012-06-28 16:48:35 +01:00
foreach ( str_split ( $requestOrder ) as $order ) {
2012-03-11 11:02:08 +00:00
$_REQUEST = array_merge ( $_REQUEST , $request [ $order ]);
}
2010-05-24 13:02:58 +01:00
}
2011-07-05 18:38:29 +01:00
/**
* Trusts $_SERVER entries coming from proxies .
*
2012-11-27 21:21:23 +00:00
* @ deprecated Deprecated since version 2.0 , to be removed in 2.3 . Use setTrustedProxies instead .
*/
public static function trustProxyData ()
{
2012-12-03 18:56:52 +00:00
trigger_error ( 'trustProxyData() is deprecated since version 2.0 and will be removed in 2.3. Use setTrustedProxies() instead.' , E_USER_DEPRECATED );
2012-11-29 11:31:26 +00:00
self :: $trustProxy = true ;
2012-11-27 21:21:23 +00:00
}
/**
* Sets a list of trusted proxies .
*
* You should only list the reverse proxies that you manage directly .
*
* @ param array $proxies A list of trusted proxies
2011-07-20 09:06:02 +01:00
*
* @ api
2011-07-05 18:38:29 +01:00
*/
2012-11-27 21:21:23 +00:00
public static function setTrustedProxies ( array $proxies )
2011-07-05 18:38:29 +01:00
{
2012-11-27 21:21:23 +00:00
self :: $trustedProxies = $proxies ;
2012-11-29 11:31:26 +00:00
self :: $trustProxy = $proxies ? true : false ;
2011-07-05 18:38:29 +01:00
}
2012-12-19 07:54:53 +00:00
/**
* Gets the list of trusted proxies .
*
* @ return array An array of trusted proxies .
*/
public static function getTrustedProxies ()
{
return self :: $trustedProxies ;
}
2012-11-28 07:25:47 +00:00
/**
* Sets the name for trusted headers .
*
* The following header keys are supported :
*
2012-11-28 10:53:55 +00:00
* * Request :: HEADER_CLIENT_IP : defaults to X - Forwarded - For ( see getClientIp ())
* * Request :: HEADER_CLIENT_HOST : defaults to X - Forwarded - Host ( see getClientHost ())
* * Request :: HEADER_CLIENT_PORT : defaults to X - Forwarded - Port ( see getClientPort ())
* * Request :: HEADER_CLIENT_PROTO : defaults to X - Forwarded - Proto ( see getScheme () and isSecure ())
2012-11-28 07:25:47 +00:00
*
* Setting an empty value allows to disable the trusted header for the given key .
*
* @ param string $key The header key
* @ param string $value The header name
2012-12-16 12:02:54 +00:00
*
* @ throws \InvalidArgumentException
2012-11-28 07:25:47 +00:00
*/
public static function setTrustedHeaderName ( $key , $value )
2011-07-05 18:38:29 +01:00
{
2012-11-28 07:25:47 +00:00
if ( ! array_key_exists ( $key , self :: $trustedHeaders )) {
throw new \InvalidArgumentException ( sprintf ( 'Unable to set the trusted header name for key "%s".' , $key ));
}
self :: $trustedHeaders [ $key ] = $value ;
2011-07-05 18:38:29 +01:00
}
2012-03-07 15:11:42 +00:00
/**
* Returns true if $_SERVER entries coming from proxies are trusted ,
* false otherwise .
*
* @ return boolean
2013-01-10 15:47:11 +00:00
*
* @ deprecated Deprecated since version 2.2 , to be removed in 2.3 . Use getTrustedProxies instead .
2012-03-07 15:11:42 +00:00
*/
2012-07-09 13:50:58 +01:00
public static function isProxyTrusted ()
2012-03-07 15:11:42 +00:00
{
return self :: $trustProxy ;
}
2012-07-02 14:48:22 +01:00
/**
* Normalizes a query string .
*
2012-07-04 02:10:48 +01:00
* It builds a normalized query string , where keys / value pairs are alphabetized ,
* have consistent escaping and unneeded delimiters are removed .
2012-07-02 14:48:22 +01:00
*
* @ param string $qs Query string
*
2012-07-04 02:10:48 +01:00
* @ return string A normalized query string for the Request
2012-07-02 14:48:22 +01:00
*/
2012-07-09 13:50:58 +01:00
public static function normalizeQueryString ( $qs )
2012-07-02 14:48:22 +01:00
{
2012-07-04 02:10:48 +01:00
if ( '' == $qs ) {
return '' ;
2012-07-02 14:48:22 +01:00
}
$parts = array ();
$order = array ();
2012-07-04 02:10:48 +01:00
foreach ( explode ( '&' , $qs ) as $param ) {
if ( '' === $param || '=' === $param [ 0 ]) {
// Ignore useless delimiters, e.g. "x=y&".
// Also ignore pairs with empty key, even if there was a value, e.g. "=value", as such nameless values cannot be retrieved anyway.
// PHP also does not include them when building _GET.
continue ;
2012-07-02 14:48:22 +01:00
}
2012-07-04 02:10:48 +01:00
$keyValuePair = explode ( '=' , $param , 2 );
// GET parameters, that are submitted from a HTML form, encode spaces as "+" by default (as defined in enctype application/x-www-form-urlencoded).
// 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
// RFC 3986 with rawurlencode.
$parts [] = isset ( $keyValuePair [ 1 ]) ?
rawurlencode ( urldecode ( $keyValuePair [ 0 ])) . '=' . rawurlencode ( urldecode ( $keyValuePair [ 1 ])) :
rawurlencode ( urldecode ( $keyValuePair [ 0 ]));
$order [] = urldecode ( $keyValuePair [ 0 ]);
2012-07-02 14:48:22 +01:00
}
2012-07-04 02:10:48 +01:00
2012-07-02 14:48:22 +01:00
array_multisort ( $order , SORT_ASC , $parts );
return implode ( '&' , $parts );
}
2012-11-28 09:31:19 +00:00
/**
* Enables support for the _method request parameter to determine the intended HTTP method .
*
* Be warned that enabling this feature might lead to CSRF issues in your code .
* Check that you are using CSRF tokens when required .
*
2013-01-08 18:19:54 +00:00
* The HTTP method can only be overridden when the real HTTP method is POST .
2012-11-28 09:31:19 +00:00
*/
public static function enableHttpMethodParameterOverride ()
{
self :: $httpMethodParameterOverride = true ;
}
2011-06-14 20:44:45 +01:00
/**
2013-02-15 07:36:52 +00:00
* Checks whether support for the _method request parameter is enabled .
2013-02-07 12:10:06 +00:00
*
2013-02-15 07:36:52 +00:00
* @ return Boolean True when the _method request parameter is enabled , false otherwise
2013-02-07 12:10:06 +00:00
*/
public static function getHttpMethodParameterOverride ()
{
return self :: $httpMethodParameterOverride ;
}
2011-06-14 20:44:45 +01:00
/**
2011-06-15 10:35:32 +01:00
* Gets a " parameter " value .
*
2011-06-14 20:44:45 +01:00
* This method is mainly useful for libraries that want to provide some flexibility .
2011-06-15 10:35:32 +01:00
*
2012-11-02 10:47:11 +00:00
* Order of precedence : GET , PATH , POST
2012-01-24 09:24:25 +00:00
*
2011-06-14 20:44:45 +01:00
* Avoid using this method in controllers :
2012-01-24 09:24:25 +00:00
*
2011-06-14 20:44:45 +01:00
* * slow
* * prefer to get from a " named " source
2011-06-15 10:35:32 +01:00
*
2012-07-28 23:02:29 +01:00
* It is better to explicitly get request parameters from the appropriate
2012-11-02 10:47:11 +00:00
* public property instead ( query , attributes , request ) .
2012-01-24 09:24:25 +00:00
*
2012-06-25 17:21:41 +01:00
* @ param string $key the key
* @ param mixed $default the default value
* @ param Boolean $deep is parameter deep in multidimensional array
2011-06-15 10:35:32 +01:00
*
2011-06-14 20:44:45 +01:00
* @ return mixed
*/
2011-05-10 10:19:15 +01:00
public function get ( $key , $default = null , $deep = false )
2010-02-17 13:53:18 +00:00
{
2011-06-15 10:35:32 +01:00
return $this -> query -> get ( $key , $this -> attributes -> get ( $key , $this -> request -> get ( $key , $default , $deep ), $deep ), $deep );
2010-02-17 13:53:18 +00:00
}
2011-05-22 08:13:03 +01:00
/**
* Gets the Session .
2011-06-08 11:12:55 +01:00
*
2011-12-08 05:50:01 +00:00
* @ return SessionInterface | null The session
2011-07-20 09:06:02 +01:00
*
* @ api
2011-05-22 08:13:03 +01:00
*/
2010-07-09 08:26:22 +01:00
public function getSession ()
{
return $this -> session ;
}
2011-05-05 07:35:02 +01:00
/**
* Whether the request contains a Session which was started in one of the
* previous requests .
*
2012-11-30 12:53:14 +00:00
* @ return Boolean
2011-07-20 09:06:02 +01:00
*
* @ api
2011-05-05 07:35:02 +01:00
*/
public function hasPreviousSession ()
2010-07-09 08:26:22 +01:00
{
2011-04-21 19:00:27 +01:00
// the check for $this->session avoids malicious users trying to fake a session cookie with proper name
2012-07-04 02:41:37 +01:00
return $this -> hasSession () && $this -> cookies -> has ( $this -> session -> getName ());
2010-07-09 08:26:22 +01:00
}
2011-05-05 07:35:02 +01:00
/**
* Whether the request contains a Session object .
*
2012-11-30 12:53:14 +00:00
* This method does not give any information about the state of the session object ,
* like whether the session is started or not . It is just a way to check if this Request
* is associated with a Session instance .
*
* @ return Boolean true when the Request contains a Session object , false otherwise
2011-07-20 09:06:02 +01:00
*
* @ api
2011-05-05 07:35:02 +01:00
*/
public function hasSession ()
{
2012-07-01 22:21:53 +01:00
return null !== $this -> session ;
2011-05-05 07:35:02 +01:00
}
2011-05-22 08:13:03 +01:00
/**
* Sets the Session .
2011-06-08 11:12:55 +01:00
*
2011-12-08 05:50:01 +00:00
* @ param SessionInterface $session The Session
2011-07-20 09:06:02 +01:00
*
* @ api
2011-05-22 08:13:03 +01:00
*/
2011-12-08 05:50:01 +00:00
public function setSession ( SessionInterface $session )
2010-07-09 08:26:22 +01:00
{
$this -> session = $session ;
}
2010-09-01 12:56:20 +01:00
/**
* Returns the client IP address .
*
2012-11-27 21:21:23 +00:00
* This method can read the client IP address from the " X-Forwarded-For " header
* when trusted proxies were set via " setTrustedProxies() " . The " X-Forwarded-For "
* header value is a comma + space separated list of IP addresses , the left - most
* being the original client , and each successive proxy that passed the request
* adding the IP address where it received the request from .
*
2012-11-28 07:25:47 +00:00
* If your reverse proxy uses a different header name than " X-Forwarded-For " ,
* ( " Client-Ip " for instance ), configure it via " setTrustedHeaderName() " with
* the " client-ip " key .
*
2010-09-01 12:56:20 +01:00
* @ return string The client IP address
2011-07-20 09:06:02 +01:00
*
2012-11-27 21:21:23 +00:00
* @ see http :// en . wikipedia . org / wiki / X - Forwarded - For
*
2011-07-20 09:06:02 +01:00
* @ api
2010-09-01 12:56:20 +01:00
*/
2012-03-07 15:11:42 +00:00
public function getClientIp ()
2010-09-01 12:56:20 +01:00
{
2012-11-27 21:21:23 +00:00
$ip = $this -> server -> get ( 'REMOTE_ADDR' );
2011-12-13 07:50:54 +00:00
2012-11-29 11:32:05 +00:00
if ( ! self :: $trustProxy ) {
2012-11-27 21:21:23 +00:00
return $ip ;
2010-09-01 12:56:20 +01:00
}
2012-06-25 17:21:41 +01:00
2012-11-28 10:53:55 +00:00
if ( ! self :: $trustedHeaders [ self :: HEADER_CLIENT_IP ] || ! $this -> headers -> has ( self :: $trustedHeaders [ self :: HEADER_CLIENT_IP ])) {
2012-11-27 21:21:23 +00:00
return $ip ;
2010-09-01 12:56:20 +01:00
}
2012-11-28 10:53:55 +00:00
$clientIps = array_map ( 'trim' , explode ( ',' , $this -> headers -> get ( self :: $trustedHeaders [ self :: HEADER_CLIENT_IP ])));
2012-11-27 21:21:23 +00:00
$clientIps [] = $ip ;
2012-11-29 11:32:05 +00:00
$trustedProxies = self :: $trustProxy && ! self :: $trustedProxies ? array ( $ip ) : self :: $trustedProxies ;
2012-11-27 21:21:23 +00:00
$clientIps = array_diff ( $clientIps , $trustedProxies );
return array_pop ( $clientIps );
2010-09-01 12:56:20 +01:00
}
2010-05-06 12:25:53 +01:00
/**
* Returns current script name .
*
* @ return string
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
public function getScriptName ()
{
return $this -> server -> get ( 'SCRIPT_NAME' , $this -> server -> get ( 'ORIG_SCRIPT_NAME' , '' ));
}
2010-02-17 13:53:18 +00:00
2010-10-23 13:36:13 +01:00
/**
* Returns the path being requested relative to the executed script .
*
2011-05-15 10:28:00 +01:00
* The path info always starts with a /.
*
2010-10-23 13:36:13 +01:00
* Suppose this request is instantiated from / mysite on localhost :
*
* * http :// localhost / mysite returns an empty string
* * http :// localhost / mysite / about returns '/about'
2013-01-08 18:19:54 +00:00
* * http :// localhost / mysite / enco % 20 ded returns '/enco%20ded'
2010-10-23 13:36:13 +01:00
* * http :// localhost / mysite / about ? var = 1 returns '/about'
*
2012-03-19 14:59:52 +00:00
* @ return string The raw path ( i . e . not urldecoded )
2011-07-20 09:06:02 +01:00
*
* @ api
2010-10-23 13:36:13 +01:00
*/
2010-05-06 12:25:53 +01:00
public function getPathInfo ()
2010-02-17 13:53:18 +00:00
{
2010-05-07 15:09:11 +01:00
if ( null === $this -> pathInfo ) {
2010-05-06 12:25:53 +01:00
$this -> pathInfo = $this -> preparePathInfo ();
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
return $this -> pathInfo ;
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
2010-10-23 13:36:13 +01:00
/**
* Returns the root path from which this request is executed .
*
* Suppose that an index . php file instantiates this request object :
*
2012-03-19 14:59:52 +00:00
* * http :// localhost / index . php returns an empty string
* * http :// localhost / index . php / page returns an empty string
* * http :// localhost / web / index . php returns '/web'
* * http :// localhost / we % 20 b / index . php returns '/we%20b'
2010-10-23 13:36:13 +01:00
*
2012-03-19 14:59:52 +00:00
* @ return string The raw path ( i . e . not urldecoded )
2011-07-20 09:06:02 +01:00
*
* @ api
2010-10-23 13:36:13 +01:00
*/
2010-05-06 12:25:53 +01:00
public function getBasePath ()
2010-02-17 13:53:18 +00:00
{
2010-05-07 15:09:11 +01:00
if ( null === $this -> basePath ) {
2010-05-06 12:25:53 +01:00
$this -> basePath = $this -> prepareBasePath ();
}
return $this -> basePath ;
2010-02-17 13:53:18 +00:00
}
2010-10-23 13:36:13 +01:00
/**
* Returns the root url from which this request is executed .
*
2011-05-15 10:28:00 +01:00
* The base URL never ends with a /.
*
2010-10-23 13:36:13 +01:00
* This is similar to getBasePath (), except that it also includes the
* script filename ( e . g . index . php ) if one exists .
*
2012-03-19 14:59:52 +00:00
* @ return string The raw url ( i . e . not urldecoded )
2011-07-20 09:06:02 +01:00
*
* @ api
2010-10-23 13:36:13 +01:00
*/
2010-05-06 12:25:53 +01:00
public function getBaseUrl ()
{
2010-05-07 15:09:11 +01:00
if ( null === $this -> baseUrl ) {
2010-05-06 12:25:53 +01:00
$this -> baseUrl = $this -> prepareBaseUrl ();
}
2010-04-25 12:34:02 +01:00
2010-05-06 12:25:53 +01:00
return $this -> baseUrl ;
}
2011-05-22 08:13:03 +01:00
/**
* Gets the request ' s scheme .
2011-06-08 11:12:55 +01:00
*
2011-05-22 08:13:03 +01:00
* @ return string
2011-07-20 09:06:02 +01:00
*
* @ api
2011-05-22 08:13:03 +01:00
*/
2010-05-06 12:25:53 +01:00
public function getScheme ()
2010-02-17 13:53:18 +00:00
{
2011-04-20 09:49:08 +01:00
return $this -> isSecure () ? 'https' : 'http' ;
2010-05-06 12:25:53 +01:00
}
2010-02-17 13:53:18 +00:00
2011-05-22 08:13:03 +01:00
/**
* Returns the port on which the request is made .
2011-06-08 11:12:55 +01:00
*
2012-11-28 07:25:47 +00:00
* This method can read the client port from the " X-Forwarded-Port " header
* when trusted proxies were set via " setTrustedProxies() " .
*
* The " X-Forwarded-Port " header must contain the client port .
*
* If your reverse proxy uses a different header name than " X-Forwarded-Port " ,
* configure it via " setTrustedHeaderName() " with the " client-port " key .
*
2011-05-22 08:13:03 +01:00
* @ return string
2011-07-20 09:06:02 +01:00
*
* @ api
2011-05-22 08:13:03 +01:00
*/
2010-05-06 12:25:53 +01:00
public function getPort ()
{
2012-11-29 11:31:26 +00:00
if ( self :: $trustProxy && self :: $trustedHeaders [ self :: HEADER_CLIENT_PORT ] && $port = $this -> headers -> get ( self :: $trustedHeaders [ self :: HEADER_CLIENT_PORT ])) {
2012-11-28 07:25:47 +00:00
return $port ;
2012-01-13 19:05:57 +00:00
}
2012-04-21 12:27:44 +01:00
return $this -> server -> get ( 'SERVER_PORT' );
2010-05-06 12:25:53 +01:00
}
2010-02-17 13:53:18 +00:00
2011-09-12 12:01:04 +01:00
/**
* Returns the user .
*
* @ return string | null
*/
public function getUser ()
{
return $this -> server -> get ( 'PHP_AUTH_USER' );
}
/**
* Returns the password .
*
* @ return string | null
*/
public function getPassword ()
{
return $this -> server -> get ( 'PHP_AUTH_PW' );
}
2012-06-28 16:12:08 +01:00
/**
* Gets the user info .
*
* @ return string A user name and , optionally , scheme - specific information about how to gain authorization to access the server
*/
public function getUserInfo ()
{
$userinfo = $this -> getUser ();
$pass = $this -> getPassword ();
if ( '' != $pass ) {
$userinfo .= " : $pass " ;
}
return $userinfo ;
}
2010-10-23 13:36:13 +01:00
/**
* Returns the HTTP host being requested .
*
* The port name will be appended to the host if it ' s non - standard .
*
* @ return string
2011-07-20 09:06:02 +01:00
*
* @ api
2010-10-23 13:36:13 +01:00
*/
2010-05-06 12:25:53 +01:00
public function getHttpHost ()
{
$scheme = $this -> getScheme ();
2010-11-13 15:07:45 +00:00
$port = $this -> getPort ();
2010-02-17 13:53:18 +00:00
2010-12-21 03:06:56 +00:00
if (( 'http' == $scheme && $port == 80 ) || ( 'https' == $scheme && $port == 443 )) {
2011-05-26 14:02:40 +01:00
return $this -> getHost ();
2010-05-06 12:25:53 +01:00
}
2011-02-27 17:28:11 +00:00
2011-05-26 14:02:40 +01:00
return $this -> getHost () . ':' . $port ;
2010-02-17 13:53:18 +00:00
}
2011-05-22 08:13:03 +01:00
/**
* Returns the requested URI .
2011-06-08 11:12:55 +01:00
*
2012-03-19 14:59:52 +00:00
* @ return string The raw URI ( i . e . not urldecoded )
2011-07-20 09:06:02 +01:00
*
* @ api
2011-05-22 08:13:03 +01:00
*/
2010-05-06 12:25:53 +01:00
public function getRequestUri ()
2010-02-17 13:53:18 +00:00
{
2010-05-07 15:09:11 +01:00
if ( null === $this -> requestUri ) {
2010-05-06 12:25:53 +01:00
$this -> requestUri = $this -> prepareRequestUri ();
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
return $this -> requestUri ;
}
2010-02-17 13:53:18 +00:00
2012-06-28 16:12:08 +01:00
/**
* Gets the scheme and HTTP host .
*
2012-09-21 07:13:45 +01:00
* If the URL was called with basic authentication , the user
* and the password are not added to the generated string .
*
2012-07-04 03:13:21 +01:00
* @ return string The scheme and HTTP host
2012-06-28 16:12:08 +01:00
*/
public function getSchemeAndHttpHost ()
{
2012-09-21 07:13:45 +01:00
return $this -> getScheme () . '://' . $this -> getHttpHost ();
2012-06-28 16:12:08 +01:00
}
2010-05-10 12:08:19 +01:00
/**
* Generates a normalized URI for the Request .
*
* @ return string A normalized URI for the Request
2010-05-10 12:20:03 +01:00
*
* @ see getQueryString ()
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-10 12:08:19 +01:00
*/
public function getUri ()
{
2013-01-10 15:08:44 +00:00
if ( null !== $qs = $this -> getQueryString ()) {
2010-05-10 12:20:03 +01:00
$qs = '?' . $qs ;
}
2010-05-10 12:08:19 +01:00
2012-06-28 16:12:08 +01:00
return $this -> getSchemeAndHttpHost () . $this -> getBaseUrl () . $this -> getPathInfo () . $qs ;
2010-05-10 12:20:03 +01:00
}
2010-05-10 12:08:19 +01:00
2010-10-19 12:09:28 +01:00
/**
* Generates a normalized URI for the given path .
*
* @ param string $path A path to use instead of the current one
*
* @ return string The normalized URI for the path
2011-07-20 09:06:02 +01:00
*
* @ api
2010-10-19 12:09:28 +01:00
*/
public function getUriForPath ( $path )
{
2012-06-28 16:12:08 +01:00
return $this -> getSchemeAndHttpHost () . $this -> getBaseUrl () . $path ;
2010-10-19 12:09:28 +01:00
}
2010-05-10 12:20:03 +01:00
/**
* Generates the normalized query string for the Request .
*
* It builds a normalized query string , where keys / value pairs are alphabetized
* and have consistent escaping .
*
2012-01-09 05:33:53 +00:00
* @ return string | null A normalized query string for the Request
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-10 12:20:03 +01:00
*/
public function getQueryString ()
{
2012-07-04 02:10:48 +01:00
$qs = static :: normalizeQueryString ( $this -> server -> get ( 'QUERY_STRING' ));
2012-07-09 13:50:58 +01:00
2012-07-04 02:10:48 +01:00
return '' === $qs ? null : $qs ;
2010-05-10 12:08:19 +01:00
}
2011-05-22 08:13:03 +01:00
/**
* Checks whether the request is secure or not .
2011-06-08 11:12:55 +01:00
*
2012-11-28 07:25:47 +00:00
* This method can read the client port from the " X-Forwarded-Proto " header
* when trusted proxies were set via " setTrustedProxies() " .
*
* The " X-Forwarded-Proto " header must contain the protocol : " https " or " http " .
*
* If your reverse proxy uses a different header name than " X-Forwarded-Proto "
* ( " SSL_HTTPS " for instance ), configure it via " setTrustedHeaderName() " with
* the " client-proto " key .
*
2011-05-22 08:13:03 +01:00
* @ return Boolean
2011-07-20 09:06:02 +01:00
*
* @ api
2011-05-22 08:13:03 +01:00
*/
2010-05-06 12:25:53 +01:00
public function isSecure ()
2010-02-17 13:53:18 +00:00
{
2012-11-29 11:31:26 +00:00
if ( self :: $trustProxy && self :: $trustedHeaders [ self :: HEADER_CLIENT_PROTO ] && $proto = $this -> headers -> get ( self :: $trustedHeaders [ self :: HEADER_CLIENT_PROTO ])) {
2012-11-28 07:37:24 +00:00
return in_array ( strtolower ( $proto ), array ( 'https' , 'on' , '1' ));
}
return 'on' == strtolower ( $this -> server -> get ( 'HTTPS' )) || 1 == $this -> server -> get ( 'HTTPS' );
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Returns the host name .
*
2012-11-28 07:25:47 +00:00
* This method can read the client port from the " X-Forwarded-Host " header
* when trusted proxies were set via " setTrustedProxies() " .
*
* The " X-Forwarded-Host " header must contain the client host name .
*
* If your reverse proxy uses a different header name than " X-Forwarded-Host " ,
* configure it via " setTrustedHeaderName() " with the " client-host " key .
*
2010-05-06 12:25:53 +01:00
* @ return string
2011-07-20 09:06:02 +01:00
*
2012-12-06 12:50:59 +00:00
* @ throws \UnexpectedValueException when the host name is invalid
*
2011-07-20 09:06:02 +01:00
* @ api
2010-05-06 12:25:53 +01:00
*/
public function getHost ()
2010-02-17 13:53:18 +00:00
{
2012-11-29 11:31:26 +00:00
if ( self :: $trustProxy && self :: $trustedHeaders [ self :: HEADER_CLIENT_HOST ] && $host = $this -> headers -> get ( self :: $trustedHeaders [ self :: HEADER_CLIENT_HOST ])) {
2010-06-22 15:25:42 +01:00
$elements = explode ( ',' , $host );
2010-02-17 13:53:18 +00:00
2012-12-06 12:50:59 +00:00
$host = $elements [ count ( $elements ) - 1 ];
} elseif ( ! $host = $this -> headers -> get ( 'HOST' )) {
if ( ! $host = $this -> server -> get ( 'SERVER_NAME' )) {
$host = $this -> server -> get ( 'SERVER_ADDR' , '' );
2011-01-30 14:07:02 +00:00
}
2010-05-06 12:25:53 +01:00
}
2010-10-27 21:56:16 +01:00
2012-12-07 09:29:55 +00:00
// trim and remove port number from host
2012-03-23 23:31:38 +00:00
// host is lowercase as per RFC 952/2181
2012-12-11 10:33:11 +00:00
$host = strtolower ( preg_replace ( '/:\d+$/' , '' , trim ( $host )));
2012-12-06 12:50:59 +00:00
// as the host can come from the user (HTTP_HOST and depending on the configuration, SERVER_NAME too can come from the user)
// check that it does not contain forbidden characters (see RFC 952 and RFC 2181)
if ( $host && ! preg_match ( '/^\[?(?:[a-zA-Z0-9-:\]_]+\.?)+$/' , $host )) {
throw new \UnexpectedValueException ( 'Invalid Host' );
}
2010-10-27 21:56:16 +01:00
2012-12-06 12:50:59 +00:00
return $host ;
2010-05-06 12:25:53 +01:00
}
2010-02-17 13:53:18 +00:00
2011-05-22 08:13:03 +01:00
/**
* Sets the request method .
2011-06-08 11:12:55 +01:00
*
2011-05-22 08:13:03 +01:00
* @ param string $method
2011-07-20 09:06:02 +01:00
*
* @ api
2011-05-22 08:13:03 +01:00
*/
2010-05-06 12:25:53 +01:00
public function setMethod ( $method )
2010-02-17 13:53:18 +00:00
{
2010-05-06 12:25:53 +01:00
$this -> method = null ;
2010-12-08 06:24:37 +00:00
$this -> server -> set ( 'REQUEST_METHOD' , $method );
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/**
2012-11-28 09:31:19 +00:00
* Gets the request " intended " method .
*
* If the X - HTTP - Method - Override header is set , and if the method is a POST ,
* then it is used to determine the " real " intended HTTP method .
*
* The _method request parameter can also be used to determine the HTTP method ,
* but only if enableHttpMethodParameterOverride () has been called .
2010-05-06 12:25:53 +01:00
*
2011-06-04 17:59:57 +01:00
* The method is always an uppercased string .
*
2010-05-06 12:25:53 +01:00
* @ return string The request method
2011-07-20 09:06:02 +01:00
*
* @ api
2012-11-28 09:31:19 +00:00
*
* @ see getRealMethod
2010-05-06 12:25:53 +01:00
*/
public function getMethod ()
2010-02-17 13:53:18 +00:00
{
2010-05-07 15:09:11 +01:00
if ( null === $this -> method ) {
2010-12-08 06:24:37 +00:00
$this -> method = strtoupper ( $this -> server -> get ( 'REQUEST_METHOD' , 'GET' ));
2012-11-28 09:31:19 +00:00
2010-12-08 06:24:37 +00:00
if ( 'POST' === $this -> method ) {
2012-11-28 09:31:19 +00:00
if ( $method = $this -> headers -> get ( 'X-HTTP-METHOD-OVERRIDE' )) {
$this -> method = strtoupper ( $method );
} elseif ( self :: $httpMethodParameterOverride ) {
$this -> method = strtoupper ( $this -> request -> get ( '_method' , $this -> query -> get ( '_method' , 'POST' )));
}
2010-05-06 12:25:53 +01:00
}
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
return $this -> method ;
2010-02-17 13:53:18 +00:00
}
2012-11-28 09:31:19 +00:00
/**
* Gets the " real " request method .
*
* @ return string The request method
*
* @ see getMethod
*/
public function getRealMethod ()
{
2012-11-30 22:41:06 +00:00
return strtoupper ( $this -> server -> get ( 'REQUEST_METHOD' , 'GET' ));
2012-11-28 09:31:19 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Gets the mime type associated with the format .
*
2012-05-15 21:19:31 +01:00
* @ param string $format The format
2010-05-06 12:25:53 +01:00
*
* @ return string The associated mime type ( null if not found )
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
public function getMimeType ( $format )
2010-02-17 13:53:18 +00:00
{
2010-05-07 15:09:11 +01:00
if ( null === static :: $formats ) {
2010-05-06 12:25:53 +01:00
static :: initializeFormats ();
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
return isset ( static :: $formats [ $format ]) ? static :: $formats [ $format ][ 0 ] : null ;
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Gets the format associated with the mime type .
*
2012-05-15 21:19:31 +01:00
* @ param string $mimeType The associated mime type
2010-05-06 12:25:53 +01:00
*
2012-07-04 03:13:21 +01:00
* @ return string | null The format ( null if not found )
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
public function getFormat ( $mimeType )
2010-02-17 13:53:18 +00:00
{
2011-06-08 10:12:57 +01:00
if ( false !== $pos = strpos ( $mimeType , ';' )) {
$mimeType = substr ( $mimeType , 0 , $pos );
}
2010-05-07 15:09:11 +01:00
if ( null === static :: $formats ) {
2010-05-06 12:25:53 +01:00
static :: initializeFormats ();
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
2010-05-07 15:09:11 +01:00
foreach ( static :: $formats as $format => $mimeTypes ) {
2010-05-08 14:32:30 +01:00
if ( in_array ( $mimeType , ( array ) $mimeTypes )) {
2010-05-06 12:25:53 +01:00
return $format ;
2010-02-17 13:53:18 +00:00
}
}
2010-05-06 12:25:53 +01:00
return null ;
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Associates a format with mime types .
*
2012-05-15 21:19:31 +01:00
* @ param string $format The format
* @ param string | array $mimeTypes The associated mime types ( the preferred one must be the first as it will be used as the content type )
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
public function setFormat ( $format , $mimeTypes )
2010-02-17 13:53:18 +00:00
{
2010-05-07 15:09:11 +01:00
if ( null === static :: $formats ) {
2010-05-06 12:25:53 +01:00
static :: initializeFormats ();
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
static :: $formats [ $format ] = is_array ( $mimeTypes ) ? $mimeTypes : array ( $mimeTypes );
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Gets the request format .
*
* Here is the process to determine the format :
*
* * format defined by the user ( with setRequestFormat ())
* * _format request parameter
2011-04-17 13:37:35 +01:00
* * $default
*
2012-05-15 21:19:31 +01:00
* @ param string $default The default format
2010-05-06 12:25:53 +01:00
*
* @ return string The request format
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
2011-04-17 13:37:35 +01:00
public function getRequestFormat ( $default = 'html' )
2010-05-06 12:25:53 +01:00
{
2010-05-07 15:09:11 +01:00
if ( null === $this -> format ) {
2011-04-17 13:37:35 +01:00
$this -> format = $this -> get ( '_format' , $default );
2010-05-06 12:25:53 +01:00
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
return $this -> format ;
2010-08-17 18:17:33 +01:00
}
2011-07-20 09:06:02 +01:00
/**
* Sets the request format .
*
* @ param string $format The request format .
*
* @ api
*/
2010-08-17 18:17:33 +01:00
public function setRequestFormat ( $format )
{
$this -> format = $format ;
2010-05-06 12:25:53 +01:00
}
2010-02-17 13:53:18 +00:00
2011-11-04 19:25:23 +00:00
/**
* Gets the format associated with the request .
*
2012-07-04 03:13:21 +01:00
* @ return string | null The format ( null if no content type is present )
2011-11-04 19:25:23 +00:00
*
* @ api
*/
2011-12-18 13:33:54 +00:00
public function getContentType ()
2011-11-04 19:25:23 +00:00
{
2012-10-09 09:56:57 +01:00
return $this -> getFormat ( $this -> headers -> get ( 'CONTENT_TYPE' ));
2011-11-04 19:25:23 +00:00
}
2011-11-09 21:08:14 +00:00
2011-11-02 15:42:51 +00:00
/**
2011-11-04 02:23:11 +00:00
* Sets the default locale .
2011-12-18 13:33:54 +00:00
*
* @ param string $locale
*
2011-11-02 15:42:51 +00:00
* @ api
*/
2011-10-05 10:09:51 +01:00
public function setDefaultLocale ( $locale )
{
2012-10-11 10:48:40 +01:00
$this -> defaultLocale = $locale ;
if ( null === $this -> locale ) {
$this -> setPhpDefaultLocale ( $locale );
}
2011-10-05 10:09:51 +01:00
}
2011-11-02 15:42:51 +00:00
/**
2011-11-04 02:23:11 +00:00
* Sets the locale .
2011-12-18 13:33:54 +00:00
*
* @ param string $locale
*
2011-11-02 15:42:51 +00:00
* @ api
*/
2011-10-05 10:09:51 +01:00
public function setLocale ( $locale )
{
$this -> setPhpDefaultLocale ( $this -> locale = $locale );
}
2011-11-02 15:42:51 +00:00
/**
2011-11-04 02:23:11 +00:00
* Get the locale .
2011-12-18 13:33:54 +00:00
*
2011-11-02 15:42:51 +00:00
* @ return string
*/
2011-10-05 10:09:51 +01:00
public function getLocale ()
{
return null === $this -> locale ? $this -> defaultLocale : $this -> locale ;
}
2012-04-06 07:48:49 +01:00
/**
* Checks if the request method is of specified type .
*
2012-04-06 08:29:37 +01:00
* @ param string $method Uppercase request method ( GET , POST etc ) .
2012-04-06 07:48:49 +01:00
*
* @ return Boolean
*/
2012-04-06 08:29:37 +01:00
public function isMethod ( $method )
2012-04-06 07:48:49 +01:00
{
2012-04-06 08:29:37 +01:00
return $this -> getMethod () === strtoupper ( $method );
2012-04-06 07:48:49 +01:00
}
2011-05-22 08:13:03 +01:00
/**
* Checks whether the method is safe or not .
2011-06-08 11:12:55 +01:00
*
2011-05-22 08:13:03 +01:00
* @ return Boolean
2011-07-20 09:06:02 +01:00
*
* @ api
2011-05-22 08:13:03 +01:00
*/
2010-05-06 12:25:53 +01:00
public function isMethodSafe ()
2010-02-17 13:53:18 +00:00
{
2010-12-06 00:34:54 +00:00
return in_array ( $this -> getMethod (), array ( 'GET' , 'HEAD' ));
2010-02-17 13:53:18 +00:00
}
2010-12-12 08:05:03 +00:00
/**
2010-12-12 23:22:47 +00:00
* Returns the request body content .
2010-12-12 08:05:03 +00:00
*
2012-05-15 21:19:31 +01:00
* @ param Boolean $asResource If true , a resource will be returned
2010-12-12 23:22:47 +00:00
*
* @ return string | resource The request body content or a resource to read the body stream .
2012-12-16 12:02:54 +00:00
*
* @ throws \LogicException
2010-12-12 08:05:03 +00:00
*/
2010-12-12 23:22:47 +00:00
public function getContent ( $asResource = false )
2010-12-12 08:05:03 +00:00
{
2010-12-12 23:22:47 +00:00
if ( false === $this -> content || ( true === $asResource && null !== $this -> content )) {
throw new \LogicException ( 'getContent() can only be called once when using the resource return type.' );
}
if ( true === $asResource ) {
$this -> content = false ;
return fopen ( 'php://input' , 'rb' );
}
2010-12-12 08:05:03 +00:00
if ( null === $this -> content ) {
$this -> content = file_get_contents ( 'php://input' );
}
return $this -> content ;
}
2011-05-22 08:13:03 +01:00
/**
* Gets the Etags .
2011-06-08 11:12:55 +01:00
*
2011-05-22 08:13:03 +01:00
* @ return array The entity tags
*/
2010-05-19 10:25:07 +01:00
public function getETags ()
{
2010-05-19 17:52:13 +01:00
return preg_split ( '/\s*,\s*/' , $this -> headers -> get ( 'if_none_match' ), null , PREG_SPLIT_NO_EMPTY );
2010-05-19 10:25:07 +01:00
}
2012-06-25 17:21:41 +01:00
/**
* @ return Boolean
*/
2010-05-06 12:25:53 +01:00
public function isNoCache ()
2010-02-17 13:53:18 +00:00
{
changed Cache-Control default value behavior
The PHP native cache limiter feature has been disabled as this is now managed
by the HeaderBag class directly instead (see below.)
The HeaderBag class uses the following rules to define a sensible and
convervative default value for the Response 'Cache-Control' header:
* If no cache header is defined ('Cache-Control', 'ETag', 'Last-Modified',
and 'Expires'), 'Cache-Control' is set to 'no-cache';
* If 'Cache-Control' is empty, its value is set to "private, max-age=0,
must-revalidate";
* But if at least one 'Cache-Control' directive is set, and no 'public' or
'private' directives have been explicitely added, Symfony2 adds the
'private' directive automatically (except when 's-maxage' is set.)
So, remember to explicitly add the 'public' directive to 'Cache-Control' when
you want shared caches to store your application resources:
// The Response is private by default
$response->setEtag($etag);
$response->setLastModified($date);
$response->setMaxAge(10);
// Change the Response to be public
$response->setPublic();
// Set cache settings in one call
$response->setCache(array(
'etag' => $etag,
'last_modified' => $date,
'max_age' => 10,
'public' => true,
));
2010-11-10 09:48:22 +00:00
return $this -> headers -> hasCacheControlDirective ( 'no-cache' ) || 'no-cache' == $this -> headers -> get ( 'Pragma' );
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Returns the preferred language .
*
2012-05-15 21:19:31 +01:00
* @ param array $locales An array of ordered available locales
2010-05-06 12:25:53 +01:00
*
2012-01-09 05:33:53 +00:00
* @ return string | null The preferred locale
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
2010-06-07 09:10:00 +01:00
public function getPreferredLanguage ( array $locales = null )
2010-05-06 12:25:53 +01:00
{
$preferredLanguages = $this -> getLanguages ();
2010-02-17 13:53:18 +00:00
2012-01-07 13:27:33 +00:00
if ( empty ( $locales )) {
2010-05-06 12:25:53 +01:00
return isset ( $preferredLanguages [ 0 ]) ? $preferredLanguages [ 0 ] : null ;
}
2010-02-17 13:53:18 +00:00
2010-05-07 15:09:11 +01:00
if ( ! $preferredLanguages ) {
2010-06-07 09:10:00 +01:00
return $locales [ 0 ];
2010-05-06 12:25:53 +01:00
}
2010-02-17 13:53:18 +00:00
2010-06-07 09:10:00 +01:00
$preferredLanguages = array_values ( array_intersect ( $preferredLanguages , $locales ));
2010-02-17 13:53:18 +00:00
2010-06-07 09:10:00 +01:00
return isset ( $preferredLanguages [ 0 ]) ? $preferredLanguages [ 0 ] : $locales [ 0 ];
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Gets a list of languages acceptable by the client browser .
*
* @ return array Languages ordered in the user browser preferences
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
public function getLanguages ()
2010-02-17 13:53:18 +00:00
{
2010-05-07 15:09:11 +01:00
if ( null !== $this -> languages ) {
2010-05-06 12:25:53 +01:00
return $this -> languages ;
}
2010-02-17 13:53:18 +00:00
2012-10-24 17:03:38 +01:00
$languages = AcceptHeader :: fromString ( $this -> headers -> get ( 'Accept-Language' )) -> all ();
2011-03-19 08:34:54 +00:00
$this -> languages = array ();
2012-10-24 17:03:38 +01:00
foreach ( array_keys ( $languages ) as $lang ) {
2010-05-08 14:32:30 +01:00
if ( strstr ( $lang , '-' )) {
2010-05-06 12:25:53 +01:00
$codes = explode ( '-' , $lang );
2010-05-07 15:09:11 +01:00
if ( $codes [ 0 ] == 'i' ) {
2010-05-06 12:25:53 +01:00
// Language not listed in ISO 639 that are not variants
// of any listed language, which can be registered with the
// i-prefix, such as i-cherokee
2010-05-07 15:09:11 +01:00
if ( count ( $codes ) > 1 ) {
2010-05-06 12:25:53 +01:00
$lang = $codes [ 1 ];
}
2010-05-07 15:09:11 +01:00
} else {
2010-05-08 14:32:30 +01:00
for ( $i = 0 , $max = count ( $codes ); $i < $max ; $i ++ ) {
2010-05-07 15:09:11 +01:00
if ( $i == 0 ) {
2010-05-06 12:25:53 +01:00
$lang = strtolower ( $codes [ 0 ]);
2010-05-07 15:09:11 +01:00
} else {
2010-05-06 12:25:53 +01:00
$lang .= '_' . strtoupper ( $codes [ $i ]);
}
}
}
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
$this -> languages [] = $lang ;
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
return $this -> languages ;
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
/**
* Gets a list of charsets acceptable by the client browser .
*
* @ return array List of charsets in preferable order
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
public function getCharsets ()
2010-02-17 13:53:18 +00:00
{
2010-05-07 15:09:11 +01:00
if ( null !== $this -> charsets ) {
2010-05-06 12:25:53 +01:00
return $this -> charsets ;
}
2012-10-24 17:03:38 +01:00
return $this -> charsets = array_keys ( AcceptHeader :: fromString ( $this -> headers -> get ( 'Accept-Charset' )) -> all ());
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Gets a list of content types acceptable by the client browser
*
2011-07-04 22:34:11 +01:00
* @ return array List of content types in preferable order
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
public function getAcceptableContentTypes ()
2010-02-17 13:53:18 +00:00
{
2010-05-07 15:09:11 +01:00
if ( null !== $this -> acceptableContentTypes ) {
2010-05-06 12:25:53 +01:00
return $this -> acceptableContentTypes ;
}
2012-10-24 17:03:38 +01:00
return $this -> acceptableContentTypes = array_keys ( AcceptHeader :: fromString ( $this -> headers -> get ( 'Accept' )) -> all ());
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Returns true if the request is a XMLHttpRequest .
*
* It works if your JavaScript library set an X - Requested - With HTTP header .
2013-01-07 10:42:04 +00:00
* It is known to work with common JavaScript frameworks :
* @ link http :// en . wikipedia . org / wiki / List_of_Ajax_frameworks #JavaScript
2010-05-06 12:25:53 +01:00
*
2011-01-21 01:39:28 +00:00
* @ return Boolean true if the request is an XMLHttpRequest , false otherwise
2011-07-20 09:06:02 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
public function isXmlHttpRequest ()
2010-02-17 13:53:18 +00:00
{
2010-05-06 12:25:53 +01:00
return 'XMLHttpRequest' == $this -> headers -> get ( 'X-Requested-With' );
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/**
* Splits an Accept -* HTTP header .
*
2012-05-15 21:19:31 +01:00
* @ param string $header Header to split
2012-01-09 05:33:53 +00:00
*
* @ return array Array indexed by the values of the Accept -* header in preferred order
2012-10-24 17:03:38 +01:00
*
* @ deprecated Deprecated since version 2.2 , to be removed in 2.3 .
2010-05-06 12:25:53 +01:00
*/
public function splitHttpAcceptHeader ( $header )
2010-02-17 13:53:18 +00:00
{
2012-12-03 18:56:52 +00:00
trigger_error ( 'splitHttpAcceptHeader() is deprecated since version 2.2 and will be removed in 2.3.' , E_USER_DEPRECATED );
2012-10-24 17:03:38 +01:00
$headers = array ();
foreach ( AcceptHeader :: fromString ( $header ) -> all () as $item ) {
$key = $item -> getValue ();
foreach ( $item -> getAttributes () as $name => $value ) {
$key .= sprintf ( ';%s=%s' , $name , $value );
2010-05-06 12:25:53 +01:00
}
2012-10-24 17:03:38 +01:00
$headers [ $key ] = $item -> getQuality ();
2010-05-06 12:25:53 +01:00
}
2010-02-17 13:53:18 +00:00
2012-10-24 17:03:38 +01:00
return $headers ;
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
/*
* The following methods are derived from code of the Zend Framework ( 1.10 dev - 2010 - 01 - 24 )
*
* Code subject to the new BSD license ( http :// framework . zend . com / license / new - bsd ) .
*
* Copyright ( c ) 2005 - 2010 Zend Technologies USA Inc . ( http :// www . zend . com )
*/
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
protected function prepareRequestUri ()
2010-02-17 13:53:18 +00:00
{
2010-05-06 12:25:53 +01:00
$requestUri = '' ;
2010-02-17 13:53:18 +00:00
2012-08-09 10:20:20 +01:00
if ( $this -> headers -> has ( 'X_ORIGINAL_URL' ) && false !== stripos ( PHP_OS , 'WIN' )) {
// IIS with Microsoft Rewrite Module
$requestUri = $this -> headers -> get ( 'X_ORIGINAL_URL' );
2013-02-04 18:34:47 +00:00
$this -> headers -> remove ( 'X_ORIGINAL_URL' );
2012-08-09 10:20:20 +01:00
} elseif ( $this -> headers -> has ( 'X_REWRITE_URL' ) && false !== stripos ( PHP_OS , 'WIN' )) {
// IIS with ISAPI_Rewrite
2010-05-06 12:25:53 +01:00
$requestUri = $this -> headers -> get ( 'X_REWRITE_URL' );
2013-02-04 18:34:47 +00:00
$this -> headers -> remove ( 'X_REWRITE_URL' );
2010-05-07 15:09:11 +01:00
} elseif ( $this -> server -> get ( 'IIS_WasUrlRewritten' ) == '1' && $this -> server -> get ( 'UNENCODED_URL' ) != '' ) {
2010-05-06 12:25:53 +01:00
// IIS7 with URL Rewrite: make sure we get the unencoded url (double slash problem)
$requestUri = $this -> server -> get ( 'UNENCODED_URL' );
2013-02-04 18:34:47 +00:00
$this -> server -> remove ( 'UNENCODED_URL' );
$this -> server -> remove ( 'IIS_WasUrlRewritten' );
2010-05-07 15:09:11 +01:00
} elseif ( $this -> server -> has ( 'REQUEST_URI' )) {
2010-05-06 12:25:53 +01:00
$requestUri = $this -> server -> get ( 'REQUEST_URI' );
// HTTP proxy reqs setup request uri with scheme and host [and port] + the url path, only use url path
2012-06-28 16:12:08 +01:00
$schemeAndHttpHost = $this -> getSchemeAndHttpHost ();
2010-05-07 15:09:11 +01:00
if ( strpos ( $requestUri , $schemeAndHttpHost ) === 0 ) {
2010-05-06 12:25:53 +01:00
$requestUri = substr ( $requestUri , strlen ( $schemeAndHttpHost ));
}
2010-05-07 15:09:11 +01:00
} elseif ( $this -> server -> has ( 'ORIG_PATH_INFO' )) {
2010-05-06 12:25:53 +01:00
// IIS 5.0, PHP as CGI
$requestUri = $this -> server -> get ( 'ORIG_PATH_INFO' );
2012-07-08 22:24:52 +01:00
if ( '' != $this -> server -> get ( 'QUERY_STRING' )) {
2010-05-06 12:25:53 +01:00
$requestUri .= '?' . $this -> server -> get ( 'QUERY_STRING' );
}
2013-02-04 18:34:47 +00:00
$this -> server -> remove ( 'ORIG_PATH_INFO' );
2010-05-06 12:25:53 +01:00
}
2010-02-17 13:53:18 +00:00
2013-02-04 18:34:47 +00:00
// normalize the request URI to ease creating sub-requests from this request
$this -> server -> set ( 'REQUEST_URI' , $requestUri );
2010-05-06 12:25:53 +01:00
return $requestUri ;
2010-02-17 13:53:18 +00:00
}
2011-11-02 15:42:51 +00:00
/**
2011-11-04 09:19:48 +00:00
* Prepares the base URL .
2011-12-18 13:33:54 +00:00
*
* @ return string
2011-11-02 15:42:51 +00:00
*/
2010-05-06 12:25:53 +01:00
protected function prepareBaseUrl ()
2010-02-17 13:53:18 +00:00
{
2010-05-06 12:25:53 +01:00
$filename = basename ( $this -> server -> get ( 'SCRIPT_FILENAME' ));
2010-02-17 13:53:18 +00:00
2010-05-07 15:09:11 +01:00
if ( basename ( $this -> server -> get ( 'SCRIPT_NAME' )) === $filename ) {
2010-05-06 12:25:53 +01:00
$baseUrl = $this -> server -> get ( 'SCRIPT_NAME' );
2010-05-07 15:09:11 +01:00
} elseif ( basename ( $this -> server -> get ( 'PHP_SELF' )) === $filename ) {
2010-05-06 12:25:53 +01:00
$baseUrl = $this -> server -> get ( 'PHP_SELF' );
2010-05-07 15:09:11 +01:00
} elseif ( basename ( $this -> server -> get ( 'ORIG_SCRIPT_NAME' )) === $filename ) {
2010-05-06 12:25:53 +01:00
$baseUrl = $this -> server -> get ( 'ORIG_SCRIPT_NAME' ); // 1and1 shared hosting compatibility
2010-05-07 15:09:11 +01:00
} else {
2010-05-06 12:25:53 +01:00
// Backtrack up the script_filename to find the portion matching
// php_self
$path = $this -> server -> get ( 'PHP_SELF' , '' );
$file = $this -> server -> get ( 'SCRIPT_FILENAME' , '' );
$segs = explode ( '/' , trim ( $file , '/' ));
$segs = array_reverse ( $segs );
$index = 0 ;
$last = count ( $segs );
$baseUrl = '' ;
2010-05-07 15:09:11 +01:00
do {
2010-05-06 12:25:53 +01:00
$seg = $segs [ $index ];
$baseUrl = '/' . $seg . $baseUrl ;
++ $index ;
} while (( $last > $index ) && ( false !== ( $pos = strpos ( $path , $baseUrl ))) && ( 0 != $pos ));
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
// Does the baseUrl have anything in common with the request_uri?
$requestUri = $this -> getRequestUri ();
2010-02-17 13:53:18 +00:00
2012-03-19 14:57:24 +00:00
if ( $baseUrl && false !== $prefix = $this -> getUrlencodedPrefix ( $requestUri , $baseUrl )) {
2010-05-06 12:25:53 +01:00
// full $baseUrl matches
2012-03-19 14:57:24 +00:00
return $prefix ;
2010-05-06 12:25:53 +01:00
}
2010-02-17 13:53:18 +00:00
2012-03-19 14:57:24 +00:00
if ( $baseUrl && false !== $prefix = $this -> getUrlencodedPrefix ( $requestUri , dirname ( $baseUrl ))) {
2010-05-06 12:25:53 +01:00
// directory portion of $baseUrl matches
2012-03-19 14:57:24 +00:00
return rtrim ( $prefix , '/' );
2010-05-06 12:25:53 +01:00
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
$truncatedRequestUri = $requestUri ;
2010-05-07 15:09:11 +01:00
if (( $pos = strpos ( $requestUri , '?' )) !== false ) {
2010-05-06 12:25:53 +01:00
$truncatedRequestUri = substr ( $requestUri , 0 , $pos );
}
2010-02-17 13:53:18 +00:00
2010-05-06 12:25:53 +01:00
$basename = basename ( $baseUrl );
2012-03-19 14:59:52 +00:00
if ( empty ( $basename ) || ! strpos ( rawurldecode ( $truncatedRequestUri ), $basename )) {
2010-05-06 12:25:53 +01:00
// no match whatsoever; set it blank
return '' ;
}
// If using mod_rewrite or ISAPI_Rewrite strip the script filename
// out of baseUrl. $pos !== 0 makes sure it is not matching a value
// from PATH_INFO or QUERY_STRING
2010-05-07 15:09:11 +01:00
if (( strlen ( $requestUri ) >= strlen ( $baseUrl )) && (( false !== ( $pos = strpos ( $requestUri , $baseUrl ))) && ( $pos !== 0 ))) {
2010-05-06 12:25:53 +01:00
$baseUrl = substr ( $requestUri , 0 , $pos + strlen ( $baseUrl ));
}
return rtrim ( $baseUrl , '/' );
2010-02-17 13:53:18 +00:00
}
2010-05-06 12:25:53 +01:00
2011-06-15 10:35:32 +01:00
/**
2011-11-04 09:19:48 +00:00
* Prepares the base path .
2011-06-15 10:35:32 +01:00
*
2011-06-14 20:44:45 +01:00
* @ return string base path
*/
2010-05-06 12:25:53 +01:00
protected function prepareBasePath ()
2010-02-17 13:53:18 +00:00
{
2010-05-06 12:25:53 +01:00
$filename = basename ( $this -> server -> get ( 'SCRIPT_FILENAME' ));
$baseUrl = $this -> getBaseUrl ();
2010-05-07 15:09:11 +01:00
if ( empty ( $baseUrl )) {
2010-05-06 12:25:53 +01:00
return '' ;
}
2010-02-17 13:53:18 +00:00
2010-05-07 15:09:11 +01:00
if ( basename ( $baseUrl ) === $filename ) {
2010-05-06 12:25:53 +01:00
$basePath = dirname ( $baseUrl );
2010-05-07 15:09:11 +01:00
} else {
2010-05-06 12:25:53 +01:00
$basePath = $baseUrl ;
}
2010-02-17 13:53:18 +00:00
2010-05-07 15:09:11 +01:00
if ( '\\' === DIRECTORY_SEPARATOR ) {
2010-05-06 12:25:53 +01:00
$basePath = str_replace ( '\\' , '/' , $basePath );
}
2010-04-06 09:21:02 +01:00
2010-05-06 12:25:53 +01:00
return rtrim ( $basePath , '/' );
}
2010-04-06 09:21:02 +01:00
2011-06-14 20:44:45 +01:00
/**
2011-11-04 09:19:48 +00:00
* Prepares the path info .
2011-06-14 20:44:45 +01:00
*
* @ return string path info
*/
2010-05-06 12:25:53 +01:00
protected function preparePathInfo ()
2010-04-08 10:15:19 +01:00
{
2010-05-06 12:25:53 +01:00
$baseUrl = $this -> getBaseUrl ();
2010-05-07 15:09:11 +01:00
if ( null === ( $requestUri = $this -> getRequestUri ())) {
2011-05-15 10:28:00 +01:00
return '/' ;
2010-05-06 12:25:53 +01:00
}
2011-05-15 10:28:00 +01:00
$pathInfo = '/' ;
2010-04-08 10:15:19 +01:00
2010-05-06 12:25:53 +01:00
// Remove the query string from REQUEST_URI
2010-05-07 15:09:11 +01:00
if ( $pos = strpos ( $requestUri , '?' )) {
2010-05-06 12:25:53 +01:00
$requestUri = substr ( $requestUri , 0 , $pos );
}
2010-04-08 10:15:19 +01:00
2012-03-19 14:57:24 +00:00
if (( null !== $baseUrl ) && ( false === ( $pathInfo = substr ( $requestUri , strlen ( $baseUrl ))))) {
2010-05-06 12:25:53 +01:00
// If substr() returns false then PATH_INFO is set to an empty string
2011-05-15 10:28:00 +01:00
return '/' ;
2010-05-07 15:09:11 +01:00
} elseif ( null === $baseUrl ) {
2010-05-06 12:25:53 +01:00
return $requestUri ;
}
2010-04-06 09:21:02 +01:00
2012-03-19 14:59:52 +00:00
return ( string ) $pathInfo ;
2010-05-06 12:25:53 +01:00
}
2010-04-06 09:21:02 +01:00
2011-06-14 20:44:45 +01:00
/**
2011-06-15 10:35:32 +01:00
* Initializes HTTP request formats .
2011-06-14 20:44:45 +01:00
*/
2012-07-09 13:50:58 +01:00
protected static function initializeFormats ()
2010-09-09 13:40:40 +01:00
{
static :: $formats = array (
2011-04-17 13:39:07 +01:00
'html' => array ( 'text/html' , 'application/xhtml+xml' ),
2011-01-30 12:13:16 +00:00
'txt' => array ( 'text/plain' ),
2010-09-09 13:40:40 +01:00
'js' => array ( 'application/javascript' , 'application/x-javascript' , 'text/javascript' ),
2011-01-30 12:13:16 +00:00
'css' => array ( 'text/css' ),
2010-09-09 13:40:40 +01:00
'json' => array ( 'application/json' , 'application/x-json' ),
'xml' => array ( 'text/xml' , 'application/xml' , 'application/x-xml' ),
2011-01-30 12:13:16 +00:00
'rdf' => array ( 'application/rdf+xml' ),
'atom' => array ( 'application/atom+xml' ),
2011-09-05 15:10:26 +01:00
'rss' => array ( 'application/rss+xml' ),
2010-09-09 13:40:40 +01:00
);
}
2011-10-05 10:09:51 +01:00
2011-11-02 15:42:51 +00:00
/**
2011-11-04 02:23:11 +00:00
* Sets the default PHP locale .
2011-12-18 13:33:54 +00:00
*
* @ param string $locale
2011-11-02 15:42:51 +00:00
*/
2011-10-05 10:09:51 +01:00
private function setPhpDefaultLocale ( $locale )
{
// if either the class Locale doesn't exist, or an exception is thrown when
// setting the default locale, the intl module is not installed, and
// the call can be ignored:
try {
if ( class_exists ( 'Locale' , false )) {
\Locale :: setDefault ( $locale );
}
} catch ( \Exception $e ) {
}
}
2012-03-19 14:57:24 +00:00
/*
* Returns the prefix as encoded in the string when the string starts with
* the given prefix , false otherwise .
*
* @ param string $string The urlencoded string
* @ param string $prefix The prefix not encoded
*
* @ return string | false The prefix as it is encoded in $string , or false
*/
private function getUrlencodedPrefix ( $string , $prefix )
{
if ( 0 !== strpos ( rawurldecode ( $string ), $prefix )) {
return false ;
}
$len = strlen ( $prefix );
if ( preg_match ( " #^(%[[:xdigit:]] { 2}|.) { { $len } }# " , $string , $match )) {
return $match [ 0 ];
}
return false ;
}
2010-02-17 13:53:18 +00:00
}