public __construct( string $uri [, HTTP_Cache $cache = NULL , array $injected_routes = array(0) ] ) (defined in Kohana_Request) link to this

?
$request = new Request($uri);

Parameters

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

Tags

• Throws - Request_Exception
• Uses - Route::all, Route::matches

Return Values

• void

?
public function __construct($uri, HTTP_Cache $cache = NULL, $injected_routes = array())
{
    // Initialise the header
    $this->_header = new HTTP_Header(array());
 
    // 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);
 
    // 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->_routes);
 
        // Return here rather than throw exception. This will allow
        // use of Request object even with unmatched route
        if ($processed_uri === NULL)
        {
            $this->_uri = $uri;
            return;
        }
 
        // 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 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(array('cache' => $cache));
    }
}

public __toString( ) (defined in Kohana_Request) link to this

?
echo $request;

Return Values

• string

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

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

?
$encodings = Request::accept_encoding();

Parameters

• string $type = NULL - Encoding type

Tags

• Uses - Request::_parse_accept

Return Values

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

?
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) link to this

?
$langs = Request::accept_lang();

Parameters

• string $lang = NULL - Language code

Tags

• Uses - Request::_parse_accept

Return Values

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

?
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) link to this

?
$types = Request::accept_type();

Parameters

• string $type = NULL - Content MIME type

Tags

• Uses - Request::_parse_accept

Return Values

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

?
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) link to this

Parameters

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

Return Values

• mixed

?
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) link to this

Parameters

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

Return Values

• mixed

?
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 client( ) (defined in Kohana_Request) link to this

Return Values

• Request_Client
• self

?
public function client(Request_Client $client = NULL)
{
    if ($client === NULL)
        return $this->_client;
    else
    {
        $this->_client = $client;
        return $this;
    }
}

public content_length( ) (defined in Kohana_Request) link to this

Return Values

• integer

?
public function content_length()
{
    return strlen($this->body());
}

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

Parameters

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

Return Values

• mixed

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

public cookie( [ mixed $key = NULL , string $value = NULL ] ) (defined in Kohana_Request) link to this

Parameters

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

Return Values

• string
• mixed

?
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) link to this

?
// 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

?
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) link to this

?
$request = Request::current();

Tags

• Since - 3.0.5

Return Values

• Request

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

public static detect_uri( ) (defined in Kohana_Request) link to this

?
$uri = Request::detect_uri();

Tags

• Throws - Kohana_Exception
• Since - 3.0.8

Return Values

• string - URI of the main request

?
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) link to this

Parameters

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

Return Values

• mixed

?
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) link to this

?
$request->execute();

Tags

• Throws - Request_Exception, HTTP_Exception_404
• Uses - [Kohana::$profiling], [Profiler]

Return Values

• Response

?
public function execute()
{
    if ( ! $this->_route instanceof Route)
    {
        throw new HTTP_Exception_404('Unable to find a route to match the URI: :uri', array(
            ':uri' => $this->_uri,
        ));
    }
 
    if ( ! $this->_client instanceof Request_Client)
    {
        throw new 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) link to this

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

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

• Throws - Request_Exception
• Uses - Route::all, Route::matches

Return Values

• void|Request

?
public static function factory($uri = TRUE, HTTP_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['SERVER_PROTOCOL']))
            {
                $protocol = $_SERVER['SERVER_PROTOCOL'];
            }
            else
            {
                $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))
            {
                // 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 = 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->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, $cache, $injected_routes);
    }
 
    return $request;
}

public generate_etag( ) (defined in Kohana_Request) link to this

?
$etag = $request->generate_etag();

Tags

• Throws - Request_Exception

Return Values

• string

?
public function generate_etag()
{
    if ($this->_response === NULL)
    {
        throw new 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 headers( [ mixed $key = NULL , string $value = NULL ] ) (defined in Kohana_Request) link to this

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

?
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) link to this

?
// 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

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

public is_ajax( ) (defined in Kohana_Request) link to this

Return Values

• boolean

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

public is_external( ) (defined in Kohana_Request) link to this

?
if ( ! $request->is_external())
     // This is an internal request

Return Values

• boolean

?
public function is_external()
{
    return $this->_external;
}

public is_initial( ) (defined in Kohana_Request) link to this

?
if ( ! $request->is_initial())
    // This is a sub request

Return Values

• boolean

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

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

Parameters

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

Return Values

• mixed

?
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) link to this

?
$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

?
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) link to this

Parameters

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

Return Values

• mixed

?
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) link to this

Tags

• Uses - Num::bytes, Arr::get

Return Values

• boolean

?
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) link to this

Parameters

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

Return Values

• array

?
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) link to this

Parameters

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

Return Values

• mixed

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

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

Parameters

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

Return Values

• mixed

?
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) link to this

?
$request->redirect($url);

Parameters

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

Tags

• Uses - URL::site, Request::send_headers

Return Values

• void

?
public function redirect($url = '', $code = 302)
{
    $referrer = $this->uri();
    $protocol = ($this->secure()) ? 'https' : TRUE;
 
    if (strpos($referrer, '://') === FALSE)
    {
        $referrer = URL::site($referrer, $protocol, ! 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) link to this

Parameters

• string $referrer = NULL - $referrer

Return Values

• mixed

?
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( ) (defined in Kohana_Request) link to this

Return Values

• string

?
public function render()
{
    if ( ! $post = $this->post())
    {
        $body = $this->body();
    }
    else
    {
        $this->headers('content-type', 'application/x-www-form-urlencoded');
        $body = http_build_query($post, NULL, '&');
    }
 
    // 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 Framework '.Kohana::VERSION.' ('.Kohana::CODENAME.')');
    }
 
    // 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->protocol()."\r\n";
    $output .= (string) $this->_header;
    $output .= $body;
 
    return $output;
}

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

Parameters

• string $requested_with = NULL - Requested with value

Return Values

• mixed

?
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) link to this

Parameters

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

Return Values

• Response
• void

?
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) link to this

Parameters

• string $route = NULL - $route

Return Values

• mixed

?
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 secure( [ boolean $secure = NULL ] ) (defined in Kohana_Request) link to this

Parameters

• boolean $secure = NULL - Is this request secure?

Return Values

• mixed

?
public function secure($secure = NULL)
{
    if ($secure === NULL)
        return $this->_secure;
 
    // Act as a setter
    $this->_secure = (bool) $secure;
    return $this;
}

public uri( ) (defined in Kohana_Request) link to this

?
$request->uri();

Tags

• Uses - Route::uri

Return Values

• string

?
public function uri()
{
    return empty($this->_uri) ? '/' : $this->_uri;
}

public url( [ array $protocol = NULL ] ) (defined in Kohana_Request) link to this

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

Parameters

• array $protocol = NULL - $params URI parameters

Tags

• Since - 3.0.7
• Uses - URL::site

Return Values

• string

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

public static user_agent( mixed $value ) (defined in Kohana_Request) link to this

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

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

Parameters

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

Tags

• Uses - Kohana::$config, Request::$user_agent

Return Values

• mixed - Requested information, FALSE if nothing is found

?
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->load('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->load('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) link to this

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

Parameters

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

Return Values

• array

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