interface/modules/zend_modules/library/Zend/Http/PhpEnvironment/Request.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Http\PhpEnvironment;
  11
  12 use Zend\Http\Header\Cookie;
  13 use Zend\Http\Request as HttpRequest;
  14 use Zend\Stdlib\Parameters;
  15 use Zend\Stdlib\ParametersInterface;
  16 use Zend\Uri\Http as HttpUri;
  17 use Zend\Validator\Hostname as HostnameValidator;
  18
  19 /**
  20  * HTTP Request for current PHP environment
  21  */
  22 class Request extends HttpRequest
  23 {
  24     /**
  25      * Base URL of the application.
  26      *
  27      * @var string
  28      */
  29     protected $baseUrl;
  30
  31     /**
  32      * Base Path of the application.
  33      *
  34      * @var string
  35      */
  36     protected $basePath;
  37
  38     /**
  39      * Actual request URI, independent of the platform.
  40      *
  41      * @var string
  42      */
  43     protected $requestUri;
  44
  45     /**
  46      * PHP server params ($_SERVER)
  47      *
  48      * @var ParametersInterface
  49      */
  50     protected $serverParams = null;
  51
  52     /**
  53      * PHP environment params ($_ENV)
  54      *
  55      * @var ParametersInterface
  56      */
  57     protected $envParams = null;
  58
  59     /**
  60      * Construct
  61      * Instantiates request.
  62      */
  63     public function __construct()
  64     {
  65         $this->setEnv(new Parameters($_ENV));
  66
  67         if ($_GET) {
  68             $this->setQuery(new Parameters($_GET));
  69         }
  70         if ($_POST) {
  71             $this->setPost(new Parameters($_POST));
  72         }
  73         if ($_COOKIE) {
  74             $this->setCookies(new Parameters($_COOKIE));
  75         }
  76         if ($_FILES) {
  77             // convert PHP $_FILES superglobal
  78             $files = $this->mapPhpFiles();
  79             $this->setFiles(new Parameters($files));
  80         }
  81
  82         $this->setServer(new Parameters($_SERVER));
  83     }
  84
  85     /**
  86      * Get raw request body
  87      *
  88      * @return string
  89      */
  90     public function getContent()
  91     {
  92         if (empty($this->content)) {
  93             $requestBody = file_get_contents('php://input');
  94             if (strlen($requestBody) > 0) {
  95                 $this->content = $requestBody;
  96             }
  97         }
  98
  99         return $this->content;
 100     }
 101
 102     /**
 103      * Set cookies
 104      *
 105      * Instantiate and set cookies.
 106      *
 107      * @param $cookie
 108      * @return Request
 109      */
 110     public function setCookies($cookie)
 111     {
 112         $this->getHeaders()->addHeader(new Cookie((array) $cookie));
 113         return $this;
 114     }
 115
 116     /**
 117      * Set the request URI.
 118      *
 119      * @param  string $requestUri
 120      * @return self
 121      */
 122     public function setRequestUri($requestUri)
 123     {
 124         $this->requestUri = $requestUri;
 125         return $this;
 126     }
 127
 128     /**
 129      * Get the request URI.
 130      *
 131      * @return string
 132      */
 133     public function getRequestUri()
 134     {
 135         if ($this->requestUri === null) {
 136             $this->requestUri = $this->detectRequestUri();
 137         }
 138         return $this->requestUri;
 139     }
 140
 141     /**
 142      * Set the base URL.
 143      *
 144      * @param  string $baseUrl
 145      * @return self
 146      */
 147     public function setBaseUrl($baseUrl)
 148     {
 149         $this->baseUrl = rtrim($baseUrl, '/');
 150         return $this;
 151     }
 152
 153     /**
 154      * Get the base URL.
 155      *
 156      * @return string
 157      */
 158     public function getBaseUrl()
 159     {
 160         if ($this->baseUrl === null) {
 161             $this->setBaseUrl($this->detectBaseUrl());
 162         }
 163         return $this->baseUrl;
 164     }
 165
 166     /**
 167      * Set the base path.
 168      *
 169      * @param  string $basePath
 170      * @return self
 171      */
 172     public function setBasePath($basePath)
 173     {
 174         $this->basePath = rtrim($basePath, '/');
 175         return $this;
 176     }
 177
 178     /**
 179      * Get the base path.
 180      *
 181      * @return string
 182      */
 183     public function getBasePath()
 184     {
 185         if ($this->basePath === null) {
 186             $this->setBasePath($this->detectBasePath());
 187         }
 188
 189         return $this->basePath;
 190     }
 191
 192     /**
 193      * Provide an alternate Parameter Container implementation for server parameters in this object,
 194      * (this is NOT the primary API for value setting, for that see getServer())
 195      *
 196      * @param  ParametersInterface $server
 197      * @return Request
 198      */
 199     public function setServer(ParametersInterface $server)
 200     {
 201         $this->serverParams = $server;
 202
 203         // This seems to be the only way to get the Authorization header on Apache
 204         if (function_exists('apache_request_headers')) {
 205             $apacheRequestHeaders = apache_request_headers();
 206             if (!isset($this->serverParams['HTTP_AUTHORIZATION'])) {
 207                 if (isset($apacheRequestHeaders['Authorization'])) {
 208                     $this->serverParams->set('HTTP_AUTHORIZATION', $apacheRequestHeaders['Authorization']);
 209                 } elseif (isset($apacheRequestHeaders['authorization'])) {
 210                     $this->serverParams->set('HTTP_AUTHORIZATION', $apacheRequestHeaders['authorization']);
 211                 }
 212             }
 213         }
 214
 215         // set headers
 216         $headers = array();
 217
 218         foreach ($server as $key => $value) {
 219             if ($value && strpos($key, 'HTTP_') === 0) {
 220                 if (strpos($key, 'HTTP_COOKIE') === 0) {
 221                     // Cookies are handled using the $_COOKIE superglobal
 222                     continue;
 223                 }
 224                 $name = strtr(substr($key, 5), '_', ' ');
 225                 $name = strtr(ucwords(strtolower($name)), ' ', '-');
 226             } elseif ($value && strpos($key, 'CONTENT_') === 0) {
 227                 $name = substr($key, 8); // Content-
 228                 $name = 'Content-' . (($name == 'MD5') ? $name : ucfirst(strtolower($name)));
 229             } else {
 230                 continue;
 231             }
 232
 233             $headers[$name] = $value;
 234         }
 235
 236         $this->getHeaders()->addHeaders($headers);
 237
 238         // set method
 239         if (isset($this->serverParams['REQUEST_METHOD'])) {
 240             $this->setMethod($this->serverParams['REQUEST_METHOD']);
 241         }
 242
 243         // set HTTP version
 244         if (isset($this->serverParams['SERVER_PROTOCOL'])
 245             && strpos($this->serverParams['SERVER_PROTOCOL'], self::VERSION_10) !== false
 246         ) {
 247             $this->setVersion(self::VERSION_10);
 248         }
 249
 250         // set URI
 251         $uri = new HttpUri();
 252
 253         // URI scheme
 254         $scheme = (!empty($this->serverParams['HTTPS'])
 255                    && $this->serverParams['HTTPS'] !== 'off') ? 'https' : 'http';
 256         $uri->setScheme($scheme);
 257
 258         // URI host & port
 259         $host = null;
 260         $port = null;
 261
 262         // Set the host
 263         if ($this->getHeaders()->get('host')) {
 264             $host = $this->getHeaders()->get('host')->getFieldValue();
 265
 266             // works for regname, IPv4 & IPv6
 267             if (preg_match('|\:(\d+)$|', $host, $matches)) {
 268                 $host = substr($host, 0, -1 * (strlen($matches[1]) + 1));
 269                 $port = (int) $matches[1];
 270             }
 271
 272             // set up a validator that check if the hostname is legal (not spoofed)
 273             $hostnameValidator = new HostnameValidator(array(
 274                 'allow'       => HostnameValidator::ALLOW_ALL,
 275                 'useIdnCheck' => false,
 276                 'useTldCheck' => false,
 277             ));
 278             // If invalid. Reset the host & port
 279             if (!$hostnameValidator->isValid($host)) {
 280                 $host = null;
 281                 $port = null;
 282             }
 283         }
 284
 285         if (!$host && isset($this->serverParams['SERVER_NAME'])) {
 286             $host = $this->serverParams['SERVER_NAME'];
 287             if (isset($this->serverParams['SERVER_PORT'])) {
 288                 $port = (int) $this->serverParams['SERVER_PORT'];
 289             }
 290             // Check for missinterpreted IPv6-Address
 291             // Reported at least for Safari on Windows
 292             if (isset($this->serverParams['SERVER_ADDR']) && preg_match('/^\[[0-9a-fA-F\:]+\]$/', $host)) {
 293                 $host = '[' . $this->serverParams['SERVER_ADDR'] . ']';
 294                 if ($port . ']' == substr($host, strrpos($host, ':')+1)) {
 295                     // The last digit of the IPv6-Address has been taken as port
 296                     // Unset the port so the default port can be used
 297                     $port = null;
 298                 }
 299             }
 300         }
 301         $uri->setHost($host);
 302         $uri->setPort($port);
 303
 304         // URI path
 305         $requestUri = $this->getRequestUri();
 306         if (($qpos = strpos($requestUri, '?')) !== false) {
 307             $requestUri = substr($requestUri, 0, $qpos);
 308         }
 309
 310         $uri->setPath($requestUri);
 311
 312         // URI query
 313         if (isset($this->serverParams['QUERY_STRING'])) {
 314             $uri->setQuery($this->serverParams['QUERY_STRING']);
 315         }
 316
 317         $this->setUri($uri);
 318
 319         return $this;
 320     }
 321
 322     /**
 323      * Return the parameter container responsible for server parameters or a single parameter value.
 324      *
 325      * @param string|null           $name            Parameter name to retrieve, or null to get the whole container.
 326      * @param mixed|null            $default         Default value to use when the parameter is missing.
 327      * @see http://www.faqs.org/rfcs/rfc3875.html
 328      * @return \Zend\Stdlib\ParametersInterface|mixed
 329      */
 330     public function getServer($name = null, $default = null)
 331     {
 332         if ($this->serverParams === null) {
 333             $this->serverParams = new Parameters();
 334         }
 335
 336         if ($name === null) {
 337             return $this->serverParams;
 338         }
 339
 340         return $this->serverParams->get($name, $default);
 341     }
 342
 343     /**
 344      * Provide an alternate Parameter Container implementation for env parameters in this object,
 345      * (this is NOT the primary API for value setting, for that see env())
 346      *
 347      * @param  ParametersInterface $env
 348      * @return Request
 349      */
 350     public function setEnv(ParametersInterface $env)
 351     {
 352         $this->envParams = $env;
 353         return $this;
 354     }
 355
 356     /**
 357      * Return the parameter container responsible for env parameters or a single parameter value.
 358      *
 359      * @param string|null           $name            Parameter name to retrieve, or null to get the whole container.
 360      * @param mixed|null            $default         Default value to use when the parameter is missing.     * @return \Zend\Stdlib\ParametersInterface
 361      * @return \Zend\Stdlib\ParametersInterface|mixed
 362      */
 363     public function getEnv($name = null, $default = null)
 364     {
 365         if ($this->envParams === null) {
 366             $this->envParams = new Parameters();
 367         }
 368
 369         if ($name === null) {
 370             return $this->envParams;
 371         }
 372
 373         return $this->envParams->get($name, $default);
 374     }
 375
 376     /**
 377      * Convert PHP superglobal $_FILES into more sane parameter=value structure
 378      * This handles form file input with brackets (name=files[])
 379      *
 380      * @return array
 381      */
 382     protected function mapPhpFiles()
 383     {
 384         $files = array();
 385         foreach ($_FILES as $fileName => $fileParams) {
 386             $files[$fileName] = array();
 387             foreach ($fileParams as $param => $data) {
 388                 if (!is_array($data)) {
 389                     $files[$fileName][$param] = $data;
 390                 } else {
 391                     foreach ($data as $i => $v) {
 392                         $this->mapPhpFileParam($files[$fileName], $param, $i, $v);
 393                     }
 394                 }
 395             }
 396         }
 397
 398         return $files;
 399     }
 400
 401     /**
 402      * @param array        $array
 403      * @param string       $paramName
 404      * @param int|string   $index
 405      * @param string|array $value
 406      */
 407     protected function mapPhpFileParam(&$array, $paramName, $index, $value)
 408     {
 409         if (!is_array($value)) {
 410             $array[$index][$paramName] = $value;
 411         } else {
 412             foreach ($value as $i => $v) {
 413                 $this->mapPhpFileParam($array[$index], $paramName, $i, $v);
 414             }
 415         }
 416     }
 417
 418     /**
 419      * Detect the base URI for the request
 420      *
 421      * Looks at a variety of criteria in order to attempt to autodetect a base
 422      * URI, including rewrite URIs, proxy URIs, etc.
 423      *
 424      * @return string
 425      */
 426     protected function detectRequestUri()
 427     {
 428         $requestUri = null;
 429         $server     = $this->getServer();
 430
 431         // Check this first so IIS will catch.
 432         $httpXRewriteUrl = $server->get('HTTP_X_REWRITE_URL');
 433         if ($httpXRewriteUrl !== null) {
 434             $requestUri = $httpXRewriteUrl;
 435         }
 436
 437         // Check for IIS 7.0 or later with ISAPI_Rewrite
 438         $httpXOriginalUrl = $server->get('HTTP_X_ORIGINAL_URL');
 439         if ($httpXOriginalUrl !== null) {
 440             $requestUri = $httpXOriginalUrl;
 441         }
 442
 443         // IIS7 with URL Rewrite: make sure we get the unencoded url
 444         // (double slash problem).
 445         $iisUrlRewritten = $server->get('IIS_WasUrlRewritten');
 446         $unencodedUrl    = $server->get('UNENCODED_URL', '');
 447         if ('1' == $iisUrlRewritten && '' !== $unencodedUrl) {
 448             return $unencodedUrl;
 449         }
 450
 451         // HTTP proxy requests setup request URI with scheme and host [and port]
 452         // + the URL path, only use URL path.
 453         if (!$httpXRewriteUrl) {
 454             $requestUri = $server->get('REQUEST_URI');
 455         }
 456
 457         if ($requestUri !== null) {
 458             return preg_replace('#^[^/:]+://[^/]+#', '', $requestUri);
 459         }
 460
 461         // IIS 5.0, PHP as CGI.
 462         $origPathInfo = $server->get('ORIG_PATH_INFO');
 463         if ($origPathInfo !== null) {
 464             $queryString = $server->get('QUERY_STRING', '');
 465             if ($queryString !== '') {
 466                 $origPathInfo .= '?' . $queryString;
 467             }
 468             return $origPathInfo;
 469         }
 470
 471         return '/';
 472     }
 473
 474     /**
 475      * Auto-detect the base path from the request environment
 476      *
 477      * Uses a variety of criteria in order to detect the base URL of the request
 478      * (i.e., anything additional to the document root).
 479      *
 480      *
 481      * @return string
 482      */
 483     protected function detectBaseUrl()
 484     {
 485         $baseUrl        = '';
 486         $filename       = $this->getServer()->get('SCRIPT_FILENAME', '');
 487         $scriptName     = $this->getServer()->get('SCRIPT_NAME');
 488         $phpSelf        = $this->getServer()->get('PHP_SELF');
 489         $origScriptName = $this->getServer()->get('ORIG_SCRIPT_NAME');
 490
 491         if ($scriptName !== null && basename($scriptName) === $filename) {
 492             $baseUrl = $scriptName;
 493         } elseif ($phpSelf !== null && basename($phpSelf) === $filename) {
 494             $baseUrl = $phpSelf;
 495         } elseif ($origScriptName !== null && basename($origScriptName) === $filename) {
 496             // 1and1 shared hosting compatibility.
 497             $baseUrl = $origScriptName;
 498         } else {
 499             // Backtrack up the SCRIPT_FILENAME to find the portion
 500             // matching PHP_SELF.
 501
 502             $baseUrl  = '/';
 503             $basename = basename($filename);
 504             if ($basename) {
 505                 $path     = ($phpSelf ? trim($phpSelf, '/') : '');
 506                 $baseUrl .= substr($path, 0, strpos($path, $basename)) . $basename;
 507             }
 508         }
 509
 510         // Does the base URL have anything in common with the request URI?
 511         $requestUri = $this->getRequestUri();
 512
 513         // Full base URL matches.
 514         if (0 === strpos($requestUri, $baseUrl)) {
 515             return $baseUrl;
 516         }
 517
 518         // Directory portion of base path matches.
 519         $baseDir = str_replace('\\', '/', dirname($baseUrl));
 520         if (0 === strpos($requestUri, $baseDir)) {
 521             return $baseDir;
 522         }
 523
 524         $truncatedRequestUri = $requestUri;
 525
 526         if (false !== ($pos = strpos($requestUri, '?'))) {
 527             $truncatedRequestUri = substr($requestUri, 0, $pos);
 528         }
 529
 530         $basename = basename($baseUrl);
 531
 532         // No match whatsoever
 533         if (empty($basename) || false === strpos($truncatedRequestUri, $basename)) {
 534             return '';
 535         }
 536
 537         // If using mod_rewrite or ISAPI_Rewrite strip the script filename
 538         // out of the base path. $pos !== 0 makes sure it is not matching a
 539         // value from PATH_INFO or QUERY_STRING.
 540         if (strlen($requestUri) >= strlen($baseUrl)
 541             && (false !== ($pos = strpos($requestUri, $baseUrl)) && $pos !== 0)
 542         ) {
 543             $baseUrl = substr($requestUri, 0, $pos + strlen($baseUrl));
 544         }
 545
 546         return $baseUrl;
 547     }
 548
 549     /**
 550      * Autodetect the base path of the request
 551      *
 552      * Uses several criteria to determine the base path of the request.
 553      *
 554      * @return string
 555      */
 556     protected function detectBasePath()
 557     {
 558         $filename = basename($this->getServer()->get('SCRIPT_FILENAME', ''));
 559         $baseUrl  = $this->getBaseUrl();
 560
 561         // Empty base url detected
 562         if ($baseUrl === '') {
 563             return '';
 564         }
 565
 566         // basename() matches the script filename; return the directory
 567         if (basename($baseUrl) === $filename) {
 568             return str_replace('\\', '/', dirname($baseUrl));
 569         }
 570
 571         // Base path is identical to base URL
 572         return $baseUrl;
 573     }
 574 }