Modules

Request
extends Kohana_Request

Implements: Kohana_HTTP_Request | Kohana_HTTP_Interaction | HTTP_Interaction | HTTP_Request

Request and response wrapper. Uses the Route class to determine what Controller to send the request to.

package
Kohana
category
Base
author
Kohana Team
copyright
© 2008-2012 Kohana Team
license
http://kohanaframework.org/license

Class declared in SYSPATH/classes/request.php on line 3.

Constants

GET

string(3) "GET"

POST

string(4) "POST"

PUT

string(3) "PUT"

DELETE

string(6) "DELETE"

HEAD

string(4) "HEAD"

OPTIONS

string(7) "OPTIONS"

TRACE

string(5) "TRACE"

CONNECT

string(7) "CONNECT"

Properties

public static string $client_ip

client IP address

string(13) "173.245.56.73"

public static Request $current

currently executing request instance

object Request()

public static Request $initial

main request instance

object Request()

public static string $user_agent

client user agent

string(39) "CCBot/2.0 (http://commoncrawl.org/faq/)"

protected string $_action

action to be executed in the controller

protected string $_body

the body

protected Kohana_Request_Client $_client

protected string $_controller

controller to be executed

protected array $_cookies

cookies to send with the request

protected string $_directory

controller directory

protected boolean $_external

external request

protected array $_get

query parameters

protected Kohana_HTTP_Header $_header

headers to sent as part of the request

protected string $_method

method: GET, POST, PUT, DELETE, HEAD, etc

protected array $_params

parameters from the route

protected array $_post

post parameters

protected string $_protocol

protocol: HTTP/1.1, FTP, CLI, etc

protected string $_referrer

referring URL

protected string $_requested_with

the x-requested-with header which most likely

protected Kohana_Response $_response

response

protected Route $_route

route matched for this request

protected Route $_routes

array of routes to manually look at instead of the global namespace

protected string $_uri

the URI of the request

Methods

public __construct( string $uri [, Cache $cache = NULL , array $injected_routes = array(0) ] ) (defined in Kohana_Request)

Creates a new request object for the given URI. New requests should be created using the Request::instance or Request::factory methods.

$request = new Request($uri);

If $cache parameter is set, the response for the request will attempt to be retrieved from the cache.

Parameters

  • string $uri required - URI of the request
  • Cache $cache = NULL - $cache
  • array $injected_routes = array(0) - An array of routes to use, for testing

Tags

Return Values

  • void

Source Code

public function __construct($uri, Cache $cache = NULL, $injected_routes = array())
{
	// Initialise the header
	$this->_header = new HTTP_Header(array());

	// Assign injected routes
	$this->_injected_routes = $injected_routes;

	// Cleanse query parameters from URI (faster that parse_url())
	$split_uri = explode('?', $uri);
	$uri = array_shift($split_uri);

	// Initial request has global $_GET already applied
	if (Request::$initial !== NULL)
	{
		if ($split_uri)
		{
			parse_str($split_uri[0], $this->_get);
		}
	}

	// Detect protocol (if present)
	// Always default to an internal request if we don't have an initial.
	// This prevents the default index.php from being able to proxy
	// external pages.
	if (Request::$initial === NULL OR strpos($uri, '://') === FALSE)
	{
		// Remove trailing slashes from the URI
		$uri = trim($uri, '/');

		$processed_uri = Request::process_uri($uri, $this->_injected_routes);

		if ($processed_uri === NULL)
		{
			throw new HTTP_Exception_404('Unable to find a route to match the URI: :uri', array(
				':uri' => $uri,
			));
		}

		// Store the URI
		$this->_uri = $uri;

		// Store the matching route
		$this->_route = $processed_uri['route'];
		$params = $processed_uri['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'];

		if (isset($params['action']))
		{
			// Store the action
			$this->_action = $params['action'];
		}
		else
		{
			// Use the default action
			$this->_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;

		// Apply the client
		$this->_client = new Request_Client_Internal(array('cache' => $cache));
	}
	else
	{
		// Create a route
		$this->_route = new Route($uri);

		// Store the URI
		$this->_uri = $uri;

		// Set external state
		$this->_external = TRUE;

		// Setup the client
		$this->_client = new Request_Client_External(array('cache' => $cache));
	}
}

public __toString( ) (defined in Kohana_Request)

Returns the response as the string representation of a request.

echo $request;

Return Values

  • string

Source Code

public function __toString()
{
	return $this->render();
}

public static accept_encoding( [ string $type = NULL ] ) (defined in Kohana_Request)

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();

Parameters

  • string $type = NULL - Encoding type

Tags

Return Values

  • mixed - An array of all types or a specific type as a string

Source Code

public 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;
}

