GeneralUtility.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Utility;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use TYPO3\CMS\Core\Core\ApplicationContext;
use TYPO3\CMS\Core\Core\ClassLoadingInformation;
use TYPO3\CMS\Core\Imaging\GraphicalFunctions;
use TYPO3\CMS\Core\Service\OpcodeCacheService;
use TYPO3\CMS\Core\SingletonInterface;
use TYPO3\CMS\Frontend\Page\PageRepository;

class GeneralUtility
{
    // Severity constants used by \TYPO3\CMS\Core\Utility\GeneralUtility::sysLog()
    const SYSLOG_SEVERITY_INFO = 0;
    const SYSLOG_SEVERITY_NOTICE = 1;
    const SYSLOG_SEVERITY_WARNING = 2;
    const SYSLOG_SEVERITY_ERROR = 3;
    const SYSLOG_SEVERITY_FATAL = 4;

    const ENV_TRUSTED_HOSTS_PATTERN_ALLOW_ALL = '.*';
    const ENV_TRUSTED_HOSTS_PATTERN_SERVER_NAME = 'SERVER_NAME';

    protected static $allowHostHeaderValue = false;

    protected static $singletonInstances = array();

    protected static $nonSingletonInstances = array();

    protected static $finalClassNameCache = array();

    protected static $applicationContext = null;

    protected static $idnaStringCache = array();

    protected static $idnaConverter = null;

    protected static $supportedCgiServerApis = array(
        'fpm-fcgi',
        'cgi',
        'isapi',
        'cgi-fcgi',
        'srv', // HHVM with fastcgi
    );

    protected static $indpEnvCache = [];

    /*************************
     *
     * GET/POST Variables
     *
     * Background:
     * Input GET/POST variables in PHP may have their quotes escaped with "\" or not depending on configuration.
     * TYPO3 has always converted quotes to BE escaped if the configuration told that they would not be so.
     * But the clean solution is that quotes are never escaped and that is what the functions below offers.
     * Eventually TYPO3 should provide this in the global space as well.
     * In the transitional phase (or forever..?) we need to encourage EVERY to read and write GET/POST vars through the API functions below.
     * This functionality was previously needed to normalize between magic quotes logic, which was removed from PHP 5.4,
     * so these methods are still in use, but not tackle the slash problem anymore.
     *
     *************************/
    public static function _GP($var)
    {
        if (empty($var)) {
            return;
        }
        $value = isset($_POST[$var]) ? $_POST[$var] : $_GET[$var];
        // This is there for backwards-compatibility, in order to avoid NULL
        if (isset($value) && !is_array($value)) {
            $value = (string)$value;
        }
        return $value;
    }

    public static function _GPmerged($parameter)
    {
        $postParameter = isset($_POST[$parameter]) && is_array($_POST[$parameter]) ? $_POST[$parameter] : array();
        $getParameter = isset($_GET[$parameter]) && is_array($_GET[$parameter]) ? $_GET[$parameter] : array();
        $mergedParameters = $getParameter;
        ArrayUtility::mergeRecursiveWithOverrule($mergedParameters, $postParameter);
        return $mergedParameters;
    }

    public static function _GET($var = null)
    {
        $value = $var === null ? $_GET : (empty($var) ? null : $_GET[$var]);
        // This is there for backwards-compatibility, in order to avoid NULL
        if (isset($value) && !is_array($value)) {
            $value = (string)$value;
        }
        return $value;
    }

    public static function _POST($var = null)
    {
        $value = $var === null ? $_POST : (empty($var) ? null : $_POST[$var]);
        // This is there for backwards-compatibility, in order to avoid NULL
        if (isset($value) && !is_array($value)) {
            $value = (string)$value;
        }
        return $value;
    }

    public static function _GETset($inputGet, $key = '')
    {
        if ($key != '') {
            if (strpos($key, '|') !== false) {
                $pieces = explode('|', $key);
                $newGet = array();
                $pointer = &$newGet;
                foreach ($pieces as $piece) {
                    $pointer = &$pointer[$piece];
                }
                $pointer = $inputGet;
                $mergedGet = $_GET;
                ArrayUtility::mergeRecursiveWithOverrule($mergedGet, $newGet);
                $_GET = $mergedGet;
                $GLOBALS['HTTP_GET_VARS'] = $mergedGet;
            } else {
                $_GET[$key] = $inputGet;
                $GLOBALS['HTTP_GET_VARS'][$key] = $inputGet;
            }
        } elseif (is_array($inputGet)) {
            $_GET = $inputGet;
            $GLOBALS['HTTP_GET_VARS'] = $inputGet;
        }
    }

    public static function removeXSS($string)
    {
        return \RemoveXSS::process($string);
    }

    /*************************
     *
     * IMAGE FUNCTIONS
     *
     *************************/
    public static function gif_compress($theFile, $type)
    {
        static::logDeprecatedFunction();
        $returnCode = GraphicalFunctions::gifCompress($theFile, $type);
        return $returnCode;
    }

    public static function png_to_gif_by_imagemagick($theFile)
    {
        static::logDeprecatedFunction();
        $newFile = GraphicalFunctions::pngToGifByImagemagick($theFile);
        return $newFile;
    }

    public static function read_png_gif($theFile, $output_png = false)
    {
        static::logDeprecatedFunction();
        $newFile = GraphicalFunctions::readPngGif($theFile, $output_png);
        return $newFile;
    }

    /*************************
     *
     * STRING FUNCTIONS
     *
     *************************/
    public static function fixed_lgd_cs($string, $chars, $appendString = '...')
    {
        if (is_object($GLOBALS['LANG'])) {
            return $GLOBALS['LANG']->csConvObj->crop($GLOBALS['LANG']->charSet, $string, $chars, $appendString);
        } elseif (is_object($GLOBALS['TSFE']) && is_object($GLOBALS['TSFE']->csConvObj)) {
            $charSet = $GLOBALS['TSFE']->renderCharset != '' ? $GLOBALS['TSFE']->renderCharset : $GLOBALS['TSFE']->defaultCharSet;
            return $GLOBALS['TSFE']->csConvObj->crop($charSet, $string, $chars, $appendString);
        } else {
            // This case should not happen
            $csConvObj = self::makeInstance(\TYPO3\CMS\Core\Charset\CharsetConverter::class);
            return $csConvObj->crop('utf-8', $string, $chars, $appendString);
        }
    }

    public static function cmpIP($baseIP, $list)
    {
        $list = trim($list);
        if ($list === '') {
            return false;
        } elseif ($list === '*') {
            return true;
        }
        if (strpos($baseIP, ':') !== false && self::validIPv6($baseIP)) {
            return self::cmpIPv6($baseIP, $list);
        } else {
            return self::cmpIPv4($baseIP, $list);
        }
    }

    public static function cmpIPv4($baseIP, $list)
    {
        $IPpartsReq = explode('.', $baseIP);
        if (count($IPpartsReq) === 4) {
            $values = self::trimExplode(',', $list, true);
            foreach ($values as $test) {
                $testList = explode('/', $test);
                if (count($testList) === 2) {
                    list($test, $mask) = $testList;
                } else {
                    $mask = false;
                }
                if ((int)$mask) {
                    // "192.168.3.0/24"
                    $lnet = ip2long($test);
                    $lip = ip2long($baseIP);
                    $binnet = str_pad(decbin($lnet), 32, '0', STR_PAD_LEFT);
                    $firstpart = substr($binnet, 0, $mask);
                    $binip = str_pad(decbin($lip), 32, '0', STR_PAD_LEFT);
                    $firstip = substr($binip, 0, $mask);
                    $yes = $firstpart === $firstip;
                } else {
                    // "192.168.*.*"
                    $IPparts = explode('.', $test);
                    $yes = 1;
                    foreach ($IPparts as $index => $val) {
                        $val = trim($val);
                        if ($val !== '*' && $IPpartsReq[$index] !== $val) {
                            $yes = 0;
                        }
                    }
                }
                if ($yes) {
                    return true;
                }
            }
        }
        return false;
    }

    public static function cmpIPv6($baseIP, $list)
    {
        // Policy default: Deny connection
        $success = false;
        $baseIP = self::normalizeIPv6($baseIP);
        $values = self::trimExplode(',', $list, true);
        foreach ($values as $test) {
            $testList = explode('/', $test);
            if (count($testList) === 2) {
                list($test, $mask) = $testList;
            } else {
                $mask = false;
            }
            if (self::validIPv6($test)) {
                $test = self::normalizeIPv6($test);
                $maskInt = (int)$mask ?: 128;
                // Special case; /0 is an allowed mask - equals a wildcard
                if ($mask === '0') {
                    $success = true;
                } elseif ($maskInt == 128) {
                    $success = $test === $baseIP;
                } else {
                    $testBin = self::IPv6Hex2Bin($test);
                    $baseIPBin = self::IPv6Hex2Bin($baseIP);
                    $success = true;
                    // Modulo is 0 if this is a 8-bit-boundary
                    $maskIntModulo = $maskInt % 8;
                    $numFullCharactersUntilBoundary = (int)($maskInt / 8);
                    if (substr($testBin, 0, $numFullCharactersUntilBoundary) !== substr($baseIPBin, 0, $numFullCharactersUntilBoundary)) {
                        $success = false;
                    } elseif ($maskIntModulo > 0) {
                        // If not an 8-bit-boundary, check bits of last character
                        $testLastBits = str_pad(decbin(ord(substr($testBin, $numFullCharactersUntilBoundary, 1))), 8, '0', STR_PAD_LEFT);
                        $baseIPLastBits = str_pad(decbin(ord(substr($baseIPBin, $numFullCharactersUntilBoundary, 1))), 8, '0', STR_PAD_LEFT);
                        if (strncmp($testLastBits, $baseIPLastBits, $maskIntModulo) != 0) {
                            $success = false;
                        }
                    }
                }
            }
            if ($success) {
                return true;
            }
        }
        return false;
    }

    public static function IPv6Hex2Bin($hex)
    {
        return inet_pton($hex);
    }

    public static function IPv6Bin2Hex($bin)
    {
        return inet_ntop($bin);
    }

    public static function normalizeIPv6($address)
    {
        $normalizedAddress = '';
        $stageOneAddress = '';
        // According to RFC lowercase-representation is recommended
        $address = strtolower($address);
        // Normalized representation has 39 characters (0000:0000:0000:0000:0000:0000:0000:0000)
        if (strlen($address) == 39) {
            // Already in full expanded form
            return $address;
        }
        // Count 2 if if address has hidden zero blocks
        $chunks = explode('::', $address);
        if (count($chunks) === 2) {
            $chunksLeft = explode(':', $chunks[0]);
            $chunksRight = explode(':', $chunks[1]);
            $left = count($chunksLeft);
            $right = count($chunksRight);
            // Special case: leading zero-only blocks count to 1, should be 0
            if ($left == 1 && strlen($chunksLeft[0]) == 0) {
                $left = 0;
            }
            $hiddenBlocks = 8 - ($left + $right);
            $hiddenPart = '';
            $h = 0;
            while ($h < $hiddenBlocks) {
                $hiddenPart .= '0000:';
                $h++;
            }
            if ($left == 0) {
                $stageOneAddress = $hiddenPart . $chunks[1];
            } else {
                $stageOneAddress = $chunks[0] . ':' . $hiddenPart . $chunks[1];
            }
        } else {
            $stageOneAddress = $address;
        }
        // Normalize the blocks:
        $blocks = explode(':', $stageOneAddress);
        $divCounter = 0;
        foreach ($blocks as $block) {
            $tmpBlock = '';
            $i = 0;
            $hiddenZeros = 4 - strlen($block);
            while ($i < $hiddenZeros) {
                $tmpBlock .= '0';
                $i++;
            }
            $normalizedAddress .= $tmpBlock . $block;
            if ($divCounter < 7) {
                $normalizedAddress .= ':';
                $divCounter++;
            }
        }
        return $normalizedAddress;
    }

    public static function compressIPv6($address)
    {
        return inet_ntop(inet_pton($address));
    }

    public static function validIP($ip)
    {
        return filter_var($ip, FILTER_VALIDATE_IP) !== false;
    }

