Request.php

Go to the documentation of this file.

<?php
namespace Elgg\Http;
 
class Request {
    public $query;
 
    public $request;
 
    public $cookies;
 
    public $files;
 
    public $server;
 
    public $headers;
 
    protected $baseUrl = null;
 
    protected $requestUri = null;
 
    protected $pathInfo = null;
 
    public function __construct(array $query = array(), array $request = array(),
            array $cookies = array(), array $files = array(), array $server = array()) {
        $this->initialize($query, $request, $cookies, $files, $server);
    }
 
    protected function initialize(array $query = array(), array $request = array(),
            array $cookies = array(), array $files = array(), array $server = array()) {
        $this->query = new \Elgg\Http\ParameterBag($this->stripSlashesIfMagicQuotes($query));
        $this->request = new \Elgg\Http\ParameterBag($this->stripSlashesIfMagicQuotes($request));
        $this->cookies = new \Elgg\Http\ParameterBag($this->stripSlashesIfMagicQuotes($cookies));
        // Symfony uses FileBag so this will change in next Elgg version
        $this->files = new \Elgg\Http\ParameterBag($files);
        $this->server = new \Elgg\Http\ParameterBag($server);
    
        $headers = $this->prepareHeaders();
        // Symfony uses HeaderBag so this will change in next Elgg version
        $this->headers = new \Elgg\Http\ParameterBag($headers);
    }
 
    public static function createFromGlobals() {
        return new \Elgg\Http\Request($_GET, $_POST, $_COOKIE, $_FILES, $_SERVER);
    }
 
    public static function create($uri, $method = 'GET', $parameters = array(), $cookies = array(), $files = array(), $server = array()) {
        $server = array_merge(array(
            'SERVER_NAME' => 'localhost',
            'SERVER_PORT' => 80,
            'HTTP_HOST' => 'localhost',
            'HTTP_USER_AGENT' => 'Symfony/2.X',
            'HTTP_ACCEPT' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            'HTTP_ACCEPT_LANGUAGE' => 'en-us,en;q=0.5',
            'HTTP_ACCEPT_CHARSET' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
            'REMOTE_ADDR' => '127.0.0.1',
            'SCRIPT_NAME' => '',
            'SCRIPT_FILENAME' => '',
            'SERVER_PROTOCOL' => 'HTTP/1.1',
            'REQUEST_TIME' => time(),
        ), $server);
 
        $server['PATH_INFO'] = '';
        $server['REQUEST_METHOD'] = strtoupper($method);
 
        $components = parse_url($uri);
        if (isset($components['host'])) {
            $server['SERVER_NAME'] = $components['host'];
            $server['HTTP_HOST'] = $components['host'];
        }
 
        if (isset($components['scheme'])) {
            if ('https' === $components['scheme']) {
                $server['HTTPS'] = 'on';
                $server['SERVER_PORT'] = 443;
            } else {
                unset($server['HTTPS']);
                $server['SERVER_PORT'] = 80;
            }
        }
 
        if (isset($components['port'])) {
            $server['SERVER_PORT'] = $components['port'];
            $server['HTTP_HOST'] = $server['HTTP_HOST'] . ':' . $components['port'];
        }
 
        if (!isset($components['path'])) {
            $components['path'] = '/';
        }
 
        switch (strtoupper($method)) {
            case 'POST':
            case 'PUT':
            case 'DELETE':
                if (!isset($server['CONTENT_TYPE'])) {
                    $server['CONTENT_TYPE'] = 'application/x-www-form-urlencoded';
                }
            case 'PATCH':
                $request = $parameters;
                $query = array();
                break;
            default:
                $request = array();
                $query = $parameters;
                break;
        }
 
        if (isset($components['query'])) {
            parse_str(html_entity_decode($components['query']), $qs);
            // original uses array_replace. using array_merge for 5.2 BC
            $query = array_merge($qs, $query);
        }
        $queryString = http_build_query($query, '', '&');
 
        $server['REQUEST_URI'] = $components['path'] . ('' !== $queryString ? '?' . $queryString : '');
        $server['QUERY_STRING'] = $queryString;
 
        return new \Elgg\Http\Request($query, $request, $cookies, $files, $server);
    }
 