public static accept_lang( [ string $lang = NULL ] ) (defined in Kohana_Request)

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();

Parameters

  • string $lang = NULL - Language code

Tags

Return Values

  • mixed - An array of all types or a specific type as a string

Source Code

public 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;
}

public static accept_type( [ string $type = NULL ] ) (defined in Kohana_Request)

Returns the accepted content types. If a specific type is defined, the quality of that type will be returned.

$types = Request::accept_type();

Parameters

  • string $type = NULL - Content MIME type

Tags

Return Values

  • mixed - An array of all types or a specific type as a string

Source Code

public static function accept_type($type = NULL)
{
	static $accepts;

	if ($accepts === NULL)
	{
		// Parse the HTTP_ACCEPT header
		$accepts = Request::_parse_accept($_SERVER['HTTP_ACCEPT'], array('*/*' => 1.0));
	}

	if (isset($type))
	{
		// Return the quality setting for this type
		return isset($accepts[$type]) ? $accepts[$type] : $accepts['*/*'];
	}

	return $accepts;
}

public action( [ string $action = NULL ] ) (defined in Kohana_Request)

Sets and gets the action for the controller.

Parameters

  • string $action = NULL - Action to execute the controller from

Return Values

  • mixed

Source Code

public function action($action = NULL)
{
	if ($action === NULL)
	{
		// Act as a getter
		return $this->_action;
	}

	// Act as a setter
	$this->_action = (string) $action;

	return $this;
}

public body( [ string $content = NULL ] ) (defined in Kohana_Request)

Gets or sets the HTTP body to the request or response. The body is included after the header, separated by a single empty new line.

Parameters

  • string $content = NULL - Content to set to the object

Return Values

  • mixed

Source Code

public function body($content = NULL)
{
	if ($content === NULL)
	{
		// Act as a getter
		return $this->_body;
	}

	// Act as a setter
	$this->_body = $content;

	return $this;
}

public controller( [ string $controller = NULL ] ) (defined in Kohana_Request)

Sets and gets the controller for the matched route.

Parameters

  • string $controller = NULL - Controller to execute the action

Return Values

  • mixed

Source Code

public 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.

Parameters

  • mixed $key = NULL - Cookie name, or array of cookie values
  • string $value = NULL - Value to set to cookie

Return Values

  • string
  • mixed

Source Code

public 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;
}

public create_response( [ boolean $bind = bool TRUE ] ) (defined in Kohana_Request)

Creates a response based on the type of request, i.e. an Request_HTTP will produce a Response_HTTP, and the same applies to CLI.

 // Create a response to the request
 $response = $request->create_response();

Parameters

  • boolean $bind = bool TRUE - Bind to this request

Tags

  • Since - 3.1.0

Return Values

  • Response

Source Code

public function create_response($bind = TRUE)
{
	$response = new Response(array('_protocol' => $this->protocol()));

	if ($bind)
	{
		// Bind a new response to the request
		$this->_response = $response;
	}

	return $response;
}

public static current( ) (defined in Kohana_Request)

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();

Tags

  • Since - 3.0.5

Return Values

  • Request

Source Code

public static function current()
{
	return Request::$current;
}

public static detect_uri( ) (defined in Kohana_Request)

Automatically detects the URI of the main request using PATH_INFO, REQUEST_URI, PHP_SELF or REDIRECT_URL.

$uri = Request::detect_uri();

Tags

Return Values

  • string - URI of the main request

