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;
|
|
|
|
|
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
|
|
|
*
|
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
|
|
|
{
|
2011-07-05 18:38:29 +01:00
|
|
|
static protected $trustProxy = 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-11-02 15:42:51 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2010-05-06 12:25:53 +01:00
|
|
|
protected $languages;
|
2011-11-02 15:42:51 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2010-05-06 12:25:53 +01:00
|
|
|
protected $charsets;
|
2011-11-02 15:42:51 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2010-05-06 12:25:53 +01:00
|
|
|
protected $acceptableContentTypes;
|
2011-11-02 15:42:51 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2010-05-06 12:25:53 +01:00
|
|
|
protected $pathInfo;
|
2011-11-02 15:42:51 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2010-05-06 12:25:53 +01:00
|
|
|
protected $requestUri;
|
2011-11-02 15:42:51 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2010-05-06 12:25:53 +01:00
|
|
|
protected $baseUrl;
|
2011-11-02 15:42:51 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2010-05-06 12:25:53 +01:00
|
|
|
protected $basePath;
|
2011-11-02 15:42:51 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2010-05-06 12:25:53 +01:00
|
|
|
protected $method;
|
2011-11-02 15:42:51 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2010-05-06 12:25:53 +01:00
|
|
|
protected $format;
|
2011-11-02 15:42:51 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var \Symfony\Component\HttpFoundation\Session
|
|
|
|
*/
|
2010-07-09 08:26:22 +01:00
|
|
|
protected $session;
|
2011-11-02 15:42:51 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2011-10-05 10:09:51 +01:00
|
|
|
protected $locale;
|
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
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2010-05-06 12:25:53 +01:00
|
|
|
static protected $formats;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
|
|
*/
|
2011-04-15 11:02:37 +01:00
|
|
|
static public 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);
|
|
|
|
|
2011-05-14 01:05:28 +01:00
|
|
|
if (0 === strpos($request->server->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.
|
|
|
|
*
|
|
|
|
* @param string $uri The URI
|
|
|
|
* @param string $method The HTTP method
|
|
|
|
* @param array $parameters The request (GET) or query (POST) parameters
|
|
|
|
* @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
|
|
|
*/
|
2011-02-04 11:37:52 +00:00
|
|
|
static public function create($uri, $method = 'GET', $parameters = array(), $cookies = array(), $files = array(), $server = array(), $content = null)
|
2010-05-06 12:25:53 +01:00
|
|
|
{
|
|
|
|
$defaults = array(
|
|
|
|
'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(),
|
2010-05-06 12:25:53 +01:00
|
|
|
);
|
|
|
|
|
2010-12-06 00:32:42 +00:00
|
|
|
$components = parse_url($uri);
|
|
|
|
if (isset($components['host'])) {
|
2010-12-07 21:51:45 +00:00
|
|
|
$defaults['SERVER_NAME'] = $components['host'];
|
2010-12-06 00:32:42 +00:00
|
|
|
$defaults['HTTP_HOST'] = $components['host'];
|
|
|
|
}
|
2010-12-07 21:51:45 +00:00
|
|
|
|
|
|
|
if (isset($components['scheme'])) {
|
|
|
|
if ('https' === $components['scheme']) {
|
|
|
|
$defaults['HTTPS'] = 'on';
|
|
|
|
$defaults['SERVER_PORT'] = 443;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-06 00:32:42 +00:00
|
|
|
if (isset($components['port'])) {
|
|
|
|
$defaults['SERVER_PORT'] = $components['port'];
|
2010-12-07 21:51:45 +00:00
|
|
|
$defaults['HTTP_HOST'] = $defaults['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'])) {
|
|
|
|
$defaults['PHP_AUTH_USER'] = $components['user'];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isset($components['pass'])) {
|
|
|
|
$defaults['PHP_AUTH_PW'] = $components['pass'];
|
|
|
|
}
|
|
|
|
|
2011-07-19 09:54:21 +01:00
|
|
|
if (!isset($components['path'])) {
|
|
|
|
$components['path'] = '';
|
|
|
|
}
|
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':
|
|
|
|
$defaults['CONTENT_TYPE'] = 'application/x-www-form-urlencoded';
|
|
|
|
case 'PATCH':
|
|
|
|
$request = $parameters;
|
|
|
|
$query = array();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
$request = array();
|
|
|
|
$query = $parameters;
|
|
|
|
if (false !== $pos = strpos($uri, '?')) {
|
|
|
|
$qs = substr($uri, $pos + 1);
|
|
|
|
parse_str($qs, $params);
|
|
|
|
|
|
|
|
$query = array_merge($params, $query);
|
|
|
|
}
|
|
|
|
break;
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
2010-02-17 13:53:18 +00:00
|
|
|
|
2010-12-06 00:32:42 +00:00
|
|
|
$queryString = isset($components['query']) ? html_entity_decode($components['query']) : '';
|
2010-05-06 12:25:53 +01:00
|
|
|
parse_str($queryString, $qs);
|
2010-05-07 15:09:11 +01:00
|
|
|
if (is_array($qs)) {
|
2010-05-06 12:25:53 +01:00
|
|
|
$query = array_replace($qs, $query);
|
|
|
|
}
|
2010-02-17 13:53:18 +00:00
|
|
|
|
2011-06-23 13:07:53 +01:00
|
|
|
$uri = $components['path'].($queryString ? '?'.$queryString : '');
|
2010-12-06 00:32:42 +00:00
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
$server = array_replace($defaults, $server, array(
|
|
|
|
'REQUEST_METHOD' => strtoupper($method),
|
|
|
|
'PATH_INFO' => '',
|
|
|
|
'REQUEST_URI' => $uri,
|
|
|
|
'QUERY_STRING' => $queryString,
|
|
|
|
));
|
|
|
|
|
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
|
|
|
*
|
|
|
|
* @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.
|
|
|
|
*
|
2010-12-03 19:19:45 +00:00
|
|
|
* It overrides $_GET, $_POST, $_REQUEST, $_SERVER, $_COOKIE, and $_FILES.
|
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
|
|
|
// FIXME: populate $_FILES
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2010-05-24 13:02:58 +01:00
|
|
|
// FIXME: should read variables_order and request_order
|
|
|
|
// to know which globals to merge and in which order
|
|
|
|
$_REQUEST = array_merge($_GET, $_POST);
|
|
|
|
}
|
|
|
|
|
2011-07-05 18:38:29 +01:00
|
|
|
/**
|
|
|
|
* Trusts $_SERVER entries coming from proxies.
|
|
|
|
*
|
|
|
|
* You should only call this method if your application
|
|
|
|
* is hosted behind a reverse proxy that you manage.
|
2011-07-20 09:06:02 +01:00
|
|
|
*
|
|
|
|
* @api
|
2011-07-05 18:38:29 +01:00
|
|
|
*/
|
|
|
|
static public function trustProxyData()
|
|
|
|
{
|
|
|
|
self::$trustProxy = true;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
*
|
2011-06-14 20:44:45 +01:00
|
|
|
* Order of precedence: GET, PATH, POST, COOKIE
|
|
|
|
* Avoid using this method in controllers:
|
|
|
|
* * slow
|
|
|
|
* * prefer to get from a "named" source
|
2011-06-15 10:35:32 +01:00
|
|
|
*
|
2011-06-14 20:44:45 +01:00
|
|
|
* @param string $key the key
|
|
|
|
* @param mixed $default the default value
|
|
|
|
* @param type $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-05-22 08:13:03 +01:00
|
|
|
* @return Session|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.
|
|
|
|
*
|
|
|
|
* @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
|
|
|
|
return $this->cookies->has(session_name()) && null !== $this->session;
|
2010-07-09 08:26:22 +01:00
|
|
|
}
|
|
|
|
|
2011-05-05 07:35:02 +01:00
|
|
|
/**
|
|
|
|
* Whether the request contains a Session object.
|
|
|
|
*
|
|
|
|
* @return boolean
|
2011-07-20 09:06:02 +01:00
|
|
|
*
|
|
|
|
* @api
|
2011-05-05 07:35:02 +01:00
|
|
|
*/
|
|
|
|
public function hasSession()
|
|
|
|
{
|
|
|
|
return null !== $this->session;
|
|
|
|
}
|
|
|
|
|
2011-05-22 08:13:03 +01:00
|
|
|
/**
|
|
|
|
* Sets the Session.
|
2011-06-08 11:12:55 +01:00
|
|
|
*
|
2011-05-22 08:13:03 +01:00
|
|
|
* @param Session $session 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 setSession(Session $session)
|
|
|
|
{
|
|
|
|
$this->session = $session;
|
|
|
|
}
|
|
|
|
|
2010-09-01 12:56:20 +01:00
|
|
|
/**
|
|
|
|
* Returns the client IP address.
|
|
|
|
*
|
|
|
|
* @param Boolean $proxy Whether the current request has been made behind a proxy or not
|
|
|
|
*
|
|
|
|
* @return string The client IP address
|
2011-07-20 09:06:02 +01:00
|
|
|
*
|
|
|
|
* @api
|
2010-09-01 12:56:20 +01:00
|
|
|
*/
|
|
|
|
public function getClientIp($proxy = false)
|
|
|
|
{
|
|
|
|
if ($proxy) {
|
|
|
|
if ($this->server->has('HTTP_CLIENT_IP')) {
|
|
|
|
return $this->server->get('HTTP_CLIENT_IP');
|
2011-07-05 18:38:29 +01:00
|
|
|
} elseif (self::$trustProxy && $this->server->has('HTTP_X_FORWARDED_FOR')) {
|
2010-09-01 12:56:20 +01:00
|
|
|
return $this->server->get('HTTP_X_FORWARDED_FOR');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $this->server->get('REMOTE_ADDR');
|
|
|
|
}
|
|
|
|
|
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'
|
|
|
|
* * http://localhost/mysite/about?var=1 returns '/about'
|
|
|
|
*
|
|
|
|
* @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 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:
|
|
|
|
*
|
|
|
|
* * http://localhost/index.php returns an empty string
|
|
|
|
* * http://localhost/index.php/page returns an empty string
|
|
|
|
* * http://localhost/web/index.php return '/web'
|
|
|
|
*
|
|
|
|
* @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 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.
|
|
|
|
*
|
|
|
|
* @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 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
|
|
|
*
|
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()
|
|
|
|
{
|
2011-05-04 17:54:31 +01:00
|
|
|
return $this->headers->get('X-Forwarded-Port') ?: $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');
|
|
|
|
}
|
|
|
|
|
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
|
|
|
*
|
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 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
|
|
|
|
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()
|
|
|
|
{
|
2010-05-10 12:20:03 +01:00
|
|
|
$qs = $this->getQueryString();
|
2010-05-11 09:36:31 +01:00
|
|
|
if (null !== $qs) {
|
2010-05-10 12:20:03 +01:00
|
|
|
$qs = '?'.$qs;
|
|
|
|
}
|
2010-05-10 12:08:19 +01:00
|
|
|
|
2011-09-12 12:01:04 +01:00
|
|
|
$auth = '';
|
|
|
|
if ($user = $this->getUser()) {
|
|
|
|
$auth = $user;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($pass = $this->getPassword()) {
|
|
|
|
$auth .= ":$pass";
|
|
|
|
}
|
|
|
|
|
|
|
|
if ('' !== $auth) {
|
|
|
|
$auth .= '@';
|
|
|
|
}
|
|
|
|
|
|
|
|
return $this->getScheme().'://'.$auth.$this->getHttpHost().$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)
|
|
|
|
{
|
2010-12-07 21:51:45 +00:00
|
|
|
return $this->getScheme().'://'.$this->getHttpHost().$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.
|
|
|
|
*
|
|
|
|
* @return string 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()
|
|
|
|
{
|
|
|
|
if (!$qs = $this->server->get('QUERY_STRING')) {
|
|
|
|
return null;
|
|
|
|
}
|
2010-05-10 12:08:19 +01:00
|
|
|
|
2010-05-10 12:20:03 +01:00
|
|
|
$parts = array();
|
2010-09-03 19:42:46 +01:00
|
|
|
$order = array();
|
|
|
|
|
2010-05-10 12:20:03 +01:00
|
|
|
foreach (explode('&', $qs) as $segment) {
|
2010-09-03 19:42:46 +01:00
|
|
|
if (false === strpos($segment, '=')) {
|
|
|
|
$parts[] = $segment;
|
|
|
|
$order[] = $segment;
|
|
|
|
} else {
|
2011-05-03 22:06:55 +01:00
|
|
|
$tmp = explode('=', rawurldecode($segment), 2);
|
|
|
|
$parts[] = rawurlencode($tmp[0]).'='.rawurlencode($tmp[1]);
|
2010-09-03 19:42:46 +01:00
|
|
|
$order[] = $tmp[0];
|
|
|
|
}
|
2010-05-10 12:08:19 +01:00
|
|
|
}
|
2010-09-03 19:42:46 +01:00
|
|
|
array_multisort($order, SORT_ASC, $parts);
|
2010-05-10 12:08:19 +01:00
|
|
|
|
2010-09-03 19:42:46 +01:00
|
|
|
return implode('&', $parts);
|
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
|
|
|
*
|
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
|
|
|
{
|
2010-05-06 12:25:53 +01:00
|
|
|
return (
|
|
|
|
(strtolower($this->server->get('HTTPS')) == 'on' || $this->server->get('HTTPS') == 1)
|
|
|
|
||
|
2011-07-05 18:38:29 +01:00
|
|
|
(self::$trustProxy && strtolower($this->headers->get('SSL_HTTPS')) == 'on' || $this->headers->get('SSL_HTTPS') == 1)
|
2010-05-06 12:25:53 +01:00
|
|
|
||
|
2011-07-05 18:38:29 +01:00
|
|
|
(self::$trustProxy && strtolower($this->headers->get('X_FORWARDED_PROTO')) == 'https')
|
2010-05-06 12:25:53 +01:00
|
|
|
);
|
2010-02-17 13:53:18 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Returns the host name.
|
|
|
|
*
|
|
|
|
* @return string
|
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
|
|
|
{
|
2011-07-05 18:38:29 +01:00
|
|
|
if (self::$trustProxy && $host = $this->headers->get('X_FORWARDED_HOST')) {
|
2010-06-22 15:25:42 +01:00
|
|
|
$elements = explode(',', $host);
|
2010-02-17 13:53:18 +00:00
|
|
|
|
2010-10-27 21:56:16 +01:00
|
|
|
$host = trim($elements[count($elements) - 1]);
|
2010-05-07 15:09:11 +01:00
|
|
|
} else {
|
2011-01-30 14:07:02 +00:00
|
|
|
if (!$host = $this->headers->get('HOST')) {
|
|
|
|
if (!$host = $this->server->get('SERVER_NAME')) {
|
|
|
|
$host = $this->server->get('SERVER_ADDR', '');
|
|
|
|
}
|
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
2010-10-27 21:56:16 +01:00
|
|
|
|
|
|
|
// Remove port number from host
|
2011-04-22 17:37:20 +01:00
|
|
|
$host = preg_replace('/:\d+$/', '', $host);
|
2010-10-27 21:56:16 +01:00
|
|
|
|
2011-04-22 15:28:15 +01:00
|
|
|
return trim($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
|
|
|
/**
|
|
|
|
* Gets the request method.
|
|
|
|
*
|
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
|
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'));
|
|
|
|
if ('POST' === $this->method) {
|
2011-08-18 11:18:12 +01:00
|
|
|
$this->method = strtoupper($this->headers->get('X-HTTP-METHOD-OVERRIDE', $this->request->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
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Gets the mime type associated with the format.
|
|
|
|
*
|
|
|
|
* @param string $format The format
|
|
|
|
*
|
|
|
|
* @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.
|
|
|
|
*
|
|
|
|
* @param string $mimeType The associated mime type
|
|
|
|
*
|
|
|
|
* @return string 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.
|
|
|
|
*
|
|
|
|
* @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
|
|
|
|
*
|
|
|
|
* @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-02 15:42:51 +00:00
|
|
|
/**
|
2011-11-04 02:23:11 +00:00
|
|
|
* Sets the default locale.
|
2011-11-02 15:42:51 +00:00
|
|
|
*
|
|
|
|
* @param string $locale
|
|
|
|
*
|
|
|
|
* @api
|
|
|
|
*/
|
2011-10-05 10:09:51 +01:00
|
|
|
public function setDefaultLocale($locale)
|
|
|
|
{
|
|
|
|
$this->setPhpDefaultLocale($this->defaultLocale = $locale);
|
|
|
|
}
|
|
|
|
|
2011-11-02 15:42:51 +00:00
|
|
|
/**
|
2011-11-04 02:23:11 +00:00
|
|
|
* Sets the locale.
|
2011-11-02 15:42:51 +00:00
|
|
|
*
|
|
|
|
* @param string $locale
|
|
|
|
*
|
|
|
|
* @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-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;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
*
|
2011-01-21 01:39:28 +00: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.
|
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
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
*
|
2010-06-07 09:10:00 +01:00
|
|
|
* @param array $locales An array of ordered available locales
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2010-06-07 09:10:00 +01:00
|
|
|
* @return string 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
|
|
|
|
2010-06-07 09:10:00 +01:00
|
|
|
if (null === $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
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
$languages = $this->splitHttpAcceptHeader($this->headers->get('Accept-Language'));
|
2011-03-19 08:34:54 +00:00
|
|
|
$this->languages = array();
|
2011-04-17 13:38:33 +01:00
|
|
|
foreach ($languages as $lang => $q) {
|
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;
|
|
|
|
}
|
|
|
|
|
2011-04-17 13:38:33 +01:00
|
|
|
return $this->charsets = array_keys($this->splitHttpAcceptHeader($this->headers->get('Accept-Charset')));
|
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;
|
|
|
|
}
|
|
|
|
|
2011-04-17 13:38:33 +01:00
|
|
|
return $this->acceptableContentTypes = array_keys($this->splitHttpAcceptHeader($this->headers->get('Accept')));
|
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.
|
|
|
|
* It is known to work with Prototype, Mootools, jQuery.
|
|
|
|
*
|
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.
|
|
|
|
*
|
|
|
|
* @param string $header Header to split
|
|
|
|
*/
|
|
|
|
public function splitHttpAcceptHeader($header)
|
2010-02-17 13:53:18 +00:00
|
|
|
{
|
2010-05-07 15:09:11 +01:00
|
|
|
if (!$header) {
|
2010-05-06 12:25:53 +01:00
|
|
|
return array();
|
|
|
|
}
|
2010-02-17 13:53:18 +00:00
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
$values = array();
|
2010-05-07 15:09:11 +01:00
|
|
|
foreach (array_filter(explode(',', $header)) as $value) {
|
2010-05-06 12:25:53 +01:00
|
|
|
// Cut off any q-value that might come after a semi-colon
|
2011-10-09 11:58:45 +01:00
|
|
|
if (preg_match('/;\s*(q=.*$)/', $value, $match)) {
|
|
|
|
$q = (float) substr(trim($match[1]), 2);
|
2011-10-09 15:09:22 +01:00
|
|
|
$value = trim(substr($value, 0, -strlen($match[0])));
|
2010-05-07 15:09:11 +01:00
|
|
|
} else {
|
2010-05-06 12:25:53 +01:00
|
|
|
$q = 1;
|
|
|
|
}
|
2010-02-17 13:53:18 +00:00
|
|
|
|
2010-05-07 15:09:11 +01:00
|
|
|
if (0 < $q) {
|
2010-05-06 12:25:53 +01:00
|
|
|
$values[trim($value)] = $q;
|
|
|
|
}
|
|
|
|
}
|
2010-02-17 13:53:18 +00:00
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
arsort($values);
|
2011-04-17 13:38:33 +01:00
|
|
|
reset($values);
|
2010-02-17 13:53:18 +00:00
|
|
|
|
2011-04-17 13:38:33 +01:00
|
|
|
return $values;
|
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.10dev - 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
|
|
|
|
2011-10-07 07:20:12 +01:00
|
|
|
if ($this->headers->has('X_REWRITE_URL') && false !== stripos(PHP_OS, 'WIN')) {
|
2010-05-06 12:25:53 +01:00
|
|
|
// check this first so IIS will catch
|
|
|
|
$requestUri = $this->headers->get('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');
|
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
|
|
|
|
$schemeAndHttpHost = $this->getScheme().'://'.$this->getHttpHost();
|
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');
|
2010-05-07 15:09:11 +01:00
|
|
|
if ($this->server->get('QUERY_STRING')) {
|
2010-05-06 12:25:53 +01:00
|
|
|
$requestUri .= '?'.$this->server->get('QUERY_STRING');
|
|
|
|
}
|
|
|
|
}
|
2010-02-17 13:53:18 +00:00
|
|
|
|
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-11-02 15:42:51 +00:00
|
|
|
*
|
|
|
|
* @return string
|
|
|
|
*/
|
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
|
|
|
|
2010-05-07 15:09:11 +01:00
|
|
|
if ($baseUrl && 0 === strpos($requestUri, $baseUrl)) {
|
2010-05-06 12:25:53 +01:00
|
|
|
// full $baseUrl matches
|
|
|
|
return $baseUrl;
|
|
|
|
}
|
2010-02-17 13:53:18 +00:00
|
|
|
|
2010-05-07 15:09:11 +01:00
|
|
|
if ($baseUrl && 0 === strpos($requestUri, dirname($baseUrl))) {
|
2010-05-06 12:25:53 +01:00
|
|
|
// directory portion of $baseUrl matches
|
|
|
|
return rtrim(dirname($baseUrl), '/');
|
|
|
|
}
|
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);
|
2010-05-07 15:09:11 +01:00
|
|
|
if (empty($basename) || !strpos($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
|
|
|
|
2011-09-28 12:18:44 +01:00
|
|
|
if ((null !== $baseUrl) && (false === ($pathInfo = substr(urldecode($requestUri), strlen(urldecode($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
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
return (string) $pathInfo;
|
|
|
|
}
|
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
|
|
|
*/
|
2010-09-09 13:40:40 +01:00
|
|
|
static protected function initializeFormats()
|
|
|
|
{
|
|
|
|
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-11-02 15:42:51 +00:00
|
|
|
*
|
|
|
|
* @param string $locale
|
|
|
|
*/
|
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) {
|
|
|
|
}
|
|
|
|
}
|
2010-02-17 13:53:18 +00:00
|
|
|
}
|