    public static function normalizeQueryString($qs) {
        if ('' == $qs) {
            return '';
        }
 
        $parts = array();
        $order = array();
 
        foreach (explode('&', $qs) as $param) {
            if ('' === $param || '=' === $param[0]) {
                // Ignore useless delimiters, e.g. "x=y&".
                // Also ignore pairs with empty key, even if there was a value, e.g. "=value",
                // as such nameless values cannot be retrieved anyway.
                // PHP also does not include them when building _GET.
                continue;
            }
 
            $keyValuePair = explode('=', $param, 2);
 
            // GET parameters, that are submitted from a HTML form,
            // encode spaces as "+" by default (as defined in enctype application/x-www-form-urlencoded).
            // PHP also converts "+" to spaces when filling the global _GET or
            // when using the function parse_str. This is why we use urldecode and then normalize to
            // RFC 3986 with rawurlencode.
            $parts[] = isset($keyValuePair[1]) ?
                    rawurlencode(urldecode($keyValuePair[0])) . '=' . rawurlencode(urldecode($keyValuePair[1])) :
                    rawurlencode(urldecode($keyValuePair[0]));
            $order[] = urldecode($keyValuePair[0]);
        }
 
        array_multisort($order, SORT_ASC, $parts);
 
        return implode('&', $parts);
    }
 
    public function get($key, $default = null) {
        if ($this->query->has($key)) {
            return $this->query->get($key);
        } else if ($this->request->has($key)) {
            return $this->request->get($key);
        } else {
            return $default;
        }
    }
 
    public function getRequestUri() {
        if (null === $this->requestUri) {
            $this->requestUri = $this->prepareRequestUri();
        }
 
        return $this->requestUri;
    }
 
    public function getUri() {
        if (null !== $qs = $this->getQueryString()) {
            $qs = '?' . $qs;
        }
 
        return $this->getSchemeAndHttpHost() . $this->getBaseUrl() . $this->getPathInfo() . $qs;
    }
 
    public function getSchemeAndHttpHost() {
        return $this->getScheme() . '://' . $this->getHttpHost();
    }
 
    public function getScheme() {
        return $this->isSecure() ? 'https' : 'http';
    }
 
    public function getHttpHost() {
        $scheme = $this->getScheme();
        $port = $this->getPort();
 
        if (('http' == $scheme && $port == 80) || ('https' == $scheme && $port == 443)) {
            return $this->getHost();
        }
 
        return $this->getHost() . ':' . $port;
    }
 
    public function getHost() {
        if (!$host = $this->headers->get('HOST')) {
            if (!$host = $this->server->get('SERVER_NAME')) {
                $host = $this->server->get('SERVER_ADDR', '');
            }
        }
 
        // trim and remove port number from host
        // host is lowercase as per RFC 952/2181
        $host = strtolower(preg_replace('/:\d+$/', '', trim($host)));
 
        // as the host can come from the user (HTTP_HOST and depending on the configuration,
        // SERVER_NAME too can come from the user)
        // check that it does not contain forbidden characters (see RFC 952 and RFC 2181)
        if ($host && !preg_match('/^\[?(?:[a-zA-Z0-9-:\]_]+\.?)+$/', $host)) {
            throw new \UnexpectedValueException('Invalid Host');
        }
 
        return $host;
    }
 
    public function isSecure() {
        return 'on' == strtolower($this->server->get('HTTPS')) || 1 == $this->server->get('HTTPS');
    }
 
    public function getPort() {
        return $this->server->get('SERVER_PORT');
    }
 
    public function getBaseUrl() {
        if (null === $this->baseUrl) {
            $this->baseUrl = $this->prepareBaseUrl();
        }
 
        return $this->baseUrl;
    }
 
    public function getPathInfo() {
        if (null === $this->pathInfo) {
            $this->pathInfo = $this->preparePathInfo();
        }
 
        return $this->pathInfo;
    }
 
    public function getQueryString() {
        $qs = \Elgg\Http\Request::normalizeQueryString($this->server->get('QUERY_STRING'));
 
        return '' === $qs ? null : $qs;
    }
 
    public function getUrlSegments() {
        $path = trim($this->query->get('__elgg_uri'), '/');
        if (!$path) {
            return array();
        }
 
        return explode('/', $path);
    }
 
    public function getFirstUrlSegment() {
        $segments = $this->getUrlSegments();
        if ($segments) {
            return array_shift($segments);
        } else {
            return '';
        }
    }
 
    public function getClientIp() {
        $server = $this->server;
 
        $ip_address = $server->get('HTTP_X_FORWARDED_FOR');
        if (!empty($ip_address)) {
            return array_pop(explode(',', $ip_address));
        }
 
        $ip_address = $server->get('HTTP_X_REAL_IP');
        if (!empty($ip_address)) {
            return array_pop(explode(',', $ip_address));
        }
 
        return $server->get('REMOTE_ADDR');
    }
 
    public function isXmlHttpRequest() {
        return $this->headers->get('X-Requested-With') == 'XMLHttpRequest' ||
            $this->get('X-Requested-With') === 'XMLHttpRequest';
    }
 
