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

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.  * @author Leo Feyer <https://github.com/leofeyer>
  25.  */
  26. class Environment
  27. {
  28.     /**
  29.      * Object instance (Singleton)
  30.      * @var Environment
  31.      */
  32.     protected static $objInstance;
  34.     /**
  35.      * The SAPI name
  36.      * @var string
  37.      */
  38.     protected static $strSapi = \PHP_SAPI;
  40.     /**
  41.      * Cache
  42.      * @var array
  43.      */
  44.     protected static $arrCache = array();
  46.     /**
  47.      * Return an environment variable
  48.      *
  49.      * @param string $strKey The variable name
  50.      *
  51.      * @return mixed The variable value
  52.      */
  53.     public static function get($strKey)
  54.     {
  55.         if (isset(static::$arrCache[$strKey]))
  56.         {
  57.             return static::$arrCache[$strKey];
  58.         }
  60.         if (\in_array($strKey, get_class_methods(self::class)))
  61.         {
  62.             static::$arrCache[$strKey] = static::$strKey();
  63.         }
  64.         else
  65.         {
  66.             $arrChunks = preg_split('/([A-Z][a-z]*)/', $strKey, -1, PREG_SPLIT_DELIM_CAPTURE|PREG_SPLIT_NO_EMPTY);
  67.             $strServerKey = strtoupper(implode('_', $arrChunks));
  68.             static::$arrCache[$strKey] = $_SERVER[$strServerKey];
  69.         }
  71.         return static::$arrCache[$strKey];
  72.     }
  74.     /**
  75.      * Set an environment variable
  76.      *
  77.      * @param string $strKey   The variable name
  78.      * @param mixed  $varValue The variable value
  79.      */
  80.     public static function set($strKey, $varValue)
  81.     {
  82.         static::$arrCache[$strKey] = $varValue;
  83.     }
  85.     /**
  86.      * Reset the internal cache
  87.      */
  88.     public static function reset()
  89.     {
  90.         static::$arrCache = array();
  91.     }
  93.     /**
  94.      * Return the absolute path to the script (e.g. /home/www/html/website/index.php)
  95.      *
  96.      * @return string The absolute path to the script
  97.      */
  98.     protected static function scriptFilename()
  99.     {
  100.         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']), '\\', '/'));
  101.     }
  103.     /**
  104.      * Return the relative path to the script (e.g. /website/index.php)
  105.      *
  106.      * @return string The relative path to the script
  107.      */
  108.     protected static function scriptName()
  109.     {
  110.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  112.         if ($request === null)
  113.         {
  114.             return $_SERVER['ORIG_SCRIPT_NAME'] ?? $_SERVER['SCRIPT_NAME'];
  115.         }
  117.         return $request->getScriptName();
  118.     }
  120.     /**
  121.      * Alias for scriptName()
  122.      *
  123.      * @return string The script name
  124.      */
  125.     protected static function phpSelf()
  126.     {
  127.         return static::scriptName();
  128.     }
  130.     /**
  131.      * Return the document root (e.g. /home/www/user/)
  132.      *
  133.      * Calculated as SCRIPT_FILENAME minus SCRIPT_NAME as some CGI versions
  134.      * and mod-rewrite rules might return an incorrect DOCUMENT_ROOT.
  135.      *
  136.      * @return string The document root
  137.      */
  138.     protected static function documentRoot()
  139.     {
  140.         $strDocumentRoot = '';
  141.         $arrUriSegments = array();
  142.         $scriptName = static::get('scriptName');
  143.         $scriptFilename = static::get('scriptFilename');
  145.         // Fallback to DOCUMENT_ROOT if SCRIPT_FILENAME and SCRIPT_NAME point to different files
  146.         if (basename($scriptName) != basename($scriptFilename))
  147.         {
  148.             return str_replace('//', '/', strtr(realpath($_SERVER['DOCUMENT_ROOT']), '\\', '/'));
  149.         }
  151.         if (0 === strncmp($scriptFilename, '/', 1))
  152.         {
  153.             $strDocumentRoot = '/';
  154.         }
  156.         $arrSnSegments = explode('/', strrev($scriptName));
  157.         $arrSfnSegments = explode('/', strrev($scriptFilename));
  159.         foreach ($arrSfnSegments as $k=>$v)
  160.         {
  161.             if (@$arrSnSegments[$k] != $v)
  162.             {
  163.                 $arrUriSegments[] = $v;
  164.             }
  165.         }
  167.         $strDocumentRoot .= strrev(implode('/', $arrUriSegments));
  169.         if (\strlen($strDocumentRoot) < 2)
  170.         {
  171.             $strDocumentRoot = substr($scriptFilename, 0, -(\strlen($strDocumentRoot) + 1));
  172.         }
  174.         return str_replace('//', '/', strtr(realpath($strDocumentRoot), '\\', '/'));
  175.     }
  177.     /**
  178.      * Return the query string (e.g. id=2)
  179.      *
  180.      * @return string The query string
  181.      */
  182.     protected static function queryString()
  183.     {
  184.         if (!isset($_SERVER['QUERY_STRING']))
  185.         {
  186.             return '';
  187.         }
  189.         return static::encodeRequestString($_SERVER['QUERY_STRING']);
  190.     }
  192.     /**
  193.      * Return the request URI [path]?[query] (e.g. /contao/index.php?id=2)
  194.      *
  195.      * @return string The request URI
  196.      */
  197.     protected static function requestUri()
  198.     {
  199.         if (!empty($_SERVER['REQUEST_URI']))
  200.         {
  201.             $arrComponents = parse_url($_SERVER['REQUEST_URI']);
  203.             if ($arrComponents === false)
  204.             {
  205.                 $strRequest = $_SERVER['REQUEST_URI'];
  206.             }
  207.             else
  208.             {
  209.                 $strRequest = $arrComponents['path'] . (isset($arrComponents['query']) ? '?' . $arrComponents['query'] : '');
  210.             }
  211.         }
  212.         else
  213.         {
  214.             $strRequest = '/' . preg_replace('/^\//', '', static::get('scriptName')) . (!empty($_SERVER['QUERY_STRING']) ? '?' . $_SERVER['QUERY_STRING'] : '');
  215.         }
  217.         return static::encodeRequestString($strRequest);
  218.     }
  220.     /**
  221.      * Return the first eight accepted languages as array
  222.      *
  223.      * @return array The languages array
  224.      *
  225.      * @author Leo Unglaub <https://github.com/LeoUnglaub>
  226.      */
  227.     protected static function httpAcceptLanguage()
  228.     {
  229.         $arrAccepted = array();
  230.         $arrLanguages = array();
  232.         // The implementation differs from the original implementation and also works with .jp browsers
  233.         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);
  235.         // Remove all invalid locales
  236.         foreach ($arrAccepted[1] as $v)
  237.         {
  238.             $chunks = explode('-', $v);
  240.             // Language plus dialect, e.g. en-US or fr-FR
  241.             if (isset($chunks[1]))
  242.             {
  243.                 $locale = $chunks[0] . '-' . strtoupper($chunks[1]);
  245.                 if (preg_match('/^[a-z]{2}(-[A-Z]{2})?$/', $locale))
  246.                 {
  247.                     $arrLanguages[] = $locale;
  248.                 }
  249.             }
  251.             $locale = $chunks[0];
  253.             // Language only, e.g. en or fr (see #29)
  254.             if (preg_match('/^[a-z]{2}$/', $locale))
  255.             {
  256.                 $arrLanguages[] = $locale;
  257.             }
  258.         }
  260.         return \array_slice(array_unique($arrLanguages), 0, 8);
  261.     }
  263.     /**
  264.      * Return accepted encoding types as array
  265.      *
  266.      * @return array The encoding types array
  267.      */
  268.     protected static function httpAcceptEncoding()
  269.     {
  270.         return array_values(array_unique(explode(',', strtolower($_SERVER['HTTP_ACCEPT_ENCODING']))));
  271.     }
  273.     /**
  274.      * Return the user agent as string
  275.      *
  276.      * @return string The user agent string
  277.      */
  278.     protected static function httpUserAgent()
  279.     {
  280.         $ua = strip_tags($_SERVER['HTTP_USER_AGENT']);
  281.         $ua = preg_replace('/javascript|vbscri?pt|script|applet|alert|document|write|cookie/i', '', $ua);
  283.         return substr($ua, 0, 255);
  284.     }
  286.     /**
  287.      * Return the HTTP Host
  288.      *
  289.      * @return string The host name
  290.      */
  291.     protected static function httpHost()
  292.     {
  293.         if (!empty($_SERVER['HTTP_HOST']))
  294.         {
  295.             $host = $_SERVER['HTTP_HOST'];
  296.         }
  297.         else
  298.         {
  299.             $host = $_SERVER['SERVER_NAME'] ?? null;
  301.             if (($_SERVER['SERVER_PORT'] ?? 80) != 80)
  302.             {
  303.                 $host .= ':' . $_SERVER['SERVER_PORT'];
  304.             }
  305.         }
  307.         return preg_replace('/[^A-Za-z0-9[\].:_-]/', '', $host);
  308.     }
  310.     /**
  311.      * Return the HTTP X-Forwarded-Host
  312.      *
  313.      * @return string The name of the X-Forwarded-Host
  314.      */
  315.     protected static function httpXForwardedHost()
  316.     {
  317.         if (!isset($_SERVER['HTTP_X_FORWARDED_HOST']))
  318.         {
  319.             return '';
  320.         }
  322.         return preg_replace('/[^A-Za-z0-9[\].:-]/', '', $_SERVER['HTTP_X_FORWARDED_HOST']);
  323.     }
  325.     /**
  326.      * Return true if the current page was requested via an SSL connection
  327.      *
  328.      * @return boolean True if SSL is enabled
  329.      */
  330.     protected static function ssl()
  331.     {
  332.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  334.         if ($request === null)
  335.         {
  336.             return false;
  337.         }
  339.         return $request->isSecure();
  340.     }
  342.     /**
  343.      * Return the current URL without path or query string
  344.      *
  345.      * @return string The URL
  346.      */
  347.     protected static function url()
  348.     {
  349.         return (static::get('ssl') ? 'https://' : 'http://') . static::get('httpHost');
  350.     }
  352.     /**
  353.      * Return the current URL with path or query string
  354.      *
  355.      * @return string The URL
  356.      */
  357.     protected static function uri()
  358.     {
  359.         return static::get('url') . static::get('requestUri');
  360.     }
  362.     /**
  363.      * Return the real REMOTE_ADDR even if a proxy server is used
  364.      *
  365.      * @return string The IP address of the client
  366.      */
  367.     protected static function ip()
  368.     {
  369.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  371.         if ($request === null)
  372.         {
  373.             return '';
  374.         }
  376.         return $request->getClientIp();
  377.     }
  379.     /**
  380.      * Return the SERVER_ADDR
  381.      *
  382.      * @return string The IP address of the server
  383.      */
  384.     protected static function server()
  385.     {
  386.         $strServer = !empty($_SERVER['SERVER_ADDR']) ? $_SERVER['SERVER_ADDR'] : $_SERVER['LOCAL_ADDR'];
  388.         // Special workaround for Strato users
  389.         if (empty($strServer))
  390.         {
  391.             $strServer = @gethostbyname($_SERVER['SERVER_NAME']);
  392.         }
  394.         return $strServer;
  395.     }
  397.     /**
  398.      * Return the relative path to the base directory (e.g. /path)
  399.      *
  400.      * @return string The relative path to the installation
  401.      */
  402.     protected static function path()
  403.     {
  404.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  406.         if ($request === null)
  407.         {
  408.             return '';
  409.         }
  411.         return $request->getBasePath();
  412.     }
  414.     /**
  415.      * Return the relativ path to the script (e.g. index.php)
  416.      *
  417.      * @return string The relative path to the script
  418.      */
  419.     protected static function script()
  420.     {
  421.         return preg_replace('/^' . preg_quote(static::get('path'), '/') . '\/?/', '', static::get('scriptName'));
  422.     }
  424.     /**
  425.      * Return the relativ path to the script and include the request (e.g. index.php?id=2)
  426.      *
  427.      * @return string The relative path to the script including the request string
  428.      */
  429.     protected static function request()
  430.     {
  431.         return preg_replace('/^' . preg_quote(static::get('path'), '/') . '\/?/', '', static::get('requestUri'));
  432.     }
  434.     /**
  435.      * Return the request string without the script name (e.g. en/news.html)
  436.      *
  437.      * @return string The base URL
  438.      */
  439.     protected static function relativeRequest()
  440.     {
  441.         return preg_replace('/^' . preg_quote(static::get('script'), '/') . '\/?/', '', static::get('request'));
  442.     }
  444.     /**
  445.      * Return the request string without the index.php fragment
  446.      *
  447.      * @return string The request string without the index.php fragment
  448.      */
  449.     protected static function indexFreeRequest()
  450.     {
  451.         $strRequest = static::get('request');
  453.         if ($strRequest == static::get('script'))
  454.         {
  455.             return '';
  456.         }
  458.         return $strRequest;
  459.     }
  461.     /**
  462.      * Return the URL and path that can be used in a <base> tag
  463.      *
  464.      * @return string The base URL
  465.      */
  466.     protected static function base()
  467.     {
  468.         return static::get('url') . static::get('path') . '/';
  469.     }
  471.     /**
  472.      * Return the host name
  473.      *
  474.      * @return string The host name
  475.      */
  476.     protected static function host()
  477.     {
  478.         return preg_replace('/:\d+$/', '', static::get('httpHost'));
  479.     }
  481.     /**
  482.      * Return true on Ajax requests
  483.      *
  484.      * @return boolean True if it is an Ajax request
  485.      */
  486.     protected static function isAjaxRequest()
  487.     {
  488.         if (!isset($_SERVER['HTTP_X_REQUESTED_WITH']))
  489.         {
  490.             return false;
  491.         }
  493.         return $_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest';
  494.     }
  496.     /**
  497.      * Return the operating system and the browser name and version
  498.      *
  499.      * @return object The agent information
  500.      */
  501.     protected static function agent()
  502.     {
  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');