Source Code

public 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;
}

public directory( [ string $directory = NULL ] ) (defined in Kohana_Request)

Sets and gets the directory for the controller.

Parameters

  • string $directory = NULL - Directory to execute the controller from

Return Values

  • mixed

Source Code

public function directory($directory = NULL)
{
	if ($directory === NULL)
	{
		// Act as a getter
		return $this->_directory;
	}

	// Act as a setter
	$this->_directory = (string) $directory;

	return $this;
}

public execute( ) (defined in Kohana_Request)

Processes the request, executing the controller action that handles this request, determined by the Route.

  1. Before the controller action is called, the Controller::before method will be called.
  2. Next the controller action will be called.
  3. After the controller action is called, the Controller::after method will be called.

By default, the output from the controller is captured and returned, and no headers are sent.

$request->execute();

Tags

Return Values

  • Response

Source Code

public function execute()
{
	if ( ! $this->_client instanceof Kohana_Request_Client)
	{
		throw new Kohana_Request_Exception('Unable to execute :uri without a Kohana_Request_Client', array(
			':uri' => $this->_uri,
		));
	}

	return $this->_client->execute($this);
}

public static factory( [ string $uri = bool TRUE , Cache $cache = NULL , array $injected_routes = array(0) ] ) (defined in Kohana_Request)

Creates a new request object for the given URI. New requests should be created using the Request::instance or Request::factory methods.

$request = Request::factory($uri);

If $cache parameter is set, the response for the request will attempt to be retrieved from the cache.

Parameters

  • string $uri = bool TRUE - URI of the request
  • Cache $cache = NULL - $cache
  • array $injected_routes = array(0) - An array of routes to use, for testing

Tags

Return Values

  • void

Source Code

public static function factory($uri = TRUE, Cache $cache = NULL, $injected_routes = array())
{
	// If this is the initial request
	if ( ! Request::$initial)
	{
		if (Kohana::$is_cli)
		{
			// Default protocol for command line is cli://
			$protocol = 'cli';

			// Get the command line options
			$options = CLI::options('uri', 'method', 'get', 'post', 'referrer');

			if (isset($options['uri']))
			{
				// Use the specified URI
				$uri = $options['uri'];
			}
			elseif ($uri === TRUE)
			{
				$uri = '';
			}

			if (isset($options['method']))
			{
				// Use the specified method
				$method = strtoupper($options['method']);
			}
			else
			{
				// Default to GET requests
				$method = HTTP_Request::GET;
			}

			if (isset($options['get']))
			{
				// Overload the global GET data
				parse_str($options['get'], $_GET);
			}

			if (isset($options['post']))
			{
				// Overload the global POST data
				parse_str($options['post'], $_POST);
			}

			if (isset($options['referrer']))
			{
				$referrer = $options['referrer'];
			}
		}
		else
		{
			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))
			{
				// This request is secure
				$protocol = 'https';
			}
			else
			{
				$protocol = 'http';
			}

			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']))
			{
				// Use the forwarded IP address, typically set when the
				// client is using a proxy server.
				Request::$client_ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
			}
			elseif (isset($_SERVER['HTTP_CLIENT_IP']))
			{
				// Use the forwarded IP address, typically set when the
				// client is using a proxy server.
				Request::$client_ip = $_SERVER['HTTP_CLIENT_IP'];
			}
			elseif (isset($_SERVER['REMOTE_ADDR']))
			{
				// The remote IP address
				Request::$client_ip = $_SERVER['REMOTE_ADDR'];
			}

			if ($method !== '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 = array();

			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, $cache, $injected_routes);

		// Store global GET and POST data in the initial request only
		$request->query($_GET);
		$request->post($_POST);

		if (isset($protocol))
		{
			// Set the request protocol
			$request->protocol($protocol);
		}

		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, $cache, $injected_routes);
	}

	return $request;
}

public generate_etag( ) (defined in Kohana_Request)

Generates an ETag from the request response.

$etag = $request->generate_etag();

If the request response is empty when this method is called, an exception will be thrown!

Tags

Return Values

  • string

Source Code

