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

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']) ? ($_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');