Implements: Kohana_HTTP_Request | Kohana_HTTP_Message | HTTP_Message | HTTP_Request
Request. Uses the Route class to determine what Controller to send the request to.
Class declared in SYSPATH/classes/Request.php on line 3.
string(3) "GET"string(4) "POST"string(3) "PUT"string(6) "DELETE"string(4) "HEAD"string(7) "OPTIONS"string(5) "TRACE"string(7) "CONNECT"string $client_ipclient IP address
string(12) "3.141.25.125"Request $currentcurrently executing request instance
object Request()
object Request(19) {
protected _requested_with => NULL
protected _method => string(3) "GET"
protected _protocol => string(8) "HTTP/1.1"
protected _secure => bool TRUE
protected _referrer => NULL
protected _route => object Route(5) {
protected _filters => array(0)
protected _uri => string(19) "guide-api(/<class>)"
protected _regex => array(1) (
"class" => string(13) "[a-zA-Z0-9_]+"
)
protected _defaults => array(3) (
"controller" => string(9) "Userguide"
"action" => string(3) "api"
"class" => NULL
)
protected _route_regex => string(45) "#^guide-api(?:/(?P<class>[a-zA-Z0-9_]+))?$#uD"
}
protected _routes => array(0)
protected _header => object HTTP_Header(0) {
}
protected _body => NULL
protected _directory => string(0) ""
protected _controller => string(9) "Userguide"
protected _action => string(3) "api"
protected _uri => string(17) "guide-api/Request"
protected _external => bool FALSE
protected _params => array(1) (
"class" => string(7) "Request"
)
protected _get => array(0)
protected _post => array(0)
protected _cookies => array(0)
protected _client => object Request_Client_Internal(9) {
protected _previous_environment => NULL
protected _cache => NULL
protected _follow => bool FALSE
protected _follow_headers => array(1) (
0 => string(13) "authorization"
)
protected _strict_redirect => bool TRUE
protected _header_callbacks => array(1) (
"Location" => string(34) "Request_Client::on_header_location"
)
protected _max_callback_depth => integer 5
protected _callback_depth => integer 1
protected _callback_params => array(0)
}
}Request $initialmain request instance
object Request()
object Request(19) {
protected _requested_with => NULL
protected _method => string(3) "GET"
protected _protocol => string(8) "HTTP/1.1"
protected _secure => bool TRUE
protected _referrer => NULL
protected _route => object Route(5) {
protected _filters => array(0)
protected _uri => string(19) "guide-api(/<class>)"
protected _regex => array(1) (
"class" => string(13) "[a-zA-Z0-9_]+"
)
protected _defaults => array(3) (
"controller" => string(9) "Userguide"
"action" => string(3) "api"
"class" => NULL
)
protected _route_regex => string(45) "#^guide-api(?:/(?P<class>[a-zA-Z0-9_]+))?$#uD"
}
protected _routes => array(0)
protected _header => object HTTP_Header(0) {
}
protected _body => NULL
protected _directory => string(0) ""
protected _controller => string(9) "Userguide"
protected _action => string(3) "api"
protected _uri => string(17) "guide-api/Request"
protected _external => bool FALSE
protected _params => array(1) (
"class" => string(7) "Request"
)
protected _get => array(0)
protected _post => array(0)
protected _cookies => array(0)
protected _client => object Request_Client_Internal(9) {
protected _previous_environment => NULL
protected _cache => NULL
protected _follow => bool FALSE
protected _follow_headers => array(1) (
0 => string(13) "authorization"
)
protected _strict_redirect => bool TRUE
protected _header_callbacks => array(1) (
"Location" => string(34) "Request_Client::on_header_location"
)
protected _max_callback_depth => integer 5
protected _callback_depth => integer 1
protected _callback_params => array(0)
}
}string $trusted_proxiestrusted proxy server IPs
array(3) ( 0 => string(9) "127.0.0.1" 1 => string(9) "localhost" 2 => string(21) "localhost.localdomain" )
string $user_agentclient user agent
string(103) "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ClaudeBot/1.0; [email protected])"
string $_actionaction to be executed in the controller
NULL
string $_bodythe body
NULL
Kohana_Request_Client $_clientNULL
string $_controllercontroller to be executed
NULL
array $_cookiescookies to send with the request
array(0) string $_directorycontroller directory
string(0) ""boolean $_externalexternal request
bool FALSE
array $_getquery parameters
array(0) Kohana_HTTP_Header $_headerheaders to sent as part of the request
NULL
string $_methodmethod: GET, POST, PUT, DELETE, HEAD, etc
string(3) "GET"array $_paramsparameters from the route
array(0) array $_postpost parameters
array(0) string $_protocolprotocol: HTTP/1.1, FTP, CLI, etc
NULL
string $_referrerreferring URL
NULL
string $_requested_withthe x-requested-with header which most likely will be xmlhttprequest
NULL
Route $_routeroute matched for this request
NULL
Route $_routesarray of routes to manually look at instead of the global namespace
NULL
boolean $_securebool FALSE
string $_urithe URI of the request
NULL
Creates a new request object for the given URI. New requests should be Created using the Request::factory method.
$request = new Request($uri);
If $cache parameter is set, the response for the request will attempt to be retrieved from the cache.
string
$uri
required - URI of the request array
$client_params
= array(0) - Array of params to pass to the request client bool
$allow_external
= bool TRUE - Allow external requests? (deprecated in 3.3) array
$injected_routes
= array(0) - An array of routes to use, for testing voidpublic function __construct($uri, $client_params = [], $allow_external = true, $injected_routes = [])
{
$client_params = is_array($client_params) ? $client_params : [];
// Initialise the header
$this->_header = new HTTP_Header([]);
// Assign injected routes
$this->_routes = $injected_routes;
// Cleanse query parameters from URI (faster that parse_url())
$split_uri = explode('?', $uri);
$uri = array_shift($split_uri);
if ($split_uri) {
parse_str($split_uri[0], $this->_get);
}
// Detect protocol (if present)
// $allow_external = false prevents the default index.php from
// being able to proxy external pages.
if (!$allow_external OR strpos($uri, '://') === false) {
// Remove leading and trailing slashes from the URI
$this->_uri = trim($uri, '/');
// Apply the client
$this->_client = new Request_Client_Internal($client_params);
} else {
// Create a route
$this->_route = new Route($uri);
// Store the URI
$this->_uri = $uri;
// Set the security setting if required
if (strpos($uri, 'https://') === 0) {
$this->secure(true);
}
// Set external state
$this->_external = true;
// Setup the client
$this->_client = Request_Client_External::factory($client_params);
}
}Returns the response as the string representation of a request.
echo $request;
stringpublic function __toString()
{
return $this->render();
}Returns the accepted encodings. If a specific encoding is defined, the quality of that encoding will be returned. If the encoding is not accepted, false will be returned.
$encodings = Request::accept_encoding();
Deprecated in favor of using HTTP_Header::accepts_encoding_at_quality.
string
$type
= NULL - Encoding type mixed - An array of all types or a specific type as a stringpublic static function accept_encoding($type = null)
{
static $accepts;
if ($accepts === null) {
// Parse the HTTP_ACCEPT_LANGUAGE header
$accepts = Request::_parse_accept($_SERVER['HTTP_ACCEPT_ENCODING']);
}
if (isset($type)) {
// Return the quality setting for this type
return isset($accepts[$type]) ? $accepts[$type] : false;
}
return $accepts;
}Returns the accepted languages. If a specific language is defined, the quality of that language will be returned. If the language is not accepted, false will be returned.
$langs = Request::accept_lang();
Deprecated in favor of using HTTP_Header::accepts_language_at_quality.
string
$lang
= NULL - Language code mixed - An array of all types or a specific type as a stringpublic static function accept_lang($lang = null)
{
static $accepts;
if ($accepts === null) {
// Parse the HTTP_ACCEPT_LANGUAGE header
$accepts = Request::_parse_accept($_SERVER['HTTP_ACCEPT_LANGUAGE']);
}
if (isset($lang)) {
// Return the quality setting for this lang
return isset($accepts[$lang]) ? $accepts[$lang] : false;
}
return $accepts;
}Returns the accepted content types. If a specific type is defined, the quality of that type will be returned.
$types = Request::accept_type();
Deprecated in favor of using HTTP_Header::accepts_at_quality.
string
$type
= NULL - Content MIME type mixed - An array of all types or a specific type as a stringpublic static function accept_type($type = null)
{
static $accepts;
if ($accepts === null) {
// Parse the HTTP_ACCEPT header
$accepts = Request::_parse_accept($_SERVER['HTTP_ACCEPT'], ['*/*' => 1.0]);
}
if (isset($type)) {
// Return the quality setting for this type
return isset($accepts[$type]) ? $accepts[$type] : $accepts['*/*'];
}
return $accepts;
}Sets and gets the action for the controller.
string
$action
= NULL - Action to execute the controller from mixedpublic function action($action = null)
{
if ($action === null) {
// Act as a getter
return $this->_action;
}
// Act as a setter
$this->_action = (string) $action;
return $this;
}Gets or sets the HTTP body of the request. The body is included after the header, separated by a single empty new line.
string
$content
= NULL - Content to set to the object mixedpublic function body($content = null)
{
if ($content === null) {
// Act as a getter
return $this->_body;
}
// Act as a setter
$this->_body = $content;
return $this;
}Provides access to the Request_Client.
Request_Clientselfpublic function client(Request_Client $client = null)
{
if ($client === null)
return $this->_client;
else {
$this->_client = $client;
return $this;
}
}Returns the length of the body for use with content header
integerpublic function content_length()
{
return strlen($this->body());
}Sets and gets the controller for the matched route.
string
$controller
= NULL - Controller to execute the action mixedpublic function controller($controller = null)
{
if ($controller === null) {
// Act as a getter
return $this->_controller;
}
// Act as a setter
$this->_controller = (string) $controller;
return $this;
}Set and get cookies values for this request.
mixed
$key
= NULL - Cookie name, or array of cookie values string
$value
= NULL - Value to set to cookie stringmixedpublic function cookie($key = null, $value = null)
{
if (is_array($key)) {
// Act as a setter, replace all cookies
$this->_cookies = $key;
return $this;
} elseif ($key === null) {
// Act as a getter, all cookies
return $this->_cookies;
} elseif ($value === null) {
// Act as a getting, single cookie
return isset($this->_cookies[$key]) ? $this->_cookies[$key] : null;
}
// Act as a setter for a single cookie
$this->_cookies[$key] = (string) $value;
return $this;
}Return the currently executing request. This is changed to the current request when Request::execute is called and restored when the request is completed.
$request = Request::current();
Requestpublic static function current()
{
return Request::$current;
}Automatically detects the URI of the main request using PATH_INFO, REQUEST_URI, PHP_SELF or REDIRECT_URL.
$uri = Request::detect_uri();
string - URI of the main requestpublic static function detect_uri()
{
if (!empty($_SERVER['PATH_INFO'])) {
// PATH_INFO does not contain the docroot or index
$uri = $_SERVER['PATH_INFO'];
} else {
// REQUEST_URI and PHP_SELF include the docroot and index
if (isset($_SERVER['REQUEST_URI'])) {
/**
* We use REQUEST_URI as the fallback value. The reason
* for this is we might have a malformed URL such as:
*
* http://localhost/http://example.com/judge.php
*
* which parse_url can't handle. So rather than leave empty
* handed, we'll use this.
*/
$uri = $_SERVER['REQUEST_URI'];
if ($request_uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH)) {
// Valid URL path found, set it.
$uri = $request_uri;
}
// Decode the request URI
$uri = rawurldecode($uri);
} elseif (isset($_SERVER['PHP_SELF'])) {
$uri = $_SERVER['PHP_SELF'];
} elseif (isset($_SERVER['REDIRECT_URL'])) {
$uri = $_SERVER['REDIRECT_URL'];
} else {
// If you ever see this error, please report an issue at http://dev.kohanaphp.com/projects/kohana3/issues
// along with any relevant information about your web server setup. Thanks!
throw new Kohana_Exception('Unable to detect the URI using PATH_INFO, REQUEST_URI, PHP_SELF or REDIRECT_URL');
}
// Get the path from the base URL, including the index file
$base_url = parse_url(Kohana::$base_url, PHP_URL_PATH);
if (strpos($uri, $base_url) === 0) {
// Remove the base URL from the URI
$uri = (string) substr($uri, strlen($base_url));
}
if (Kohana::$index_file AND strpos($uri, Kohana::$index_file) === 0) {
// Remove the index file from the URI
$uri = (string) substr($uri, strlen(Kohana::$index_file));
}
}
return $uri;
}Sets and gets the directory for the controller.
string
$directory
= NULL - Directory to execute the controller from mixedpublic function directory($directory = null)
{
if ($directory === null) {
// Act as a getter
return $this->_directory;
}
// Act as a setter
$this->_directory = (string) $directory;
return $this;
}Processes the request, executing the controller action that handles this request, determined by the Route.
By default, the output from the controller is captured and returned, and no headers are sent.
$request->execute();
Responsepublic function execute()
{
if (!$this->_external) {
$processed = Request::process($this, $this->_routes);
if ($processed) {
// Store the matching route
$this->_route = $processed['route'];
$params = $processed['params'];
// Is this route external?
$this->_external = $this->_route->is_external();
if (isset($params['directory'])) {
// Controllers are in a sub-directory
$this->_directory = $params['directory'];
}
// Store the controller
$this->_controller = $params['controller'];
// Store the action
$this->_action = (isset($params['action'])) ? $params['action'] : Route::$default_action;
// These are accessible as public vars and can be overloaded
unset($params['controller'], $params['action'], $params['directory']);
// Params cannot be changed once matched
$this->_params = $params;
}
}
if (!$this->_route instanceof Route) {
return HTTP_Exception::factory(404, 'Unable to find a route to match the URI: :uri', [':uri' => $this->_uri])
->request($this)
->get_response();
}
if (!$this->_client instanceof Request_Client) {
throw new Request_Exception('Unable to execute :uri without a Kohana_Request_Client', [':uri' => $this->_uri]);
}
return $this->_client->execute($this);
}Creates a new request object for the given URI. New requests should be Created using the Request::factory method.
$request = Request::factory($uri);
If $cache parameter is set, the response for the request will attempt to be retrieved from the cache.
string
$uri
= bool TRUE - URI of the request array
$client_params
= array(0) - An array of params to pass to the request client bool
$allow_external
= bool TRUE - Allow external requests? (deprecated in 3.3) array
$injected_routes
= array(0) - An array of routes to use, for testing void|Requestpublic static function factory($uri = true, $client_params = [], $allow_external = true, $injected_routes = [])
{
// If this is the initial request
if (!Request::$initial) {
$protocol = HTTP::$protocol;
if (isset($_SERVER['REQUEST_METHOD'])) {
// Use the server request method
$method = $_SERVER['REQUEST_METHOD'];
} else {
// Default to GET requests
$method = HTTP_Request::GET;
}
if ((!empty($_SERVER['HTTPS']) AND filter_var($_SERVER['HTTPS'], FILTER_VALIDATE_BOOLEAN))
OR ( isset($_SERVER['HTTP_X_FORWARDED_PROTO'])
AND $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https')
AND in_array($_SERVER['REMOTE_ADDR'], Request::$trusted_proxies)) {
// This request is secure
$secure = true;
}
if (isset($_SERVER['HTTP_REFERER'])) {
// There is a referrer for this request
$referrer = $_SERVER['HTTP_REFERER'];
}
if (isset($_SERVER['HTTP_USER_AGENT'])) {
// Browser type
Request::$user_agent = $_SERVER['HTTP_USER_AGENT'];
}
if (isset($_SERVER['HTTP_X_REQUESTED_WITH'])) {
// Typically used to denote AJAX requests
$requested_with = $_SERVER['HTTP_X_REQUESTED_WITH'];
}
if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])
AND isset($_SERVER['REMOTE_ADDR'])
AND in_array($_SERVER['REMOTE_ADDR'], Request::$trusted_proxies)) {
// Use the forwarded IP address, typically set when the
// client is using a proxy server.
// Format: "X-Forwarded-For: client1, proxy1, proxy2"
$client_ips = explode(',', $_SERVER['HTTP_X_FORWARDED_FOR']);
Request::$client_ip = array_shift($client_ips);
unset($client_ips);
} elseif (isset($_SERVER['HTTP_CLIENT_IP'])
AND isset($_SERVER['REMOTE_ADDR'])
AND in_array($_SERVER['REMOTE_ADDR'], Request::$trusted_proxies)) {
// Use the forwarded IP address, typically set when the
// client is using a proxy server.
$client_ips = explode(',', $_SERVER['HTTP_CLIENT_IP']);
Request::$client_ip = array_shift($client_ips);
unset($client_ips);
} elseif (isset($_SERVER['REMOTE_ADDR'])) {
// The remote IP address
Request::$client_ip = $_SERVER['REMOTE_ADDR'];
}
if ($method !== HTTP_Request::GET) {
// Ensure the raw body is saved for future use
$body = file_get_contents('php://input');
}
if ($uri === true) {
// Attempt to guess the proper URI
$uri = Request::detect_uri();
}
$cookies = [];
if (($cookie_keys = array_keys($_COOKIE))) {
foreach ($cookie_keys as $key) {
$cookies[$key] = Cookie::get($key);
}
}
// Create the instance singleton
Request::$initial = $request = new Request($uri, $client_params, $allow_external, $injected_routes);
// Store global GET and POST data in the initial request only
$request->protocol($protocol)
->query($_GET)
->post($_POST);
if (isset($secure)) {
// Set the request security
$request->secure($secure);
}
if (isset($method)) {
// Set the request method
$request->method($method);
}
if (isset($referrer)) {
// Set the referrer
$request->referrer($referrer);
}
if (isset($requested_with)) {
// Apply the requested with variable
$request->requested_with($requested_with);
}
if (isset($body)) {
// Set the request body (probably a PUT type)
$request->body($body);
}
if (isset($cookies)) {
$request->cookie($cookies);
}
} else {
$request = new Request($uri, $client_params, $allow_external, $injected_routes);
}
return $request;
}Gets or sets HTTP headers oo the request. All headers are included immediately after the HTTP protocol definition during transmission. This method provides a simple array or key/value interface to the headers.
mixed
$key
= NULL - Key or array of key/value pairs to set string
$value
= NULL - Value to set to the supplied key mixedpublic function headers($key = null, $value = null)
{
if ($key instanceof HTTP_Header) {
// Act a setter, replace all headers
$this->_header = $key;
return $this;
}
if (is_array($key)) {
// Act as a setter, replace all headers
$this->_header->exchangeArray($key);
return $this;
}
if ($this->_header->count() === 0 AND $this->is_initial()) {
// Lazy load the request headers
$this->_header = HTTP::request_headers();
}
if ($key === null) {
// Act as a getter, return all headers
return $this->_header;
} elseif ($value === null) {
// Act as a getter, single header
return ($this->_header->offsetExists($key)) ? $this->_header->offsetGet($key) : null;
}
// Act as a setter for a single header
$this->_header[$key] = $value;
return $this;
}Returns the first request encountered by this framework. This will should only be set once during the first Request::factory invocation.
// Get the first request
$request = Request::initial();
// Test whether the current request is the first request
if (Request::initial() === Request::current())
// Do something useful
Requestpublic static function initial()
{
return Request::$initial;
}Returns whether this is an ajax request (as used by JS frameworks)
booleanpublic function is_ajax()
{
return ($this->requested_with() === 'xmlhttprequest');
}Readonly access to the Request::$_external property.
if ( ! $request->is_external())
// This is an internal request
booleanpublic function is_external()
{
return $this->_external;
}Returns whether this request is the initial request Kohana received. Can be used to test for sub requests.
if ( ! $request->is_initial())
// This is a sub request
booleanpublic function is_initial()
{
return ($this === Request::$initial);
}Gets or sets the HTTP method. Usually GET, POST, PUT or DELETE in traditional CRUD applications.
string
$method
= NULL - Method to use for this request mixedpublic function method($method = null)
{
if ($method === null) {
// Act as a getter
return $this->_method;
}
// Act as a setter
$this->_method = strtoupper($method);
return $this;
}Retrieves a value from the route parameters.
$id = $request->param('id');
string
$key
= NULL - Key of the value mixed
$default
= NULL - Default value if the key is not set mixedpublic function param($key = null, $default = null)
{
if ($key === null) {
// Return the full array
return $this->_params;
}
return isset($this->_params[$key]) ? $this->_params[$key] : $default;
}Gets or sets HTTP POST parameters to the request.
mixed
$key
= NULL - Key or key value pairs to set string
$value
= NULL - Value to set to a key mixedpublic function post($key = null, $value = null)
{
if (is_array($key)) {
// Act as a setter, replace all fields
$this->_post = $key;
return $this;
}
if ($key === null) {
// Act as a getter, all fields
return $this->_post;
} elseif ($value === null) {
// Act as a getter, single field
return Arr::path($this->_post, $key);
}
// Act as a setter, single field
$this->_post[$key] = $value;
return $this;
}Determines if a file larger than the post_max_size has been uploaded. PHP does not handle this situation gracefully on its own, so this method helps to solve that problem.
booleanpublic static function post_max_size_exceeded()
{
// Make sure the request method is POST
if (Request::$initial->method() !== HTTP_Request::POST)
return false;
// Get the post_max_size in bytes
$max_bytes = Num::bytes(ini_get('post_max_size'));
// Error occurred if method is POST, and content length is too long
return (Arr::get($_SERVER, 'CONTENT_LENGTH') > $max_bytes);
}Process a request to find a matching route
object
$request
required - Request array
$routes
= NULL - Route arraypublic static function process(Request $request, $routes = null)
{
// Load routes
$routes = (empty($routes)) ? Route::all() : $routes;
$params = null;
foreach ($routes as $name => $route) {
// Use external routes for reverse routing only
if ($route->is_external()) {
continue;
}
// We found something suitable
if ($params = $route->matches($request)) {
return [
'params' => $params,
'route' => $route,
];
}
}
return null;
}Gets or sets the HTTP protocol. If there is no current protocol set, it will use the default set in HTTP::$protocol
string
$protocol
= NULL - Protocol to set to the request mixedpublic function protocol($protocol = null)
{
if ($protocol === null) {
if ($this->_protocol)
return $this->_protocol;
else
return $this->_protocol = HTTP::$protocol;
}
// Act as a setter
$this->_protocol = strtoupper($protocol);
return $this;
}Gets or sets HTTP query string.
mixed
$key
= NULL - Key or key value pairs to set string
$value
= NULL - Value to set to a key mixedpublic function query($key = null, $value = null)
{
if (is_array($key)) {
// Act as a setter, replace all query strings
$this->_get = $key;
return $this;
}
if ($key === null) {
// Act as a getter, all query strings
return $this->_get;
} elseif ($value === null) {
// Act as a getter, single query string
return Arr::path($this->_get, $key);
}
// Act as a setter, single query string
$this->_get[$key] = $value;
return $this;
}Sets and gets the referrer from the request.
string
$referrer
= NULL - $referrer mixedpublic function referrer($referrer = null)
{
if ($referrer === null) {
// Act as a getter
return $this->_referrer;
}
// Act as a setter
$this->_referrer = (string) $referrer;
return $this;
}Renders the HTTP_Interaction to a string, producing
Body
If there are variables set to the Kohana_Request::$_post
they will override any values set to body.
stringpublic function render()
{
if (!$post = $this->post()) {
$body = $this->body();
} else {
$body = http_build_query($post, null, '&');
$this->body($body)
->headers('content-type', 'application/x-www-form-urlencoded; charset=' . Kohana::$charset);
}
// Set the content length
$this->headers('content-length', (string) $this->content_length());
// If Kohana expose, set the user-agent
if (Kohana::$expose) {
$this->headers('user-agent', Kohana::version());
}
// Prepare cookies
if ($this->_cookies) {
$cookie_string = [];
// Parse each
foreach ($this->_cookies as $key => $value) {
$cookie_string[] = $key . '=' . $value;
}
// Create the cookie string
$this->_header['cookie'] = implode('; ', $cookie_string);
}
$output = $this->method() . ' ' . $this->uri() . ' ' . $this->protocol() . "\r\n";
$output .= (string) $this->_header;
$output .= $body;
return $output;
}Gets and sets the requested with property, which should be relative to the x-requested-with pseudo header.
string
$requested_with
= NULL - Requested with value mixedpublic function requested_with($requested_with = null)
{
if ($requested_with === null) {
// Act as a getter
return $this->_requested_with;
}
// Act as a setter
$this->_requested_with = strtolower($requested_with);
return $this;
}Sets and gets the route from the request.
string
$route
= NULL - $route mixedpublic function route(Route $route = null)
{
if ($route === null) {
// Act as a getter
return $this->_route;
}
// Act as a setter
$this->_route = $route;
return $this;
}Getter/Setter to the security settings for this request. This method should be treated as immutable.
boolean
$secure
= NULL - Is this request secure? mixedpublic function secure($secure = null)
{
if ($secure === null)
return $this->_secure;
// Act as a setter
$this->_secure = (bool) $secure;
return $this;
}Sets and gets the uri from the request.
string
$uri
= NULL - $uri mixedpublic function uri($uri = null)
{
if ($uri === null) {
// Act as a getter
return ($this->_uri === '') ? '/' : $this->_uri;
}
// Act as a setter
$this->_uri = $uri;
return $this;
}Create a URL string from the current request. This is a shortcut for:
echo URL::site($this->request->uri(), $protocol);
mixed
$protocol
= NULL - Protocol string or Request object stringpublic function url($protocol = null)
{
if ($this->is_external()) {
// If it's an external request return the URI
return $this->uri();
}
// Create a URI with the current route, convert to a URL and returns
return URL::site($this->uri(), $protocol);
}Returns information about the initial user agent.
mixed
$value
required - Array or string to return: browser, version, robot, mobile, platform mixed - Requested information, false if nothing is foundpublic static function user_agent($value)
{
return Text::user_agent(Request::$user_agent, $value);
}Parses an accept header and returns an array (type => quality) of the accepted types, ordered by quality.
$accept = Request::_parse_accept($header, $defaults);
byref string
$header
required - Header to parse array
$accepts
= NULL - Default values arrayprotected static function _parse_accept(& $header, array $accepts = null)
{
if (!empty($header)) {
// Get all of the types
$types = explode(',', $header);
foreach ($types as $type) {
// Split the type into parts
$parts = explode(';', $type);
// Make the type only the MIME
$type = trim(array_shift($parts));
// Default quality is 1.0
$quality = 1.0;
foreach ($parts as $part) {
// Prevent undefined $value notice below
if (strpos($part, '=') === false)
continue;
// Separate the key and value
list ($key, $value) = explode('=', trim($part));
if ($key === 'q') {
// There is a quality for this type
$quality = (float) trim($value);
}
}
// Add the accept type and quality
$accepts[$type] = $quality;
}
}
// Make sure that accepts is an array
$accepts = (array) $accepts;
// Order by quality
arsort($accepts);
return $accepts;
}