public function generate_etag()
{
    if ($this->_response === NULL)
	{
		throw new Kohana_Request_Exception('No response yet associated with request - cannot auto generate resource ETag');
	}

	// Generate a unique hash for the response
	return '"'.sha1($this->_response).'"';
}

public get_client( ) (defined in Kohana_Request)

Provides readonly access to the Request_Client, useful for accessing the caching methods within the request client.

Return Values

  • Request_Client

Source Code

public function get_client()
{
	return $this->_client;
}

public headers( [ mixed $key = NULL , string $value = NULL ] ) (defined in Kohana_Request)

Gets or sets HTTP headers to the request or response. 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.

Parameters

  • mixed $key = NULL - Key or array of key/value pairs to set
  • string $value = NULL - Value to set to the supplied key

Return Values

  • mixed

Source Code

public 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;
}

public static initial( ) (defined in Kohana_Request)

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

Tags

  • Since - 3.1.0

Return Values

  • Request

Source Code

public static function initial()
{
	return Request::$initial;
}

public is_ajax( ) (defined in Kohana_Request)

Returns whether this is an ajax request (as used by JS frameworks)

Return Values

  • boolean

Source Code

public function is_ajax()
{
	return ($this->requested_with() === 'xmlhttprequest');
}

public is_initial( ) (defined in Kohana_Request)

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

Return Values

  • boolean

Source Code

public function is_initial()
{
	return ($this === Request::$initial);
}

public method( [ string $method = NULL ] ) (defined in Kohana_Request)

Gets or sets the HTTP method. Usually GET, POST, PUT or DELETE in traditional CRUD applications.

Parameters

  • string $method = NULL - Method to use for this request

Return Values

  • mixed

Source Code

public function method($method = NULL)
{
	if ($method === NULL)
	{
		// Act as a getter
		return $this->_method;
	}

	// Act as a setter
	$this->_method = strtoupper($method);

	return $this;
}

public param( [ string $key = NULL , mixed $default = NULL ] ) (defined in Kohana_Request)

Retrieves a value from the route parameters.

$id = $request->param('id');

Parameters

  • string $key = NULL - Key of the value
  • mixed $default = NULL - Default value if the key is not set

Return Values

  • mixed

Source Code

public 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;
}

public post( [ mixed $key = NULL , string $value = NULL ] ) (defined in Kohana_Request)

Gets or sets HTTP POST parameters to the request.

Parameters

  • mixed $key = NULL - Key or key value pairs to set
  • string $value = NULL - Value to set to a key

Return Values

  • mixed

Source Code

public 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::get($this->_post, $key);
	}

	// Act as a setter, single field
	$this->_post[$key] = $value;

	return $this;
}

public static post_max_size_exceeded( ) (defined in Kohana_Request)

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.

Tags

Return Values

  • boolean

Source Code

public 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);
}

public static process_uri( string $uri [, array $routes = NULL ] ) (defined in Kohana_Request)

Process URI

Parameters

  • string $uri required - URI
  • array $routes = NULL - Route

Return Values

  • array

Source Code

public static function process_uri($uri, $routes = NULL)
{
	// Load routes
	$routes = (empty($routes)) ? Route::all() : $routes;
	$params = NULL;

	foreach ($routes as $name => $route)
	{
		// We found something suitable
		if ($params = $route->matches($uri))
		{
			return array(
				'params' => $params,
				'route' => $route,
			);
		}
	}

	return NULL;
}

public protocol( [ string $protocol = NULL ] ) (defined in Kohana_Request)

Gets or sets the HTTP protocol. The standard protocol to use is http.

Parameters

  • string $protocol = NULL - Protocol to set to the request/response

Return Values

  • mixed

Source Code

public function protocol($protocol = NULL)
{
	if ($protocol === NULL)
	{
		if ($this->_protocol)
		{
			// Act as a getter
			return $this->_protocol;
		}
		else
		{
			// Get the default protocol
			return HTTP::$protocol;
		}
	}

	// Act as a setter
	$this->_protocol = strtolower($protocol);

	return $this;
}

