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

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];
  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']) ? ($_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.         $ua = strip_tags($_SERVER['HTTP_USER_AGENT']);
  277.         $ua = preg_replace('/javascript|vbscri?pt|script|applet|alert|document|write|cookie/i', '', $ua);
  279.         return substr($ua, 0, 255);
  280.     }
  282.     /**
  283.      * Return the HTTP Host
  284.      *
  285.      * @return string The host name
  286.      */
  287.     protected static function httpHost()
  288.     {
  289.         if (!empty($_SERVER['HTTP_HOST']))
  290.         {
  291.             $host = $_SERVER['HTTP_HOST'];
  292.         }
  293.         else
  294.         {
  295.             $host = $_SERVER['SERVER_NAME'] ?? null;
  297.             if (($_SERVER['SERVER_PORT'] ?? 80) != 80)
  298.             {
  299.                 $host .= ':' . $_SERVER['SERVER_PORT'];
  300.             }
  301.         }
  303.         return preg_replace('/[^A-Za-z0-9[\].:_-]/', '', $host);
  304.     }
  306.     /**
  307.      * Return the HTTP X-Forwarded-Host
  308.      *
  309.      * @return string The name of the X-Forwarded-Host
  310.      */
  311.     protected static function httpXForwardedHost()
  312.     {
  313.         if (!isset($_SERVER['HTTP_X_FORWARDED_HOST']))
  314.         {
  315.             return '';
  316.         }
  318.         return preg_replace('/[^A-Za-z0-9[\].:-]/', '', $_SERVER['HTTP_X_FORWARDED_HOST']);
  319.     }
  321.     /**
  322.      * Return true if the current page was requested via an SSL connection
  323.      *
  324.      * @return boolean True if SSL is enabled
  325.      */
  326.     protected static function ssl()
  327.     {
  328.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  330.         if ($request === null)
  331.         {
  332.             return false;
  333.         }
  335.         return $request->isSecure();
  336.     }
  338.     /**
  339.      * Return the current URL without path or query string
  340.      *
  341.      * @return string The URL
  342.      */
  343.     protected static function url()
  344.     {
  345.         return (static::get('ssl') ? 'https://' : 'http://') . static::get('httpHost');
  346.     }
  348.     /**
  349.      * Return the current URL with path or query string
  350.      *
  351.      * @return string The URL
  352.      */
  353.     protected static function uri()
  354.     {
  355.         return static::get('url') . static::get('requestUri');
  356.     }
  358.     /**
  359.      * Return the real REMOTE_ADDR even if a proxy server is used
  360.      *
  361.      * @return string The IP address of the client
  362.      */
  363.     protected static function ip()
  364.     {
  365.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  367.         if ($request === null)
  368.         {
  369.             return '';
  370.         }
  372.         return $request->getClientIp();
  373.     }
  375.     /**
  376.      * Return the SERVER_ADDR
  377.      *
  378.      * @return string The IP address of the server
  379.      */
  380.     protected static function server()
  381.     {
  382.         $strServer = !empty($_SERVER['SERVER_ADDR']) ? $_SERVER['SERVER_ADDR'] : $_SERVER['LOCAL_ADDR'];
  384.         // Special workaround for Strato users
  385.         if (empty($strServer))
  386.         {
  387.             $strServer = @gethostbyname($_SERVER['SERVER_NAME']);
  388.         }
  390.         return $strServer;
  391.     }
  393.     /**
  394.      * Return the relative path to the base directory (e.g. /path)
  395.      *
  396.      * @return string The relative path to the installation
  397.      */
  398.     protected static function path()
  399.     {
  400.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  402.         if ($request === null)
  403.         {
  404.             return '';
  405.         }
  407.         return $request->getBasePath();
  408.     }
  410.     /**
  411.      * Return the relative path to the script (e.g. index.php)
  412.      *
  413.      * @return string The relative path to the script
  414.      */
  415.     protected static function script()
  416.     {
  417.         return preg_replace('/^' . preg_quote(static::get('path'), '/') . '\/?/', '', static::get('scriptName'));
  418.     }
  420.     /**
  421.      * Return the relative path to the script and include the request (e.g. index.php?id=2)
  422.      *
  423.      * @return string The relative path to the script including the request string
  424.      */
  425.     protected static function request()
  426.     {
  427.         return preg_replace('/^' . preg_quote(static::get('path'), '/') . '\/?/', '', static::get('requestUri'));
  428.     }
  430.     /**
  431.      * Return the request string without the script name (e.g. en/news.html)
  432.      *
  433.      * @return string The base URL
  434.      */
  435.     protected static function relativeRequest()
  436.     {
  437.         return preg_replace('/^' . preg_quote(static::get('script'), '/') . '\/?/', '', static::get('request'));
  438.     }
  440.     /**
  441.      * Return the request string without the index.php fragment
  442.      *
  443.      * @return string The request string without the index.php fragment
  444.      */
  445.     protected static function indexFreeRequest()
  446.     {
  447.         $strRequest = static::get('request');
  449.         if ($strRequest == static::get('script'))
  450.         {
  451.             return '';
  452.         }
  454.         return $strRequest;
  455.     }
  457.     /**
  458.      * Return the URL and path that can be used in a <base> tag
  459.      *
  460.      * @return string The base URL
  461.      */
  462.     protected static function base()
  463.     {
  464.         return static::get('url') . static::get('path') . '/';
  465.     }
  467.     /**
  468.      * Return the host name
  469.      *
  470.      * @return string The host name
  471.      */
  472.     protected static function host()
  473.     {
  474.         return preg_replace('/:\d+$/', '', static::get('httpHost'));
  475.     }
  477.     /**
  478.      * Return true on Ajax requests
  479.      *
  480.      * @return boolean True if it is an Ajax request
  481.      */
  482.     protected static function isAjaxRequest()
  483.     {
  484.         if (!isset($_SERVER['HTTP_X_REQUESTED_WITH']))
  485.         {
  486.             return false;
  487.         }
  489.         return $_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest';
  490.     }
  492.     /**
  493.      * Return the operating system and the browser name and version
  494.      *
  495.      * @return object The agent information
  496.      *
  497.      * @deprecated Deprecated since Contao 4.13, to be removed in Contao 5.0.
  498.      */
  499.     protected static function agent()
  500.     {
  501.         trigger_deprecation('contao/core-bundle', '4.13', 'Using "%s::get(\'agent\')" has been deprecated and will no longer work in Contao 5.0.', __CLASS__);
  503.         $ua = static::get('httpUserAgent');
  505.         $return = new \stdClass();
  506.         $return->string = $ua;
  508.         $os = 'unknown';
  509.         $mobile = false;
  510.         $browser = 'other';
  511.         $shorty = '';
  512.         $version = '';
  513.         $engine = '';
  515.         // Operating system
  516.         foreach (Config::get('os') as $k=>$v)
  517.         {
  518.             if (stripos($ua, $k) !== false)
  519.             {
  520.                 $os = $v['os'];
  521.                 $mobile = $v['mobile'];
  522.                 break;
  523.             }
  524.         }
  526.         $return->os = $os;
  528.         // Browser and version
  529.         foreach (Config::get('browser') as $k=>$v)
  530.         {
  531.             if (stripos($ua, $k) !== false)
  532.             {
  533.                 $browser = $v['browser'];
  534.                 $shorty  = $v['shorty'];
  535.                 $version = preg_replace($v['version'], '$1', $ua);
  536.                 $engine  = $v['engine'];
  537.                 break;
  538.             }
  539.         }
  541.         $versions = explode('.', $version);
  542.         $version  = $versions[0];
  544.         $return->class = $os . ' ' . $browser . ' ' . $engine;
  546.         // Add the version number if available
  547.         if ($version)
  548.         {
  549.             $return->class .= ' ' . $shorty . $version;
  550.         }
  552.         // Android tablets are not mobile (see #4150 and #5869)
  553.         if ($os == 'android' && $engine != 'presto' && stripos($ua, 'mobile') === false)
  554.         {
  555.             $mobile = false;
  556.         }
  558.         // Mark mobile devices
  559.         if ($mobile)
  560.         {
  561.             $return->class .= ' mobile';
  562.         }
  564.         $return->browser  = $browser;
  565.         $return->shorty   = $shorty;
  566.         $return->version  = $version;
  567.         $return->engine   = $engine;
  568.         $return->versions = $versions;
  569.         $return->mobile   = $mobile;
  571.         return $return;
  572.     }
  574.     /**
  575.      * Encode a request string preserving certain reserved characters
  576.      *
  577.      * @param string $strRequest The request string
  578.      *
  579.      * @return string The encoded request string
  580.      */
  581.     protected static function encodeRequestString($strRequest)
  582.     {
  583.         return preg_replace_callback('/[^A-Za-z0-9\-_.~&=+,\/?%\[\]]+/', static function ($matches) { return rawurlencode($matches[0]); }, $strRequest);
  584.     }
  586.     /**
  587.      * Prevent direct instantiation (Singleton)
  588.      *
  589.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  590.      *             The Environment class is now static.
  591.      */
  592.     protected function __construct()
  593.     {
  594.     }
  596.     /**
  597.      * Prevent cloning of the object (Singleton)
  598.      *
  599.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  600.      *             The Environment class is now static.
  601.      */
  602.     final public function __clone()
  603.     {
  604.     }
  606.     /**
  607.      * Return an environment variable
  608.      *
  609.      * @param string $strKey The variable name
  610.      *
  611.      * @return string The variable value
  612.      *
  613.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  614.      *             Use Environment::get() instead.
  615.      */
  616.     public function __get($strKey)
  617.     {
  618.         return static::get($strKey);
  619.     }
  621.     /**
  622.      * Set an environment variable
  623.      *
  624.      * @param string $strKey   The variable name
  625.      * @param mixed  $varValue The variable value
  626.      *
  627.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  628.      *             Use Environment::set() instead.
  629.      */
  630.     public function __set($strKey, $varValue)
  631.     {
  632.         static::set($strKey, $varValue);
  633.     }
  635.     /**
  636.      * Return the object instance (Singleton)
  637.      *
  638.      * @return Environment The object instance
  639.      *
  640.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  641.      *             The Environment class is now static.
  642.      */
  643.     public static function getInstance()
  644.     {
  645.         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.');
  647.         if (static::$objInstance === null)
  648.         {
  649.             static::$objInstance = new static();
  650.         }
  652.         return static::$objInstance;
  653.     }
  654. }
  656. class_alias(Environment::class, 'Environment');