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

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']);
  202.             $strRequest = $arrComponents['path'] . (isset($arrComponents['query']) ? '?' . $arrComponents['query'] : '');
  203.         }
  204.         else
  205.         {
  206.             $strRequest = '/' . preg_replace('/^\//', '', static::get('scriptName')) . (!empty($_SERVER['QUERY_STRING']) ? '?' . $_SERVER['QUERY_STRING'] : '');
  207.         }
  209.         return static::encodeRequestString($strRequest);
  210.     }
  212.     /**
  213.      * Return the first eight accepted languages as array
  214.      *
  215.      * @return array The languages array
  216.      *
  217.      * @author Leo Unglaub <https://github.com/LeoUnglaub>
  218.      */
  219.     protected static function httpAcceptLanguage()
  220.     {
  221.         $arrAccepted = array();
  222.         $arrLanguages = array();
  224.         // The implementation differs from the original implementation and also works with .jp browsers
  225.         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);
  227.         // Remove all invalid locales
  228.         foreach ($arrAccepted[1] as $v)
  229.         {
  230.             $chunks = explode('-', $v);
  232.             // Language plus dialect, e.g. en-US or fr-FR
  233.             if (isset($chunks[1]))
  234.             {
  235.                 $locale = $chunks[0] . '-' . strtoupper($chunks[1]);
  237.                 if (preg_match('/^[a-z]{2}(-[A-Z]{2})?$/', $locale))
  238.                 {
  239.                     $arrLanguages[] = $locale;
  240.                 }
  241.             }
  243.             $locale = $chunks[0];
  245.             // Language only, e.g. en or fr (see #29)
  246.             if (preg_match('/^[a-z]{2}$/', $locale))
  247.             {
  248.                 $arrLanguages[] = $locale;
  249.             }
  250.         }
  252.         return \array_slice(array_unique($arrLanguages), 0, 8);
  253.     }
  255.     /**
  256.      * Return accepted encoding types as array
  257.      *
  258.      * @return array The encoding types array
  259.      */
  260.     protected static function httpAcceptEncoding()
  261.     {
  262.         return array_values(array_unique(explode(',', strtolower($_SERVER['HTTP_ACCEPT_ENCODING']))));
  263.     }
  265.     /**
  266.      * Return the user agent as string
  267.      *
  268.      * @return string The user agent string
  269.      */
  270.     protected static function httpUserAgent()
  271.     {
  272.         $ua = strip_tags($_SERVER['HTTP_USER_AGENT']);
  273.         $ua = preg_replace('/javascript|vbscri?pt|script|applet|alert|document|write|cookie/i', '', $ua);
  275.         return substr($ua, 0, 255);
  276.     }
  278.     /**
  279.      * Return the HTTP Host
  280.      *
  281.      * @return string The host name
  282.      */
  283.     protected static function httpHost()
  284.     {
  285.         if (!empty($_SERVER['HTTP_HOST']))
  286.         {
  287.             $host = $_SERVER['HTTP_HOST'];
  288.         }
  289.         else
  290.         {
  291.             $host = $_SERVER['SERVER_NAME'];
  293.             if ($_SERVER['SERVER_PORT'] != 80)
  294.             {
  295.                 $host .= ':' . $_SERVER['SERVER_PORT'];
  296.             }
  297.         }
  299.         return preg_replace('/[^A-Za-z0-9[\].:_-]/', '', $host);
  300.     }
  302.     /**
  303.      * Return the HTTP X-Forwarded-Host
  304.      *
  305.      * @return string The name of the X-Forwarded-Host
  306.      */
  307.     protected static function httpXForwardedHost()
  308.     {
  309.         if (!isset($_SERVER['HTTP_X_FORWARDED_HOST']))
  310.         {
  311.             return '';
  312.         }
  314.         return preg_replace('/[^A-Za-z0-9[\].:-]/', '', $_SERVER['HTTP_X_FORWARDED_HOST']);
  315.     }
  317.     /**
  318.      * Return true if the current page was requested via an SSL connection
  319.      *
  320.      * @return boolean True if SSL is enabled
  321.      */
  322.     protected static function ssl()
  323.     {
  324.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  326.         if ($request === null)
  327.         {
  328.             return false;
  329.         }
  331.         return $request->isSecure();
  332.     }
  334.     /**
  335.      * Return the current URL without path or query string
  336.      *
  337.      * @return string The URL
  338.      */
  339.     protected static function url()
  340.     {
  341.         return (static::get('ssl') ? 'https://' : 'http://') . static::get('httpHost');
  342.     }
  344.     /**
  345.      * Return the current URL with path or query string
  346.      *
  347.      * @return string The URL
  348.      */
  349.     protected static function uri()
  350.     {
  351.         return static::get('url') . static::get('requestUri');
  352.     }
  354.     /**
  355.      * Return the real REMOTE_ADDR even if a proxy server is used
  356.      *
  357.      * @return string The IP address of the client
  358.      */
  359.     protected static function ip()
  360.     {
  361.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  363.         if ($request === null)
  364.         {
  365.             return '';
  366.         }
  368.         return $request->getClientIp();
  369.     }
  371.     /**
  372.      * Return the SERVER_ADDR
  373.      *
  374.      * @return string The IP address of the server
  375.      */
  376.     protected static function server()
  377.     {
  378.         $strServer = !empty($_SERVER['SERVER_ADDR']) ? $_SERVER['SERVER_ADDR'] : $_SERVER['LOCAL_ADDR'];
  380.         // Special workaround for Strato users
  381.         if (empty($strServer))
  382.         {
  383.             $strServer = @gethostbyname($_SERVER['SERVER_NAME']);
  384.         }
  386.         return $strServer;
  387.     }
  389.     /**
  390.      * Return the relative path to the base directory (e.g. /path)
  391.      *
  392.      * @return string The relative path to the installation
  393.      */
  394.     protected static function path()
  395.     {
  396.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  398.         if ($request === null)
  399.         {
  400.             return '';
  401.         }
  403.         return $request->getBasePath();
  404.     }
  406.     /**
  407.      * Return the relative path to the script (e.g. index.php)
  408.      *
  409.      * @return string The relative path to the script
  410.      */
  411.     protected static function script()
  412.     {
  413.         return preg_replace('/^' . preg_quote(static::get('path'), '/') . '\/?/', '', static::get('scriptName'));
  414.     }
  416.     /**
  417.      * Return the relative path to the script and include the request (e.g. index.php?id=2)
  418.      *
  419.      * @return string The relative path to the script including the request string
  420.      */
  421.     protected static function request()
  422.     {
  423.         return preg_replace('/^' . preg_quote(static::get('path'), '/') . '\/?/', '', static::get('requestUri'));
  424.     }
  426.     /**
  427.      * Return the request string without the script name (e.g. en/news.html)
  428.      *
  429.      * @return string The base URL
  430.      */
  431.     protected static function relativeRequest()
  432.     {
  433.         return preg_replace('/^' . preg_quote(static::get('script'), '/') . '\/?/', '', static::get('request'));
  434.     }
  436.     /**
  437.      * Return the request string without the index.php fragment
  438.      *
  439.      * @return string The request string without the index.php fragment
  440.      */
  441.     protected static function indexFreeRequest()
  442.     {
  443.         $strRequest = static::get('request');
  445.         if ($strRequest == static::get('script'))
  446.         {
  447.             return '';
  448.         }
  450.         return $strRequest;
  451.     }
  453.     /**
  454.      * Return the URL and path that can be used in a <base> tag
  455.      *
  456.      * @return string The base URL
  457.      */
  458.     protected static function base()
  459.     {
  460.         return static::get('url') . static::get('path') . '/';
  461.     }
  463.     /**
  464.      * Return the host name
  465.      *
  466.      * @return string The host name
  467.      */
  468.     protected static function host()
  469.     {
  470.         return preg_replace('/:\d+$/', '', static::get('httpHost'));
  471.     }
  473.     /**
  474.      * Return true on Ajax requests
  475.      *
  476.      * @return boolean True if it is an Ajax request
  477.      */
  478.     protected static function isAjaxRequest()
  479.     {
  480.         if (!isset($_SERVER['HTTP_X_REQUESTED_WITH']))
  481.         {
  482.             return false;
  483.         }
  485.         return $_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest';
  486.     }
  488.     /**
  489.      * Return the operating system and the browser name and version
  490.      *
  491.      * @return object The agent information
  492.      */
  493.     protected static function agent()
  494.     {
  495.         $ua = static::get('httpUserAgent');
  497.         $return = new \stdClass();
  498.         $return->string = $ua;
  500.         $os = 'unknown';
  501.         $mobile = false;
  502.         $browser = 'other';
  503.         $shorty = '';
  504.         $version = '';
  505.         $engine = '';
  507.         // Operating system
  508.         foreach (Config::get('os') as $k=>$v)
  509.         {
  510.             if (stripos($ua, $k) !== false)
  511.             {
  512.                 $os = $v['os'];
  513.                 $mobile = $v['mobile'];
  514.                 break;
  515.             }
  516.         }
  518.         $return->os = $os;
  520.         // Browser and version
  521.         foreach (Config::get('browser') as $k=>$v)
  522.         {
  523.             if (stripos($ua, $k) !== false)
  524.             {
  525.                 $browser = $v['browser'];
  526.                 $shorty  = $v['shorty'];
  527.                 $version = preg_replace($v['version'], '$1', $ua);
  528.                 $engine  = $v['engine'];
  529.                 break;
  530.             }
  531.         }
  533.         $versions = explode('.', $version);
  534.         $version  = $versions[0];
  536.         $return->class = $os . ' ' . $browser . ' ' . $engine;
  538.         // Add the version number if available
  539.         if ($version)
  540.         {
  541.             $return->class .= ' ' . $shorty . $version;
  542.         }
  544.         // Android tablets are not mobile (see #4150 and #5869)
  545.         if ($os == 'android' && $engine != 'presto' && stripos($ua, 'mobile') === false)
  546.         {
  547.             $mobile = false;
  548.         }
  550.         // Mark mobile devices
  551.         if ($mobile)
  552.         {
  553.             $return->class .= ' mobile';
  554.         }
  556.         $return->browser  = $browser;
  557.         $return->shorty   = $shorty;
  558.         $return->version  = $version;
  559.         $return->engine   = $engine;
  560.         $return->versions = $versions;
  561.         $return->mobile   = $mobile;
  563.         return $return;
  564.     }
  566.     /**
  567.      * Encode a request string preserving certain reserved characters
  568.      *
  569.      * @param string $strRequest The request string
  570.      *
  571.      * @return string The encoded request string
  572.      */
  573.     protected static function encodeRequestString($strRequest)
  574.     {
  575.         return preg_replace_callback('/[^A-Za-z0-9\-_.~&=+,\/?%\[\]]+/', static function ($matches) { return rawurlencode($matches[0]); }, $strRequest);
  576.     }
  578.     /**
  579.      * Prevent direct instantiation (Singleton)
  580.      *
  581.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  582.      *             The Environment class is now static.
  583.      */
  584.     protected function __construct()
  585.     {
  586.     }
  588.     /**
  589.      * Prevent cloning of the object (Singleton)
  590.      *
  591.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  592.      *             The Environment class is now static.
  593.      */
  594.     final public function __clone()
  595.     {
  596.     }
  598.     /**
  599.      * Return an environment variable
  600.      *
  601.      * @param string $strKey The variable name
  602.      *
  603.      * @return string The variable value
  604.      *
  605.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  606.      *             Use Environment::get() instead.
  607.      */
  608.     public function __get($strKey)
  609.     {
  610.         return static::get($strKey);
  611.     }
  613.     /**
  614.      * Set an environment variable
  615.      *
  616.      * @param string $strKey   The variable name
  617.      * @param mixed  $varValue The variable value
  618.      *
  619.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  620.      *             Use Environment::set() instead.
  621.      */
  622.     public function __set($strKey, $varValue)
  623.     {
  624.         static::set($strKey, $varValue);
  625.     }
  627.     /**
  628.      * Return the object instance (Singleton)
  629.      *
  630.      * @return Environment The object instance
  631.      *
  632.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  633.      *             The Environment class is now static.
  634.      */
  635.     public static function getInstance()
  636.     {
  637.         @trigger_error('Using Environment::getInstance() has been deprecated and will no longer work in Contao 5.0. The Environment class is now static.', E_USER_DEPRECATED);
  639.         if (static::$objInstance === null)
  640.         {
  641.             static::$objInstance = new static();
  642.         }
  644.         return static::$objInstance;
  645.     }
  646. }
  648. class_alias(Environment::class, 'Environment');