public query( [ mixed $key = NULL , string $value = NULL ] ) (defined in Kohana_Request)

Gets or sets HTTP query string.

Parameters

  • mixed $key = NULL - Key or key value pairs to set
  • string $value = NULL - Value to set to a key

Return Values

  • mixed

Source Code

public 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::get($this->_get, $key);
	}

	// Act as a setter, single query string
	$this->_get[$key] = $value;

	return $this;
}

public redirect( [ string $url = string(0) "" , integer $code = integer 302 ] ) (defined in Kohana_Request)

Redirects as the request response. If the URL does not include a protocol, it will be converted into a complete URL.

$request->redirect($url);

No further processing can be done after this method is called!

Parameters

  • string $url = string(0) "" - Redirect location
  • integer $code = integer 302 - Status code: 301, 302, etc

Tags

Return Values

  • void

Source Code

public function redirect($url = '', $code = 302)
{
	$referrer = $this->uri();

	if (strpos($referrer, '://') === FALSE)
	{
		$referrer = URL::site($referrer, TRUE, ! empty(Kohana::$index_file));
	}

	if (strpos($url, '://') === FALSE)
	{
		// Make the URI into a URL
		$url = URL::site($url, TRUE, ! empty(Kohana::$index_file));
	}

	if (($response = $this->response()) === NULL)
	{
		$response = $this->create_response();
	}

	echo $response->status($code)
		->headers('Location', $url)
		->headers('Referer', $referrer)
		->send_headers()
		->body();

	// Stop execution
	exit;
}

public referrer( [ string $referrer = NULL ] ) (defined in Kohana_Request)

Sets and gets the referrer from the request.

Parameters

  • string $referrer = NULL - $referrer

Return Values

  • mixed

Source Code

public function referrer($referrer = NULL)
{
	if ($referrer === NULL)
	{
		// Act as a getter
		return $this->_referrer;
	}

	// Act as a setter
	$this->_referrer = (string) $referrer;

	return $this;
}

public render( [ boolean $response = bool TRUE ] ) (defined in Kohana_Request)

Renders the HTTP_Interaction to a string, producing

  • Protocol
  • Headers
  • Body

    If there are variables set to the Kohana_Request::$_post they will override any values set to body.

Parameters

  • boolean $response = bool TRUE - Return the rendered response, else returns the rendered request

Return Values

  • string

Source Code

public function render($response = TRUE)
{
	if ($response)
	{
		// Act as a getter
		return (string) $this->_response;
	}

	if ( ! $post = $this->post())
	{
		$body = $this->body();
	}
	else
	{
		$this->headers('content-type', 'application/x-www-form-urlencoded');
		$body = http_build_query($post, NULL, '&');
	}

	// Prepare cookies
	if ($this->_cookies)
	{
		$cookie_string = array();

		// 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->param()).' '.strtoupper($this->protocol()).'/'.HTTP::$version."\n";
	$output .= (string) $this->_header;
	$output .= $body;

	return $output;
}

public requested_with( [ string $requested_with = NULL ] ) (defined in Kohana_Request)

Gets and sets the requested with property, which should be relative to the x-requested-with pseudo header.

Parameters

  • string $requested_with = NULL - Requested with value

Return Values

  • mixed

Source Code

public 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;
}

public response( [ Response $response = NULL ] ) (defined in Kohana_Request)

Set or get the response for this request

Parameters

  • Response $response = NULL - Response to apply to this request

Return Values

  • Response
  • void

Source Code

public function response(Response $response = NULL)
{
	if ($response === NULL)
	{
		// Act as a getter
		return $this->_response;
	}

	// Act as a setter
	$this->_response = $response;

	return $this;
}

public route( [ string $route = NULL ] ) (defined in Kohana_Request)

Sets and gets the route from the request.

Parameters

  • string $route = NULL - $route

Return Values

  • mixed

Source Code

public function route(Route $route = NULL)
{
	if ($route === NULL)
	{
		// Act as a getter
		return $this->_route;
	}

	// Act as a setter
	$this->_route = $route;

	return $this;
}