    public static function validIPv4($ip)
    {
        return filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) !== false;
    }

    public static function validIPv6($ip)
    {
        return filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) !== false;
    }

    public static function cmpFQDN($baseHost, $list)
    {
        $baseHost = trim($baseHost);
        if (empty($baseHost)) {
            return false;
        }
        if (self::validIPv4($baseHost) || self::validIPv6($baseHost)) {
            // Resolve hostname
            // Note: this is reverse-lookup and can be randomly set as soon as somebody is able to set
            // the reverse-DNS for his IP (security when for example used with REMOTE_ADDR)
            $baseHostName = gethostbyaddr($baseHost);
            if ($baseHostName === $baseHost) {
                // Unable to resolve hostname
                return false;
            }
        } else {
            $baseHostName = $baseHost;
        }
        $baseHostNameParts = explode('.', $baseHostName);
        $values = self::trimExplode(',', $list, true);
        foreach ($values as $test) {
            $hostNameParts = explode('.', $test);
            // To match hostNameParts can only be shorter (in case of wildcards) or equal
            $hostNamePartsCount = count($hostNameParts);
            $baseHostNamePartsCount = count($baseHostNameParts);
            if ($hostNamePartsCount > $baseHostNamePartsCount) {
                continue;
            }
            $yes = true;
            foreach ($hostNameParts as $index => $val) {
                $val = trim($val);
                if ($val === '*') {
                    // Wildcard valid for one or more hostname-parts
                    $wildcardStart = $index + 1;
                    // Wildcard as last/only part always matches, otherwise perform recursive checks
                    if ($wildcardStart < $hostNamePartsCount) {
                        $wildcardMatched = false;
                        $tempHostName = implode('.', array_slice($hostNameParts, $index + 1));
                        while ($wildcardStart < $baseHostNamePartsCount && !$wildcardMatched) {
                            $tempBaseHostName = implode('.', array_slice($baseHostNameParts, $wildcardStart));
                            $wildcardMatched = self::cmpFQDN($tempBaseHostName, $tempHostName);
                            $wildcardStart++;
                        }
                        if ($wildcardMatched) {
                            // Match found by recursive compare
                            return true;
                        } else {
                            $yes = false;
                        }
                    }
                } elseif ($baseHostNameParts[$index] !== $val) {
                    // In case of no match
                    $yes = false;
                }
            }
            if ($yes) {
                return true;
            }
        }
        return false;
    }

    public static function isOnCurrentHost($url)
    {
        return stripos($url . '/', self::getIndpEnv('TYPO3_REQUEST_HOST') . '/') === 0;
    }

    public static function inList($list, $item)
    {
        return strpos(',' . $list . ',', ',' . $item . ',') !== false;
    }

    public static function rmFromList($element, $list)
    {
        $items = explode(',', $list);
        foreach ($items as $k => $v) {
            if ($v == $element) {
                unset($items[$k]);
            }
        }
        return implode(',', $items);
    }

    public static function expandList($list)
    {
        $items = explode(',', $list);
        $list = array();
        foreach ($items as $item) {
            $range = explode('-', $item);
            if (isset($range[1])) {
                $runAwayBrake = 1000;
                for ($n = $range[0]; $n <= $range[1]; $n++) {
                    $list[] = $n;
                    $runAwayBrake--;
                    if ($runAwayBrake <= 0) {
                        break;
                    }
                }
            } else {
                $list[] = $item;
            }
        }
        return implode(',', $list);
    }

    public static function compat_version($verNumberStr)
    {
        return VersionNumberUtility::convertVersionNumberToInteger(TYPO3_branch) >= VersionNumberUtility::convertVersionNumberToInteger($verNumberStr);
    }

    public static function md5int($str)
    {
        return hexdec(substr(md5($str), 0, 7));
    }

    public static function shortMD5($input, $len = 10)
    {
        return substr(md5($input), 0, $len);
    }

    public static function hmac($input, $additionalSecret = '')
    {
        $hashAlgorithm = 'sha1';
        $hashBlocksize = 64;
        $hmac = '';
        $secret = $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'] . $additionalSecret;
        if (extension_loaded('hash') && function_exists('hash_hmac') && function_exists('hash_algos') && in_array($hashAlgorithm, hash_algos())) {
            $hmac = hash_hmac($hashAlgorithm, $input, $secret);
        } else {
            // Outer padding
            $opad = str_repeat(chr(92), $hashBlocksize);
            // Inner padding
            $ipad = str_repeat(chr(54), $hashBlocksize);
            if (strlen($secret) > $hashBlocksize) {
                // Keys longer than block size are shorten
                $key = str_pad(pack('H*', call_user_func($hashAlgorithm, $secret)), $hashBlocksize, chr(0));
            } else {
                // Keys shorter than block size are zero-padded
                $key = str_pad($secret, $hashBlocksize, chr(0));
            }
            $hmac = call_user_func($hashAlgorithm, ($key ^ $opad) . pack('H*', call_user_func($hashAlgorithm, (($key ^ $ipad) . $input))));
        }
        return $hmac;
    }

    public static function uniqueList($in_list, $secondParameter = null)
    {
        if (is_array($in_list)) {
            throw new \InvalidArgumentException('TYPO3 Fatal Error: TYPO3\\CMS\\Core\\Utility\\GeneralUtility::uniqueList() does NOT support array arguments anymore! Only string comma lists!', 1270853885);
        }
        if (isset($secondParameter)) {
            throw new \InvalidArgumentException('TYPO3 Fatal Error: TYPO3\\CMS\\Core\\Utility\\GeneralUtility::uniqueList() does NOT support more than a single argument value anymore. You have specified more than one!', 1270853886);
        }
        return implode(',', array_unique(self::trimExplode(',', $in_list, true)));
    }

    public static function split_fileref($fileNameWithPath)
    {
        $reg = array();
        if (preg_match('/(.*\\/)(.*)$/', $fileNameWithPath, $reg)) {
            $info['path'] = $reg[1];
            $info['file'] = $reg[2];
        } else {
            $info['path'] = '';
            $info['file'] = $fileNameWithPath;
        }
        $reg = '';
        // If open_basedir is set and the fileName was supplied without a path the is_dir check fails
        if (!is_dir($fileNameWithPath) && preg_match('/(.*)\\.([^\\.]*$)/', $info['file'], $reg)) {
            $info['filebody'] = $reg[1];
            $info['fileext'] = strtolower($reg[2]);
            $info['realFileext'] = $reg[2];
        } else {
            $info['filebody'] = $info['file'];
            $info['fileext'] = '';
        }
        reset($info);
        return $info;
    }

    public static function dirname($path)
    {
        $p = self::revExplode('/', $path, 2);
        return count($p) === 2 ? $p[0] : '';
    }

    public static function modifyHTMLColor($color, $R, $G, $B)
    {
        self::logDeprecatedFunction();
        // This takes a hex-color (# included!) and adds $R, $G and $B to the HTML-color (format: #xxxxxx) and returns the new color
        $nR = MathUtility::forceIntegerInRange(hexdec(substr($color, 1, 2)) + $R, 0, 255);
        $nG = MathUtility::forceIntegerInRange(hexdec(substr($color, 3, 2)) + $G, 0, 255);
        $nB = MathUtility::forceIntegerInRange(hexdec(substr($color, 5, 2)) + $B, 0, 255);
        return '#' . substr(('0' . dechex($nR)), -2) . substr(('0' . dechex($nG)), -2) . substr(('0' . dechex($nB)), -2);
    }

    public static function modifyHTMLColorAll($color, $all)
    {
        self::logDeprecatedFunction();
        return self::modifyHTMLColor($color, $all, $all, $all);
    }

    public static function isFirstPartOfStr($str, $partStr)
    {
        return $partStr != '' && strpos((string)$str, (string)$partStr, 0) === 0;
    }

    public static function formatSize($sizeInBytes, $labels = '', $base = 0)
    {
        $defaultFormats = array(
            'iec' => array('base' => 1024, 'labels' => array(' ', ' Ki', ' Mi', ' Gi', ' Ti', ' Pi', ' Ei', ' Zi', ' Yi')),
            'si' => array('base' => 1000, 'labels' => array(' ', ' k', ' M', ' G', ' T', ' P', ' E', ' Z', ' Y')),
        );
        // Set labels and base:
        if (empty($labels)) {
            $labels = 'iec';
        }
        if (isset($defaultFormats[$labels])) {
            $base = $defaultFormats[$labels]['base'];
            $labelArr = $defaultFormats[$labels]['labels'];
        } else {
            $base = (int)$base;
            if ($base !== 1000 && $base !== 1024) {
                $base = 1024;
            }
            $labelArr = explode('|', str_replace('"', '', $labels));
        }
        // @todo find out which locale is used for current BE user to cover the BE case as well
        $oldLocale = setlocale(LC_NUMERIC, 0);
        $newLocale = is_object($GLOBALS['TSFE']) ? $GLOBALS['TSFE']->config['config']['locale_all'] : '';
        if ($newLocale) {
            setlocale(LC_NUMERIC, $newLocale);
        }
        $localeInfo = localeconv();
        if ($newLocale) {
            setlocale(LC_NUMERIC, $oldLocale);
        }
        $sizeInBytes = max($sizeInBytes, 0);
        $multiplier = floor(($sizeInBytes ? log($sizeInBytes) : 0) / log($base));
        $sizeInUnits = $sizeInBytes / pow($base, $multiplier);
        if ($sizeInUnits > ($base * .9)) {
            $multiplier++;
        }
        $multiplier = min($multiplier, count($labelArr) - 1);
        $sizeInUnits = $sizeInBytes / pow($base, $multiplier);
        return number_format($sizeInUnits, (($multiplier > 0) && ($sizeInUnits < 20)) ? 2 : 0, $localeInfo['decimal_point'], '') . $labelArr[$multiplier];
    }

    public static function convertMicrotime($microtime)
    {
        $parts = explode(' ', $microtime);
        return round(($parts[0] + $parts[1]) * 1000);
    }

    public static function splitCalc($string, $operators)
    {
        $res = array();
        $sign = '+';
        while ($string) {
            $valueLen = strcspn($string, $operators);
            $value = substr($string, 0, $valueLen);
            $res[] = array($sign, trim($value));
            $sign = substr($string, $valueLen, 1);
            $string = substr($string, $valueLen + 1);
        }
        reset($res);
        return $res;
    }

    public static function deHSCentities($str)
    {
        return preg_replace('/&amp;([#[:alnum:]]*;)/', '&\\1', $str);
    }

    public static function slashJS($string, $extended = false, $char = '\'')
    {
        if ($extended) {
            $string = str_replace('\\', '\\\\', $string);
        }
        return str_replace($char, '\\' . $char, $string);
    }

    public static function rawUrlEncodeJS($str)
    {
        return str_replace('%20', ' ', rawurlencode($str));
    }

    public static function rawUrlEncodeFP($str)
    {
        return str_replace('%2F', '/', rawurlencode($str));
    }

    public static function validEmail($email)
    {
        // Early return in case input is not a string
        if (!is_string($email)) {
            return false;
        }
        $atPosition = strrpos($email, '@');
        if (!$atPosition || $atPosition + 1 === strlen($email)) {
            // Return if no @ found or it is placed at the very beginning or end of the email
            return false;
        }
        $domain = substr($email, $atPosition + 1);
        $user = substr($email, 0, $atPosition);
        if (!preg_match('/^[a-z0-9.\\-]*$/i', $domain)) {
            $domain = self::idnaEncode($domain);
        }
        return filter_var($user . '@' . $domain, FILTER_VALIDATE_EMAIL) !== false;
    }

    public static function isBrokenEmailEnvironment()
    {
        self::logDeprecatedFunction();
        return TYPO3_OS == 'WIN' || false !== strpos(ini_get('sendmail_path'), 'mini_sendmail');
    }

    public static function normalizeMailAddress($address)
    {
        self::logDeprecatedFunction();
        if (self::isBrokenEmailEnvironment() && false !== ($pos1 = strrpos($address, '<'))) {
            $pos2 = strpos($address, '>', $pos1);
            $address = substr($address, $pos1 + 1, ($pos2 ? $pos2 : strlen($address)) - $pos1 - 1);
        }
        return $address;
    }

    public static function formatForTextarea($content)
    {
        self::logDeprecatedFunction();
        return LF . htmlspecialchars($content);
    }

    public static function strtoupper($str)
    {
        return strtr((string)$str, 'abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');
    }

    public static function strtolower($str)
    {
        return strtr((string)$str, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz');
    }

    public static function generateRandomBytes($bytesToReturn)
    {
        // Cache 4k of the generated bytestream.
        static $bytes = '';
        $bytesToGenerate = max(4096, $bytesToReturn);
        // if we have not enough random bytes cached, we generate new ones
        if (!isset($bytes[($bytesToReturn - 1)])) {
            if (TYPO3_OS === 'WIN') {
                // Openssl seems to be deadly slow on Windows, so try to use mcrypt
                $bytes .= self::generateRandomBytesMcrypt($bytesToGenerate);
            } else {
                // Try to use native PHP functions first, precedence has openssl
                $bytes .= self::generateRandomBytesOpenSsl($bytesToGenerate);
                if (!isset($bytes[($bytesToReturn - 1)])) {
                    $bytes .= self::generateRandomBytesMcrypt($bytesToGenerate);
                }
                // If openssl and mcrypt failed, try /dev/urandom
                if (!isset($bytes[($bytesToReturn - 1)])) {
                    $bytes .= self::generateRandomBytesUrandom($bytesToGenerate);
                }
            }
            // Fall back if other random byte generation failed until now
            if (!isset($bytes[($bytesToReturn - 1)])) {
                $bytes .= self::generateRandomBytesFallback($bytesToReturn);
            }
        }
        // get first $bytesToReturn and remove it from the byte cache
        $output = substr($bytes, 0, $bytesToReturn);
        $bytes = substr($bytes, $bytesToReturn);
        return $output;
    }

    protected static function generateRandomBytesOpenSsl($bytesToGenerate)
    {
        if (!function_exists('openssl_random_pseudo_bytes')) {
            return '';
        }
        $isStrong = null;
        return (string)openssl_random_pseudo_bytes($bytesToGenerate, $isStrong);
    }

    protected static function generateRandomBytesMcrypt($bytesToGenerate)
    {
        if (!function_exists('mcrypt_create_iv')) {
            return '';
        }
        return (string)(@mcrypt_create_iv($bytesToGenerate, MCRYPT_DEV_URANDOM));
    }

    protected static function generateRandomBytesUrandom($bytesToGenerate)
    {
        $bytes = '';
        $fh = @fopen('/dev/urandom', 'rb');
        if ($fh) {
            // PHP only performs buffered reads, so in reality it will always read
            // at least 4096 bytes. Thus, it costs nothing extra to read and store
            // that much so as to speed any additional invocations.
            $bytes = fread($fh, $bytesToGenerate);
            fclose($fh);
        }
        return $bytes;
    }

    protected static function generateRandomBytesFallback($bytesToReturn)
    {
        $bytes = '';
        // We initialize with somewhat random.
        $randomState = $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'] . base_convert(memory_get_usage() % pow(10, 6), 10, 2) . microtime() . StringUtility::getUniqueId() . getmypid();
        while (!isset($bytes[($bytesToReturn - 1)])) {
            $randomState = sha1(microtime() . mt_rand() . $randomState);
            $bytes .= sha1(mt_rand() . $randomState, true);
        }
        return $bytes;
    }

    public static function idnaEncode($value)
    {
        if (isset(self::$idnaStringCache[$value])) {
            return self::$idnaStringCache[$value];
        } else {
            if (!self::$idnaConverter) {
                self::$idnaConverter = new \idna_convert(array('idn_version' => 2008));
            }
            self::$idnaStringCache[$value] = self::$idnaConverter->encode($value);
            return self::$idnaStringCache[$value];
        }
    }

    public static function getRandomHexString($count)
    {
        return substr(bin2hex(self::generateRandomBytes((int)(($count + 1) / 2))), 0, $count);
    }

    public static function underscoredToUpperCamelCase($string)
    {
        $upperCamelCase = str_replace(' ', '', ucwords(str_replace('_', ' ', self::strtolower($string))));
        return $upperCamelCase;
    }

    public static function underscoredToLowerCamelCase($string)
    {
        $upperCamelCase = str_replace(' ', '', ucwords(str_replace('_', ' ', self::strtolower($string))));
        $lowerCamelCase = self::lcfirst($upperCamelCase);
        return $lowerCamelCase;
    }

    public static function camelCaseToLowerCaseUnderscored($string)
    {
        return self::strtolower(preg_replace('/(?<=\\w)([A-Z])/', '_\\1', $string));
    }

    public static function lcfirst($string)
    {
        return self::strtolower($string[0]) . substr($string, 1);
    }

    public static function isValidUrl($url)
    {
        $parsedUrl = parse_url($url);
        if (!$parsedUrl || !isset($parsedUrl['scheme'])) {
            return false;
        }
        // HttpUtility::buildUrl() will always build urls with <scheme>://
        // our original $url might only contain <scheme>: (e.g. mail:)
        // so we convert that to the double-slashed version to ensure
        // our check against the $recomposedUrl is proper
        if (!self::isFirstPartOfStr($url, $parsedUrl['scheme'] . '://')) {
            $url = str_replace($parsedUrl['scheme'] . ':', $parsedUrl['scheme'] . '://', $url);
        }
        $recomposedUrl = HttpUtility::buildUrl($parsedUrl);
        if ($recomposedUrl !== $url) {
            // The parse_url() had to modify characters, so the URL is invalid
            return false;
        }
        if (isset($parsedUrl['host']) && !preg_match('/^[a-z0-9.\\-]*$/i', $parsedUrl['host'])) {
            $parsedUrl['host'] = self::idnaEncode($parsedUrl['host']);
        }
        return filter_var(HttpUtility::buildUrl($parsedUrl), FILTER_VALIDATE_URL) !== false;
    }

    /*************************
     *
     * ARRAY FUNCTIONS
     *
     *************************/
    public static function inArray(array $in_array, $item)
    {
        static::logDeprecatedFunction();
        return ArrayUtility::inArray($in_array, $item);
    }

    public static function intExplode($delimiter, $string, $removeEmptyValues = false, $limit = 0)
    {
        $result = explode($delimiter, $string);
        foreach ($result as $key => &$value) {
            if ($removeEmptyValues && ($value === '' || trim($value) === '')) {
                unset($result[$key]);
            } else {
                $value = (int)$value;
            }
        }
        unset($value);
        if ($limit !== 0) {
            if ($limit < 0) {
                $result = array_slice($result, 0, $limit);
            } elseif (count($result) > $limit) {
                $lastElements = array_slice($result, $limit - 1);
                $result = array_slice($result, 0, $limit - 1);
                $result[] = implode($delimiter, $lastElements);
            }
        }
        return $result;
    }

    public static function revExplode($delimiter, $string, $count = 0)
    {
        // 2 is the (currently, as of 2014-02) most-used value for $count in the core, therefore we check it first
        if ($count === 2) {
            $position = strrpos($string, strrev($delimiter));
            if ($position !== false) {
                return array(substr($string, 0, $position), substr($string, $position + strlen($delimiter)));
            } else {
                return array($string);
            }
        } elseif ($count <= 1) {
            return array($string);
        } else {
            $explodedValues = explode($delimiter, strrev($string), $count);
            $explodedValues = array_map('strrev', $explodedValues);
            return array_reverse($explodedValues);
        }
    }

    public static function trimExplode($delim, $string, $removeEmptyValues = false, $limit = 0)
    {
        $result = explode($delim, $string);
        if ($removeEmptyValues) {
            $temp = array();
            foreach ($result as $value) {
                if (trim($value) !== '') {
                    $temp[] = $value;
                }
            }
            $result = $temp;
        }
        if ($limit > 0 && count($result) > $limit) {
            $lastElements = array_splice($result, $limit - 1);
            $result[] = implode($delim, $lastElements);
        } elseif ($limit < 0) {
            $result = array_slice($result, 0, $limit);
        }
        $result = array_map('trim', $result);
        return $result;
    }

    public static function removeArrayEntryByValue(array $array, $cmpValue)
    {
        static::logDeprecatedFunction();
        return ArrayUtility::removeArrayEntryByValue($array, $cmpValue);
    }

    public static function keepItemsInArray(array $array, $keepItems, $getValueFunc = null)
    {
        static::logDeprecatedFunction();
        return ArrayUtility::keepItemsInArray($array, $keepItems, $getValueFunc);
    }

    public static function implodeArrayForUrl($name, array $theArray, $str = '', $skipBlank = false, $rawurlencodeParamName = false)
    {
        foreach ($theArray as $Akey => $AVal) {
            $thisKeyName = $name ? $name . '[' . $Akey . ']' : $Akey;
            if (is_array($AVal)) {
                $str = self::implodeArrayForUrl($thisKeyName, $AVal, $str, $skipBlank, $rawurlencodeParamName);
            } else {
                if (!$skipBlank || (string)$AVal !== '') {
                    $str .= '&' . ($rawurlencodeParamName ? rawurlencode($thisKeyName) : $thisKeyName) . '=' . rawurlencode($AVal);
                }
            }
        }
        return $str;
    }

    public static function explodeUrl2Array($string, $multidim = false)
    {
        $output = array();
        if ($multidim) {
            parse_str($string, $output);
        } else {
            $p = explode('&', $string);
            foreach ($p as $v) {
                if ($v !== '') {
                    list($pK, $pV) = explode('=', $v, 2);
                    $output[rawurldecode($pK)] = rawurldecode($pV);
                }
            }
        }
        return $output;
    }

    public static function compileSelectedGetVarsFromArray($varList, array $getArray, $GPvarAlt = true)
    {
        $keys = self::trimExplode(',', $varList, true);
        $outArr = array();
        foreach ($keys as $v) {
            if (isset($getArray[$v])) {
                $outArr[$v] = $getArray[$v];
            } elseif ($GPvarAlt) {
                $outArr[$v] = self::_GP($v);
            }
        }
        return $outArr;
    }

    public static function addSlashesOnArray(array &$theArray)
    {
        self::logDeprecatedFunction();
        foreach ($theArray as &$value) {
            if (is_array($value)) {
                self::addSlashesOnArray($value);
            } else {
                $value = addslashes($value);
            }
        }
        unset($value);
        reset($theArray);
    }

    public static function stripSlashesOnArray(array &$theArray)
    {
        foreach ($theArray as &$value) {
            if (is_array($value)) {
                self::stripSlashesOnArray($value);
            } else {
                $value = stripslashes($value);
            }
        }
        unset($value);
        reset($theArray);
    }

    public static function slashArray(array $arr, $cmd)
    {
        self::logDeprecatedFunction();
        if ($cmd == 'strip') {
            self::stripSlashesOnArray($arr);
        }
        if ($cmd == 'add') {
            self::addSlashesOnArray($arr);
        }
        return $arr;
    }

    public static function remapArrayKeys(&$array, $mappingTable)
    {
        static::logDeprecatedFunction();
        ArrayUtility::remapArrayKeys($array, $mappingTable);
    }

    public static function array_merge(array $arr1, array $arr2)
    {
        static::logDeprecatedFunction();
        return $arr2 + $arr1;
    }

    public static function arrayDiffAssocRecursive(array $array1, array $array2)
    {
        static::logDeprecatedFunction();
        return ArrayUtility::arrayDiffAssocRecursive($array1, $array2);
    }

    public static function csvValues(array $row, $delim = ',', $quote = '"')
    {
        $out = array();
        foreach ($row as $value) {
            $out[] = str_replace($quote, $quote . $quote, $value);
        }
        $str = $quote . implode(($quote . $delim . $quote), $out) . $quote;
        return $str;
    }

    public static function removeDotsFromTS(array $ts)
    {
        $out = array();
        foreach ($ts as $key => $value) {
            if (is_array($value)) {
                $key = rtrim($key, '.');
                $out[$key] = self::removeDotsFromTS($value);
            } else {
                $out[$key] = $value;
            }
        }
        return $out;
    }

    public static function naturalKeySortRecursive(&$array)
    {
        static::logDeprecatedFunction();
        return ArrayUtility::naturalKeySortRecursive($array);
    }

    /*************************
     *
     * HTML/XML PROCESSING
     *
     *************************/
    public static function get_tag_attributes($tag)
    {
        $components = self::split_tag_attributes($tag);
        // Attribute name is stored here
        $name = '';
        $valuemode = false;
        $attributes = array();
        foreach ($components as $key => $val) {
            // Only if $name is set (if there is an attribute, that waits for a value), that valuemode is enabled. This ensures that the attribute is assigned it's value
            if ($val != '=') {
                if ($valuemode) {
                    if ($name) {
                        $attributes[$name] = $val;
                        $name = '';
                    }
                } else {
                    if ($key = strtolower(preg_replace('/[^[:alnum:]_\\:\\-]/', '', $val))) {
                        $attributes[$key] = '';
                        $name = $key;
                    }
                }
                $valuemode = false;
            } else {
                $valuemode = true;
            }
        }
        return $attributes;
    }

    public static function split_tag_attributes($tag)
    {
        $tag_tmp = trim(preg_replace('/^<[^[:space:]]*/', '', trim($tag)));
        // Removes any > in the end of the string
        $tag_tmp = trim(rtrim($tag_tmp, '>'));
        $value = array();
        // Compared with empty string instead , 030102
        while ($tag_tmp !== '') {
            $firstChar = $tag_tmp[0];
            if ($firstChar === '"' || $firstChar === '\'') {
                $reg = explode($firstChar, $tag_tmp, 3);
                $value[] = $reg[1];
                $tag_tmp = trim($reg[2]);
            } elseif ($firstChar === '=') {
                $value[] = '=';
                // Removes = chars.
                $tag_tmp = trim(substr($tag_tmp, 1));
            } else {
                // There are '' around the value. We look for the next ' ' or '>'
                $reg = preg_split('/[[:space:]=]/', $tag_tmp, 2);
                $value[] = trim($reg[0]);
                $tag_tmp = trim(substr($tag_tmp, strlen($reg[0]), 1) . $reg[1]);
            }
        }
        reset($value);
        return $value;
    }

    public static function implodeAttributes(array $arr, $xhtmlSafe = false, $dontOmitBlankAttribs = false)
    {
        if ($xhtmlSafe) {
            $newArr = array();
            foreach ($arr as $p => $v) {
                if (!isset($newArr[strtolower($p)])) {
                    $newArr[strtolower($p)] = htmlspecialchars($v);
                }
            }
            $arr = $newArr;
        }
        $list = array();
        foreach ($arr as $p => $v) {
            if ((string)$v !== '' || $dontOmitBlankAttribs) {
                $list[] = $p . '="' . $v . '"';
            }
        }
        return implode(' ', $list);
    }

    public static function wrapJS($string, $linebreak = true)
    {
        if (trim($string)) {
            // <script wrapped in nl?
            $cr = $linebreak ? LF : '';
            // remove nl from the beginning
            $string = preg_replace('/^\\n+/', '', $string);
            // re-ident to one tab using the first line as reference
            $match = array();
            if (preg_match('/^(\\t+)/', $string, $match)) {
                $string = str_replace($match[1], TAB, $string);
            }
            $string = $cr . '<script type="text/javascript">
/*<![CDATA[*/
' . $string . '
/*]]>*/
</script>' . $cr;
        }
        return trim($string);
    }

    public static function xml2tree($string, $depth = 999, $parserOptions = array())
    {
        $parser = xml_parser_create();
        $vals = array();
        $index = array();
        xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
        xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 0);
        foreach ($parserOptions as $option => $value) {
            xml_parser_set_option($parser, $option, $value);
        }
        xml_parse_into_struct($parser, $string, $vals, $index);
        if (xml_get_error_code($parser)) {
            return 'Line ' . xml_get_current_line_number($parser) . ': ' . xml_error_string(xml_get_error_code($parser));
        }
        xml_parser_free($parser);
        $stack = array(array());
        $stacktop = 0;
        $startPoint = 0;
        $tagi = array();
        foreach ($vals as $key => $val) {
            $type = $val['type'];
            // open tag:
            if ($type == 'open' || $type == 'complete') {
                $stack[$stacktop++] = $tagi;
                if ($depth == $stacktop) {
                    $startPoint = $key;
                }
                $tagi = array('tag' => $val['tag']);
                if (isset($val['attributes'])) {
                    $tagi['attrs'] = $val['attributes'];
                }
                if (isset($val['value'])) {
                    $tagi['values'][] = $val['value'];
                }
            }
            // finish tag:
            if ($type == 'complete' || $type == 'close') {
                $oldtagi = $tagi;
                $tagi = $stack[--$stacktop];
                $oldtag = $oldtagi['tag'];
                unset($oldtagi['tag']);
                if ($depth == $stacktop + 1) {
                    if ($key - $startPoint > 0) {
                        $partArray = array_slice($vals, $startPoint + 1, $key - $startPoint - 1);
                        $oldtagi['XMLvalue'] = self::xmlRecompileFromStructValArray($partArray);
                    } else {
                        $oldtagi['XMLvalue'] = $oldtagi['values'][0];
                    }
                }
                $tagi['ch'][$oldtag][] = $oldtagi;
                unset($oldtagi);
            }
            // cdata
            if ($type == 'cdata') {
                $tagi['values'][] = $val['value'];
            }
        }
        return $tagi['ch'];
    }

    public static function array2xml_cs(array $array, $docTag = 'phparray', array $options = array(), $charset = '')
    {
        // Set default charset unless explicitly specified
        $charset = $charset ?: 'utf-8';
        // Return XML:
        return '<?xml version="1.0" encoding="' . htmlspecialchars($charset) . '" standalone="yes" ?>' . LF . self::array2xml($array, '', 0, $docTag, 0, $options);
    }

    public static function array2xml(array $array, $NSprefix = '', $level = 0, $docTag = 'phparray', $spaceInd = 0, array $options = array(), array $stackData = array())
    {
        // The list of byte values which will trigger binary-safe storage. If any value has one of these char values in it, it will be encoded in base64
        $binaryChars = chr(0) . chr(1) . chr(2) . chr(3) . chr(4) . chr(5) . chr(6) . chr(7) . chr(8) . chr(11) . chr(12) . chr(14) . chr(15) . chr(16) . chr(17) . chr(18) . chr(19) . chr(20) . chr(21) . chr(22) . chr(23) . chr(24) . chr(25) . chr(26) . chr(27) . chr(28) . chr(29) . chr(30) . chr(31);
        // Set indenting mode:
        $indentChar = $spaceInd ? ' ' : TAB;
        $indentN = $spaceInd > 0 ? $spaceInd : 1;
        $nl = $spaceInd >= 0 ? LF : '';
        // Init output variable:
        $output = '';
        // Traverse the input array
        foreach ($array as $k => $v) {
            $attr = '';
            $tagName = $k;
            // Construct the tag name.
            // Use tag based on grand-parent + parent tag name
            if (isset($options['grandParentTagMap'][$stackData['grandParentTagName'] . '/' . $stackData['parentTagName']])) {
                $attr .= ' index="' . htmlspecialchars($tagName) . '"';
                $tagName = (string)$options['grandParentTagMap'][($stackData['grandParentTagName'] . '/' . $stackData['parentTagName'])];
            } elseif (isset($options['parentTagMap'][$stackData['parentTagName'] . ':_IS_NUM']) && MathUtility::canBeInterpretedAsInteger($tagName)) {
                // Use tag based on parent tag name + if current tag is numeric
                $attr .= ' index="' . htmlspecialchars($tagName) . '"';
                $tagName = (string)$options['parentTagMap'][($stackData['parentTagName'] . ':_IS_NUM')];
            } elseif (isset($options['parentTagMap'][$stackData['parentTagName'] . ':' . $tagName])) {
                // Use tag based on parent tag name + current tag
                $attr .= ' index="' . htmlspecialchars($tagName) . '"';
                $tagName = (string)$options['parentTagMap'][($stackData['parentTagName'] . ':' . $tagName)];
            } elseif (isset($options['parentTagMap'][$stackData['parentTagName']])) {
                // Use tag based on parent tag name:
                $attr .= ' index="' . htmlspecialchars($tagName) . '"';
                $tagName = (string)$options['parentTagMap'][$stackData['parentTagName']];
            } elseif (MathUtility::canBeInterpretedAsInteger($tagName)) {
                // If integer...;
                if ($options['useNindex']) {
                    // If numeric key, prefix "n"
                    $tagName = 'n' . $tagName;
                } else {
                    // Use special tag for num. keys:
                    $attr .= ' index="' . $tagName . '"';
                    $tagName = $options['useIndexTagForNum'] ?: 'numIndex';
                }
            } elseif ($options['useIndexTagForAssoc']) {
                // Use tag for all associative keys:
                $attr .= ' index="' . htmlspecialchars($tagName) . '"';
                $tagName = $options['useIndexTagForAssoc'];
            }
            // The tag name is cleaned up so only alphanumeric chars (plus - and _) are in there and not longer than 100 chars either.
            $tagName = substr(preg_replace('/[^[:alnum:]_-]/', '', $tagName), 0, 100);
            // If the value is an array then we will call this function recursively:
            if (is_array($v)) {
                // Sub elements:
                if ($options['alt_options'][$stackData['path'] . '/' . $tagName]) {
                    $subOptions = $options['alt_options'][$stackData['path'] . '/' . $tagName];
                    $clearStackPath = $subOptions['clearStackPath'];
                } else {
                    $subOptions = $options;
                    $clearStackPath = false;
                }
                if (empty($v)) {
                    $content = '';
                } else {
                    $content = $nl . self::array2xml($v, $NSprefix, ($level + 1), '', $spaceInd, $subOptions, array(
                            'parentTagName' => $tagName,
                            'grandParentTagName' => $stackData['parentTagName'],
                            'path' => ($clearStackPath ? '' : $stackData['path'] . '/' . $tagName)
                        )) . ($spaceInd >= 0 ? str_pad('', ($level + 1) * $indentN, $indentChar) : '');
                }
                // Do not set "type = array". Makes prettier XML but means that empty arrays are not restored with xml2array
                if ((int)$options['disableTypeAttrib'] != 2) {
                    $attr .= ' type="array"';
                }
            } else {
                // Just a value:
                // Look for binary chars:
                $vLen = strlen($v);
                // Go for base64 encoding if the initial segment NOT matching any binary char has the same length as the whole string!
                if ($vLen && strcspn($v, $binaryChars) != $vLen) {
                    // If the value contained binary chars then we base64-encode it an set an attribute to notify this situation:
                    $content = $nl . chunk_split(base64_encode($v));
                    $attr .= ' base64="1"';
                } else {
                    // Otherwise, just htmlspecialchar the stuff:
                    $content = htmlspecialchars($v);
                    $dType = gettype($v);
                    if ($dType == 'string') {
                        if ($options['useCDATA'] && $content != $v) {
                            $content = '<![CDATA[' . $v . ']]>';
                        }
                    } elseif (!$options['disableTypeAttrib']) {
                        $attr .= ' type="' . $dType . '"';
                    }
                }
            }
            if ((string)$tagName !== '') {
                // Add the element to the output string:
                $output .= ($spaceInd >= 0 ? str_pad('', ($level + 1) * $indentN, $indentChar) : '')
                    . '<' . $NSprefix . $tagName . $attr . '>' . $content . '</' . $NSprefix . $tagName . '>' . $nl;
            }
        }
        // If we are at the outer-most level, then we finally wrap it all in the document tags and return that as the value:
        if (!$level) {
            $output = '<' . $docTag . '>' . $nl . $output . '</' . $docTag . '>';
        }
        return $output;
    }

    public static function xml2array($string, $NSprefix = '', $reportDocTag = false)
    {
        static $firstLevelCache = array();
        $identifier = md5($string . $NSprefix . ($reportDocTag ? '1' : '0'));
        // Look up in first level cache
        if (!empty($firstLevelCache[$identifier])) {
            $array = $firstLevelCache[$identifier];
        } else {
            // Look up in second level cache
            // @todo: Is this cache really required? It basically substitutes a little cpu work with a db query?
            $array = PageRepository::getHash($identifier, 0);
            if (!is_array($array)) {
                $array = self::xml2arrayProcess($string, $NSprefix, $reportDocTag);
                PageRepository::storeHash($identifier, $array, 'ident_xml2array');
            }
            // Store content in first level cache
            $firstLevelCache[$identifier] = $array;
        }
        return $array;
    }

    protected static function xml2arrayProcess($string, $NSprefix = '', $reportDocTag = false)
    {
        // Create parser:
        $parser = xml_parser_create();
        $vals = array();
        $index = array();
        xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
        xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 0);
        // Default output charset is UTF-8, only ASCII, ISO-8859-1 and UTF-8 are supported!!!
        $match = array();
        preg_match('/^[[:space:]]*<\\?xml[^>]*encoding[[:space:]]*=[[:space:]]*"([^"]*)"/', substr($string, 0, 200), $match);
        $theCharset = $match[1] ?: 'utf-8';
        // us-ascii / utf-8 / iso-8859-1
        xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, $theCharset);
        // Parse content:
        xml_parse_into_struct($parser, $string, $vals, $index);
        // If error, return error message:
        if (xml_get_error_code($parser)) {
            return 'Line ' . xml_get_current_line_number($parser) . ': ' . xml_error_string(xml_get_error_code($parser));
        }
        xml_parser_free($parser);
        // Init vars:
        $stack = array(array());
        $stacktop = 0;
        $current = array();
        $tagName = '';
        $documentTag = '';
        // Traverse the parsed XML structure:
        foreach ($vals as $key => $val) {
            // First, process the tag-name (which is used in both cases, whether "complete" or "close")
            $tagName = $val['tag'];
            if (!$documentTag) {
                $documentTag = $tagName;
            }
            // Test for name space:
            $tagName = $NSprefix && substr($tagName, 0, strlen($NSprefix)) == $NSprefix ? substr($tagName, strlen($NSprefix)) : $tagName;
            // Test for numeric tag, encoded on the form "nXXX":
            $testNtag = substr($tagName, 1);
            // Closing tag.
            $tagName = $tagName[0] === 'n' && MathUtility::canBeInterpretedAsInteger($testNtag) ? (int)$testNtag : $tagName;
            // Test for alternative index value:
            if ((string)$val['attributes']['index'] !== '') {
                $tagName = $val['attributes']['index'];
            }
            // Setting tag-values, manage stack:
            switch ($val['type']) {
                case 'open':
                    // If open tag it means there is an array stored in sub-elements. Therefore increase the stackpointer and reset the accumulation array:
                    // Setting blank place holder
                    $current[$tagName] = array();
                    $stack[$stacktop++] = $current;
                    $current = array();
                    break;
                case 'close':
                    // If the tag is "close" then it is an array which is closing and we decrease the stack pointer.
                    $oldCurrent = $current;
                    $current = $stack[--$stacktop];
                    // Going to the end of array to get placeholder key, key($current), and fill in array next:
                    end($current);
                    $current[key($current)] = $oldCurrent;
                    unset($oldCurrent);
                    break;
                case 'complete':
                    // If "complete", then it's a value. If the attribute "base64" is set, then decode the value, otherwise just set it.
                    if ($val['attributes']['base64']) {
                        $current[$tagName] = base64_decode($val['value']);
                    } else {
                        // Had to cast it as a string - otherwise it would be evaluate FALSE if tested with isset()!!
                        $current[$tagName] = (string)$val['value'];
                        // Cast type:
                        switch ((string)$val['attributes']['type']) {
                            case 'integer':
                                $current[$tagName] = (int)$current[$tagName];
                                break;
                            case 'double':
                                $current[$tagName] = (double) $current[$tagName];
                                break;
                            case 'boolean':
                                $current[$tagName] = (bool)$current[$tagName];
                                break;
                            case 'NULL':
                                $current[$tagName] = null;
                                break;
                            case 'array':
                                // MUST be an empty array since it is processed as a value; Empty arrays would end up here because they would have no tags inside...
                                $current[$tagName] = array();
                                break;
                        }
                    }
                    break;
            }
        }
        if ($reportDocTag) {
            $current[$tagName]['_DOCUMENT_TAG'] = $documentTag;
        }
        // Finally return the content of the document tag.
        return $current[$tagName];
    }

    public static function xmlRecompileFromStructValArray(array $vals)
    {
        $XMLcontent = '';
        foreach ($vals as $val) {
            $type = $val['type'];
            // Open tag:
            if ($type == 'open' || $type == 'complete') {
                $XMLcontent .= '<' . $val['tag'];
                if (isset($val['attributes'])) {
                    foreach ($val['attributes'] as $k => $v) {
                        $XMLcontent .= ' ' . $k . '="' . htmlspecialchars($v) . '"';
                    }
                }
                if ($type == 'complete') {
                    if (isset($val['value'])) {
                        $XMLcontent .= '>' . htmlspecialchars($val['value']) . '</' . $val['tag'] . '>';
                    } else {
                        $XMLcontent .= '/>';
                    }
                } else {
                    $XMLcontent .= '>';
                }
                if ($type == 'open' && isset($val['value'])) {
                    $XMLcontent .= htmlspecialchars($val['value']);
                }
            }
            // Finish tag:
            if ($type == 'close') {
                $XMLcontent .= '</' . $val['tag'] . '>';
            }
            // Cdata
            if ($type == 'cdata') {
                $XMLcontent .= htmlspecialchars($val['value']);
            }
        }
        return $XMLcontent;
    }

    public static function xmlGetHeaderAttribs($xmlData)
    {
        $match = array();
        if (preg_match('/^\\s*<\\?xml([^>]*)\\?\\>/', $xmlData, $match)) {
            return self::get_tag_attributes($match[1]);
        }
    }

    public static function minifyJavaScript($script, &$error = '')
    {
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['minifyJavaScript'])) {
            $fakeThis = false;
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['minifyJavaScript'] as $hookMethod) {
                try {
                    $parameters = array('script' => $script);
                    $script = static::callUserFunction($hookMethod, $parameters, $fakeThis);
                } catch (\Exception $e) {
                    $errorMessage = 'Error minifying java script: ' . $e->getMessage();
                    $error .= $errorMessage;
                    static::devLog($errorMessage, \TYPO3\CMS\Core\Utility\GeneralUtility::class, 2, array(
                        'JavaScript' => $script,
                        'Stack trace' => $e->getTrace(),
                        'hook' => $hookMethod
                    ));
                }
            }
        }
        return $script;
    }

    /*************************
     *
     * FILES FUNCTIONS
     *
     *************************/
    public static function getUrl($url, $includeHeader = 0, $requestHeaders = false, &$report = null)
    {
        $content = false;
        if (isset($report)) {
            $report['error'] = 0;
            $report['message'] = '';
        }
        // Use cURL for: http, https, ftp, ftps, sftp and scp
        if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlUse'] == '1' && preg_match('/^(?:http|ftp)s?|s(?:ftp|cp):/', $url)) {
            if (isset($report)) {
                $report['lib'] = 'cURL';
            }
            // External URL without error checking.
            if (!function_exists('curl_init') || !($ch = curl_init())) {
                if (isset($report)) {
                    $report['error'] = -1;
                    $report['message'] = 'Couldn\'t initialize cURL.';
                }
                return false;
            }

            $followLocationSucceeded = @curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);

            curl_setopt($ch, CURLOPT_URL, $url);
            curl_setopt($ch, CURLOPT_HEADER, !$followLocationSucceeded || $includeHeader ? 1 : 0);
            curl_setopt($ch, CURLOPT_NOBODY, $includeHeader == 2 ? 1 : 0);
            curl_setopt($ch, CURLOPT_HTTPGET, $includeHeader == 2 ? 'HEAD' : 'GET');
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
            curl_setopt($ch, CURLOPT_FAILONERROR, 1);
            curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, max(0, (int)$GLOBALS['TYPO3_CONF_VARS']['SYS']['curlTimeout']));

            if (is_array($requestHeaders)) {
                curl_setopt($ch, CURLOPT_HTTPHEADER, $requestHeaders);
            }
            // (Proxy support implemented by Arco <arco@appeltaart.mine.nu>)
            if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyServer']) {
                curl_setopt($ch, CURLOPT_PROXY, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyServer']);
                if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyNTLM']) {
                    curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_NTLM);
                }
                if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyTunnel']) {
                    curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyTunnel']);
                }
                if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyUserPass']) {
                    curl_setopt($ch, CURLOPT_PROXYUSERPWD, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyUserPass']);
                }
            }
            $content = curl_exec($ch);
            $curlInfo = curl_getinfo($ch);

            if (!$followLocationSucceeded) {
                // Check if we need to do redirects
                if ($curlInfo['http_code'] >= 300 && $curlInfo['http_code'] < 400) {
                    $locationUrl = $curlInfo['redirect_url'];
                    if (!$locationUrl) {
                        // Some curllib versions do not return redirect_url. Examine headers.
                        $locationUrl = self::getRedirectUrlFromHttpHeaders($content);
                    }
                    if ($locationUrl) {
                        $content = self::getUrl($locationUrl, $includeHeader, $requestHeaders, $report);
                        $followLocationSucceeded = true;
                    } else {
                        // Failure: we got a redirection status code but not the URL to redirect to.
                        $content = false;
                    }
                }
                if ($content && !$includeHeader) {
                    $content = self::stripHttpHeaders($content);
                }
            }

            if (isset($report)) {
                if (!$followLocationSucceeded && $curlInfo['http_code'] >= 300 && $curlInfo['http_code'] < 400) {
                    $report['http_code'] = $curlInfo['http_code'];
                    $report['content_type'] = $curlInfo['content_type'];
                    $report['error'] = CURLE_GOT_NOTHING;
                    $report['message'] = 'Expected "Location" header but got nothing.';
                } elseif ($content === false) {
                    $report['error'] = curl_errno($ch);
                    $report['message'] = curl_error($ch);
                } elseif ($includeHeader) {
                    // Set only for $includeHeader to work exactly like PHP variant
                    $report['http_code'] = $curlInfo['http_code'];
                    $report['content_type'] = $curlInfo['content_type'];
                }
            }
            curl_close($ch);
        } elseif ($includeHeader) {
            if (isset($report)) {
                $report['lib'] = 'socket';
            }
            $parsedURL = parse_url($url);
            if (!preg_match('/^https?/', $parsedURL['scheme'])) {
                if (isset($report)) {
                    $report['error'] = -1;
                    $report['message'] = 'Reading headers is not allowed for this protocol.';
                }
                return false;
            }
            $port = (int)$parsedURL['port'];
            if ($port < 1) {
                if ($parsedURL['scheme'] == 'http') {
                    $port = $port > 0 ? $port : 80;
                    $scheme = '';
                } else {
                    $port = $port > 0 ? $port : 443;
                    $scheme = 'ssl://';
                }
            }
            $errno = 0;
            $fp = @fsockopen(($scheme . $parsedURL['host']), $port, $errno, $errstr, 2.0);
            if (!$fp || $errno > 0) {
                if (isset($report)) {
                    $report['error'] = $errno ?: -1;
                    $report['message'] = $errno ? ($errstr ?: 'Socket error.') : 'Socket initialization error.';
                }
                return false;
            }
            $method = $includeHeader == 2 ? 'HEAD' : 'GET';
            $msg = $method . ' ' . (isset($parsedURL['path']) ? $parsedURL['path'] : '/') . ($parsedURL['query'] ? '?' . $parsedURL['query'] : '') . ' HTTP/1.0' . CRLF . 'Host: ' . $parsedURL['host'] . '

Connection: close

';
            if (is_array($requestHeaders)) {
                $msg .= implode(CRLF, $requestHeaders) . CRLF;
            }
            $msg .= CRLF;
            fputs($fp, $msg);
            while (!feof($fp)) {
                $line = fgets($fp, 2048);
                if (isset($report)) {
                    if (preg_match('|^HTTP/\\d\\.\\d +(\\d+)|', $line, $status)) {
                        $report['http_code'] = $status[1];
                    } elseif (preg_match('/^Content-Type: *(.*)/i', $line, $type)) {
                        $report['content_type'] = $type[1];
                    }
                }
                $content .= $line;
                if (trim($line) === '') {
                    // Stop at the first empty line (= end of header)
                    break;
                }
            }
            if ($includeHeader != 2) {
                $content .= stream_get_contents($fp);
            }
            fclose($fp);
        } elseif (is_array($requestHeaders)) {
            if (isset($report)) {
                $report['lib'] = 'file/context';
            }
            $parsedURL = parse_url($url);
            if (!preg_match('/^https?/', $parsedURL['scheme'])) {
                if (isset($report)) {
                    $report['error'] = -1;
                    $report['message'] = 'Sending request headers is not allowed for this protocol.';
                }
                return false;
            }
            $ctx = stream_context_create(array(
                'http' => array(
                    'header' => implode(CRLF, $requestHeaders)
                )
            ));
            $defaultCtx = stream_context_get_default();
            if ($defaultCtx) {
                $content = @file_get_contents($url);
            } else {
                $content = @file_get_contents($url, false, $ctx);
            }
            if ($content === false && isset($report)) {
                $report['error'] = -1;
                $report['message'] = 'Couldn\'t get URL: ' . (isset($http_response_header) ? implode(LF, $http_response_header) : $url);
            }
        } else {
            if (isset($report)) {
                $report['lib'] = 'file';
            }
            $content = @file_get_contents($url);
            if ($content === false && isset($report)) {
                $report['error'] = -1;
                $report['message'] = 'Couldn\'t get URL: ' . (isset($http_response_header) ? implode(LF, $http_response_header) : $url);
            }
        }
        return $content;
    }

    protected static function getRedirectUrlFromHttpHeaders($content)
    {
        $result = '';
        $headers = explode("\r\n", $content);
        foreach ($headers as $header) {
            if ($header == '') {
                break;
            }
            if (preg_match('/^\s*Location\s*:/i', $header)) {
                list(, $result) = self::trimExplode(':', $header, false, 2);
                if ($result) {
                    $result = self::locationHeaderUrl($result);
                }
                break;
            }
        }
        return $result;
    }

    protected static function stripHttpHeaders($content)
    {
        $headersEndPos = strpos($content, "\r\n\r\n");
        if ($headersEndPos) {
            $content = substr($content, $headersEndPos + 4);
        }
        return $content;
    }

    public static function writeFile($file, $content, $changePermissions = false)
    {
        if (!@is_file($file)) {
            $changePermissions = true;
        }
        if ($fd = fopen($file, 'wb')) {
            $res = fwrite($fd, $content);
            fclose($fd);
            if ($res === false) {
                return false;
            }
            // Change the permissions only if the file has just been created
            if ($changePermissions) {
                static::fixPermissions($file);
            }
            return true;
        }
        return false;
    }

    public static function fixPermissions($path, $recursive = false)
    {
        if (TYPO3_OS === 'WIN') {
            return true;
        }
        $result = false;
        // Make path absolute
        if (!static::isAbsPath($path)) {
            $path = static::getFileAbsFileName($path, false);
        }
        if (static::isAllowedAbsPath($path)) {
            if (@is_file($path)) {
                $targetPermissions = isset($GLOBALS['TYPO3_CONF_VARS']['SYS']['fileCreateMask'])
                    ? $GLOBALS['TYPO3_CONF_VARS']['SYS']['fileCreateMask']
                    : '0644';
            } elseif (@is_dir($path)) {
                $targetPermissions = isset($GLOBALS['TYPO3_CONF_VARS']['SYS']['folderCreateMask'])
                    ? $GLOBALS['TYPO3_CONF_VARS']['SYS']['folderCreateMask']
                    : '0755';
            }
            if (!empty($targetPermissions)) {
                // make sure it's always 4 digits
                $targetPermissions = str_pad($targetPermissions, 4, 0, STR_PAD_LEFT);
                $targetPermissions = octdec($targetPermissions);
                // "@" is there because file is not necessarily OWNED by the user
                $result = @chmod($path, $targetPermissions);
            }
            // Set createGroup if not empty
            if (
                isset($GLOBALS['TYPO3_CONF_VARS']['SYS']['createGroup'])
                && $GLOBALS['TYPO3_CONF_VARS']['SYS']['createGroup'] !== ''
            ) {
                // "@" is there because file is not necessarily OWNED by the user
                $changeGroupResult = @chgrp($path, $GLOBALS['TYPO3_CONF_VARS']['SYS']['createGroup']);
                $result = $changeGroupResult ? $result : false;
            }
            // Call recursive if recursive flag if set and $path is directory
            if ($recursive && @is_dir($path)) {
                $handle = opendir($path);
                while (($file = readdir($handle)) !== false) {
                    $recursionResult = null;
                    if ($file !== '.' && $file !== '..') {
                        if (@is_file(($path . '/' . $file))) {
                            $recursionResult = static::fixPermissions($path . '/' . $file);
                        } elseif (@is_dir(($path . '/' . $file))) {
                            $recursionResult = static::fixPermissions($path . '/' . $file, true);
                        }
                        if (isset($recursionResult) && !$recursionResult) {
                            $result = false;
                        }
                    }
                }
                closedir($handle);
            }
        }
        return $result;
    }

    public static function writeFileToTypo3tempDir($filepath, $content)
    {
        if (!defined('PATH_site')) {
            return 'PATH_site constant was NOT defined!';
        }

        // Parse filepath into directory and basename:
        $fI = pathinfo($filepath);
        $fI['dirname'] .= '/';
        // Check parts:
        if (!static::validPathStr($filepath) || !$fI['basename'] || strlen($fI['basename']) >= 60) {
            return 'Input filepath "' . $filepath . '" was generally invalid!';
        }
        // Setting main temporary directory name (standard)
        $dirName = PATH_site . 'typo3temp/';
        if (!@is_dir($dirName)) {
            return 'PATH_site + "typo3temp/" was not a directory!';
        }
        if (!static::isFirstPartOfStr($fI['dirname'], $dirName)) {
            return '"' . $fI['dirname'] . '" was not within directory PATH_site + "typo3temp/"';
        }
        // Checking if the "subdir" is found:
        $subdir = substr($fI['dirname'], strlen($dirName));
        if ($subdir) {
            if (preg_match('/^[[:alnum:]_]+\\/$/', $subdir) || preg_match('/^[[:alnum:]_]+\\/[[:alnum:]_]+\\/$/', $subdir)) {
                $dirName .= $subdir;
                if (!@is_dir($dirName)) {
                    static::mkdir_deep(PATH_site . 'typo3temp/', $subdir);
                }
            } else {
                return 'Subdir, "' . $subdir . '", was NOT on the form "[[:alnum:]_]/" or  "[[:alnum:]_]/[[:alnum:]_]/"';
            }
        }
        // Checking dir-name again (sub-dir might have been created):
        if (@is_dir($dirName)) {
            if ($filepath == $dirName . $fI['basename']) {
                static::writeFile($filepath, $content);
                if (!@is_file($filepath)) {
                    return 'The file was not written to the disk. Please, check that you have write permissions to the typo3temp/ directory.';
                }
            } else {
                return 'Calculated filelocation didn\'t match input "' . $filepath . '".';
            }
        } else {
            return '"' . $dirName . '" is not a directory!';
        }
        return null;
    }

    public static function mkdir($newFolder)
    {
        $result = @mkdir($newFolder, octdec($GLOBALS['TYPO3_CONF_VARS']['SYS']['folderCreateMask']));
        if ($result) {
            static::fixPermissions($newFolder);
        }
        return $result;
    }

    public static function mkdir_deep($directory, $deepDirectory = '')
    {
        if (!is_string($directory)) {
            throw new \InvalidArgumentException('The specified directory is of type "' . gettype($directory) . '" but a string is expected.', 1303662955);
        }
        if (!is_string($deepDirectory)) {
            throw new \InvalidArgumentException('The specified directory is of type "' . gettype($deepDirectory) . '" but a string is expected.', 1303662956);
        }
        // Ensure there is only one slash
        $fullPath = rtrim($directory, '/') . '/' . ltrim($deepDirectory, '/');
        if ($fullPath !== '' && !is_dir($fullPath)) {
            $firstCreatedPath = static::createDirectoryPath($fullPath);
            if ($firstCreatedPath !== '') {
                static::fixPermissions($firstCreatedPath, true);
            }
        }
    }

    protected static function createDirectoryPath($fullDirectoryPath)
    {
        $currentPath = $fullDirectoryPath;
        $firstCreatedPath = '';
        $permissionMask = octdec($GLOBALS['TYPO3_CONF_VARS']['SYS']['folderCreateMask']);
        if (!@is_dir($currentPath)) {
            do {
                $firstCreatedPath = $currentPath;
                $separatorPosition = strrpos($currentPath, DIRECTORY_SEPARATOR);
                $currentPath = substr($currentPath, 0, $separatorPosition);
            } while (!is_dir($currentPath) && $separatorPosition !== false);
            $result = @mkdir($fullDirectoryPath, $permissionMask, true);
            // Check existence of directory again to avoid race condition. Directory could have get created by another process between previous is_dir() and mkdir()
            if (!$result && !@is_dir($fullDirectoryPath)) {
                throw new \RuntimeException('Could not create directory "' . $fullDirectoryPath . '"!', 1170251401);
            }
        }
        return $firstCreatedPath;
    }

    public static function rmdir($path, $removeNonEmpty = false)
    {
        $OK = false;
        // Remove trailing slash
        $path = preg_replace('|/$|', '', $path);
        if (file_exists($path)) {
            $OK = true;
            if (!is_link($path) && is_dir($path)) {
                if ($removeNonEmpty == true && ($handle = @opendir($path))) {
                    while ($OK && false !== ($file = readdir($handle))) {
                        if ($file == '.' || $file == '..') {
                            continue;
                        }
                        $OK = static::rmdir($path . '/' . $file, $removeNonEmpty);
                    }
                    closedir($handle);
                }
                if ($OK) {
                    $OK = @rmdir($path);
                }
            } elseif (is_link($path) && is_dir($path) && TYPO3_OS === 'WIN') {
                $OK = @rmdir($path);
            } else {
                // If $path is a file, simply remove it
                $OK = @unlink($path);
            }
            clearstatcache();
        } elseif (is_link($path)) {
            $OK = @unlink($path);
            clearstatcache();
        }
        return $OK;
    }

    public static function flushDirectory($directory, $keepOriginalDirectory = false, $flushOpcodeCache = false)
    {
        $result = false;

        if (is_dir($directory)) {
            $temporaryDirectory = rtrim($directory, '/') . '.' . StringUtility::getUniqueId('remove') . '/';
            if (rename($directory, $temporaryDirectory)) {
                if ($flushOpcodeCache) {
                    GeneralUtility::makeInstance(OpcodeCacheService::class)->clearAllActive($directory);
                }
                if ($keepOriginalDirectory) {
                    static::mkdir($directory);
                }
                clearstatcache();
                $result = static::rmdir($temporaryDirectory, true);
            }
        }

        return $result;
    }

    public static function get_dirs($path)
    {
        if ($path) {
            if (is_dir($path)) {
                $dir = scandir($path);
                $dirs = array();
                foreach ($dir as $entry) {
                    if (is_dir($path . '/' . $entry) && $entry != '..' && $entry != '.') {
                        $dirs[] = $entry;
                    }
                }
            } else {
                $dirs = 'error';
            }
        }
        return $dirs;
    }

    public static function getFilesInDir($path, $extensionList = '', $prependPath = false, $order = '', $excludePattern = '')
    {
        $excludePattern = (string)$excludePattern;
        $path = rtrim($path, '/');
        if (!@is_dir($path)) {
            return array();
        }

        $rawFileList = scandir($path);
        if ($rawFileList === false) {
            return 'error opening path: "' . $path . '"';
        }

        $pathPrefix = $path . '/';
        $extensionList = ',' . $extensionList . ',';
        $files = array();
        foreach ($rawFileList as $entry) {
            $completePathToEntry = $pathPrefix . $entry;
            if (!@is_file($completePathToEntry)) {
                continue;
            }

            if (
                ($extensionList === ',,' || stripos($extensionList, ',' . pathinfo($entry, PATHINFO_EXTENSION) . ',') !== false)
                && ($excludePattern === '' || !preg_match(('/^' . $excludePattern . '$/'), $entry))
            ) {
                if ($order !== 'mtime') {
                    $files[] = $entry;
                } else {
                    // Store the value in the key so we can do a fast asort later.
                    $files[$entry] = filemtime($completePathToEntry);
                }
            }
        }

        $valueName = 'value';
        if ($order === 'mtime') {
            asort($files);
            $valueName = 'key';
        }

        $valuePathPrefix = $prependPath ? $pathPrefix : '';
        $foundFiles = array();
        foreach ($files as $key => $value) {
            // Don't change this ever - extensions may depend on the fact that the hash is an md5 of the path! (import/export extension)
            $foundFiles[md5($pathPrefix . ${$valueName})] = $valuePathPrefix . ${$valueName};
        }

        return $foundFiles;
    }

    public static function getAllFilesAndFoldersInPath(array $fileArr, $path, $extList = '', $regDirs = false, $recursivityLevels = 99, $excludePattern = '')
    {
        if ($regDirs) {
            $fileArr[md5($path)] = $path;
        }
        $fileArr = array_merge($fileArr, self::getFilesInDir($path, $extList, 1, 1, $excludePattern));
        $dirs = self::get_dirs($path);
        if ($recursivityLevels > 0 && is_array($dirs)) {
            foreach ($dirs as $subdirs) {
                if ((string)$subdirs !== '' && ($excludePattern === '' || !preg_match(('/^' . $excludePattern . '$/'), $subdirs))) {
                    $fileArr = self::getAllFilesAndFoldersInPath($fileArr, $path . $subdirs . '/', $extList, $regDirs, $recursivityLevels - 1, $excludePattern);
                }
            }
        }
        return $fileArr;
    }

    public static function removePrefixPathFromList(array $fileArr, $prefixToRemove)
    {
        foreach ($fileArr as $k => &$absFileRef) {
            if (self::isFirstPartOfStr($absFileRef, $prefixToRemove)) {
                $absFileRef = substr($absFileRef, strlen($prefixToRemove));
            } else {
                return 'ERROR: One or more of the files was NOT prefixed with the prefix-path!';
            }
        }
        unset($absFileRef);
        return $fileArr;
    }

    public static function fixWindowsFilePath($theFile)
    {
        return str_replace(array('\\', '//'), '/', $theFile);
    }

    public static function resolveBackPath($pathStr)
    {
        if (strpos($pathStr, '..') === false) {
            return $pathStr;
        }
        $parts = explode('/', $pathStr);
        $output = array();
        $c = 0;
        foreach ($parts as $part) {
            if ($part === '..') {
                if ($c) {
                    array_pop($output);
                    --$c;
                } else {
                    $output[] = $part;
                }
            } else {
                ++$c;
                $output[] = $part;
            }
        }
        return implode('/', $output);
    }

    public static function locationHeaderUrl($path)
    {
        $uI = parse_url($path);
        // relative to HOST
        if ($path[0] === '/') {
            $path = self::getIndpEnv('TYPO3_REQUEST_HOST') . $path;
        } elseif (!$uI['scheme']) {
            // No scheme either
            $path = self::getIndpEnv('TYPO3_REQUEST_DIR') . $path;
        }
        return $path;
    }

    public static function getMaxUploadFileSize()
    {
        // Check for PHP restrictions of the maximum size of one of the $_FILES
        $phpUploadLimit = self::getBytesFromSizeMeasurement(ini_get('upload_max_filesize'));
        // Check for PHP restrictions of the maximum $_POST size
        $phpPostLimit = self::getBytesFromSizeMeasurement(ini_get('post_max_size'));
        // If the total amount of post data is smaller (!) than the upload_max_filesize directive,
        // then this is the real limit in PHP
        $phpUploadLimit = $phpPostLimit > 0 && $phpPostLimit < $phpUploadLimit ? $phpPostLimit : $phpUploadLimit;
        return floor(($phpUploadLimit)) / 1024;
    }

    public static function getBytesFromSizeMeasurement($measurement)
    {
        $bytes = doubleval($measurement);
        if (stripos($measurement, 'G')) {
            $bytes *= 1024 * 1024 * 1024;
        } elseif (stripos($measurement, 'M')) {
            $bytes *= 1024 * 1024;
        } elseif (stripos($measurement, 'K')) {
            $bytes *= 1024;
        }
        return $bytes;
    }

    public static function getMaximumPathLength()
    {
        return PHP_MAXPATHLEN;
    }

    public static function createVersionNumberedFilename($file)
    {
        $lookupFile = explode('?', $file);
        $path = self::resolveBackPath(self::dirname(PATH_thisScript) . '/' . $lookupFile[0]);

        $doNothing = false;
        if (TYPO3_MODE == 'FE') {
            $mode = strtolower($GLOBALS['TYPO3_CONF_VARS'][TYPO3_MODE]['versionNumberInFilename']);
            if ($mode === 'embed') {
                $mode = true;
            } else {
                if ($mode === 'querystring') {
                    $mode = false;
                } else {
                    $doNothing = true;
                }
            }
        } else {
            $mode = $GLOBALS['TYPO3_CONF_VARS'][TYPO3_MODE]['versionNumberInFilename'];
        }
        if (!file_exists($path) || $doNothing) {
            // File not found, return filename unaltered
            $fullName = $file;
        } else {
            if (!$mode) {
                // If use of .htaccess rule is not configured,
                // we use the default query-string method
                if ($lookupFile[1]) {
                    $separator = '&';
                } else {
                    $separator = '?';
                }
                $fullName = $file . $separator . filemtime($path);
            } else {
                // Change the filename
                $name = explode('.', $lookupFile[0]);
                $extension = array_pop($name);
                array_push($name, filemtime($path), $extension);
                $fullName = implode('.', $name);
                // Append potential query string
                $fullName .= $lookupFile[1] ? '?' . $lookupFile[1] : '';
            }
        }
        return $fullName;
    }

    /*************************
     *
     * SYSTEM INFORMATION
     *
     *************************/
    public static function getThisUrl()
    {
        self::logDeprecatedFunction();
        // Url of this script
        $p = parse_url(self::getIndpEnv('TYPO3_REQUEST_SCRIPT'));
        $dir = self::dirname($p['path']) . '/';
        // Strip file
        $url = str_replace('//', '/', $p['host'] . ($p['port'] ? ':' . $p['port'] : '') . $dir);
        return $url;
    }

    public static function linkThisScript(array $getParams = array())
    {
        $parts = self::getIndpEnv('SCRIPT_NAME');
        $params = self::_GET();
        foreach ($getParams as $key => $value) {
            if ($value !== '') {
                $params[$key] = $value;
            } else {
                unset($params[$key]);
            }
        }
        $pString = self::implodeArrayForUrl('', $params);
        return $pString ? $parts . '?' . ltrim($pString, '&') : $parts;
    }

    public static function linkThisUrl($url, array $getParams = array())
    {
        $parts = parse_url($url);
        $getP = array();
        if ($parts['query']) {
            parse_str($parts['query'], $getP);
        }
        ArrayUtility::mergeRecursiveWithOverrule($getP, $getParams);
        $uP = explode('?', $url);
        $params = self::implodeArrayForUrl('', $getP);
        $outurl = $uP[0] . ($params ? '?' . substr($params, 1) : '');
        return $outurl;
    }

    public static function getIndpEnv($getEnvName)
    {
        if (isset(self::$indpEnvCache[$getEnvName])) {
            return self::$indpEnvCache[$getEnvName];
        }

        /*
        Conventions:
        output from parse_url():
        URL:    http://username:password@192.168.1.4:8080/typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/?arg1,arg2,arg3&p1=parameter1&p2[key]=value#link1
        [scheme] => 'http'
        [user] => 'username'
        [pass] => 'password'
        [host] => '192.168.1.4'
        [port] => '8080'
        [path] => '/typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/'
        [query] => 'arg1,arg2,arg3&p1=parameter1&p2[key]=value'
        [fragment] => 'link1'Further definition: [path_script] = '/typo3/32/temp/phpcheck/index.php'
        [path_dir] = '/typo3/32/temp/phpcheck/'
        [path_info] = '/arg1/arg2/arg3/'
        [path] = [path_script/path_dir][path_info]Keys supported:URI______:
        REQUEST_URI             =       [path]?[query]          = /typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/?arg1,arg2,arg3&p1=parameter1&p2[key]=value
        HTTP_HOST               =       [host][:[port]]         = 192.168.1.4:8080
        SCRIPT_NAME             =       [path_script]++         = /typo3/32/temp/phpcheck/index.php             // NOTICE THAT SCRIPT_NAME will return the php-script name ALSO. [path_script] may not do that (eg. '/somedir/' may result in SCRIPT_NAME '/somedir/index.php')!
        PATH_INFO               =       [path_info]                     = /arg1/arg2/arg3/
        QUERY_STRING    =       [query]                         = arg1,arg2,arg3&p1=parameter1&p2[key]=value
        HTTP_REFERER    =       [scheme]://[host][:[port]][path]        = http://192.168.1.4:8080/typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/?arg1,arg2,arg3&p1=parameter1&p2[key]=value
        (Notice: NO username/password + NO fragment)CLIENT____:
        REMOTE_ADDR             =       (client IP)
        REMOTE_HOST             =       (client host)
        HTTP_USER_AGENT =       (client user agent)
        HTTP_ACCEPT_LANGUAGE    = (client accept language)SERVER____:
        SCRIPT_FILENAME =       Absolute filename of script             (Differs between windows/unix). On windows 'C:\\blabla\\blabl\\' will be converted to 'C:/blabla/blabl/'Special extras:
        TYPO3_HOST_ONLY =               [host] = 192.168.1.4
        TYPO3_PORT =                    [port] = 8080 (blank if 80, taken from host value)
        TYPO3_REQUEST_HOST =            [scheme]://[host][:[port]]
        TYPO3_REQUEST_URL =             [scheme]://[host][:[port]][path]?[query] (scheme will by default be "http" until we can detect something different)
        TYPO3_REQUEST_SCRIPT =          [scheme]://[host][:[port]][path_script]
        TYPO3_REQUEST_DIR =             [scheme]://[host][:[port]][path_dir]
        TYPO3_SITE_URL =                [scheme]://[host][:[port]][path_dir] of the TYPO3 website frontend
        TYPO3_SITE_PATH =               [path_dir] of the TYPO3 website frontend
        TYPO3_SITE_SCRIPT =             [script / Speaking URL] of the TYPO3 website
        TYPO3_DOCUMENT_ROOT =           Absolute path of root of documents: TYPO3_DOCUMENT_ROOT.SCRIPT_NAME = SCRIPT_FILENAME (typically)
        TYPO3_SSL =                     Returns TRUE if this session uses SSL/TLS (https)
        TYPO3_PROXY =                   Returns TRUE if this session runs over a well known proxyNotice: [fragment] is apparently NEVER available to the script!Testing suggestions:
        - Output all the values.
        - In the script, make a link to the script it self, maybe add some parameters and click the link a few times so HTTP_REFERER is seen
        - ALSO TRY the script from the ROOT of a site (like 'http://www.mytest.com/' and not 'http://www.mytest.com/test/' !!)
         */
        $retVal = '';
        switch ((string)$getEnvName) {
            case 'SCRIPT_NAME':
                $retVal = self::isRunningOnCgiServerApi()
                    && ($_SERVER['ORIG_PATH_INFO'] ?: $_SERVER['PATH_INFO'])
                        ? ($_SERVER['ORIG_PATH_INFO'] ?: $_SERVER['PATH_INFO'])
                        : ($_SERVER['ORIG_SCRIPT_NAME'] ?: $_SERVER['SCRIPT_NAME']);
                // Add a prefix if TYPO3 is behind a proxy: ext-domain.com => int-server.com/prefix
                if (self::cmpIP($_SERVER['REMOTE_ADDR'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyIP'])) {
                    if (self::getIndpEnv('TYPO3_SSL') && $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyPrefixSSL']) {
                        $retVal = $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyPrefixSSL'] . $retVal;
                    } elseif ($GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyPrefix']) {
                        $retVal = $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyPrefix'] . $retVal;
                    }
                }
                break;
            case 'SCRIPT_FILENAME':
                $retVal = PATH_thisScript;
                break;
            case 'REQUEST_URI':
                // Typical application of REQUEST_URI is return urls, forms submitting to itself etc. Example: returnUrl='.rawurlencode(\TYPO3\CMS\Core\Utility\GeneralUtility::getIndpEnv('REQUEST_URI'))
                if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['requestURIvar']) {
                    // This is for URL rewriters that store the original URI in a server variable (eg ISAPI_Rewriter for IIS: HTTP_X_REWRITE_URL)
                    list($v, $n) = explode('|', $GLOBALS['TYPO3_CONF_VARS']['SYS']['requestURIvar']);
                    $retVal = $GLOBALS[$v][$n];
                } elseif (!$_SERVER['REQUEST_URI']) {
                    // This is for ISS/CGI which does not have the REQUEST_URI available.
                    $retVal = '/' . ltrim(self::getIndpEnv('SCRIPT_NAME'), '/') . ($_SERVER['QUERY_STRING'] ? '?' . $_SERVER['QUERY_STRING'] : '');
                } else {
                    $retVal = '/' . ltrim($_SERVER['REQUEST_URI'], '/');
                }
                // Add a prefix if TYPO3 is behind a proxy: ext-domain.com => int-server.com/prefix
                if (self::cmpIP($_SERVER['REMOTE_ADDR'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyIP'])) {
                    if (self::getIndpEnv('TYPO3_SSL') && $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyPrefixSSL']) {
                        $retVal = $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyPrefixSSL'] . $retVal;
                    } elseif ($GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyPrefix']) {
                        $retVal = $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyPrefix'] . $retVal;
                    }
                }
                break;
            case 'PATH_INFO':
                // $_SERVER['PATH_INFO'] != $_SERVER['SCRIPT_NAME'] is necessary because some servers (Windows/CGI)
                // are seen to set PATH_INFO equal to script_name
                // Further, there must be at least one '/' in the path - else the PATH_INFO value does not make sense.
                // IF 'PATH_INFO' never works for our purpose in TYPO3 with CGI-servers,
                // then 'PHP_SAPI=='cgi'' might be a better check.
                // Right now strcmp($_SERVER['PATH_INFO'], GeneralUtility::getIndpEnv('SCRIPT_NAME')) will always
                // return FALSE for CGI-versions, but that is only as long as SCRIPT_NAME is set equal to PATH_INFO
                // because of PHP_SAPI=='cgi' (see above)
                if (!self::isRunningOnCgiServerApi()) {
                    $retVal = $_SERVER['PATH_INFO'];
                }
                break;
            case 'TYPO3_REV_PROXY':
                $retVal = self::cmpIP($_SERVER['REMOTE_ADDR'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyIP']);
                break;
            case 'REMOTE_ADDR':
                $retVal = $_SERVER['REMOTE_ADDR'];
                if (self::cmpIP($_SERVER['REMOTE_ADDR'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyIP'])) {
                    $ip = self::trimExplode(',', $_SERVER['HTTP_X_FORWARDED_FOR']);
                    // Choose which IP in list to use
                    if (!empty($ip)) {
                        switch ($GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyHeaderMultiValue']) {
                            case 'last':
                                $ip = array_pop($ip);
                                break;
                            case 'first':
                                $ip = array_shift($ip);
                                break;
                            case 'none':

                            default:
                                $ip = '';
                        }
                    }
                    if (self::validIP($ip)) {
                        $retVal = $ip;
                    }
                }
                break;
            case 'HTTP_HOST':
                $retVal = $_SERVER['HTTP_HOST'];
                if (self::cmpIP($_SERVER['REMOTE_ADDR'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyIP'])) {
                    $host = self::trimExplode(',', $_SERVER['HTTP_X_FORWARDED_HOST']);
                    // Choose which host in list to use
                    if (!empty($host)) {
                        switch ($GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyHeaderMultiValue']) {
                            case 'last':
                                $host = array_pop($host);
                                break;
                            case 'first':
                                $host = array_shift($host);
                                break;
                            case 'none':

                            default:
                                $host = '';
                        }
                    }
                    if ($host) {
                        $retVal = $host;
                    }
                }
                if (!static::isAllowedHostHeaderValue($retVal)) {
                    throw new \UnexpectedValueException(
                        'The current host header value does not match the configured trusted hosts pattern! Check the pattern defined in $GLOBALS[\'TYPO3_CONF_VARS\'][\'SYS\'][\'trustedHostsPattern\'] and adapt it, if you want to allow the current host header \'' . $retVal . '\' for your installation.',
                        1396795884
                    );
                }
                break;
            case 'HTTP_REFERER':

            case 'HTTP_USER_AGENT':

            case 'HTTP_ACCEPT_ENCODING':

            case 'HTTP_ACCEPT_LANGUAGE':

            case 'REMOTE_HOST':

            case 'QUERY_STRING':
                $retVal = '';
                if (isset($_SERVER[$getEnvName])) {
                    $retVal = $_SERVER[$getEnvName];
                }
                break;
            case 'TYPO3_DOCUMENT_ROOT':
                // Get the web root (it is not the root of the TYPO3 installation)
                // The absolute path of the script can be calculated with TYPO3_DOCUMENT_ROOT + SCRIPT_FILENAME
                // Some CGI-versions (LA13CGI) and mod-rewrite rules on MODULE versions will deliver a 'wrong' DOCUMENT_ROOT (according to our description). Further various aliases/mod_rewrite rules can disturb this as well.
                // Therefore the DOCUMENT_ROOT is now always calculated as the SCRIPT_FILENAME minus the end part shared with SCRIPT_NAME.
                $SFN = self::getIndpEnv('SCRIPT_FILENAME');
                $SN_A = explode('/', strrev(self::getIndpEnv('SCRIPT_NAME')));
                $SFN_A = explode('/', strrev($SFN));
                $acc = array();
                foreach ($SN_A as $kk => $vv) {
                    if ((string)$SFN_A[$kk] === (string)$vv) {
                        $acc[] = $vv;
                    } else {
                        break;
                    }
                }
                $commonEnd = strrev(implode('/', $acc));
                if ((string)$commonEnd !== '') {
                    $DR = substr($SFN, 0, -(strlen($commonEnd) + 1));
                }
                $retVal = $DR;
                break;
            case 'TYPO3_HOST_ONLY':
                $httpHost = self::getIndpEnv('HTTP_HOST');
                $httpHostBracketPosition = strpos($httpHost, ']');
                $httpHostParts = explode(':', $httpHost);
                $retVal = $httpHostBracketPosition !== false ? substr($httpHost, 0, $httpHostBracketPosition + 1) : array_shift($httpHostParts);
                break;
            case 'TYPO3_PORT':
                $httpHost = self::getIndpEnv('HTTP_HOST');
                $httpHostOnly = self::getIndpEnv('TYPO3_HOST_ONLY');
                $retVal = strlen($httpHost) > strlen($httpHostOnly) ? substr($httpHost, strlen($httpHostOnly) + 1) : '';
                break;
            case 'TYPO3_REQUEST_HOST':
                $retVal = (self::getIndpEnv('TYPO3_SSL') ? 'https://' : 'http://') . self::getIndpEnv('HTTP_HOST');
                break;
            case 'TYPO3_REQUEST_URL':
                $retVal = self::getIndpEnv('TYPO3_REQUEST_HOST') . self::getIndpEnv('REQUEST_URI');
                break;
            case 'TYPO3_REQUEST_SCRIPT':
                $retVal = self::getIndpEnv('TYPO3_REQUEST_HOST') . self::getIndpEnv('SCRIPT_NAME');
                break;
            case 'TYPO3_REQUEST_DIR':
                $retVal = self::getIndpEnv('TYPO3_REQUEST_HOST') . self::dirname(self::getIndpEnv('SCRIPT_NAME')) . '/';
                break;
            case 'TYPO3_SITE_URL':
                $url = self::getIndpEnv('TYPO3_REQUEST_DIR');
                // This can only be set by external entry scripts
                if (defined('TYPO3_PATH_WEB')) {
                    $retVal = $url;
                } elseif (defined('PATH_thisScript') && defined('PATH_site')) {
                    $lPath = PathUtility::stripPathSitePrefix(dirname(PATH_thisScript)) . '/';
                    $siteUrl = substr($url, 0, -strlen($lPath));
                    if (substr($siteUrl, -1) != '/') {
                        $siteUrl .= '/';
                    }
                    $retVal = $siteUrl;
                }
                break;
            case 'TYPO3_SITE_PATH':
                $retVal = substr(self::getIndpEnv('TYPO3_SITE_URL'), strlen(self::getIndpEnv('TYPO3_REQUEST_HOST')));
                break;
            case 'TYPO3_SITE_SCRIPT':
                $retVal = substr(self::getIndpEnv('TYPO3_REQUEST_URL'), strlen(self::getIndpEnv('TYPO3_SITE_URL')));
                break;
            case 'TYPO3_SSL':
                $proxySSL = trim($GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxySSL']);
                if ($proxySSL == '*') {
                    $proxySSL = $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyIP'];
                }
                if (self::cmpIP($_SERVER['REMOTE_ADDR'], $proxySSL)) {
                    $retVal = true;
                } else {
                    $retVal = $_SERVER['SSL_SESSION_ID'] || strtolower($_SERVER['HTTPS']) === 'on' || (string)$_SERVER['HTTPS'] === '1';
                }
                break;
            case '_ARRAY':
                $out = array();
                // Here, list ALL possible keys to this function for debug display.
                $envTestVars = array(
                    'HTTP_HOST',
                    'TYPO3_HOST_ONLY',
                    'TYPO3_PORT',
                    'PATH_INFO',
                    'QUERY_STRING',
                    'REQUEST_URI',
                    'HTTP_REFERER',
                    'TYPO3_REQUEST_HOST',
                    'TYPO3_REQUEST_URL',
                    'TYPO3_REQUEST_SCRIPT',
                    'TYPO3_REQUEST_DIR',
                    'TYPO3_SITE_URL',
                    'TYPO3_SITE_SCRIPT',
                    'TYPO3_SSL',
                    'TYPO3_REV_PROXY',
                    'SCRIPT_NAME',
                    'TYPO3_DOCUMENT_ROOT',
                    'SCRIPT_FILENAME',
                    'REMOTE_ADDR',
                    'REMOTE_HOST',
                    'HTTP_USER_AGENT',
                    'HTTP_ACCEPT_LANGUAGE'
                );
                foreach ($envTestVars as $v) {
                    $out[$v] = self::getIndpEnv($v);
                }
                reset($out);
                $retVal = $out;
                break;
        }
        self::$indpEnvCache[$getEnvName] = $retVal;
        return $retVal;
    }

    public static function isAllowedHostHeaderValue($hostHeaderValue)
    {
        if (static::$allowHostHeaderValue === true) {
            return true;
        }

        if (static::isInternalRequestType()) {
            return static::$allowHostHeaderValue = true;
        }

        // Deny the value if trusted host patterns is empty, which means we are early in the bootstrap
        if (empty($GLOBALS['TYPO3_CONF_VARS']['SYS']['trustedHostsPattern'])) {
            return false;
        }

        if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['trustedHostsPattern'] === self::ENV_TRUSTED_HOSTS_PATTERN_ALLOW_ALL) {
            static::$allowHostHeaderValue = true;
        } else {
            static::$allowHostHeaderValue = static::hostHeaderValueMatchesTrustedHostsPattern($hostHeaderValue);
        }

        return static::$allowHostHeaderValue;
    }

    public static function hostHeaderValueMatchesTrustedHostsPattern($hostHeaderValue)
    {
        if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['trustedHostsPattern'] === self::ENV_TRUSTED_HOSTS_PATTERN_SERVER_NAME) {
            // Allow values that equal the server name
            // Note that this is only secure if name base virtual host are configured correctly in the webserver
            $defaultPort = self::getIndpEnv('TYPO3_SSL') ? '443' : '80';
            $parsedHostValue = parse_url('http://' . $hostHeaderValue);
            if (isset($parsedHostValue['port'])) {
                $hostMatch = (strtolower($parsedHostValue['host']) === strtolower($_SERVER['SERVER_NAME']) && (string)$parsedHostValue['port'] === $_SERVER['SERVER_PORT']);
            } else {
                $hostMatch = (strtolower($hostHeaderValue) === strtolower($_SERVER['SERVER_NAME']) && $defaultPort === $_SERVER['SERVER_PORT']);
            }
        } else {
            // In case name based virtual hosts are not possible, we allow setting a trusted host pattern
            // See https://typo3.org/teams/security/security-bulletins/typo3-core/typo3-core-sa-2014-001/ for further details
            $hostMatch = (bool)preg_match('/^' . $GLOBALS['TYPO3_CONF_VARS']['SYS']['trustedHostsPattern'] . '$/i', $hostHeaderValue);
        }

        return $hostMatch;
    }

    protected static function isInternalRequestType()
    {
        return (!defined('TYPO3_REQUESTTYPE') || (defined('TYPO3_REQUESTTYPE') && TYPO3_REQUESTTYPE & (TYPO3_REQUESTTYPE_INSTALL | TYPO3_REQUESTTYPE_CLI)));
    }

    public static function milliseconds()
    {
        return round(microtime(true) * 1000);
    }

    public static function clientInfo($useragent = '')
    {
        if (!$useragent) {
            $useragent = self::getIndpEnv('HTTP_USER_AGENT');
        }
        $bInfo = array();
        // Which browser?
        if (strpos($useragent, 'Konqueror') !== false) {
            $bInfo['BROWSER'] = 'konqu';
        } elseif (strpos($useragent, 'Opera') !== false) {
            $bInfo['BROWSER'] = 'opera';
        } elseif (strpos($useragent, 'MSIE') !== false) {
            $bInfo['BROWSER'] = 'msie';
        } elseif (strpos($useragent, 'Mozilla') !== false) {
            $bInfo['BROWSER'] = 'net';
        } elseif (strpos($useragent, 'Flash') !== false) {
            $bInfo['BROWSER'] = 'flash';
        }
        if (isset($bInfo['BROWSER'])) {
            // Browser version
            switch ($bInfo['BROWSER']) {
                case 'net':
                    $bInfo['VERSION'] = doubleval(substr($useragent, 8));
                    if (strpos($useragent, 'Netscape6/') !== false) {
                        $bInfo['VERSION'] = doubleval(substr(strstr($useragent, 'Netscape6/'), 10));
                    }
                    // Will we ever know if this was a typo or intention...?! :-(
                    if (strpos($useragent, 'Netscape/6') !== false) {
                        $bInfo['VERSION'] = doubleval(substr(strstr($useragent, 'Netscape/6'), 10));
                    }
                    if (strpos($useragent, 'Netscape/7') !== false) {
                        $bInfo['VERSION'] = doubleval(substr(strstr($useragent, 'Netscape/7'), 9));
                    }
                    break;
                case 'msie':
                    $tmp = strstr($useragent, 'MSIE');
                    $bInfo['VERSION'] = doubleval(preg_replace('/^[^0-9]*/', '', substr($tmp, 4)));
                    break;
                case 'opera':
                    $tmp = strstr($useragent, 'Opera');
                    $bInfo['VERSION'] = doubleval(preg_replace('/^[^0-9]*/', '', substr($tmp, 5)));
                    break;
                case 'konqu':
                    $tmp = strstr($useragent, 'Konqueror/');
                    $bInfo['VERSION'] = doubleval(substr($tmp, 10));
                    break;
            }
            // Client system
            if (strpos($useragent, 'Win') !== false) {
                $bInfo['SYSTEM'] = 'win';
            } elseif (strpos($useragent, 'Mac') !== false) {
                $bInfo['SYSTEM'] = 'mac';
            } elseif (strpos($useragent, 'Linux') !== false || strpos($useragent, 'X11') !== false || strpos($useragent, 'SGI') !== false || strpos($useragent, ' SunOS ') !== false || strpos($useragent, ' HP-UX ') !== false) {
                $bInfo['SYSTEM'] = 'unix';
            }
        }
        return $bInfo;
    }

    public static function getHostname($requestHost = true)
    {
        $host = '';
        // If not called from the command-line, resolve on getIndpEnv()
        // Note that TYPO3_REQUESTTYPE is not used here as it may not yet be defined
        if ($requestHost && (!defined('TYPO3_cliMode') || !TYPO3_cliMode)) {
            $host = self::getIndpEnv('HTTP_HOST');
        }
        if (!$host) {
            // will fail for PHP 4.1 and 4.2
            $host = @php_uname('n');
            // 'n' is ignored in broken installations
            if (strpos($host, ' ')) {
                $host = '';
            }
        }
        // We have not found a FQDN yet
        if ($host && strpos($host, '.') === false) {
            $ip = gethostbyname($host);
            // We got an IP address
            if ($ip != $host) {
                $fqdn = gethostbyaddr($ip);
                if ($ip != $fqdn) {
                    $host = $fqdn;
                }
            }
        }
        if (!$host) {
            $host = 'localhost.localdomain';
        }
        return $host;
    }

    /*************************
     *
     * TYPO3 SPECIFIC FUNCTIONS
     *
     *************************/
    public static function getFileAbsFileName($filename, $onlyRelative = true, $relToTYPO3_mainDir = false)
    {
        if ((string)$filename === '') {
            return '';
        }
        $relPathPrefix = PATH_site;
        if ($relToTYPO3_mainDir) {
            $relPathPrefix = PATH_typo3;
        }

        // Extension
        if (strpos($filename, 'EXT:') === 0) {
            list($extKey, $local) = explode('/', substr($filename, 4), 2);
            $filename = '';
            if ((string)$extKey !== '' && ExtensionManagementUtility::isLoaded($extKey) && (string)$local !== '') {
                $filename = ExtensionManagementUtility::extPath($extKey) . $local;
            }
        } elseif (!static::isAbsPath($filename)) {
            // relative. Prepended with $relPathPrefix
            $filename = $relPathPrefix . $filename;
        } elseif ($onlyRelative && !static::isFirstPartOfStr($filename, $relPathPrefix)) {
            // absolute, but set to blank if not allowed
            $filename = '';
        }
        if ((string)$filename !== '' && static::validPathStr($filename)) {
            // checks backpath.
            return $filename;
        }
        return '';
    }

    public static function validPathStr($theFile)
    {
        return strpos($theFile, '//') === false && strpos($theFile, '\\') === false
            && !preg_match('#(?:^\\.\\.|/\\.\\./|[[:cntrl:]])#u', $theFile);
    }

    public static function isAbsPath($path)
    {
        return $path[0] === '/' || TYPO3_OS === 'WIN' && (strpos($path, ':/') === 1 || strpos($path, ':\\') === 1);
    }

    public static function isAllowedAbsPath($path)
    {
        $lockRootPath = $GLOBALS['TYPO3_CONF_VARS']['BE']['lockRootPath'];
        return static::isAbsPath($path) && static::validPathStr($path)
            && (static::isFirstPartOfStr($path, PATH_site)
                || $lockRootPath && static::isFirstPartOfStr($path, $lockRootPath));
    }

    public static function verifyFilenameAgainstDenyPattern($filename)
    {
        $pattern = '/[[:cntrl:]]/';
        if ((string)$filename !== '' && (string)$GLOBALS['TYPO3_CONF_VARS']['BE']['fileDenyPattern'] !== '') {
            $pattern = '/(?:[[:cntrl:]]|' . $GLOBALS['TYPO3_CONF_VARS']['BE']['fileDenyPattern'] . ')/i';
        }
        return !preg_match($pattern, $filename);
    }

    public static function copyDirectory($source, $destination)
    {
        if (strpos($source, PATH_site) === false) {
            $source = PATH_site . $source;
        }
        if (strpos($destination, PATH_site) === false) {
            $destination = PATH_site . $destination;
        }
        if (static::isAllowedAbsPath($source) && static::isAllowedAbsPath($destination)) {
            $iterator = new \RecursiveIteratorIterator(
                new \RecursiveDirectoryIterator($source, \RecursiveDirectoryIterator::SKIP_DOTS),
                \RecursiveIteratorIterator::SELF_FIRST
            );
            foreach ($iterator as $item) {
                $target = $destination . '/' . $iterator->getSubPathName();
                if ($item->isDir()) {
                    static::mkdir($target);
                } else {
                    static::upload_copy_move($item, $target);
                }
            }
        }
    }

    public static function sanitizeLocalUrl($url = '')
    {
        $sanitizedUrl = '';
        $decodedUrl = rawurldecode($url);
        if (!empty($url) && self::removeXSS($decodedUrl) === $decodedUrl) {
            $parsedUrl = parse_url($decodedUrl);
            $testAbsoluteUrl = self::resolveBackPath($decodedUrl);
            $testRelativeUrl = self::resolveBackPath(self::dirname(self::getIndpEnv('SCRIPT_NAME')) . '/' . $decodedUrl);
            // Pass if URL is on the current host:
            if (self::isValidUrl($decodedUrl)) {
                if (self::isOnCurrentHost($decodedUrl) && strpos($decodedUrl, self::getIndpEnv('TYPO3_SITE_URL')) === 0) {
                    $sanitizedUrl = $url;
                }
            } elseif (self::isAbsPath($decodedUrl) && self::isAllowedAbsPath($decodedUrl)) {
                $sanitizedUrl = $url;
            } elseif (strpos($testAbsoluteUrl, self::getIndpEnv('TYPO3_SITE_PATH')) === 0 && $decodedUrl[0] === '/') {
                $sanitizedUrl = $url;
            } elseif (empty($parsedUrl['scheme']) && strpos($testRelativeUrl, self::getIndpEnv('TYPO3_SITE_PATH')) === 0 && $decodedUrl[0] !== '/') {
                $sanitizedUrl = $url;
            }
        }
        if (!empty($url) && empty($sanitizedUrl)) {
            self::sysLog('The URL "' . $url . '" is not considered to be local and was denied.', 'core', self::SYSLOG_SEVERITY_NOTICE);
        }
        return $sanitizedUrl;
    }

    public static function upload_copy_move($source, $destination)
    {
        if (is_uploaded_file($source)) {
            $uploaded = true;
            // Return the value of move_uploaded_file, and if FALSE the temporary $source is still around so the user can use unlink to delete it:
            $uploadedResult = move_uploaded_file($source, $destination);
        } else {
            $uploaded = false;
            @copy($source, $destination);
        }
        // Change the permissions of the file
        self::fixPermissions($destination);
        // If here the file is copied and the temporary $source is still around, so when returning FALSE the user can try unlink to delete the $source
        return $uploaded ? $uploadedResult : false;
    }

    public static function upload_to_tempfile($uploadedFileName)
    {
        if (is_uploaded_file($uploadedFileName)) {
            $tempFile = self::tempnam('upload_temp_');
            move_uploaded_file($uploadedFileName, $tempFile);
            return @is_file($tempFile) ? $tempFile : '';
        }
    }

    public static function unlink_tempfile($uploadedTempFileName)
    {
        if ($uploadedTempFileName) {
            $uploadedTempFileName = self::fixWindowsFilePath($uploadedTempFileName);
            if (
                self::validPathStr($uploadedTempFileName)
                && self::isFirstPartOfStr($uploadedTempFileName, PATH_site . 'typo3temp/')
                && @is_file($uploadedTempFileName)
            ) {
                if (unlink($uploadedTempFileName)) {
                    return true;
                }
            }
        }
    }

    public static function tempnam($filePrefix, $fileSuffix = '')
    {
        $temporaryPath = PATH_site . 'typo3temp/';
        if ($fileSuffix === '') {
            $tempFileName = static::fixWindowsFilePath(tempnam($temporaryPath, $filePrefix));
        } else {
            do {
                $tempFileName = $temporaryPath . $filePrefix . mt_rand(1, PHP_INT_MAX) . $fileSuffix;
            } while (file_exists($tempFileName));
            touch($tempFileName);
            clearstatcache(null, $tempFileName);
        }
        return $tempFileName;
    }

    public static function stdAuthCode($uid_or_record, $fields = '', $codeLength = 8)
    {
        if (is_array($uid_or_record)) {
            $recCopy_temp = array();
            if ($fields) {
                $fieldArr = self::trimExplode(',', $fields, true);
                foreach ($fieldArr as $k => $v) {
                    $recCopy_temp[$k] = $uid_or_record[$v];
                }
            } else {
                $recCopy_temp = $uid_or_record;
            }
            $preKey = implode('|', $recCopy_temp);
        } else {
            $preKey = $uid_or_record;
        }
        $authCode = $preKey . '||' . $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'];
        $authCode = substr(md5($authCode), 0, $codeLength);
        return $authCode;
    }

    public static function hideIfNotTranslated($l18n_cfg_fieldValue)
    {
        return $GLOBALS['TYPO3_CONF_VARS']['FE']['hidePagesIfNotTranslatedByDefault'] xor ($l18n_cfg_fieldValue & 2);
    }

    public static function hideIfDefaultLanguage($localizationConfiguration)
    {
        return (bool)($localizationConfiguration & 1);
    }

    public static function readLLfile($fileRef, $langKey, $charset = '', $errorMode = 0)
    {
        self::logDeprecatedFunction();
        $languageFactory = self::makeInstance(\TYPO3\CMS\Core\Localization\LocalizationFactory::class);
        return $languageFactory->getParsedData($fileRef, $langKey, $charset, $errorMode);
    }

    public static function llXmlAutoFileName($fileRef, $language, $sameLocation = false)
    {
        // If $fileRef is already prefixed with "[language key]" then we should return it as is
        $fileName = basename($fileRef);
        if (self::isFirstPartOfStr($fileName, $language . '.')) {
            return $fileRef;
        }

        if ($sameLocation) {
            return str_replace($fileName, $language . '.' . $fileName, $fileRef);
        }

        // Analyse file reference:
        // Is system:
        if (self::isFirstPartOfStr($fileRef, PATH_typo3 . 'sysext/')) {
            $validatedPrefix = PATH_typo3 . 'sysext/';
        } elseif (self::isFirstPartOfStr($fileRef, PATH_typo3 . 'ext/')) {
            // Is global:
            $validatedPrefix = PATH_typo3 . 'ext/';
        } elseif (self::isFirstPartOfStr($fileRef, PATH_typo3conf . 'ext/')) {
            // Is local:
            $validatedPrefix = PATH_typo3conf . 'ext/';
        } else {
            $validatedPrefix = '';
        }
        if ($validatedPrefix) {
            // Divide file reference into extension key, directory (if any) and base name:
            list($file_extKey, $file_extPath) = explode('/', substr($fileRef, strlen($validatedPrefix)), 2);
            $temp = self::revExplode('/', $file_extPath, 2);
            if (count($temp) === 1) {
                array_unshift($temp, '');
            }
            // Add empty first-entry if not there.
            list($file_extPath, $file_fileName) = $temp;
            // The filename is prefixed with "[language key]." because it prevents the llxmltranslate tool from detecting it.
            $location = 'typo3conf/l10n/' . $language . '/' . $file_extKey . '/' . ($file_extPath ? $file_extPath . '/' : '');
            return $location . $language . '.' . $file_fileName;
        }
        return null;
    }

    public static function resolveSheetDefInDS($dataStructArray, $sheet = 'sDEF')
    {
        if (!is_array($dataStructArray)) {
            return 'Data structure must be an array';
        }
        if (is_array($dataStructArray['sheets'])) {
            $singleSheet = false;
            if (!isset($dataStructArray['sheets'][$sheet])) {
                $sheet = 'sDEF';
            }
            $dataStruct = $dataStructArray['sheets'][$sheet];
            // If not an array, but still set, then regard it as a relative reference to a file:
            if ($dataStruct && !is_array($dataStruct)) {
                $file = self::getFileAbsFileName($dataStruct);
                if ($file && @is_file($file)) {
                    $dataStruct = self::xml2array(self::getUrl($file));
                }
            }
        } else {
            $singleSheet = true;
            $dataStruct = $dataStructArray;
            if (isset($dataStruct['meta'])) {
                unset($dataStruct['meta']);
            }
            // Meta data should not appear there.
            // Default sheet
            $sheet = 'sDEF';
        }
        return array($dataStruct, $sheet, $singleSheet);
    }

    public static function resolveAllSheetsInDS(array $dataStructArray)
    {
        if (is_array($dataStructArray['sheets'])) {
            $out = array('sheets' => array());
            foreach ($dataStructArray['sheets'] as $sheetId => $sDat) {
                list($ds, $aS) = self::resolveSheetDefInDS($dataStructArray, $sheetId);
                if ($sheetId == $aS) {
                    $out['sheets'][$aS] = $ds;
                }
            }
        } else {
            list($ds) = self::resolveSheetDefInDS($dataStructArray);
            $out = array('sheets' => array('sDEF' => $ds));
        }
        return $out;
    }

    public static function callUserFunction($funcName, &$params, &$ref, $checkPrefix = '', $errorMode = 0)
    {
        $content = false;
        // Check if we're using a closure and invoke it directly.
        if (is_object($funcName) && is_a($funcName, 'Closure')) {
            return call_user_func_array($funcName, array(&$params, &$ref));
        }
        // Check persistent object and if found, call directly and exit.
        if (isset($GLOBALS['T3_VAR']['callUserFunction'][$funcName]) && is_array($GLOBALS['T3_VAR']['callUserFunction'][$funcName])) {
            return call_user_func_array(array(
                &$GLOBALS['T3_VAR']['callUserFunction'][$funcName]['obj'],
                $GLOBALS['T3_VAR']['callUserFunction'][$funcName]['method']
            ), array(&$params, &$ref));
        }
        // Check file-reference prefix; if found, require_once() the file (should be library of code)
        if (strpos($funcName, ':') !== false) {
            list($file, $funcRef) = self::revExplode(':', $funcName, 2);
            $requireFile = self::getFileAbsFileName($file);
            if ($requireFile) {
                self::requireOnce($requireFile);
            }
        } else {
            $funcRef = $funcName;
        }
        // Check for persistent object token, "&"
        if ($funcRef[0] === '&') {
            $funcRef = substr($funcRef, 1);
            $storePersistentObject = true;
        } else {
            $storePersistentObject = false;
        }
        // Call function or method:
        $parts = explode('->', $funcRef);
        if (count($parts) === 2) {
            // Class
            // Check if class/method exists:
            if (class_exists($parts[0])) {
                // Get/Create object of class:
                if ($storePersistentObject) {
                    // Get reference to current instance of class:
                    if (!is_object($GLOBALS['T3_VAR']['callUserFunction_classPool'][$parts[0]])) {
                        $GLOBALS['T3_VAR']['callUserFunction_classPool'][$parts[0]] = self::makeInstance($parts[0]);
                    }
                    $classObj = $GLOBALS['T3_VAR']['callUserFunction_classPool'][$parts[0]];
                } else {
                    // Create new object:
                    $classObj = self::makeInstance($parts[0]);
                }
                if (method_exists($classObj, $parts[1])) {
                    // If persistent object should be created, set reference:
                    if ($storePersistentObject) {
                        $GLOBALS['T3_VAR']['callUserFunction'][$funcName] = array(
                            'method' => $parts[1],
                            'obj' => &$classObj
                        );
                    }
                    // Call method:
                    $content = call_user_func_array(array(&$classObj, $parts[1]), array(&$params, &$ref));
                } else {
                    $errorMsg = 'No method name \'' . $parts[1] . '\' in class ' . $parts[0];
                    if ($errorMode == 2) {
                        throw new \InvalidArgumentException($errorMsg, 1294585865);
                    } elseif (!$errorMode) {
                        debug($errorMsg, \TYPO3\CMS\Core\Utility\GeneralUtility::class . '::callUserFunction');
                    }
                }
            } else {
                $errorMsg = 'No class named ' . $parts[0];
                if ($errorMode == 2) {
                    throw new \InvalidArgumentException($errorMsg, 1294585866);
                } elseif (!$errorMode) {
                    debug($errorMsg, \TYPO3\CMS\Core\Utility\GeneralUtility::class . '::callUserFunction');
                }
            }
        } else {
            // Function
            if (function_exists($funcRef)) {
                $content = call_user_func_array($funcRef, array(&$params, &$ref));
            } else {
                $errorMsg = 'No function named: ' . $funcRef;
                if ($errorMode == 2) {
                    throw new \InvalidArgumentException($errorMsg, 1294585867);
                } elseif (!$errorMode) {
                    debug($errorMsg, \TYPO3\CMS\Core\Utility\GeneralUtility::class . '::callUserFunction');
                }
            }
        }
        return $content;
    }

    public static function getUserObj($classRef)
    {
        // Check persistent object and if found, call directly and exit.
        if (is_object($GLOBALS['T3_VAR']['getUserObj'][$classRef])) {
            return $GLOBALS['T3_VAR']['getUserObj'][$classRef];
        } else {
            // Check file-reference prefix; if found, require_once() the file (should be library of code)
            if (strpos($classRef, ':') !== false) {
                list($file, $class) = self::revExplode(':', $classRef, 2);
                $requireFile = self::getFileAbsFileName($file);
                if ($requireFile) {
                    self::requireOnce($requireFile);
                }
            } else {
                $class = $classRef;
            }
            // Check for persistent object token, "&"
            if ($class[0] === '&') {
                self::deprecationLog(
                    'The persistent functionality of getUserObj(), prepending the class name with & is deprecated since'
                    . ' TYPO3 CMS 7 and will be removed in TYPO3 CMS 8. To allow this functionality, implement '
                    . ' the \\TYPO3\\CMS\\Core\\SingletonInterface in the class "' . $classRef . '" instead.'
                );
                $class = substr($class, 1);
                $storePersistentObject = true;
            } else {
                $storePersistentObject = false;
            }
            // Check if class exists:
            if (class_exists($class)) {
                $classObj = self::makeInstance($class);
                // If persistent object should be created, set reference:
                if ($storePersistentObject) {
                    $GLOBALS['T3_VAR']['getUserObj'][$classRef] = $classObj;
                }
                return $classObj;
            }
        }
    }

    public static function makeInstance($className)
    {
        if (!is_string($className) || empty($className)) {
            throw new \InvalidArgumentException('$className must be a non empty string.', 1288965219);
        }
        // Never instantiate with a beginning backslash, otherwise things like singletons won't work.
        if ($className[0] === '\\') {
            throw new \InvalidArgumentException(
                '$className "' . $className . '" must not start with a backslash.', 1420281366
            );
        }
        if (isset(static::$finalClassNameCache[$className])) {
            $finalClassName = static::$finalClassNameCache[$className];
        } else {
            $finalClassName = self::getClassName($className);
            static::$finalClassNameCache[$className] = $finalClassName;
        }
        // Return singleton instance if it is already registered
        if (isset(self::$singletonInstances[$finalClassName])) {
            return self::$singletonInstances[$finalClassName];
        }
        // Return instance if it has been injected by addInstance()
        if (
            isset(self::$nonSingletonInstances[$finalClassName])
            && !empty(self::$nonSingletonInstances[$finalClassName])
        ) {
            return array_shift(self::$nonSingletonInstances[$finalClassName]);
        }
        // Create new instance and call constructor with parameters
        $instance = static::instantiateClass($finalClassName, func_get_args());
        // Register new singleton instance
        if ($instance instanceof SingletonInterface) {
            self::$singletonInstances[$finalClassName] = $instance;
        }
        return $instance;
    }

    protected static function instantiateClass($className, $arguments)
    {
        switch (count($arguments)) {
            case 1:
                $instance = new $className();
                break;
            case 2:
                $instance = new $className($arguments[1]);
                break;
            case 3:
                $instance = new $className($arguments[1], $arguments[2]);
                break;
            case 4:
                $instance = new $className($arguments[1], $arguments[2], $arguments[3]);
                break;
            case 5:
                $instance = new $className($arguments[1], $arguments[2], $arguments[3], $arguments[4]);
                break;
            case 6:
                $instance = new $className($arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5]);
                break;
            case 7:
                $instance = new $className($arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6]);
                break;
            case 8:
                $instance = new $className($arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6], $arguments[7]);
                break;
            case 9:
                $instance = new $className($arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6], $arguments[7], $arguments[8]);
                break;
            default:
                // The default case for classes with constructors that have more than 8 arguments.
                // This will fail when one of the arguments shall be passed by reference.
                // In case we really need to support this edge case, we can implement the solution from here: https://review.typo3.org/26344
                $class = new \ReflectionClass($className);
                array_shift($arguments);
                $instance = $class->newInstanceArgs($arguments);
        }
        return $instance;
    }

    protected static function getClassName($className)
    {
        if (class_exists($className)) {
            while (static::classHasImplementation($className)) {
                $className = static::getImplementationForClass($className);
            }
        }
        return ClassLoadingInformation::getClassNameForAlias($className);
    }

    protected static function getImplementationForClass($className)
    {
        return $GLOBALS['TYPO3_CONF_VARS']['SYS']['Objects'][$className]['className'];
    }

    protected static function classHasImplementation($className)
    {
        // If we are early in the bootstrap, the configuration might not yet be present
        if (!isset($GLOBALS['TYPO3_CONF_VARS']['SYS']['Objects'])) {
            return false;
        }

        return isset($GLOBALS['TYPO3_CONF_VARS']['SYS']['Objects'][$className])
                && is_array($GLOBALS['TYPO3_CONF_VARS']['SYS']['Objects'][$className])
                && !empty($GLOBALS['TYPO3_CONF_VARS']['SYS']['Objects'][$className]['className']);
    }

    public static function setSingletonInstance($className, SingletonInterface $instance)
    {
        self::checkInstanceClassName($className, $instance);
        self::$singletonInstances[$className] = $instance;
    }

    public static function removeSingletonInstance($className, SingletonInterface $instance)
    {
        self::checkInstanceClassName($className, $instance);
        if (!isset(self::$singletonInstances[$className])) {
            throw new \InvalidArgumentException('No Instance registered for ' . $className . '.', 1394099179);
        }
        if ($instance !== self::$singletonInstances[$className]) {
            throw new \InvalidArgumentException('The instance you are trying to remove has not been registered before.', 1394099256);
        }
        unset(self::$singletonInstances[$className]);
    }

    public static function resetSingletonInstances(array $newSingletonInstances)
    {
        static::$singletonInstances = array();
        foreach ($newSingletonInstances as $className => $instance) {
            static::setSingletonInstance($className, $instance);
        }
    }

    public static function getSingletonInstances()
    {
        return static::$singletonInstances;
    }

    public static function addInstance($className, $instance)
    {
        self::checkInstanceClassName($className, $instance);
        if ($instance instanceof SingletonInterface) {
            throw new \InvalidArgumentException('$instance must not be an instance of TYPO3\\CMS\\Core\\SingletonInterface. ' . 'For setting singletons, please use setSingletonInstance.', 1288969325);
        }
        if (!isset(self::$nonSingletonInstances[$className])) {
            self::$nonSingletonInstances[$className] = array();
        }
        self::$nonSingletonInstances[$className][] = $instance;
    }

    protected static function checkInstanceClassName($className, $instance)
    {
        if ($className === '') {
            throw new \InvalidArgumentException('$className must not be empty.', 1288967479);
        }
        if (!$instance instanceof $className) {
            throw new \InvalidArgumentException('$instance must be an instance of ' . $className . ', but actually is an instance of ' . get_class($instance) . '.', 1288967686);
        }
    }

    public static function purgeInstances()
    {
        self::$singletonInstances = array();
        self::$nonSingletonInstances = array();
    }

    public static function flushInternalRuntimeCaches()
    {
        self::$indpEnvCache = [];
        self::$idnaStringCache = [];
    }

    public static function makeInstanceService($serviceType, $serviceSubType = '', $excludeServiceKeys = array())
    {
        $error = false;
        if (!is_array($excludeServiceKeys)) {
            $excludeServiceKeys = self::trimExplode(',', $excludeServiceKeys, true);
        }
        $requestInfo = array(
            'requestedServiceType' => $serviceType,
            'requestedServiceSubType' => $serviceSubType,
            'requestedExcludeServiceKeys' => $excludeServiceKeys
        );
        while ($info = ExtensionManagementUtility::findService($serviceType, $serviceSubType, $excludeServiceKeys)) {
            // provide information about requested service to service object
            $info = array_merge($info, $requestInfo);
            // Check persistent object and if found, call directly and exit.
            if (is_object($GLOBALS['T3_VAR']['makeInstanceService'][$info['className']])) {
                // update request info in persistent object
                $GLOBALS['T3_VAR']['makeInstanceService'][$info['className']]->info = $info;
                // reset service and return object
                $GLOBALS['T3_VAR']['makeInstanceService'][$info['className']]->reset();
                return $GLOBALS['T3_VAR']['makeInstanceService'][$info['className']];
            } else {
                $obj = self::makeInstance($info['className']);
                if (is_object($obj)) {
                    if (!@is_callable(array($obj, 'init'))) {
                        // use silent logging??? I don't think so.
                        die('Broken service:' . DebugUtility::viewArray($info));
                    }
                    $obj->info = $info;
                    // service available?
                    if ($obj->init()) {
                        // create persistent object
                        $GLOBALS['T3_VAR']['makeInstanceService'][$info['className']] = $obj;
                        return $obj;
                    }
                    $error = $obj->getLastErrorArray();
                    unset($obj);
                }
            }
            // deactivate the service
            ExtensionManagementUtility::deactivateService($info['serviceType'], $info['serviceKey']);
        }
        return $error;
    }

    public static function requireOnce($requireFile)
    {
        // Needed for require_once
        global $T3_SERVICES, $T3_VAR, $TYPO3_CONF_VARS;
        require_once $requireFile;
    }

    public static function requireFile($requireFile)
    {
        // Needed for require
        global $T3_SERVICES, $T3_VAR, $TYPO3_CONF_VARS;
        require $requireFile;
    }

    public static function quoted_printable($string, $maxlen = 76)
    {
        static::logDeprecatedFunction();
        // Make sure the string contains only Unix line breaks
        // Replace Windows breaks (\r\n)
        $string = str_replace(CRLF, LF, $string);
        // Replace Mac breaks (\r)
        $string = str_replace(CR, LF, $string);
        // Default line break for Unix systems.
        $linebreak = LF;
        if (TYPO3_OS == 'WIN') {
            // Line break for Windows. This is needed because PHP on Windows systems send mails via SMTP instead of using sendmail, and thus the line break needs to be \r\n.
            $linebreak = CRLF;
        }
        $newString = '';
        // Split lines
        $theLines = explode(LF, $string);
        foreach ($theLines as $val) {
            $newVal = '';
            $theValLen = strlen($val);
            $len = 0;
            // Walk through each character of this line
            for ($index = 0; $index < $theValLen; $index++) {
                $char = substr($val, $index, 1);
                $ordVal = ord($char);
                if ($len > $maxlen - 4 || $len > $maxlen - 14 && $ordVal == 32) {
                    // Add a line break
                    $newVal .= '=' . $linebreak;
                    // Reset the length counter
                    $len = 0;
                }
                if ($ordVal >= 33 && $ordVal <= 60 || $ordVal >= 62 && $ordVal <= 126 || $ordVal == 9 || $ordVal == 32) {
                    // This character is ok, add it to the message
                    $newVal .= $char;
                    $len++;
                } else {
                    // Special character, needs to be encoded
                    $newVal .= sprintf('=%02X', $ordVal);
                    $len += 3;
                }
            }
            // Replaces a possible SPACE-character at the end of a line
            $newVal = preg_replace('/' . chr(32) . '$/', '=20', $newVal);
            // Replaces a possible TAB-character at the end of a line
            $newVal = preg_replace('/' . TAB . '$/', '=09', $newVal);
            $newString .= $newVal . $linebreak;
        }
        // Remove last newline
        return preg_replace('/' . $linebreak . '$/', '', $newString);
    }

    public static function encodeHeader($line, $enc = 'quoted-printable', $charset = 'utf-8')
    {
        static::logDeprecatedFunction();
        // Avoid problems if "###" is found in $line (would conflict with the placeholder which is used below)
        if (strpos($line, '###') !== false) {
            return $line;
        }
        // Check if any non-ASCII characters are found - otherwise encoding is not needed
        if (!preg_match(('/[^' . chr(32) . '-' . chr(127) . ']/'), $line)) {
            return $line;
        }
        // Wrap email addresses in a special marker
        $line = preg_replace('/([^ ]+@[^ ]+)/', '###$1###', $line);
        $matches = preg_split('/(.?###.+###.?|\\(|\\))/', $line, -1, PREG_SPLIT_NO_EMPTY);
        foreach ($matches as $part) {
            $oldPart = $part;
            $partWasQuoted = $part[0] == '"';
            $part = trim($part, '"');
            switch ((string)$enc) {
                case 'base64':
                    $part = '=?' . $charset . '?B?' . base64_encode($part) . '?=';
                    break;
                case 'quoted-printable':

                default:
                    $qpValue = self::quoted_printable($part, 1000);
                    if ($part != $qpValue) {
                        // Encoded words in the header should not contain non-encoded:
                        // * spaces. "_" is a shortcut for "=20". See RFC 2047 for details.
                        // * question mark. See RFC 1342 (http://tools.ietf.org/html/rfc1342)
                        $search = array(' ', '?');
                        $replace = array('_', '=3F');
                        $qpValue = str_replace($search, $replace, $qpValue);
                        $part = '=?' . $charset . '?Q?' . $qpValue . '?=';
                    }
            }
            if ($partWasQuoted) {
                $part = '"' . $part . '"';
            }
            $line = str_replace($oldPart, $part, $line);
        }
        // Remove the wrappers
        $line = preg_replace('/###(.+?)###/', '$1', $line);
        return $line;
    }

    public static function substUrlsInPlainText($message, $urlmode = '76', $index_script_url = '')
    {
        static::logDeprecatedFunction();
        switch ((string)$urlmode) {
            case '':
                $lengthLimit = false;
                break;
            case 'all':
                $lengthLimit = 0;
                break;
            case '76':

            default:
                $lengthLimit = (int)$urlmode;
        }
        if ($lengthLimit === false) {
            // No processing
            $messageSubstituted = $message;
        } else {
            $messageSubstituted = preg_replace_callback(
                '/(http|https):\\/\\/.+(?=[\\]\\.\\?]*([\\! \'"()<>]+|$))/iU',
                function (array $matches) use ($lengthLimit, $index_script_url) {
                    return GeneralUtility::makeRedirectUrl($matches[0], $lengthLimit, $index_script_url);
                },
                $message
            );
        }
        return $messageSubstituted;
    }

    public static function makeRedirectUrl($inUrl, $l = 0, $index_script_url = '')
    {
        if (strlen($inUrl) > $l) {
            $md5 = substr(md5($inUrl), 0, 20);
            $count = $GLOBALS['TYPO3_DB']->exec_SELECTcountRows('*', 'cache_md5params', 'md5hash=' . $GLOBALS['TYPO3_DB']->fullQuoteStr($md5, 'cache_md5params'));
            if (!$count) {
                $insertFields = array(
                    'md5hash' => $md5,
                    'tstamp' => $GLOBALS['EXEC_TIME'],
                    'type' => 2,
                    'params' => $inUrl
                );
                $GLOBALS['TYPO3_DB']->exec_INSERTquery('cache_md5params', $insertFields);
            }
            $inUrl = ($index_script_url ? $index_script_url : self::getIndpEnv('TYPO3_REQUEST_DIR') . 'index.php') . '?RDCT=' . $md5;
        }
        return $inUrl;
    }

    public static function freetypeDpiComp($fontSize)
    {
        // FreeType 2 always has 96 dpi.
        $dpi = 96.0;
        return $fontSize / $dpi * 72;
    }

    public static function initSysLog()
    {
        // For CLI logging name is <fqdn-hostname>:<TYPO3-path>
        // Note that TYPO3_REQUESTTYPE is not used here as it may not yet be defined
        if (defined('TYPO3_cliMode') && TYPO3_cliMode) {
            $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] = self::getHostname(($requestHost = false)) . ':' . PATH_site;
        } else {
            $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] = self::getIndpEnv('TYPO3_SITE_URL');
        }
        // Init custom logging
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'])) {
            $params = array('initLog' => true);
            $fakeThis = false;
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'] as $hookMethod) {
                self::callUserFunction($hookMethod, $params, $fakeThis);
            }
        }
        // Init TYPO3 logging
        foreach (explode(';', $GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLog'], 2) as $log) {
            list($type, $destination) = explode(',', $log, 3);
            if ($type == 'syslog') {
                if (TYPO3_OS == 'WIN') {
                    $facility = LOG_USER;
                } else {
                    $facility = constant('LOG_' . strtoupper($destination));
                }
                openlog($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'], LOG_ODELAY, $facility);
            }
        }
        $GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLogLevel'] = MathUtility::forceIntegerInRange($GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLogLevel'], 0, 4);
        $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogInit'] = true;
    }

    public static function sysLog($msg, $extKey, $severity = 0)
    {
        $severity = MathUtility::forceIntegerInRange($severity, 0, 4);
        // Is message worth logging?
        if ((int)$GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLogLevel'] > $severity) {
            return;
        }
        // Initialize logging
        if (!$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogInit']) {
            self::initSysLog();
        }
        // Do custom logging
        if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog']) && is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'])) {
            $params = array('msg' => $msg, 'extKey' => $extKey, 'backTrace' => debug_backtrace(), 'severity' => $severity);
            $fakeThis = false;
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'] as $hookMethod) {
                self::callUserFunction($hookMethod, $params, $fakeThis);
            }
        }
        // TYPO3 logging enabled?
        if (!$GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLog']) {
            return;
        }
        $dateFormat = $GLOBALS['TYPO3_CONF_VARS']['SYS']['ddmmyy'];
        $timeFormat = $GLOBALS['TYPO3_CONF_VARS']['SYS']['hhmm'];
        // Use all configured logging options
        foreach (explode(';', $GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLog'], 2) as $log) {
            list($type, $destination, $level) = explode(',', $log, 4);
            // Is message worth logging for this log type?
            if ((int)$level > $severity) {
                continue;
            }
            $msgLine = ' - ' . $extKey . ': ' . $msg;
            // Write message to a file
            if ($type == 'file') {
                $file = fopen($destination, 'a');
                if ($file) {
                    fwrite($file, date(($dateFormat . ' ' . $timeFormat)) . $msgLine . LF);
                    fclose($file);
                    self::fixPermissions($destination);
                }
            } elseif ($type == 'mail') {
                list($to, $from) = explode('/', $destination);
                if (!self::validEmail($from)) {
                    $from = MailUtility::getSystemFrom();
                }
                $mail = self::makeInstance(\TYPO3\CMS\Core\Mail\MailMessage::class);
                $mail->setTo($to)->setFrom($from)->setSubject('Warning - error in TYPO3 installation')->setBody('Host: ' . $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] . LF . 'Extension: ' . $extKey . LF . 'Severity: ' . $severity . LF . LF . $msg);
                $mail->send();
            } elseif ($type == 'error_log') {
                error_log($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] . $msgLine, 0);
            } elseif ($type == 'syslog') {
                $priority = array(LOG_INFO, LOG_NOTICE, LOG_WARNING, LOG_ERR, LOG_CRIT);
                syslog($priority[(int)$severity], $msgLine);
            }
        }
    }

    public static function devLog($msg, $extKey, $severity = 0, $dataVar = false)
    {
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['devLog'])) {
            $params = array('msg' => $msg, 'extKey' => $extKey, 'severity' => $severity, 'dataVar' => $dataVar);
            $fakeThis = false;
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['devLog'] as $hookMethod) {
                self::callUserFunction($hookMethod, $params, $fakeThis);
            }
        }
    }

    public static function deprecationLog($msg)
    {
        if (!$GLOBALS['TYPO3_CONF_VARS']['SYS']['enableDeprecationLog']) {
            return;
        }
        // Legacy values (no strict comparison, $log can be boolean, string or int)
        $log = $GLOBALS['TYPO3_CONF_VARS']['SYS']['enableDeprecationLog'];
        if ($log === true || $log == '1') {
            $log = array('file');
        } else {
            $log = self::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['SYS']['enableDeprecationLog'], true);
        }
        $date = date($GLOBALS['TYPO3_CONF_VARS']['SYS']['ddmmyy'] . ' ' . $GLOBALS['TYPO3_CONF_VARS']['SYS']['hhmm'] . ': ');
        if (in_array('file', $log) !== false) {
            // Write a longer message to the deprecation log
            $destination = static::getDeprecationLogFileName();
            $file = @fopen($destination, 'a');
            if ($file) {
                @fwrite($file, ($date . $msg . LF));
                @fclose($file);
                self::fixPermissions($destination);
            }
        }
        if (in_array('devlog', $log) !== false) {
            // Copy message also to the developer log
            self::devLog($msg, 'Core', self::SYSLOG_SEVERITY_WARNING);
        }
        // Do not use console in login screen
        if (in_array('console', $log) !== false && isset($GLOBALS['BE_USER']->user['uid'])) {
            DebugUtility::debug($msg, $date, 'Deprecation Log');
        }
    }

    public static function getDeprecationLogFileName()
    {
        return PATH_typo3conf . 'deprecation_' . self::shortMD5((PATH_site . $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'])) . '.log';
    }

    public static function logDeprecatedFunction()
    {
        if (!$GLOBALS['TYPO3_CONF_VARS']['SYS']['enableDeprecationLog']) {
            return;
        }
        $trail = debug_backtrace();
        if ($trail[1]['type']) {
            $function = new \ReflectionMethod($trail[1]['class'], $trail[1]['function']);
        } else {
            $function = new \ReflectionFunction($trail[1]['function']);
        }
        $msg = '';
        if (preg_match('/@deprecated\\s+(.*)/', $function->getDocComment(), $match)) {
            $msg = $match[1];
        }
            // Write a longer message to the deprecation log: <function> <annotion> - <trace> (<source>)
        $logMsg = $trail[1]['class'] . $trail[1]['type'] . $trail[1]['function'];
        $logMsg .= '() - ' . $msg . ' - ' . DebugUtility::debugTrail();
        $logMsg .= ' (' . PathUtility::stripPathSitePrefix($function->getFileName()) . '#' . $function->getStartLine() . ')';
        self::deprecationLog($logMsg);
    }

    public static function arrayToLogString(array $arr, $valueList = array(), $valueLength = 20)
    {
        $str = '';
        if (!is_array($valueList)) {
            $valueList = self::trimExplode(',', $valueList, true);
        }
        $valListCnt = count($valueList);
        foreach ($arr as $key => $value) {
            if (!$valListCnt || in_array($key, $valueList)) {
                $str .= (string)$key . trim(': ' . self::fixed_lgd_cs(str_replace(LF, '|', (string)$value), $valueLength)) . '; ';
            }
        }
        return $str;
    }

    public static function imageMagickCommand($command, $parameters, $path = '')
    {
        return CommandUtility::imageMagickCommand($command, $parameters, $path);
    }

    public static function unQuoteFilenames($parameters, $unQuote = false)
    {
        $paramsArr = explode(' ', trim($parameters));
        // Whenever a quote character (") is found, $quoteActive is set to the element number inside of $params. A value of -1 means that there are not open quotes at the current position.
        $quoteActive = -1;
        foreach ($paramsArr as $k => $v) {
            if ($quoteActive > -1) {
                $paramsArr[$quoteActive] .= ' ' . $v;
                unset($paramsArr[$k]);
                if (substr($v, -1) === $paramsArr[$quoteActive][0]) {
                    $quoteActive = -1;
                }
            } elseif (!trim($v)) {
                // Remove empty elements
                unset($paramsArr[$k]);
            } elseif (preg_match('/^(["\'])/', $v) && substr($v, -1) !== $v[0]) {
                $quoteActive = $k;
            }
        }
        if ($unQuote) {
            foreach ($paramsArr as $key => &$val) {
                $val = preg_replace('/(?:^"|"$)/', '', $val);
                $val = preg_replace('/(?:^\'|\'$)/', '', $val);
            }
            unset($val);
        }
        // Return reindexed array
        return array_values($paramsArr);
    }

    public static function quoteJSvalue($value)
    {
        return strtr(
            json_encode((string)$value, JSON_HEX_AMP|JSON_HEX_APOS|JSON_HEX_QUOT|JSON_HEX_TAG),
            array(
                '"' => '\'',
                '\\\\' => '\\u005C',
                ' ' => '\\u0020',
                '!' => '\\u0021',
                '\\t' => '\\u0009',
                '\\n' => '\\u000A',
                '\\r' => '\\u000D'
            )
        );
    }

    public static function cleanOutputBuffers()
    {
        self::logDeprecatedFunction();
        while (ob_end_clean()) {
        }
        header('Content-Encoding: None', true);
    }

    public static function flushOutputBuffers()
    {
        $obContent = '';
        while ($content = ob_get_clean()) {
            $obContent .= $content;
        }
        // If previously a "Content-Encoding: whatever" has been set, we have to unset it
        if (!headers_sent()) {
            $headersList = headers_list();
            foreach ($headersList as $header) {
                // Split it up at the :
                list($key, $value) = self::trimExplode(':', $header, true);
                // Check if we have a Content-Encoding other than 'None'
                if (strtolower($key) === 'content-encoding' && strtolower($value) !== 'none') {
                    header('Content-Encoding: None');
                    break;
                }
            }
        }
        echo $obContent;
    }

    public static function presetApplicationContext(ApplicationContext $applicationContext)
    {
        if (is_null(static::$applicationContext)) {
            static::$applicationContext = $applicationContext;
        } else {
            throw new \RuntimeException('Trying to override applicationContext which has already been defined!', 1376084316);
        }
    }

    public static function getApplicationContext()
    {
        return static::$applicationContext;
    }

    public static function isRunningOnCgiServerApi()
    {
        return in_array(PHP_SAPI, self::$supportedCgiServerApis, true);
    }
}