538 lines
12 KiB
PHP
538 lines
12 KiB
PHP
<?php defined('SYSPATH') or die('No direct script access.');
|
|
/**
|
|
* Request and response wrapper.
|
|
*
|
|
* @package Kohana
|
|
* @author Kohana Team
|
|
* @copyright (c) 2008-2009 Kohana Team
|
|
* @license http://kohanaphp.com/license.html
|
|
*/
|
|
class Request_Core {
|
|
|
|
// HTTP status codes and messages
|
|
protected static $messages = array(
|
|
// Informational 1xx
|
|
100 => 'Continue',
|
|
101 => 'Switching Protocols',
|
|
|
|
// Success 2xx
|
|
200 => 'OK',
|
|
201 => 'Created',
|
|
202 => 'Accepted',
|
|
203 => 'Non-Authoritative Information',
|
|
204 => 'No Content',
|
|
205 => 'Reset Content',
|
|
206 => 'Partial Content',
|
|
|
|
// Redirection 3xx
|
|
300 => 'Multiple Choices',
|
|
301 => 'Moved Permanently',
|
|
302 => 'Found', // 1.1
|
|
303 => 'See Other',
|
|
304 => 'Not Modified',
|
|
305 => 'Use Proxy',
|
|
// 306 is deprecated but reserved
|
|
307 => 'Temporary Redirect',
|
|
|
|
// Client Error 4xx
|
|
400 => 'Bad Request',
|
|
401 => 'Unauthorized',
|
|
402 => 'Payment Required',
|
|
403 => 'Forbidden',
|
|
404 => 'Not Found',
|
|
405 => 'Method Not Allowed',
|
|
406 => 'Not Acceptable',
|
|
407 => 'Proxy Authentication Required',
|
|
408 => 'Request Timeout',
|
|
409 => 'Conflict',
|
|
410 => 'Gone',
|
|
411 => 'Length Required',
|
|
412 => 'Precondition Failed',
|
|
413 => 'Request Entity Too Large',
|
|
414 => 'Request-URI Too Long',
|
|
415 => 'Unsupported Media Type',
|
|
416 => 'Requested Range Not Satisfiable',
|
|
417 => 'Expectation Failed',
|
|
|
|
// Server Error 5xx
|
|
500 => 'Internal Server Error',
|
|
501 => 'Not Implemented',
|
|
502 => 'Bad Gateway',
|
|
503 => 'Service Unavailable',
|
|
504 => 'Gateway Timeout',
|
|
505 => 'HTTP Version Not Supported',
|
|
509 => 'Bandwidth Limit Exceeded'
|
|
);
|
|
|
|
// Main request instance
|
|
protected static $_instance;
|
|
|
|
/**
|
|
* Main request singleton instance. If no URI is provided, the URI will
|
|
* be automatically detected using PATH_INFO, REQUEST_URI, or PHP_SELF.
|
|
*
|
|
* @param string URI of the request
|
|
* @return Request
|
|
*/
|
|
public static function instance( & $uri = FALSE)
|
|
{
|
|
if (Request::$_instance === NULL)
|
|
{
|
|
// Create the initial request parameters
|
|
$params = array('method' => 'GET', 'get' => NULL, 'post' => NULL);
|
|
|
|
if (Kohana::$is_cli)
|
|
{
|
|
// Get the command line options
|
|
$options = cli::options('uri', 'method', 'get', 'post');
|
|
|
|
if (isset($options['uri']))
|
|
{
|
|
// Use the specified URI
|
|
$uri = $options['uri'];
|
|
}
|
|
|
|
if (isset($options['method']))
|
|
{
|
|
// Request method specified
|
|
$params['method'] = $options['method'];
|
|
}
|
|
|
|
if (isset($options['get']))
|
|
{
|
|
// GET data specified
|
|
parse_str($options['get'], $params['get']);
|
|
}
|
|
|
|
if (isset($options['post']))
|
|
{
|
|
// POST data specified
|
|
parse_str($options['post'], $params['post']);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (isset($_SERVER['REQUEST_METHOD']))
|
|
{
|
|
// Use the server request method
|
|
$params['method'] = $_SERVER['REQUEST_METHOD'];
|
|
}
|
|
|
|
if ($params['method'] !== 'GET' AND $params['method'] !== 'POST')
|
|
{
|
|
// Methods besides GET and POST do not properly parse the form-encoded
|
|
// query string into the $_POST array, so we do it manually.
|
|
parse_str(file_get_contents('php://input'), $params['post']);
|
|
}
|
|
}
|
|
|
|
if ($uri === FALSE)
|
|
{
|
|
if (isset($_SERVER['PATH_INFO']))
|
|
{
|
|
// PATH_INFO is most realiable way to handle routing, as it
|
|
// does not include the document root or index file
|
|
$uri = $_SERVER['PATH_INFO'];
|
|
}
|
|
else
|
|
{
|
|
// REQUEST_URI and PHP_SELF both provide the full path,
|
|
// including the document root and index file
|
|
if (isset($_SERVER['REQUEST_URI']))
|
|
{
|
|
$uri = $_SERVER['REQUEST_URI'];
|
|
}
|
|
elseif (isset($_SERVER['PHP_SELF']))
|
|
{
|
|
$uri = $_SERVER['PHP_SELF'];
|
|
}
|
|
|
|
if (isset($_SERVER['SCRIPT_NAME']) AND strpos($uri, $_SERVER['SCRIPT_NAME']) === 0)
|
|
{
|
|
// Remove the document root and index file from the URI
|
|
$uri = substr($uri, strlen($_SERVER['SCRIPT_NAME']));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create the instance singleton
|
|
Request::$_instance = new Request($uri, $params);
|
|
}
|
|
|
|
return Request::$_instance;
|
|
}
|
|
|
|
/**
|
|
* Creates a new request object for the given URI. Global GET and POST data
|
|
* can be overloaded.
|
|
*
|
|
* @chainable
|
|
* @param string URI of the request
|
|
* @param array overloaded GET data
|
|
* @param array overloaded POST data
|
|
* @return Request
|
|
*/
|
|
public static function factory($uri, array $params = NULL)
|
|
{
|
|
return new Request($uri, $params);
|
|
}
|
|
|
|
/**
|
|
* @var object route used for this request
|
|
*/
|
|
public $route;
|
|
|
|
/**
|
|
* @var string request method type (GET, POST, PUT, etc)
|
|
*/
|
|
public $method = 'GET';
|
|
|
|
/**
|
|
* @var decimal HTTP version (1.0, 1.1)
|
|
*/
|
|
public $version = 1.1;
|
|
|
|
/**
|
|
* @var integer HTTP response code (200, 404, 500, etc)
|
|
*/
|
|
public $status = 200;
|
|
|
|
/**
|
|
* @var string response body
|
|
*/
|
|
public $response;
|
|
|
|
/**
|
|
* @var array headers to send with the response body
|
|
*/
|
|
public $headers = array('content-type' => 'text/html; charset=utf-8');
|
|
|
|
/**
|
|
* @var string controller directory
|
|
*/
|
|
public $directory = '';
|
|
|
|
/**
|
|
* @var string controller to be executed
|
|
*/
|
|
public $controller;
|
|
|
|
/**
|
|
* @var string action to be executed in the controller
|
|
*/
|
|
public $action;
|
|
|
|
/**
|
|
* @var string the URI of the request
|
|
*/
|
|
public $uri;
|
|
|
|
// Parameters extracted from the route
|
|
protected $_params;
|
|
|
|
// Request GET and POST data
|
|
protected $_get;
|
|
protected $_post;
|
|
|
|
/**
|
|
* Creates a new request object for the given URI. Global GET and POST data
|
|
* can be overloaded by setting "get" and "post" in the parameters.
|
|
*
|
|
* @param string URI of the request
|
|
* @param array request parameters
|
|
* @return void
|
|
* @throws Kohana_Exception if no route matches the URI
|
|
*/
|
|
public function __construct($uri, array $params = NULL)
|
|
{
|
|
if (isset($params['method']))
|
|
{
|
|
// Set the request method
|
|
$this->method = strtoupper($params['method']);
|
|
}
|
|
|
|
// Load GET data
|
|
$this->_get = isset($params['get']) ? $params['get'] : $_GET;
|
|
|
|
// Load POST data
|
|
$this->_post = isset($params['post']) ? $params['post'] : $_POST;
|
|
|
|
// Remove trailing slashes from the URI
|
|
$uri = trim($uri, '/');
|
|
|
|
// Load routes
|
|
$routes = Route::all();
|
|
|
|
foreach ($routes as $name => $route)
|
|
{
|
|
if ($params = $route->matches($uri))
|
|
{
|
|
// Store the URI
|
|
$this->uri = $uri;
|
|
|
|
// Store the matching route
|
|
$this->route = $route;
|
|
|
|
if (isset($params['directory']))
|
|
{
|
|
// Controllers are in a sub-directory
|
|
$this->directory = $params['directory'];
|
|
}
|
|
|
|
// Store the controller and action
|
|
$this->controller = $params['controller'];
|
|
$this->action = $params['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;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
throw new Kohana_Exception('Unable to find a route to handle :uri', array(':uri' => $uri));
|
|
}
|
|
|
|
/**
|
|
* Generates a complete URL for the current route.
|
|
*
|
|
* @param array additional route parameters
|
|
* @return string
|
|
*/
|
|
public function url(array $params = NULL)
|
|
{
|
|
return Kohana::$base_url.$this->uri($params);
|
|
}
|
|
|
|
/**
|
|
* Generates a relative URI for the current route.
|
|
*
|
|
* @param array additional route parameters
|
|
* @return string
|
|
*/
|
|
public function uri(array $params = NULL)
|
|
{
|
|
if ( ! isset($params['controller']))
|
|
{
|
|
// Add the current controller
|
|
$params['controller'] = $this->controller;
|
|
}
|
|
|
|
if ( ! isset($params['action']))
|
|
{
|
|
// Add the current action
|
|
$params['action'] = $this->action;
|
|
}
|
|
|
|
return $this->route->uri($params);
|
|
}
|
|
|
|
/**
|
|
* Retrieves a value from the route parameters.
|
|
*
|
|
* @param string key of the value
|
|
* @param mixed default value if the key is not set
|
|
* @return 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;
|
|
}
|
|
|
|
/**
|
|
* Retrieves a value from GET data.
|
|
*
|
|
* @param string key of the value
|
|
* @param mixed default value if the key is not set
|
|
* @return mixed
|
|
*/
|
|
public function get($key = NULL, $default = NULL)
|
|
{
|
|
if ($key === NULL)
|
|
{
|
|
// Return the full array
|
|
return $this->_get;
|
|
}
|
|
|
|
return isset($this->_get[$key]) ? $this->_get[$key] : $default;
|
|
}
|
|
|
|
/**
|
|
* Retrieves a value from POST data.
|
|
*
|
|
* @param string key of the value
|
|
* @param mixed default value if the key is not set
|
|
* @return mixed
|
|
*/
|
|
public function post($key = NULL, $default = NULL)
|
|
{
|
|
if ($key === NULL)
|
|
{
|
|
// Return the full array
|
|
return $this->_post;
|
|
}
|
|
|
|
return isset($this->_post[$key]) ? $this->_post[$key] : $default;
|
|
}
|
|
|
|
/**
|
|
* Gets an named header.
|
|
*
|
|
* @param string header name
|
|
* @return string header value
|
|
* @return FALSE if no header is found
|
|
*/
|
|
public function get_header($name)
|
|
{
|
|
// The header name is always stored lowercase
|
|
$name = strtolower($name);
|
|
|
|
return isset($this->headers[$name]) ? $this->headers[$name] : FALSE;
|
|
}
|
|
|
|
/**
|
|
* Sets an named header.
|
|
*
|
|
* @param string header name
|
|
* @param string header value
|
|
* @return $this
|
|
*/
|
|
public function set_header($name, $value)
|
|
{
|
|
// The header name is always stored lowercase
|
|
$name = strtolower($name);
|
|
|
|
// Add the header to the list
|
|
$this->headers[$name] = $value;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sets an unnamed header. Raw headers cannot be retrieved with get_header!
|
|
*
|
|
* @param string header string
|
|
* @return $this
|
|
*/
|
|
public function set_raw_header($value)
|
|
{
|
|
$this->headers[] = $value;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Deletes a named header.
|
|
*
|
|
* @param string header name
|
|
* @return $this
|
|
*/
|
|
public function delete_header($name)
|
|
{
|
|
// The header name is always stored lowercase
|
|
$name = strtolower($name);
|
|
|
|
// Remove the header from the list
|
|
unset($this->_headers[$name]);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sends the response status and all set headers.
|
|
*
|
|
* @return $this
|
|
*/
|
|
public function send_headers()
|
|
{
|
|
// Get the status message
|
|
$message = Request::$messages[$this->status];
|
|
|
|
// Send the HTTP status message
|
|
header("HTTP/{$this->version} {$this->status} {$message}", TRUE, $this->status);
|
|
|
|
foreach ($this->headers as $name => $value)
|
|
{
|
|
if (is_string($name))
|
|
{
|
|
// Convert the header name to Title-Case, to match RFC spec
|
|
$name = str_replace('-', ' ', $name);
|
|
$name = str_replace(' ', '-', ucwords($name));
|
|
|
|
// Combine the name and value to make a raw header
|
|
$value = "{$name}: {$value}";
|
|
}
|
|
|
|
// Send the raw header
|
|
header($value, TRUE);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Processes the request, executing the controller. Before the routed action
|
|
* is run, the before() method will be called, which allows the controller
|
|
* to overload the action based on the request parameters. After the action
|
|
* is run, the after() method will be called, for post-processing.
|
|
*
|
|
* By default, the output from the controller is captured and returned, and
|
|
* no headers are sent.
|
|
*
|
|
* @param boolean capture the output and return it
|
|
* @return string for captured output
|
|
* @return void for displayed output
|
|
*/
|
|
public function execute($capture = TRUE)
|
|
{
|
|
if (empty($this->directory))
|
|
{
|
|
// There is no controller prefix
|
|
$prefix = '';
|
|
}
|
|
else
|
|
{
|
|
// Make the directory name into a class prefix
|
|
$prefix = str_replace(array('\\', '/'), '_', trim($this->directory, '/')).'_';
|
|
}
|
|
|
|
// Set the controller class name
|
|
$controller = 'controller_'.$prefix.$this->controller;
|
|
|
|
// Load the controller
|
|
$controller = new $controller($this);
|
|
|
|
// A new action is about to be run
|
|
$controller->before($this->method);
|
|
|
|
// Set the action name after running before() to allow the controller
|
|
// to change the action based on the current parameters
|
|
$action = 'action_'.$this->action;
|
|
|
|
// Execute the action
|
|
$controller->$action();
|
|
|
|
// The action has been run
|
|
$controller->after($this->method);
|
|
|
|
if ($capture === TRUE)
|
|
return $this->response;
|
|
|
|
// Send the headers
|
|
$this->send_headers();
|
|
|
|
// Send the response
|
|
echo $this->response;
|
|
}
|
|
|
|
} // End Request
|