public send_headers( ) (defined in Kohana_Request)

Sends the response status and all set headers. The current server protocol (HTTP/1.0 or HTTP/1.1) will be used when available. If not available, HTTP/1.1 will be used.

$request->send_headers();

Response::send_headers() where it is implemented correctly.

Tags

Return Values

  • $this

Source Code

public function send_headers()
{
	if ( ! ($response = $this->response()) instanceof Response)
		return $this;

	$response->send_headers();
	return $this;
}

public uri( [ array $params = NULL ] ) (defined in Kohana_Request)

Generates a relative URI for the current route.

$request->uri($params);

Parameters

  • array $params = NULL - Additional route parameters

Tags

Return Values

  • string

Source Code

public function uri(array $params = NULL)
{
	if ( ! isset($params['directory']))
	{
		// Add the current directory
		$params['directory'] = $this->directory();
	}

	if ( ! isset($params['controller']))
	{
		// Add the current controller
		$params['controller'] = $this->controller();
	}

	if ( ! isset($params['action']))
	{
		// Add the current action
		$params['action'] = $this->action();
	}

	// Add the current parameters
	$params += $this->_params;

	$uri = $this->_route->uri($params);

	return $uri;
}

public url( [ array $params = NULL , mixed $protocol = NULL ] ) (defined in Kohana_Request)

Create a URL from the current request. This is a shortcut for:

echo URL::site($this->request->uri($params), $protocol);

Parameters

  • array $params = NULL - URI parameters
  • mixed $protocol = NULL - Protocol string or Request object

Tags

Return Values

  • string

Source Code

public function url(array $params = NULL, $protocol = NULL)
{
	// Create a URI with the current route and convert it to a URL
	$url = URL::site($this->uri($params), $protocol);

	return $url;
}

public static user_agent( mixed $value ) (defined in Kohana_Request)

Returns information about the client user agent.

// Returns "Chrome" when using Google Chrome
$browser = Request::user_agent('browser');

Multiple values can be returned at once by using an array:

// Get the browser and platform with a single call
$info = Request::user_agent(array('browser', 'platform'));

When using an array for the value, an associative array will be returned.

Parameters

  • mixed $value required - String to return: browser, version, robot, mobile, platform; or array of values

Tags

Return Values

  • mixed - Requested information, FALSE if nothing is found

Source Code

public static function user_agent($value)
{
	if (is_array($value))
	{
		$agent = array();
		foreach ($value as $v)
		{
			// Add each key to the set
			$agent[$v] = Request::user_agent($v);
		}

		return $agent;
	}

	static $info;

	if (isset($info[$value]))
	{
		// This value has already been found
		return $info[$value];
	}

	if ($value === 'browser' OR $value == 'version')
	{
		// Load browsers
		$browsers = Kohana::config('user_agents')->browser;

		foreach ($browsers as $search => $name)
		{
			if (stripos(Request::$user_agent, $search) !== FALSE)
			{
				// Set the browser name
				$info['browser'] = $name;

				if (preg_match('#'.preg_quote($search).'[^0-9.]*+([0-9.][0-9.a-z]*)#i', Request::$user_agent, $matches))
				{
					// Set the version number
					$info['version'] = $matches[1];
				}
				else
				{
					// No version number found
					$info['version'] = FALSE;
				}

				return $info[$value];
			}
		}
	}
	else
	{
		// Load the search group for this type
		$group = Kohana::config('user_agents')->$value;

		foreach ($group as $search => $name)
		{
			if (stripos(Request::$user_agent, $search) !== FALSE)
			{
				// Set the value name
				return $info[$value] = $name;
			}
		}
	}

	// The value requested could not be found
	return $info[$value] = FALSE;
}

protected static _parse_accept( string & $header [, array $accepts = NULL ] ) (defined in Kohana_Request)

Parses an accept header and returns an array (type => quality) of the accepted types, ordered by quality.

$accept = Request::_parse_accept($header, $defaults);

Parameters

  • byref string $header required - Header to parse
  • array $accepts = NULL - Default values

Return Values

  • array

Source Code

protected 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;
}