    protected function stripSlashesIfMagicQuotes($data) {
        if (get_magic_quotes_gpc()) {
            return _elgg_stripslashes_deep($data);
        } else {
            return $data;
        }
    }
 
    protected function prepareHeaders() {
        $headers = array();
        $contentHeaders = array('CONTENT_LENGTH' => true, 'CONTENT_MD5' => true, 'CONTENT_TYPE' => true);
        foreach ($this->server as $key => $value) {
            if (0 === strpos($key, 'HTTP_')) {
                $key = strtr(strtolower(substr($key, 5)), '_', '-');
                $key = implode('-', array_map('ucfirst', explode('-', $key)));
                $headers[$key] = $value;
            } elseif (isset($contentHeaders[$key])) {
                $key = strtr(strtolower($key), '_', '-');
                $key = implode('-', array_map('ucfirst', explode('-', $key)));
                $headers[$key] = $value;
            }
        }
 
        return $headers;
    }
 
    protected function prepareRequestUri() {
        return $this->server->get('REQUEST_URI');
    }
 
    protected function prepareBaseUrl() {
        $filename = basename($this->server->get('SCRIPT_FILENAME'));
 
        if (basename($this->server->get('SCRIPT_NAME')) === $filename) {
            $baseUrl = $this->server->get('SCRIPT_NAME');
        } elseif (basename($this->server->get('PHP_SELF')) === $filename) {
            $baseUrl = $this->server->get('PHP_SELF');
        } elseif (basename($this->server->get('ORIG_SCRIPT_NAME')) === $filename) {
            $baseUrl = $this->server->get('ORIG_SCRIPT_NAME'); // 1and1 shared hosting compatibility
        } else {
            // Backtrack up the script_filename to find the portion matching
            // php_self
            $path = $this->server->get('PHP_SELF', '');
            $file = $this->server->get('SCRIPT_FILENAME', '');
            $segs = explode('/', trim($file, '/'));
            $segs = array_reverse($segs);
            $index = 0;
            $last = count($segs);
            $baseUrl = '';
            do {
                $seg = $segs[$index];
                $baseUrl = '/' . $seg . $baseUrl;
                ++$index;
            } while (($last > $index) && (false !== ($pos = strpos($path, $baseUrl))) && (0 != $pos));
        }
 
        // Does the baseUrl have anything in common with the request_uri?
        $requestUri = $this->getRequestUri();
 
        if ($baseUrl && false !== $prefix = $this->getUrlencodedPrefix($requestUri, $baseUrl)) {
            // full $baseUrl matches
            return $prefix;
        }
 
        if ($baseUrl && false !== $prefix = $this->getUrlencodedPrefix($requestUri, dirname($baseUrl))) {
            // directory portion of $baseUrl matches
            return rtrim($prefix, '/');
        }
 
        $truncatedRequestUri = $requestUri;
        if (($pos = strpos($requestUri, '?')) !== false) {
            $truncatedRequestUri = substr($requestUri, 0, $pos);
        }
 
        $basename = basename($baseUrl);
        if (empty($basename) || !strpos(rawurldecode($truncatedRequestUri), $basename)) {
            // no match whatsoever; set it blank
            return '';
        }
 
        // If using mod_rewrite or ISAPI_Rewrite strip the script filename
        // out of baseUrl. $pos !== 0 makes sure it is not matching a value
        // from PATH_INFO or QUERY_STRING
        if ((strlen($requestUri) >= strlen($baseUrl)) && ((false !== ($pos = strpos($requestUri, $baseUrl))) && ($pos !== 0))) {
            $baseUrl = substr($requestUri, 0, $pos + strlen($baseUrl));
        }
 
        return rtrim($baseUrl, '/');
    }
 
    protected function preparePathInfo() {
        $baseUrl = $this->getBaseUrl();
 
        if (null === ($requestUri = $this->getRequestUri())) {
            return '/';
        }
 
        $pathInfo = '/';
 
        // Remove the query string from REQUEST_URI
        if ($pos = strpos($requestUri, '?')) {
            $requestUri = substr($requestUri, 0, $pos);
        }
 
        if ((null !== $baseUrl) && (false === ($pathInfo = substr($requestUri, strlen($baseUrl))))) {
            // If substr() returns false then PATH_INFO is set to an empty string
            return '/';
        } elseif (null === $baseUrl) {
            return $requestUri;
        }
 
        return (string) $pathInfo;
    }
 
    private function getUrlencodedPrefix($string, $prefix) {
        if (0 !== strpos(rawurldecode($string), $prefix)) {
            return false;
        }
 
        $len = strlen($prefix);
 
        if (preg_match("#^(%[[:xdigit:]]{2}|.){{$len}}#", $string, $match)) {
            return $match[0];
        }
 
        return false;
    }
 
}