vendor/contao/core-bundle/src/Resources/contao/library/Contao/Environment.php line 60

Open in your IDE?
  1. <?php
  3. /*
  4. * This file is part of Contao.
  5. *
  6. * (c) Leo Feyer
  7. *
  8. * @license LGPL-3.0-or-later
  9. */
  11. namespace Contao;
  13. /**
  14. * Reads the environment variables
  15. *
  16. * The class returns the environment variables (which are stored in the PHP
  17. * $_SERVER array) independent of the operating system.
  18. *
  19. * Usage:
  20. *
  21. * echo Environment::get('scriptName');
  22. * echo Environment::get('requestUri');
  23. */
  24. class Environment
  25. {
  26. /**
  27. * Object instance (Singleton)
  28. * @var Environment
  29. */
  30. protected static $objInstance;
  32. /**
  33. * The SAPI name
  34. * @var string
  35. */
  36. protected static $strSapi = \PHP_SAPI;
  38. /**
  39. * Cache
  40. * @var array
  41. */
  42. protected static $arrCache = array();
  44. /**
  45. * Return an environment variable
  46. *
  47. * @param string $strKey The variable name
  48. *
  49. * @return mixed The variable value
  50. */
  51. public static function get($strKey)
  52. {
  53. if (isset(static::$arrCache[$strKey]))
  54. {
  55. return static::$arrCache[$strKey];
  56. }
  58. if (\in_array($strKey, get_class_methods(self::class)))
  59. {
  60. static::$arrCache[$strKey] = static::$strKey();
  61. }
  62. else
  63. {
  64. $arrChunks = preg_split('/([A-Z][a-z]*)/', $strKey, -1, PREG_SPLIT_DELIM_CAPTURE|PREG_SPLIT_NO_EMPTY);
  65. $strServerKey = strtoupper(implode('_', $arrChunks));
  66. static::$arrCache[$strKey] = $_SERVER[$strServerKey] ?? null;
  67. }
  69. return static::$arrCache[$strKey];
  70. }
  72. /**
  73. * Set an environment variable
  74. *
  75. * @param string $strKey The variable name
  76. * @param mixed $varValue The variable value
  77. */
  78. public static function set($strKey, $varValue)
  79. {
  80. static::$arrCache[$strKey] = $varValue;
  81. }
  83. /**
  84. * Reset the internal cache
  85. */
  86. public static function reset()
  87. {
  88. static::$arrCache = array();
  89. }
  91. /**
  92. * Return the absolute path to the script (e.g. /home/www/html/website/index.php)
  93. *
  94. * @return string The absolute path to the script
  95. */
  96. protected static function scriptFilename()
  97. {
  98. return str_replace('//', '/', strtr((static::$strSapi == 'cgi' || static::$strSapi == 'isapi' || static::$strSapi == 'cgi-fcgi' || static::$strSapi == 'fpm-fcgi') && ($_SERVER['ORIG_PATH_TRANSLATED'] ?? $_SERVER['PATH_TRANSLATED'] ?? null) ? ($_SERVER['ORIG_PATH_TRANSLATED'] ?? $_SERVER['PATH_TRANSLATED']) : ($_SERVER['ORIG_SCRIPT_FILENAME'] ?? $_SERVER['SCRIPT_FILENAME'] ?? ''), '\\', '/'));
  99. }
  101. /**
  102. * Return the relative path to the script (e.g. /website/index.php)
  103. *
  104. * @return string The relative path to the script
  105. */
  106. protected static function scriptName()
  107. {
  108. $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  110. if ($request === null)
  111. {
  112. return $_SERVER['ORIG_SCRIPT_NAME'] ?? $_SERVER['SCRIPT_NAME'];
  113. }
  115. return $request->getScriptName();
  116. }
  118. /**
  119. * Alias for scriptName()
  120. *
  121. * @return string The script name
  122. */
  123. protected static function phpSelf()
  124. {
  125. return static::scriptName();
  126. }
  128. /**
  129. * Return the document root (e.g. /home/www/user/)
  130. *
  131. * Calculated as SCRIPT_FILENAME minus SCRIPT_NAME as some CGI versions
  132. * and mod-rewrite rules might return an incorrect DOCUMENT_ROOT.
  133. *
  134. * @return string The document root
  135. */
  136. protected static function documentRoot()
  137. {
  138. $strDocumentRoot = '';
  139. $arrUriSegments = array();
  140. $scriptName = static::get('scriptName');
  141. $scriptFilename = static::get('scriptFilename');
  143. // Fallback to DOCUMENT_ROOT if SCRIPT_FILENAME and SCRIPT_NAME point to different files
  144. if (basename($scriptName) != basename($scriptFilename))
  145. {
  146. return str_replace('//', '/', strtr(realpath($_SERVER['DOCUMENT_ROOT']), '\\', '/'));
  147. }
  149. if (0 === strncmp($scriptFilename, '/', 1))
  150. {
  151. $strDocumentRoot = '/';
  152. }
  154. $arrSnSegments = explode('/', strrev($scriptName));
  155. $arrSfnSegments = explode('/', strrev($scriptFilename));
  157. foreach ($arrSfnSegments as $k=>$v)
  158. {
  159. if (@$arrSnSegments[$k] != $v)
  160. {
  161. $arrUriSegments[] = $v;
  162. }
  163. }
  165. $strDocumentRoot .= strrev(implode('/', $arrUriSegments));
  167. if (\strlen($strDocumentRoot) < 2)
  168. {
  169. $strDocumentRoot = substr($scriptFilename, 0, -(\strlen($strDocumentRoot) + 1));
  170. }
  172. return str_replace('//', '/', strtr(realpath($strDocumentRoot), '\\', '/'));
  173. }
  175. /**
  176. * Return the query string (e.g. id=2)
  177. *
  178. * @return string The query string
  179. */
  180. protected static function queryString()
  181. {
  182. if (!isset($_SERVER['QUERY_STRING']))
  183. {
  184. return '';
  185. }
  187. return static::encodeRequestString($_SERVER['QUERY_STRING']);
  188. }
  190. /**
  191. * Return the request URI [path]?[query] (e.g. /contao/index.php?id=2)
  192. *
  193. * @return string The request URI
  194. */
  195. protected static function requestUri()
  196. {
  197. if (!empty($_SERVER['REQUEST_URI']))
  198. {
  199. $arrComponents = parse_url($_SERVER['REQUEST_URI']);
  201. if ($arrComponents === false)
  202. {
  203. $strRequest = $_SERVER['REQUEST_URI'];
  204. }
  205. else
  206. {
  207. $strRequest = ($arrComponents['path'] ?? '') . (isset($arrComponents['query']) ? '?' . $arrComponents['query'] : '');
  208. }
  209. }
  210. else
  211. {
  212. $strRequest = '/' . preg_replace('/^\//', '', static::get('scriptName')) . (!empty($_SERVER['QUERY_STRING']) ? '?' . $_SERVER['QUERY_STRING'] : '');
  213. }
  215. return static::encodeRequestString($strRequest);
  216. }
  218. /**
  219. * Return the first eight accepted languages as array
  220. *
  221. * @return array The languages array
  222. */
  223. protected static function httpAcceptLanguage()
  224. {
  225. $arrAccepted = array();
  226. $arrLanguages = array();
  228. // The implementation differs from the original implementation and also works with .jp browsers
  229. preg_match_all('/([a-z]{1,8}(-[a-z]{1,8})?)\s*(;\s*q\s*=\s*(1|0\.[0-9]+))?/i', $_SERVER['HTTP_ACCEPT_LANGUAGE'] ?? '', $arrAccepted);
  231. // Remove all invalid locales
  232. foreach ($arrAccepted[1] as $v)
  233. {
  234. $chunks = explode('-', $v);
  236. // Language plus dialect, e.g. en-US or fr-FR
  237. if (isset($chunks[1]))
  238. {
  239. $locale = $chunks[0] . '-' . strtoupper($chunks[1]);
  241. if (preg_match('/^[a-z]{2}(-[A-Z]{2})?$/', $locale))
  242. {
  243. $arrLanguages[] = $locale;
  244. }
  245. }
  247. $locale = $chunks[0];
  249. // Language only, e.g. en or fr (see #29)
  250. if (preg_match('/^[a-z]{2}$/', $locale))
  251. {
  252. $arrLanguages[] = $locale;
  253. }
  254. }
  256. return \array_slice(array_unique($arrLanguages), 0, 8);
  257. }
  259. /**
  260. * Return accepted encoding types as array
  261. *
  262. * @return array The encoding types array
  263. */
  264. protected static function httpAcceptEncoding()
  265. {
  266. return array_values(array_unique(explode(',', strtolower($_SERVER['HTTP_ACCEPT_ENCODING']))));
  267. }
  269. /**
  270. * Return the user agent as string
  271. *
  272. * @return string The user agent string
  273. */
  274. protected static function httpUserAgent()
  275. {
  276. if (!isset($_SERVER['HTTP_USER_AGENT']))
  277. {
  278. return '';
  279. }
  281. $ua = strip_tags($_SERVER['HTTP_USER_AGENT']);
  282. $ua = preg_replace('/javascript|vbscri?pt|script|applet|alert|document|write|cookie/i', '', $ua);
  284. return substr($ua, 0, 255);
  285. }
  287. /**
  288. * Return the HTTP Host
  289. *
  290. * @return string The host name
  291. */
  292. protected static function httpHost()
  293. {
  294. if (!empty($_SERVER['HTTP_HOST']))
  295. {
  296. $host = $_SERVER['HTTP_HOST'];
  297. }
  298. else
  299. {
  300. $host = $_SERVER['SERVER_NAME'] ?? null;
  302. if (($_SERVER['SERVER_PORT'] ?? 80) != 80)
  303. {
  304. $host .= ':' . $_SERVER['SERVER_PORT'];
  305. }
  306. }
  308. return preg_replace('/[^A-Za-z0-9[\].:_-]/', '', $host);
  309. }
  311. /**
  312. * Return the HTTP X-Forwarded-Host
  313. *
  314. * @return string The name of the X-Forwarded-Host
  315. */
  316. protected static function httpXForwardedHost()
  317. {
  318. if (!isset($_SERVER['HTTP_X_FORWARDED_HOST']))
  319. {
  320. return '';
  321. }
  323. return preg_replace('/[^A-Za-z0-9[\].:-]/', '', $_SERVER['HTTP_X_FORWARDED_HOST']);
  324. }
  326. /**
  327. * Return true if the current page was requested via an SSL connection
  328. *
  329. * @return boolean True if SSL is enabled
  330. */
  331. protected static function ssl()
  332. {
  333. $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  335. if ($request === null)
  336. {
  337. return false;
  338. }
  340. return $request->isSecure();
  341. }
  343. /**
  344. * Return the current URL without path or query string
  345. *
  346. * @return string The URL
  347. */
  348. protected static function url()
  349. {
  350. return (static::get('ssl') ? 'https://' : 'http://') . static::get('httpHost');
  351. }
  353. /**
  354. * Return the current URL with path or query string
  355. *
  356. * @return string The URL
  357. */
  358. protected static function uri()
  359. {
  360. return static::get('url') . static::get('requestUri');
  361. }
  363. /**
  364. * Return the real REMOTE_ADDR even if a proxy server is used
  365. *
  366. * @return string The IP address of the client
  367. */
  368. protected static function ip()
  369. {
  370. $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  372. if ($request === null)
  373. {
  374. return '';
  375. }
  377. return $request->getClientIp();
  378. }
  380. /**
  381. * Return the SERVER_ADDR
  382. *
  383. * @return string The IP address of the server
  384. */
  385. protected static function server()
  386. {
  387. $strServer = !empty($_SERVER['SERVER_ADDR']) ? $_SERVER['SERVER_ADDR'] : $_SERVER['LOCAL_ADDR'];
  389. // Special workaround for Strato users
  390. if (empty($strServer))
  391. {
  392. $strServer = @gethostbyname($_SERVER['SERVER_NAME']);
  393. }
  395. return $strServer;
  396. }
  398. /**
  399. * Return the relative path to the base directory (e.g. /path)
  400. *
  401. * @return string The relative path to the installation
  402. */
  403. protected static function path()
  404. {
  405. $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  407. if ($request === null)
  408. {
  409. return '';
  410. }
  412. return $request->getBasePath();
  413. }
  415. /**
  416. * Return the relative path to the script (e.g. index.php)
  417. *
  418. * @return string The relative path to the script
  419. */
  420. protected static function script()
  421. {
  422. return preg_replace('/^' . preg_quote(static::get('path'), '/') . '\/?/', '', static::get('scriptName'));
  423. }
  425. /**
  426. * Return the relative path to the script and include the request (e.g. index.php?id=2)
  427. *
  428. * @return string The relative path to the script including the request string
  429. */
  430. protected static function request()
  431. {
  432. return preg_replace('/^' . preg_quote(static::get('path'), '/') . '\/?/', '', static::get('requestUri'));
  433. }
  435. /**
  436. * Return the request string without the script name (e.g. en/news.html)
  437. *
  438. * @return string The base URL
  439. */
  440. protected static function relativeRequest()
  441. {
  442. return preg_replace('/^' . preg_quote(static::get('script'), '/') . '\/?/', '', static::get('request'));
  443. }
  445. /**
  446. * Return the request string without the index.php fragment
  447. *
  448. * @return string The request string without the index.php fragment
  449. */
  450. protected static function indexFreeRequest()
  451. {
  452. $strRequest = static::get('request');
  454. if ($strRequest == static::get('script'))
  455. {
  456. return '';
  457. }
  459. return $strRequest;
  460. }
  462. /**
  463. * Return the URL and path that can be used in a <base> tag
  464. *
  465. * @return string The base URL
  466. */
  467. protected static function base()
  468. {
  469. return static::get('url') . static::get('path') . '/';
  470. }
  472. /**
  473. * Return the host name
  474. *
  475. * @return string The host name
  476. */
  477. protected static function host()
  478. {
  479. return preg_replace('/:\d+$/', '', static::get('httpHost'));
  480. }
  482. /**
  483. * Return true on Ajax requests
  484. *
  485. * @return boolean True if it is an Ajax request
  486. */
  487. protected static function isAjaxRequest()
  488. {
  489. if (!isset($_SERVER['HTTP_X_REQUESTED_WITH']))
  490. {
  491. return false;
  492. }
  494. return $_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest';
  495. }
  497. /**
  498. * Return the operating system and the browser name and version
  499. *
  500. * @return object The agent information
  501. *
  502. * @deprecated Deprecated since Contao 4.13, to be removed in Contao 5.0.
  503. */
  504. protected static function agent()
  505. {
  506. trigger_deprecation('contao/core-bundle', '4.13', 'Using "%s::get(\'agent\')" has been deprecated and will no longer work in Contao 5.0.', __CLASS__);
  508. $ua = static::get('httpUserAgent');
  510. $return = new \stdClass();
  511. $return->string = $ua;
  513. $os = 'unknown';
  514. $mobile = false;
  515. $browser = 'other';
  516. $shorty = '';
  517. $version = '';
  518. $engine = '';
  520. // Operating system
  521. foreach (Config::get('os') as $k=>$v)
  522. {
  523. if (stripos($ua, $k) !== false)
  524. {
  525. $os = $v['os'];
  526. $mobile = $v['mobile'];
  527. break;
  528. }
  529. }
  531. $return->os = $os;
  533. // Browser and version
  534. foreach (Config::get('browser') as $k=>$v)
  535. {
  536. if (stripos($ua, $k) !== false)
  537. {
  538. $browser = $v['browser'];
  539. $shorty = $v['shorty'];
  540. $version = preg_replace($v['version'], '$1', $ua);
  541. $engine = $v['engine'];
  542. break;
  543. }
  544. }
  546. $versions = explode('.', $version);
  547. $version = $versions[0];
  549. $return->class = $os . ' ' . $browser . ' ' . $engine;
  551. // Add the version number if available
  552. if ($version)
  553. {
  554. $return->class .= ' ' . $shorty . $version;
  555. }
  557. // Android tablets are not mobile (see #4150 and #5869)
  558. if ($os == 'android' && $engine != 'presto' && stripos($ua, 'mobile') === false)
  559. {
  560. $mobile = false;
  561. }
  563. // Mark mobile devices
  564. if ($mobile)
  565. {
  566. $return->class .= ' mobile';
  567. }
  569. $return->browser = $browser;
  570. $return->shorty = $shorty;
  571. $return->version = $version;
  572. $return->engine = $engine;
  573. $return->versions = $versions;
  574. $return->mobile = $mobile;
  576. return $return;
  577. }
  579. /**
  580. * Encode a request string preserving certain reserved characters
  581. *
  582. * @param string $strRequest The request string
  583. *
  584. * @return string The encoded request string
  585. */
  586. protected static function encodeRequestString($strRequest)
  587. {
  588. return preg_replace_callback('/[^A-Za-z0-9\-_.~&=+,\/?%\[\]]+/', static function ($matches) { return rawurlencode($matches[0]); }, $strRequest);
  589. }
  591. /**
  592. * Prevent direct instantiation (Singleton)
  593. *
  594. * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  595. * The Environment class is now static.
  596. */
  597. protected function __construct()
  598. {
  599. }
  601. /**
  602. * Prevent cloning of the object (Singleton)
  603. *
  604. * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  605. * The Environment class is now static.
  606. */
  607. final public function __clone()
  608. {
  609. }
  611. /**
  612. * Return an environment variable
  613. *
  614. * @param string $strKey The variable name
  615. *
  616. * @return string The variable value
  617. *
  618. * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  619. * Use Environment::get() instead.
  620. */
  621. public function __get($strKey)
  622. {
  623. return static::get($strKey);
  624. }
  626. /**
  627. * Set an environment variable
  628. *
  629. * @param string $strKey The variable name
  630. * @param mixed $varValue The variable value
  631. *
  632. * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  633. * Use Environment::set() instead.
  634. */
  635. public function __set($strKey, $varValue)
  636. {
  637. static::set($strKey, $varValue);
  638. }
  640. /**
  641. * Return the object instance (Singleton)
  642. *
  643. * @return Environment The object instance
  644. *
  645. * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  646. * The Environment class is now static.
  647. */
  648. public static function getInstance()
  649. {
  650. trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Environment::getInstance()" has been deprecated and will no longer work in Contao 5.0. The "Contao\Environment" class is now static.');
  652. if (static::$objInstance === null)
  653. {
  654. static::$objInstance = new static();
  655. }
  657. return static::$objInstance;
  658. }
  659. }
  661. class_alias(Environment::class, 'Environment');