C:/xampp/htdocs/moodle/lib/typo3/class.t3lib_div.php

Go to the documentation of this file.

<?php
/***************************************************************
 *  Copyright notice
 *
 *  (c) 1999-2011 Kasper Skårhøj (kasperYYYY@typo3.com)
 *  All rights reserved
 *
 *  This script is part of the TYPO3 project. The TYPO3 project is
 *  free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  The GNU General Public License can be found at
 *  http://www.gnu.org/copyleft/gpl.html.
 *  A copy is found in the textfile GPL.txt and important notices to the license
 *  from the author is found in LICENSE.txt distributed with these scripts.
 *
 *
 *  This script is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  This copyright notice MUST APPEAR in all copies of the script!
 ***************************************************************/
        // a tabulator
define('TAB', chr(9));
        // a linefeed
define('LF', chr(10));
        // a carriage return
define('CR', chr(13));
        // a CR-LF combination
define('CRLF', CR . LF);

final class t3lib_div {

                // Severity constants used by t3lib_div::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;

        protected static $singletonInstances = array();

        protected static $nonSingletonInstances = array();

        protected static $finalClassNameRegister = array();

        /*************************
         *
         * 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.
         *
         *************************/

        public static function _GP($var) {
                if (empty($var)) {
                        return;
                }
                $value = isset($_POST[$var]) ? $_POST[$var] : $_GET[$var];
                if (isset($value)) {
                        if (is_array($value)) {
                                self::stripSlashesOnArray($value);
                        } else {
                                $value = stripslashes($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 = self::array_merge_recursive_overrule($getParameter, $postParameter);
                self::stripSlashesOnArray($mergedParameters);

                return $mergedParameters;
        }

        public static function _GET($var = NULL) {
                $value = ($var === NULL) ? $_GET : (empty($var) ? NULL : $_GET[$var]);
                if (isset($value)) { // Removes slashes since TYPO3 has added them regardless of magic_quotes setting.
                        if (is_array($value)) {
                                self::stripSlashesOnArray($value);
                        } else {
                                $value = stripslashes($value);
                        }
                }
                return $value;
        }

        public static function _POST($var = NULL) {
                $value = ($var === NULL) ? $_POST : (empty($var) ? NULL : $_POST[$var]);
                if (isset($value)) { // Removes slashes since TYPO3 has added them regardless of magic_quotes setting.
                        if (is_array($value)) {
                                self::stripSlashesOnArray($value);
                        } else {
                                $value = stripslashes($value);
                        }
                }
                return $value;
        }

        public static function _GETset($inputGet, $key = '') {
                        // adds slashes since TYPO3 standard currently is that slashes
                        // must be applied (regardless of magic_quotes setting)
                if (is_array($inputGet)) {
                        self::addSlashesOnArray($inputGet);
                } else {
                        $inputGet = addslashes($inputGet);
                }

                if ($key != '') {
                        if (strpos($key, '|') !== FALSE) {
                                $pieces = explode('|', $key);
                                $newGet = array();
                                $pointer =& $newGet;
                                foreach ($pieces as $piece) {
                                        $pointer =& $pointer[$piece];
                                }
                                $pointer = $inputGet;
                                $mergedGet = self::array_merge_recursive_overrule(
                                        $_GET, $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 GPvar($var, $strip = 0) {
                self::logDeprecatedFunction();

                if (empty($var)) {
                        return;
                }
                $value = isset($_POST[$var]) ? $_POST[$var] : $_GET[$var];
                if (isset($value) && is_string($value)) {
                        $value = stripslashes($value);
                } // Originally check '&& get_magic_quotes_gpc() ' but the values of $_GET are always slashed regardless of get_magic_quotes_gpc() because HTTP_POST/GET_VARS are run through addSlashesOnArray in the very beginning of index_ts.php eg.
                if ($strip && isset($value) && is_array($value)) {
                        self::stripSlashesOnArray($value);
                }
                return $value;
        }

        public static function GParrayMerged($var) {
                self::logDeprecatedFunction();

                return self::_GPmerged($var);
        }

        public static function removeXSS($string) {
                require_once(PATH_typo3 . 'contrib/RemoveXSS/RemoveXSS.php');
                $string = RemoveXSS::process($string);
                return $string;
        }


        /*************************
         *
         * IMAGE FUNCTIONS
         *
         *************************/


        public static function gif_compress($theFile, $type) {
                $gfxConf = $GLOBALS['TYPO3_CONF_VARS']['GFX'];
                $returnCode = '';
                if ($gfxConf['gif_compress'] && strtolower(substr($theFile, -4, 4)) == '.gif') { // GIF...
                        if (($type == 'IM' || !$type) && $gfxConf['im'] && $gfxConf['im_path_lzw']) { // IM
                                        // use temporary file to prevent problems with read and write lock on same file on network file systems
                                $temporaryName  =  dirname($theFile) . '/' . md5(uniqid()) . '.gif';
                                        // rename could fail, if a simultaneous thread is currently working on the same thing
                                if (@rename($theFile, $temporaryName)) {
                                        $cmd = self::imageMagickCommand('convert', '"' . $temporaryName . '" "' . $theFile . '"', $gfxConf['im_path_lzw']);
                                        t3lib_utility_Command::exec($cmd);
                                        unlink($temporaryName);
                                }

                                $returnCode = 'IM';
                                if (@is_file($theFile)) {
                                        self::fixPermissions($theFile);
                                }
                        } elseif (($type == 'GD' || !$type) && $gfxConf['gdlib'] && !$gfxConf['gdlib_png']) { // GD
                                $tempImage = imageCreateFromGif($theFile);
                                imageGif($tempImage, $theFile);
                                imageDestroy($tempImage);
                                $returnCode = 'GD';
                                if (@is_file($theFile)) {
                                        self::fixPermissions($theFile);
                                }
                        }
                }
                return $returnCode;
        }

        public static function png_to_gif_by_imagemagick($theFile) {
                if ($GLOBALS['TYPO3_CONF_VARS']['FE']['png_to_gif']
                                && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im']
                                && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw']
                                && strtolower(substr($theFile, -4, 4)) == '.png'
                                && @is_file($theFile)) { // IM
                        $newFile = substr($theFile, 0, -4) . '.gif';
                        $cmd = self::imageMagickCommand('convert', '"' . $theFile . '" "' . $newFile . '"', $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw']);
                        t3lib_utility_Command::exec($cmd);
                        $theFile = $newFile;
                        if (@is_file($newFile)) {
                                self::fixPermissions($newFile);
                        }
                                // unlink old file?? May be bad idea bacause TYPO3 would then recreate the file every time as TYPO3 thinks the file is not generated because it's missing!! So do not unlink $theFile here!!
                }
                return $theFile;
        }

        public static function read_png_gif($theFile, $output_png = 0) {
                if ($GLOBALS['TYPO3_CONF_VARS']['GFX']['im'] && @is_file($theFile)) {
                        $ext = strtolower(substr($theFile, -4, 4));
                        if (
                                ((string) $ext == '.png' && $output_png) ||
                                ((string) $ext == '.gif' && !$output_png)
                        ) {
                                return $theFile;
                        } else {
                                $newFile = PATH_site . 'typo3temp/readPG_' . md5($theFile . '|' . filemtime($theFile)) . ($output_png ? '.png' : '.gif');
                                $cmd = self::imageMagickCommand('convert', '"' . $theFile . '" "' . $newFile . '"', $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path']);
                                t3lib_utility_Command::exec($cmd);
                                if (@is_file($newFile)) {
                                        self::fixPermissions($newFile);
                                        return $newFile;
                                }
                        }
                }
        }


        /*************************
         *
         * STRING FUNCTIONS
         *
         *************************/

        public static function fixed_lgd($string, $origChars, $preStr = '...') {
                self::logDeprecatedFunction();

                $chars = abs($origChars);
                if ($chars >= 4) {
                        if (strlen($string) > $chars) {
                                return $origChars < 0 ?
                                                $preStr . trim(substr($string, -($chars - 3))) :
                                                trim(substr($string, 0, $chars - 3)) . $preStr;
                        }
                }
                return $string;
        }

        public static function fixed_lgd_pre($string, $chars) {
                self::logDeprecatedFunction();

                return strrev(self::fixed_lgd(strrev($string), $chars));
        }

        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'])) {
                        $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('t3lib_cs');
                        return $csConvObj->crop('iso-8859-1', $string, $chars, $appendString);
                }
        }

        public static function breakTextForEmail($str, $implChar = LF, $charWidth = 76) {
                self::logDeprecatedFunction();

                $lines = explode(LF, $str);
                $outArr = array();
                foreach ($lines as $lStr) {
                        $outArr[] = self::breakLinesForEmail($lStr, $implChar, $charWidth);
                }
                return implode(LF, $outArr);
        }

        public static function breakLinesForEmail($str, $implChar = LF, $charWidth = 76) {
                $lines = array();
                $l = $charWidth;
                $p = 0;
                while (strlen($str) > $p) {
                        $substr = substr($str, $p, $l);
                        if (strlen($substr) == $l) {
                                $count = count(explode(' ', trim(strrev($substr))));
                                if ($count > 1) { // OK...
                                        $parts = explode(' ', strrev($substr), 2);
                                        $theLine = strrev($parts[1]);
                                } else {
                                        $afterParts = explode(' ', substr($str, $l + $p), 2);
                                        $theLine = $substr . $afterParts[0];
                                }
                                if (!strlen($theLine)) {
                                        break;
                                } // Error, because this would keep us in an endless loop.
                        } else {
                                $theLine = $substr;
                        }

                        $lines[] = trim($theLine);
                        $p += strlen($theLine);
                        if (!trim(substr($str, $p, $l))) {
                                break;
                        } // added...
                }
                return implode($implChar, $lines);
        }

        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, 1);

                        foreach ($values as $test) {
                                list($test, $mask) = explode('/', $test);

                                if (intval($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 = (strcmp($firstpart, $firstip) == 0);
                                } else {
                                                // "192.168.*.*"
                                        $IPparts = explode('.', $test);
                                        $yes = 1;
                                        foreach ($IPparts as $index => $val) {
                                                $val = trim($val);
                                                if (strcmp($val, '*') && strcmp($IPpartsReq[$index], $val)) {
                                                        $yes = 0;
                                                }
                                        }
                                }
                                if ($yes) {
                                        return TRUE;
                                }
                        }
                }
                return FALSE;
        }

        public static function cmpIPv6($baseIP, $list) {
                $success = FALSE; // Policy default: Deny connection
                $baseIP = self::normalizeIPv6($baseIP);

                $values = self::trimExplode(',', $list, 1);
                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 = intval($mask) ? intval($mask) : 128;
                                if ($mask === '0') { // special case; /0 is an allowed mask - equals a wildcard
                                        $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 = intval($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) {
                // normalized representation has 39 characters (0000:0000:0000:0000:0000:0000:0000:0000)
                if (strlen($hex) < 39) {
                        $hex = self::normalizeIPv6($hex);
                }
                $hex = str_replace(':', '', $hex); // Replace colon to nothing
                $bin = pack("H*" , $hex);
                return $bin;
        }

        public static function normalizeIPv6($address) {
                $normalizedAddress = '';
                $stageOneAddress = '';

                $chunks = explode('::', $address); // Count 2 if if address has hidden zero blocks
                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 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, 1);

                foreach ($values as $test) {
                        $hostNameParts = explode('.', $test);

                                // to match hostNameParts can only be shorter (in case of wildcards) or equal
                        if (count($hostNameParts) > count($baseHostNameParts)) {
                                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 < count($hostNameParts)) {
                                                $wildcardMatched = FALSE;
                                                $tempHostName = implode('.', array_slice($hostNameParts, $index + 1));
                                                while (($wildcardStart < count($baseHostNameParts)) && (!$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 ? TRUE : 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 intInRange($theInt, $min, $max = 2000000000, $zeroValue = 0) {
                        // Returns $theInt as an integer in the integerspace from $min to $max
                $theInt = intval($theInt);
                if ($zeroValue && !$theInt) {
                        $theInt = $zeroValue;
                } // If the input value is zero after being converted to integer, zeroValue may set another default value for it.
                if ($theInt < $min) {
                        $theInt = $min;
                }
                if ($theInt > $max) {
                        $theInt = $max;
                }
                return $theInt;
        }

        public static function intval_positive($theInt) {
                $theInt = intval($theInt);
                if ($theInt < 0) {
                        $theInt = 0;
                }
                return $theInt;
        }

        public static function int_from_ver($verNumberStr) {
                $verParts = explode('.', $verNumberStr);
                return intval((int) $verParts[0] . str_pad((int) $verParts[1], 3, '0', STR_PAD_LEFT) . str_pad((int) $verParts[2], 3, '0', STR_PAD_LEFT));
        }

        public static function compat_version($verNumberStr) {
                global $TYPO3_CONF_VARS;
                $currVersionStr = $TYPO3_CONF_VARS['SYS']['compat_version'] ? $TYPO3_CONF_VARS['SYS']['compat_version'] : TYPO3_branch;

                if (self::int_from_ver($currVersionStr) < self::int_from_ver($verNumberStr)) {
                        return FALSE;
                } else {
                        return TRUE;
                }
        }

        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) {
                $hashAlgorithm = 'sha1';
                $hashBlocksize = 64;
                $hmac = '';

                if (extension_loaded('hash') && function_exists('hash_hmac') && function_exists('hash_algos') && in_array($hashAlgorithm, hash_algos())) {
                        $hmac = hash_hmac($hashAlgorithm, $input, $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey']);
                } else {
                                // outer padding
                        $opad = str_repeat(chr(0x5C), $hashBlocksize);
                                // innner padding
                        $ipad = str_repeat(chr(0x36), $hashBlocksize);
                        if (strlen($GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey']) > $hashBlocksize) {
                                        // keys longer than blocksize are shorten
                                $key = str_pad(pack('H*', call_user_func($hashAlgorithm, $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'])), $hashBlocksize, chr(0x00));
                        } else {
                                        // keys shorter than blocksize are zero-padded
                                $key = str_pad($GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'], $hashBlocksize, chr(0x00));
                        }
                        $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: t3lib_div::uniqueList() does NOT support array arguments anymore! Only string comma lists!',
                                1270853885
                        );
                }
                if (isset($secondParameter)) {
                        throw new InvalidArgumentException(
                                'TYPO3 Fatal Error: t3lib_div::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, 1)));
        }

        public static function split_fileref($fileref) {
                $reg = array();
                if (preg_match('/(.*\/)(.*)$/', $fileref, $reg)) {
                        $info['path'] = $reg[1];
                        $info['file'] = $reg[2];
                } else {
                        $info['path'] = '';
                        $info['file'] = $fileref;
                }

                $reg = '';
                if (!is_dir($fileref) && 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) {
                        // This takes a hex-color (# included!) and adds $R, $G and $B to the HTML-color (format: #xxxxxx) and returns the new color
                $nR = self::intInRange(hexdec(substr($color, 1, 2)) + $R, 0, 255);
                $nG = self::intInRange(hexdec(substr($color, 3, 2)) + $G, 0, 255);
                $nB = self::intInRange(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) {
                return self::modifyHTMLColor($color, $all, $all, $all);
        }

        public static function rm_endcomma($string) {
                self::logDeprecatedFunction();

                return rtrim($string, ',');
        }

        public static function danish_strtoupper($string) {
                self::logDeprecatedFunction();

                $value = strtoupper($string);
                return strtr($value, array(
                        chr(225) => chr(193),
                        chr(233) => chr(201),
                        chr(250) => chr(218),
                        chr(237) => chr(205),
                        chr(226) => chr(196),
                        chr(234) => chr(203),
                        chr(251) => chr(220),
                        chr(244) => chr(214),
                        chr(238) => chr(207),
                        chr(230) => chr(198),
                        chr(248) => chr(216),
                        chr(229) => chr(197),
                        chr(228) => chr(196),
                        chr(246) => chr(214),
                        chr(252) => chr(220),
                ));
        }

        public static function convUmlauts($str) {
                self::logDeprecatedFunction();

                $pattern = array(chr(228), chr(196), chr(246), chr(214), chr(252), chr(220), chr(223), chr(229), chr(197), chr(248), chr(216), chr(230), chr(198));
                $replace = array('ae', 'Ae', 'oe', 'Oe', 'ue', 'Ue', 'ss', 'aa', 'AA', 'oe', 'OE', 'ae', 'AE');
                return str_replace($pattern, $replace, $str);
        }

        public static function testInt($var) {
                if ($var === '') {
                        return FALSE;
                }
                return (string) intval($var) === (string) $var;
        }

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

        public static function formatSize($sizeInBytes, $labels = '') {

                        // Set labels:
                if (strlen($labels) == 0) {
                        $labels = ' | K| M| G';
                } else {
                        $labels = str_replace('"', '', $labels);
                }
                $labelArr = explode('|', $labels);

                        // Find size:
                if ($sizeInBytes > 900) {
                        if ($sizeInBytes > 900000000) { // GB
                                $val = $sizeInBytes / (1024 * 1024 * 1024);
                                return number_format($val, (($val < 20) ? 1 : 0), '.', '') . $labelArr[3];
                        }
                        elseif ($sizeInBytes > 900000) { // MB
                                $val = $sizeInBytes / (1024 * 1024);
                                return number_format($val, (($val < 20) ? 1 : 0), '.', '') . $labelArr[2];
                        } else { // KB
                                $val = $sizeInBytes / (1024);
                                return number_format($val, (($val < 20) ? 1 : 0), '.', '') . $labelArr[1];
                        }
                } else { // Bytes
                        return $sizeInBytes . $labelArr[0];
                }
        }

        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 calcPriority($string) {
                $string = preg_replace('/[[:space:]]*/', '', $string); // removing all whitespace
                $string = '+' . $string; // Ensuring an operator for the first entrance
                $qm = '\*\/\+-^%';
                $regex = '([' . $qm . '])([' . $qm . ']?[0-9\.]*)';
                        // split the expression here:
                $reg = array();
                preg_match_all('/' . $regex . '/', $string, $reg);

                reset($reg[2]);
                $number = 0;
                $Msign = '+';
                $err = '';
                $buffer = doubleval(current($reg[2]));
                next($reg[2]); // Advance pointer

                while (list($k, $v) = each($reg[2])) {
                        $v = doubleval($v);
                        $sign = $reg[1][$k];
                        if ($sign == '+' || $sign == '-') {
                                $number = $Msign == '-' ? $number -= $buffer : $number += $buffer;
                                $Msign = $sign;
                                $buffer = $v;
                        } else {
                                if ($sign == '/') {
                                        if ($v) {
                                                $buffer /= $v;
                                        } else {
                                                $err = 'dividing by zero';
                                        }
                                }
                                if ($sign == '%') {
                                        if ($v) {
                                                $buffer %= $v;
                                        } else {
                                                $err = 'dividing by zero';
                                        }
                                }
                                if ($sign == '*') {
                                        $buffer *= $v;
                                }
                                if ($sign == '^') {
                                        $buffer = pow($buffer, $v);
                                }
                        }
                }
                $number = $Msign == '-' ? $number -= $buffer : $number += $buffer;
                return $err ? 'ERROR: ' . $err : $number;
        }

        public static function calcParenthesis($string) {
                $securC = 100;
                do {
                        $valueLenO = strcspn($string, '(');
                        $valueLenC = strcspn($string, ')');
                        if ($valueLenC == strlen($string) || $valueLenC < $valueLenO) {
                                $value = self::calcPriority(substr($string, 0, $valueLenC));
                                $string = $value . substr($string, $valueLenC + 1);
                                return $string;
                        } else {
                                $string = substr($string, 0, $valueLenO) . self::calcParenthesis(substr($string, $valueLenO + 1));
                        }
                                // Security:
                        $securC--;
                        if ($securC <= 0) {
                                break;
                        }
                } while ($valueLenO < strlen($string));
                return $string;
        }

        public static function htmlspecialchars_decode($value) {
                $value = str_replace('&gt;', '>', $value);
                $value = str_replace('&lt;', '<', $value);
                $value = str_replace('&quot;', '"', $value);
                $value = str_replace('&amp;', '&', $value);
                return $value;
        }

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

        public static function slashJS($string, $extended = 0, $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) {
                        // enforce maximum length to prevent libpcre recursion crash bug #52929 in PHP
                        // fixed in PHP 5.2+ later than Sept 2010; length restriction per SMTP RFC 2821
                if (strlen($email) > 320) {
                        return FALSE;
                }
                return (filter_var($email, FILTER_VALIDATE_EMAIL) !== FALSE);
        }

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

        public static function normalizeMailAddress($address) {
                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) {
                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($count) {
                $output = '';
                        // /dev/urandom is available on many *nix systems and is considered
                        // the best commonly available pseudo-random source.
                if (TYPO3_OS != 'WIN' && ($fh = @fopen('/dev/urandom', 'rb'))) {
                        $output = fread($fh, $count);
                        fclose($fh);
                } elseif (TYPO3_OS == 'WIN') {
                        if (class_exists('COM')) {
                                try {
                                        $com = new COM('CAPICOM.Utilities.1');
                                        $output = base64_decode($com->GetRandom($count, 0));
                                } catch (Exception $e) {
                                        // CAPICOM not installed
                                }
                        }
                        if ($output === '' && version_compare(PHP_VERSION, '5.3.0', '>=')) {
                                if (function_exists('mcrypt_create_iv')) {
                                        $output = mcrypt_create_iv($count, MCRYPT_DEV_URANDOM);
                                } elseif (function_exists('openssl_random_pseudo_bytes')) {
                                        $isStrong = NULL;
                                        $output = openssl_random_pseudo_bytes($count, $isStrong);
                                                // skip ssl since it wasn't using the strong algo
                                        if ($isStrong !== TRUE) {
                                                $output = '';
                                        }
                                }
                        }
                }

                        // fallback if other random byte generation failed until now
                if (!isset($output{$count - 1})) {
                                // We initialize with the somewhat random.
                        $randomState = $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey']
                                        . base_convert(memory_get_usage() % pow(10, 6), 10, 2)
                                        . microtime() . uniqid('') . getmypid();
                        while (!isset($output{$count - 1})) {
                                $randomState = sha1(microtime() . mt_rand() . $randomState);
                                $output .= sha1(mt_rand() . $randomState, TRUE);
                        }
                        $output = substr($output, strlen($output) - $count, $count);
                }
                return $output;
        }

        public static function getRandomHexString($count) {
                return substr(bin2hex(self::generateRandomBytes(intval(($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(substr($string, 0, 1)) . substr($string, 1);
        }

        public static function isValidUrl($url) {
                return (filter_var($url, FILTER_VALIDATE_URL, FILTER_FLAG_SCHEME_REQUIRED) !== FALSE);
        }


        /*************************
         *
         * ARRAY FUNCTIONS
         *
         *************************/

        public static function inArray(array $in_array, $item) {
                foreach ($in_array as $val) {
                        if (!is_array($val) && !strcmp($val, $item)) {
                                return TRUE;
                        }
                }
                return FALSE;
        }

        public static function intExplode($delimiter, $string, $onlyNonEmptyValues = FALSE, $limit = 0) {
                $explodedValues = self::trimExplode($delimiter, $string, $onlyNonEmptyValues, $limit);
                return array_map('intval', $explodedValues);
        }

        public static function revExplode($delimiter, $string, $count = 0) {
                $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) {
                $explodedValues = explode($delim, $string);

                $result = array_map('trim', $explodedValues);

                if ($removeEmptyValues) {
                        $temp = array();
                        foreach ($result as $value) {
                                if ($value !== '') {
                                        $temp[] = $value;
                                }
                        }
                        $result = $temp;
                }

                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($delim, $lastElements);
                        }
                }

                return $result;
        }

        public static function uniqueArray(array $valueArray) {
                self::logDeprecatedFunction();

                return array_unique($valueArray);
        }

        public static function removeArrayEntryByValue(array $array, $cmpValue) {
                foreach ($array as $k => $v) {
                        if (is_array($v)) {
                                $array[$k] = self::removeArrayEntryByValue($v, $cmpValue);
                        } elseif (!strcmp($v, $cmpValue)) {
                                unset($array[$k]);
                        }
                }
                return $array;
        }

        public static function keepItemsInArray(array $array, $keepItems, $getValueFunc = NULL) {
                if ($array) {
                                // Convert strings to arrays:
                        if (is_string($keepItems)) {
                                $keepItems = self::trimExplode(',', $keepItems);
                        }
                                // create_function() returns a string:
                        if (!is_string($getValueFunc)) {
                                $getValueFunc = NULL;
                        }
                                // Do the filtering:
                        if (is_array($keepItems) && count($keepItems)) {
                                foreach ($array as $key => $value) {
                                                // Get the value to compare by using the callback function:
                                        $keepValue = (isset($getValueFunc) ? $getValueFunc($value) : $value);
                                        if (!in_array($keepValue, $keepItems)) {
                                                unset($array[$key]);
                                        }
                                }
                        }
                }
                return $array;
        }

        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 || strcmp($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 (strlen($v)) {
                                        list($pK, $pV) = explode('=', $v, 2);
                                        $output[rawurldecode($pK)] = rawurldecode($pV);
                                }
                        }
                }
                return $output;
        }

        public static function compileSelectedGetVarsFromArray($varList, array $getArray, $GPvarAlt = 1) {
                $keys = self::trimExplode(',', $varList, 1);
                $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) {
                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) {
                if ($cmd == 'strip') {
                        self::stripSlashesOnArray($arr);
                }
                if ($cmd == 'add') {
                        self::addSlashesOnArray($arr);
                }
                return $arr;
        }

        function remapArrayKeys(&$array, $mappingTable) {
                if (is_array($mappingTable)) {
                        foreach ($mappingTable as $old => $new) {
                                if ($new && isset($array[$old])) {
                                        $array[$new] = $array[$old];
                                        unset ($array[$old]);
                                }
                        }
                }
        }


        public static function array_merge_recursive_overrule(array $arr0, array $arr1, $notAddKeys = 0, $includeEmtpyValues = TRUE) {
                foreach ($arr1 as $key => $val) {
                        if (is_array($arr0[$key])) {
                                if (is_array($arr1[$key])) {
                                        $arr0[$key] = self::array_merge_recursive_overrule($arr0[$key], $arr1[$key], $notAddKeys, $includeEmtpyValues);
                                }
                        } else {
                                if ($notAddKeys) {
                                        if (isset($arr0[$key])) {
                                                if ($includeEmtpyValues || $val) {
                                                        $arr0[$key] = $val;
                                                }
                                        }
                                } else {
                                        if ($includeEmtpyValues || $val) {
                                                $arr0[$key] = $val;
                                        }
                                }
                        }
                }
                reset($arr0);
                return $arr0;
        }

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

        public static function arrayDiffAssocRecursive(array $array1, array $array2) {
                $differenceArray = array();
                foreach ($array1 as $key => $value) {
                        if (!array_key_exists($key, $array2)) {
                                $differenceArray[$key] = $value;
                        } elseif (is_array($value)) {
                                if (is_array($array2[$key])) {
                                        $differenceArray[$key] = self::arrayDiffAssocRecursive($value, $array2[$key]);
                                }
                        }
                }

                return $differenceArray;
        }

        public static function csvValues(array $row, $delim = ',', $quote = '"') {
                reset($row);
                $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 array2json(array $jsonArray) {
                self::logDeprecatedFunction();

                return json_encode($jsonArray);
        }

        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) {
                if (!is_array($array)) {
                        return FALSE;
                }
                uksort($array, 'strnatcasecmp');
                foreach ($array as $key => $value) {
                        self::naturalKeySortRecursive($array[$key]);
                }
                return TRUE;
        }


        /*************************
         *
         * HTML/XML PROCESSING
         *
         *************************/

        public static function get_tag_attributes($tag) {
                $components = self::split_tag_attributes($tag);
                $name = ''; // attribute name is stored here
                $valuemode = FALSE;
                $attributes = array();
                foreach ($components as $key => $val) {
                        if ($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 ($valuemode) {
                                        if ($name) {
                                                $attributes[$name] = $val;
                                                $name = '';
                                        }
                                } else {
                                        if ($key = strtolower(preg_replace('/[^a-zA-Z0-9]/', '', $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();
                while (strcmp($tag_tmp, '')) { // Compared with empty string instead , 030102
                        $firstChar = substr($tag_tmp, 0, 1);
                        if (!strcmp($firstChar, '"') || !strcmp($firstChar, "'")) {
                                $reg = explode($firstChar, $tag_tmp, 3);
                                $value[] = $reg[1];
                                $tag_tmp = trim($reg[2]);
                        } elseif (!strcmp($firstChar, '=')) {
                                $value[] = '=';
                                $tag_tmp = trim(substr($tag_tmp, 1)); // Removes = chars.
                        } 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 (strcmp($v, '') || $dontOmitBlankAttribs) {
                                $list[] = $p . '="' . $v . '"';
                        }
                }
                return implode(' ', $list);
        }

        public static function implodeParams(array $arr, $xhtmlSafe = FALSE, $dontOmitBlankAttribs = FALSE) {
                self::logDeprecatedFunction();

                return self::implodeAttributes($arr, $xhtmlSafe, $dontOmitBlankAttribs);
        }

        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) {
                $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);
                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=array('XMLvalue'=>self::xmlRecompileFromStructValArray($partArray));
                                                $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 = '') {

                        // Figure out charset if not given explicitly:
                if (!$charset) {
                        if ($GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset']) { // First priority: forceCharset! If set, this will be authoritative!
                                $charset = $GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'];
                        } elseif (is_object($GLOBALS['LANG'])) {
                                $charset = $GLOBALS['LANG']->charSet; // If "LANG" is around, that will hold the current charset
                        } else {
                                $charset = 'iso-8859-1'; // THIS is just a hopeful guess!
                        }
                }

                        // 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.
                        if (isset($options['grandParentTagMap'][$stackData['grandParentTagName'] . '/' . $stackData['parentTagName']])) { // Use tag based on grand-parent + parent tag name
                                $attr .= ' index="' . htmlspecialchars($tagName) . '"';
                                $tagName = (string) $options['grandParentTagMap'][$stackData['grandParentTagName'] . '/' . $stackData['parentTagName']];
                        } elseif (isset($options['parentTagMap'][$stackData['parentTagName'] . ':_IS_NUM']) && self::testInt($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 (!strcmp(intval($tagName), $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'] ? $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;
                                }

                                $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) : '');
                                if ((int) $options['disableTypeAttrib'] != 2) { // Do not set "type = array". Makes prettier XML but means that empty arrays are not restored with xml2array
                                        $attr .= ' type="array"';
                                }
                        } else { // Just a value:

                                        // Look for binary chars:
                                $vLen = strlen($v); // check for length, because PHP 5.2.0 may crash when first argument of strcspn is empty
                                if ($vLen && strcspn($v, $binaryChars) != $vLen) { // Go for base64 encoding if the initial segment NOT matching any binary char has the same length as the whole string!
                                                // 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 . '"';
                                        }
                                }
                        }

                                // 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
                        $cacheContent = t3lib_pageSelect::getHash($identifier, 0);
                        $array = unserialize($cacheContent);

                        if ($array === FALSE) {
                                $array = self::xml2arrayProcess($string, $NSprefix, $reportDocTag);
                                t3lib_pageSelect::storeHash($identifier, serialize($array), 'ident_xml2array');
                        }
                                // store content in first level cache
                        $firstLevelCache[$identifier] = $array;
                }
                return $array;
        }

        protected function xml2arrayProcess($string, $NSprefix = '', $reportDocTag = FALSE) {
                global $TYPO3_CONF_VARS;

                        // 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] ? $match[1] : ($TYPO3_CONF_VARS['BE']['forceCharset'] ? $TYPO3_CONF_VARS['BE']['forceCharset'] : 'iso-8859-1');
                xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, $theCharset); // us-ascii / utf-8 / iso-8859-1

                        // 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 = (substr($tagName, 0, 1) == 'n' && !strcmp(intval($testNtag), $testNtag)) ? intval($testNtag) : $tagName;

                                // Test for alternative index value:
                        if (strlen($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:
                                        $current[$tagName] = array(); // Setting blank place holder
                                        $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];
                                        end($current); // Going to the end of array to get placeholder key, key($current), and fill in array next:
                                        $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 {
                                                $current[$tagName] = (string) $val['value']; // Had to cast it as a string - otherwise it would be evaluate false if tested with isset()!!

                                                        // Cast type:
                                                switch ((string) $val['attributes']['type']) {
                                                        case 'integer':
                                                                $current[$tagName] = (integer) $current[$tagName];
                                                                break;
                                                        case 'double':
                                                                $current[$tagName] = (double) $current[$tagName];
                                                                break;
                                                        case 'boolean':
                                                                $current[$tagName] = (bool) $current[$tagName];
                                                                break;
                                                        case 'array':
                                                                $current[$tagName] = 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...
                                                                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 = '') {
                require_once(PATH_typo3 . 'contrib/jsmin/jsmin.php');
                try {
                        $error = '';
                        $script = trim(JSMin::minify(str_replace(CR, '', $script)));
                }
                catch (JSMinException $e) {
                        $error = 'Error while minifying JavaScript: ' . $e->getMessage();
                        self::devLog($error, 't3lib_div', 2,
                                array('JavaScript' => $script, 'Stack trace' => $e->getTrace()));
                }
                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.
                        $ch = curl_init();
                        if (!$ch) {
                                if (isset($report)) {
                                        $report['error'] = -1;
                                        $report['message'] = 'Couldn\'t initialize cURL.';
                                }
                                return FALSE;
                        }

                        curl_setopt($ch, CURLOPT_URL, $url);
                        curl_setopt($ch, CURLOPT_HEADER, $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, intval($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlTimeout'])));

                                // may fail (PHP 5.2.0+ and 5.1.5+) when open_basedir or safe_mode are enabled
                        $followLocation = @curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);

                        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']['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);
                        if (isset($report)) {
                                if ($content === FALSE) {
                                        $report['error'] = curl_errno($ch);
                                        $report['message'] = curl_error($ch);
                                } else {
                                        $curlInfo = curl_getinfo($ch);
                                                // We hit a redirection but we couldn't follow it
                                        if (!$followLocation && $curlInfo['status'] >= 300 && $curlInfo['status'] < 400) {
                                                $report['error'] = -1;
                                                $report['message'] = 'Couldn\'t follow location redirect (either PHP configuration option safe_mode or open_basedir is in effect).';
                                        } 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 = intval($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;
                                // $errstr = '';
                        $fp = @fsockopen($scheme . $parsedURL['host'], $port, $errno, $errstr, 2.0);
                        if (!$fp || $errno > 0) {
                                if (isset($report)) {
                                        $report['error'] = $errno ? $errno : -1;
                                        $report['message'] = $errno ? ($errstr ? $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'] . "\r\nConnection: close\r\n";
                        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 (!strlen(trim($line))) {
                                        break; // Stop at the first empty line (= end of header)
                                }
                        }
                        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)
                                )
                        )
                        );
                        $content = @file_get_contents($url, FALSE, $ctx);
                        if ($content === FALSE && isset($report)) {
                                $phpError = error_get_last();
                                $report['error'] = $phpError['type'];
                                $report['message'] = $phpError['message'];
                        }
                } else {
                        if (isset($report)) {
                                $report['lib'] = 'file';
                        }
                        $content = @file_get_contents($url);
                        if ($content === FALSE && isset($report)) {
                                if (function_exists('error_get_last')) {
                                        $phpError = error_get_last();
                                        $report['error'] = $phpError['type'];
                                        $report['message'] = $phpError['message'];
                                } else {
                                        $report['error'] = -1;
                                        $report['message'] = 'Couldn\'t get URL.';
                                }
                        }
                }

                return $content;
        }

        public static function writeFile($file, $content) {
                if (!@is_file($file)) {
                        $changePermissions = TRUE;
                }

                if ($fd = fopen($file, 'wb')) {
                        $res = fwrite($fd, $content);
                        fclose($fd);

                        if ($res === FALSE) {
                                return FALSE;
                        }

                        if ($changePermissions) { // Change the permissions only if the file has just been created
                                self::fixPermissions($file);
                        }

                        return TRUE;
                }

                return FALSE;
        }

        public static function fixPermissions($path, $recursive = FALSE) {
                if (TYPO3_OS != 'WIN') {
                        $result = FALSE;

                                // Make path absolute
                        if (!self::isAbsPath($path)) {
                                $path = self::getFileAbsFileName($path, FALSE);
                        }

                        if (self::isAllowedAbsPath($path)) {
                                if (@is_file($path)) {
                                                // "@" is there because file is not necessarily OWNED by the user
                                        $result = @chmod($path, octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['fileCreateMask']));
                                } elseif (@is_dir($path)) {
                                        $path = preg_replace('|/$|', '', $path);
                                                // "@" is there because file is not necessarily OWNED by the user
                                        $result = @chmod($path, octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['folderCreateMask']));
                                }

                                        // Set createGroup if not empty
                                if ($GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup']) {
                                                // "@" is there because file is not necessarily OWNED by the user
                                        $changeGroupResult = @chgrp($path, $GLOBALS['TYPO3_CONF_VARS']['BE']['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 = self::fixPermissions($path . '/' . $file);
                                                        } elseif (@is_dir($path . '/' . $file)) {
                                                                $recursionResult = self::fixPermissions($path . '/' . $file, TRUE);
                                                        }
                                                        if (isset($recursionResult) && !$recursionResult) {
                                                                $result = FALSE;
                                                        }
                                                }
                                        }
                                        closedir($handle);
                                }
                        }
                } else {
                        $result = TRUE;
                }
                return $result;
        }

        public static function writeFileToTypo3tempDir($filepath, $content) {

                        // Parse filepath into directory and basename:
                $fI = pathinfo($filepath);
                $fI['dirname'] .= '/';

                        // Check parts:
                if (self::validPathStr($filepath) && $fI['basename'] && strlen($fI['basename']) < 60) {
                        if (defined('PATH_site')) {
                                $dirName = PATH_site . 'typo3temp/'; // Setting main temporary directory name (standard)
                                if (@is_dir($dirName)) {
                                        if (self::isFirstPartOfStr($fI['dirname'], $dirName)) {

                                                        // 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)) {
                                                                        self::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']) {
                                                                self::writeFile($filepath, $content);
                                                                if (!@is_file($filepath)) {
                                                                        return 'File not written to disk! Write permission error in filesystem?';
                                                                }
                                                        } else {
                                                                return 'Calculated filelocation didn\'t match input $filepath!';
                                                        }
                                                } else {
                                                        return '"' . $dirName . '" is not a directory!';
                                                }
                                        } else {
                                                return '"' . $fI['dirname'] . '" was not within directory PATH_site + "typo3temp/"';
                                        }
                                } else {
                                        return 'PATH_site + "typo3temp/" was not a directory!';
                                }
                        } else {
                                return 'PATH_site constant was NOT defined!';
                        }
                } else {
                        return 'Input filepath "' . $filepath . '" was generally invalid!';
                }
        }

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

        public static function mkdir_deep($destination, $deepDir) {
                $allParts = self::trimExplode('/', $deepDir, 1);
                $root = '';
                foreach ($allParts as $part) {
                        $root .= $part . '/';
                        if (!is_dir($destination . $root)) {
                                self::mkdir($destination . $root);
                                if (!@is_dir($destination . $root)) {
                                        return 'Error: The directory "' . $destination . $root . '" could not be created...';
                                }
                        }
                }
        }

        public static function rmdir($path, $removeNonEmpty = FALSE) {
                $OK = FALSE;
                $path = preg_replace('|/$|', '', $path); // Remove trailing slash

                if (file_exists($path)) {
                        $OK = TRUE;

                        if (is_dir($path)) {
                                if ($removeNonEmpty == TRUE && $handle = opendir($path)) {
                                        while ($OK && FALSE !== ($file = readdir($handle))) {
                                                if ($file == '.' || $file == '..') {
                                                        continue;
                                                }
                                                $OK = self::rmdir($path . '/' . $file, $removeNonEmpty);
                                        }
                                        closedir($handle);
                                }
                                if ($OK) {
                                        $OK = rmdir($path);
                                }

                        } else { // If $dirname is a file, simply remove it
                                $OK = unlink($path);
                        }

                        clearstatcache();
                }

                return $OK;
        }

        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 = 0, $order = '', $excludePattern = '') {

                        // Initialize variabels:
                $filearray = array();
                $sortarray = array();
                $path = rtrim($path, '/');

                        // Find files+directories:
                if (@is_dir($path)) {
                        $extensionList = strtolower($extensionList);
                        $d = dir($path);
                        if (is_object($d)) {
                                while ($entry = $d->read()) {
                                        if (@is_file($path . '/' . $entry)) {
                                                $fI = pathinfo($entry);
                                                $key = md5($path . '/' . $entry); // Don't change this ever - extensions may depend on the fact that the hash is an md5 of the path! (import/export extension)
                                                if ((!strlen($extensionList) || self::inList($extensionList, strtolower($fI['extension']))) && (!strlen($excludePattern) || !preg_match('/^' . $excludePattern . '$/', $entry))) {
                                                        $filearray[$key] = ($prependPath ? $path . '/' : '') . $entry;
                                                        if ($order == 'mtime') {
                                                                $sortarray[$key] = filemtime($path . '/' . $entry);
                                                        }
                                                        elseif ($order) {
                                                                $sortarray[$key] = $entry;
                                                        }
                                                }
                                        }
                                }
                                $d->close();
                        } else {
                                return 'error opening path: "' . $path . '"';
                        }
                }

                        // Sort them:
                if ($order) {
                        asort($sortarray);
                        $newArr = array();
                        foreach ($sortarray as $k => $v) {
                                $newArr[$k] = $filearray[$k];
                        }
                        $filearray = $newArr;
                }

                        // Return result
                reset($filearray);
                return $filearray;
        }

        public static function getAllFilesAndFoldersInPath(array $fileArr, $path, $extList = '', $regDirs = 0, $recursivityLevels = 99, $excludePattern = '') {
                if ($regDirs) {
                        $fileArr[] = $path;
                }
                $fileArr = array_merge($fileArr, self::getFilesInDir($path, $extList, 1, 1, $excludePattern));

                $dirs = self::get_dirs($path);
                if (is_array($dirs) && $recursivityLevels > 0) {
                        foreach ($dirs as $subdirs) {
                                if ((string) $subdirs != '' && (!strlen($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!';
                        }
                }
                return $fileArr;
        }

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

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

        public static function locationHeaderUrl($path) {
                $uI = parse_url($path);
                if (substr($path, 0, 1) == '/') { // relative to HOST
                        $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($localLimit = 0) {
                        // don't allow more than the global max file size at all
                $t3Limit = (intval($localLimit > 0 ? $localLimit : $GLOBALS['TYPO3_CONF_VARS']['BE']['maxFileSize']));
                        // as TYPO3 is handling the file size in KB, multiply by 1024 to get bytes
                $t3Limit = $t3Limit * 1024;

                        // 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 < $phpUploadLimit ? $phpPostLimit : $phpUploadLimit);

                        // is the allowed PHP limit (upload_max_filesize) lower than the TYPO3 limit?, also: revert back to KB
                return floor($phpUploadLimit < $t3Limit ? $phpUploadLimit : $t3Limit) / 1024;
        }

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

        public static function getMaximumPathLength() {
                $maximumPathLength = 0;

                if (version_compare(PHP_VERSION, '5.3.0', '<')) {
                                // rough assumptions
                        if (TYPO3_OS == 'WIN') {
                                        // WIN is usually 255, Vista 260, although NTFS can hold about 2k
                                $maximumPathLength = 255;
                        } else {
                                $maximumPathLength = 2048;
                        }
                } else {
                                // precise information is available since PHP 5.3
                        $maximumPathLength = PHP_MAXPATHLEN;
                }

                return $maximumPathLength;
        }


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

                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 || $forceQueryString) {
                                        // 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;
        }


        /*************************
         *
         * DEBUG helper FUNCTIONS
         *
         *************************/

        /* Deprecated since 4.5, use t3lib_utility_Debug */


        public static function debug_ordvalue($string, $characters = 100) {
                self::logDeprecatedFunction();
                return t3lib_utility_Debug::ordinalValue($string, $characters);
        }

        public static function view_array($array_in) {
                self::logDeprecatedFunction();
                return t3lib_utility_Debug::viewArray($array_in);
        }

        public static function print_array($array_in) {
                self::logDeprecatedFunction();
                t3lib_utility_Debug::printArray($array_in);
        }

        public static function debug($var = '', $header = '', $group = 'Debug') {
                self::logDeprecatedFunction();
                t3lib_utility_Debug::debug($var, $header, $group);
        }

        public static function debug_trail() {
                self::logDeprecatedFunction();
                return t3lib_utility_Debug::debugTrail();
        }

        public static function debugRows($rows, $header = '', $returnHTML = FALSE) {
                self::logDeprecatedFunction();
                return t3lib_utility_Debug::debugRows($rows, $header, $returnHTML);
        }


        /*************************
         *
         * SYSTEM INFORMATION
         *
         *************************/

        public static function getThisUrl() {
                $p = parse_url(self::getIndpEnv('TYPO3_REQUEST_SCRIPT')); // Url of this 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 . '?' . preg_replace('/^&/', '', $pString) : $parts;
        }

        public static function linkThisUrl($url, array $getParams = array()) {
                $parts = parse_url($url);
                $getP = array();
                if ($parts['query']) {
                        parse_str($parts['query'], $getP);
                }
                $getP = self::array_merge_recursive_overrule($getP, $getParams);
                $uP = explode('?', $url);

                $params = self::implodeArrayForUrl('', $getP);
                $outurl = $uP[0] . ($params ? '?' . substr($params, 1) : '');

                return $outurl;
        }

        public static function getIndpEnv($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 proxy

                        Notice: [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/' !!)

                */

                #               if ($getEnvName=='HTTP_REFERER')        return '';

                $retVal = '';

                switch ((string) $getEnvName) {
                        case 'SCRIPT_NAME':
                                $retVal = (PHP_SAPI == 'fpm-fcgi' || PHP_SAPI == 'cgi' || PHP_SAPI == 'cgi-fcgi') &&
                                                ($_SERVER['ORIG_PATH_INFO'] ? $_SERVER['ORIG_PATH_INFO'] : $_SERVER['PATH_INFO']) ?
                                                ($_SERVER['ORIG_PATH_INFO'] ? $_SERVER['ORIG_PATH_INFO'] : $_SERVER['PATH_INFO']) :
                                                ($_SERVER['ORIG_SCRIPT_NAME'] ? $_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 = str_replace('//', '/', str_replace('\\', '/',
                                        (PHP_SAPI == 'fpm-fcgi' || PHP_SAPI == 'cgi' || PHP_SAPI == 'isapi' || PHP_SAPI == 'cgi-fcgi') &&
                                                        ($_SERVER['ORIG_PATH_TRANSLATED'] ? $_SERVER['ORIG_PATH_TRANSLATED'] : $_SERVER['PATH_TRANSLATED']) ?
                                                        ($_SERVER['ORIG_PATH_TRANSLATED'] ? $_SERVER['ORIG_PATH_TRANSLATED'] : $_SERVER['PATH_TRANSLATED']) :
                                                        ($_SERVER['ORIG_SCRIPT_FILENAME'] ? $_SERVER['ORIG_SCRIPT_FILENAME'] : $_SERVER['SCRIPT_FILENAME'])));

                                break;
                        case 'REQUEST_URI':
                                        // Typical application of REQUEST_URI is return urls, forms submitting to itself etc. Example: returnUrl='.rawurlencode(t3lib_div::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 = $_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'],t3lib_div::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 (strcmp($_SERVER['PATH_INFO'],self::getIndpEnv('SCRIPT_NAME')) && count(explode('/',$_SERVER['PATH_INFO']))>1)       {
                                if (PHP_SAPI != 'cgi' && PHP_SAPI != 'cgi-fcgi' && PHP_SAPI != 'fpm-fcgi') {
                                        $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 (count($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 = '';
                                                                break;
                                                }
                                        }
                                        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 (count($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 = '';
                                                                break;
                                                }
                                        }
                                        if ($host) {
                                                $retVal = $host;
                                        }
                                }
                                break;
                                // These are let through without modification
                        case 'HTTP_REFERER':
                        case 'HTTP_USER_AGENT':
                        case 'HTTP_ACCEPT_ENCODING':
                        case 'HTTP_ACCEPT_LANGUAGE':
                        case 'REMOTE_HOST':
                        case 'QUERY_STRING':
                                $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 (!strcmp($SFN_A[$kk], $vv)) {
                                                $acc[] = $vv;
                                        } else {
                                                break;
                                        }
                                }
                                $commonEnd = strrev(implode('/', $acc));
                                if (strcmp($commonEnd, '')) {
                                        $DR = substr($SFN, 0, -(strlen($commonEnd) + 1));
                                }
                                $retVal = $DR;
                                break;
                        case 'TYPO3_HOST_ONLY':
                                $httpHost = self::getIndpEnv('HTTP_HOST');
                                $httpHostBracketPosition = strpos($httpHost, ']');
                                $retVal = ($httpHostBracketPosition !== FALSE) ? substr($httpHost, 0, ($httpHostBracketPosition + 1)) : array_shift(explode(':', $httpHost));
                                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':
                                if (defined('PATH_thisScript') && defined('PATH_site')) {
                                        $lPath = substr(dirname(PATH_thisScript), strlen(PATH_site)) . '/';
                                        $url = self::getIndpEnv('TYPO3_REQUEST_DIR');
                                        $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'] || !strcasecmp($_SERVER['HTTPS'], 'on') || !strcmp($_SERVER['HTTPS'], '1') ? TRUE : FALSE; // see http://bugs.typo3.org/view.php?id=3909
                                }
                                break;
                        case '_ARRAY':
                                $out = array();
                                        // Here, list ALL possible keys to this function for debug display.
                                $envTestVars = self::trimExplode(',', '
                                        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', 1);
                                foreach ($envTestVars as $v) {
                                        $out[$v] = self::getIndpEnv($v);
                                }
                                reset($out);
                                $retVal = $out;
                                break;
                }
                return $retVal;
        }

        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 ($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';
                        }
                }
                // Is true if the browser supports css to format forms, especially the width
                $bInfo['FORMSTYLE'] = ($bInfo['BROWSER'] == 'msie' || ($bInfo['BROWSER'] == 'net' && $bInfo['VERSION'] >= 5) || $bInfo['BROWSER'] == 'opera' || $bInfo['BROWSER'] == 'konqu');

                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 (!strcmp($filename, '')) {
                        return '';
                }

                if ($relToTYPO3_mainDir) {
                        if (!defined('PATH_typo3')) {
                                return '';
                        }
                        $relPathPrefix = PATH_typo3;
                } else {
                        $relPathPrefix = PATH_site;
                }
                if (substr($filename, 0, 4) == 'EXT:') { // extension
                        list($extKey, $local) = explode('/', substr($filename, 4), 2);
                        $filename = '';
                        if (strcmp($extKey, '') && t3lib_extMgm::isLoaded($extKey) && strcmp($local, '')) {
                                $filename = t3lib_extMgm::extPath($extKey) . $local;
                        }
                } elseif (!self::isAbsPath($filename)) { // relative. Prepended with $relPathPrefix
                        $filename = $relPathPrefix . $filename;
                } elseif ($onlyRelative && !self::isFirstPartOfStr($filename, $relPathPrefix)) { // absolute, but set to blank if not allowed
                        $filename = '';
                }
                if (strcmp($filename, '') && self::validPathStr($filename)) { // checks backpath.
                        return $filename;
                }
        }

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

        public static function isAbsPath($path) {
                        // on Windows also a path starting with a drive letter is absolute: X:/
                if (TYPO3_OS === 'WIN' && substr($path, 1, 2) === ':/') {
                        return TRUE;
                }

                        // path starting with a / is always absolute, on every system
                return (substr($path, 0, 1) === '/');
        }

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

        public static function verifyFilenameAgainstDenyPattern($filename) {
                        // Filenames are not allowed to contain control characters
                if (preg_match('/[[:cntrl:]]/', $filename)) {
                        return FALSE;
                }

                if (strcmp($filename, '') && strcmp($GLOBALS['TYPO3_CONF_VARS']['BE']['fileDenyPattern'], '')) {
                        $result = preg_match('/' . $GLOBALS['TYPO3_CONF_VARS']['BE']['fileDenyPattern'] . '/i', $filename);
                        if ($result) {
                                return FALSE;
                        } // so if a matching filename is found, return FALSE;
                }
                return TRUE;
        }

        public static function sanitizeLocalUrl($url = '') {
                $sanitizedUrl = '';
                $decodedUrl = rawurldecode($url);

                if (!empty($url) && self::removeXSS($decodedUrl) === $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;
                                }
                                // Pass if URL is an absolute file path:
                        } elseif (self::isAbsPath($decodedUrl) && self::isAllowedAbsPath($decodedUrl)) {
                                $sanitizedUrl = $url;
                                // Pass if URL is absolute and below TYPO3 base directory:
                        } elseif (strpos($testAbsoluteUrl, self::getIndpEnv('TYPO3_SITE_PATH')) === 0 && substr($decodedUrl, 0, 1) === '/') {
                                $sanitizedUrl = $url;
                                // Pass if URL is relative and below TYPO3 base directory:
                        } elseif (strpos($testRelativeUrl, self::getIndpEnv('TYPO3_SITE_PATH')) === 0 && substr($decodedUrl, 0, 1) !== '/') {
                                $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);
                }

                self::fixPermissions($destination); // Change the permissions of the file

                        // 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 && self::validPathStr($uploadedTempFileName) && self::isFirstPartOfStr($uploadedTempFileName, PATH_site . 'typo3temp/') && @is_file($uploadedTempFileName)) {
                        if (unlink($uploadedTempFileName)) {
                                return TRUE;
                        }
                }
        }

        public static function tempnam($filePrefix) {
                return tempnam(PATH_site . 'typo3temp/', $filePrefix);
        }

        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, 1);
                                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 cHashParams($addQueryParams) {
                $params = explode('&', substr($addQueryParams, 1)); // Splitting parameters up

                        // Make array:
                $pA = array();
                foreach ($params as $theP) {
                        $pKV = explode('=', $theP); // Splitting single param by '=' sign
                        if (!self::inList('id,type,no_cache,cHash,MP,ftu', $pKV[0]) && !preg_match('/TSFE_ADMIN_PANEL\[.*?\]/', $pKV[0])) {
                                $pA[rawurldecode($pKV[0])] = (string) rawurldecode($pKV[1]);
                        }
                }
                        // Hook: Allows to manipulate the parameters which are taken to build the chash:
                if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['cHashParamsHook'])) {
                        $cHashParamsHook =& $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['cHashParamsHook'];
                        if (is_array($cHashParamsHook)) {
                                $hookParameters = array(
                                        'addQueryParams' => &$addQueryParams,
                                        'params' => &$params,
                                        'pA' => &$pA,
                                );
                                $hookReference = NULL;
                                foreach ($cHashParamsHook as $hookFunction) {
                                        self::callUserFunction($hookFunction, $hookParameters, $hookReference);
                                }
                        }
                }
                        // Finish and sort parameters array by keys:
                $pA['encryptionKey'] = $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'];
                ksort($pA);

                return $pA;
        }

        public static function generateCHash($addQueryParams) {
                $cHashParams = self::cHashParams($addQueryParams);
                $cHash = self::calculateCHash($cHashParams);
                return $cHash;
        }

        public static function calculateCHash($params) {
                $cHash = md5(serialize($params));
                return $cHash;
        }

        public static function hideIfNotTranslated($l18n_cfg_fieldValue) {
                if ($GLOBALS['TYPO3_CONF_VARS']['FE']['hidePagesIfNotTranslatedByDefault']) {
                        return $l18n_cfg_fieldValue & 2 ? FALSE : TRUE;
                } else {
                        return $l18n_cfg_fieldValue & 2 ? TRUE : FALSE;
                }
        }

        public static function readLLfile($fileRef, $langKey, $charset = '', $errorMode = 0) {

                $result = FALSE;
                $file = self::getFileAbsFileName($fileRef);
                if ($file) {
                        $baseFile = preg_replace('/\.(php|xml)$/', '', $file);

                        if (@is_file($baseFile . '.xml')) {
                                $LOCAL_LANG = self::readLLXMLfile($baseFile . '.xml', $langKey, $charset);
                        } elseif (@is_file($baseFile . '.php')) {
                                if ($GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'] || $charset) {
                                        $LOCAL_LANG = self::readLLPHPfile($baseFile . '.php', $langKey, $charset);
                                } else {
                                        include($baseFile . '.php');
                                        if (is_array($LOCAL_LANG)) {
                                                $LOCAL_LANG = array('default' => $LOCAL_LANG['default'], $langKey => $LOCAL_LANG[$langKey]);
                                        }
                                }
                        } else {
                                $errorMsg = 'File "' . $fileRef . '" not found!';
                                if ($errorMode == 2) {
                                        throw new t3lib_exception($errorMsg);
                                } elseif (!$errorMode) {
                                        self::sysLog($errorMsg, 'Core', self::SYSLOG_SEVERITY_ERROR);
                                }
                                $fileNotFound = TRUE;
                        }


                        $overrides = array();
                        $fileRefWithoutExtension = preg_replace('/\.(php|xml)$/', '', $fileRef);

                        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SYS']['locallangXMLOverride'][$fileRefWithoutExtension . '.php'])) {
                                $overrides = array_merge($overrides, $GLOBALS['TYPO3_CONF_VARS']['SYS']['locallangXMLOverride'][$fileRefWithoutExtension . '.php']);
                        }
                        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SYS']['locallangXMLOverride'][$fileRefWithoutExtension . '.xml'])) {
                                $overrides = array_merge($overrides, $GLOBALS['TYPO3_CONF_VARS']['SYS']['locallangXMLOverride'][$fileRefWithoutExtension . '.xml']);
                        }

                        if (count($overrides) > 0) {
                                foreach ($overrides as $overrideFile) {
                                        $languageOverrideFileName = self::getFileAbsFileName($overrideFile);
                                        if (@is_file($languageOverrideFileName)) {
                                                $languageOverrideArray = self::readLLXMLfile($languageOverrideFileName, $langKey, $charset);
                                                $LOCAL_LANG = self::array_merge_recursive_overrule($LOCAL_LANG, $languageOverrideArray);
                                        }
                                }
                        }
                }
                if ($fileNotFound !== TRUE) {
                        $result = is_array($LOCAL_LANG) ? $LOCAL_LANG : array();
                }
                return $result;
        }

        public static function readLLPHPfile($fileRef, $langKey, $charset = '') {

                if (is_object($GLOBALS['LANG'])) {
                        $csConvObj = $GLOBALS['LANG']->csConvObj;
                } elseif (is_object($GLOBALS['TSFE'])) {
                        $csConvObj = $GLOBALS['TSFE']->csConvObj;
                } else {
                        $csConvObj = self::makeInstance('t3lib_cs');
                }

                if (@is_file($fileRef) && $langKey) {

                                // Set charsets:
                        $sourceCharset = $csConvObj->parse_charset($csConvObj->charSetArray[$langKey] ? $csConvObj->charSetArray[$langKey] : 'iso-8859-1');
                        if ($charset) {
                                $targetCharset = $csConvObj->parse_charset($charset);
                        } elseif ($GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset']) {
                                        // when forceCharset is set, we store ALL labels in this charset!!!
                                $targetCharset = $csConvObj->parse_charset($GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset']);
                        } else {
                                $targetCharset = $csConvObj->parse_charset($csConvObj->charSetArray[$langKey] ? $csConvObj->charSetArray[$langKey] : 'iso-8859-1');
                        }

                                // Cache file name:
                        $hashSource = substr($fileRef, strlen(PATH_site)) . '|' . date('d-m-Y H:i:s', filemtime($fileRef)) . '|version=2.3';
                        $cacheFileName = PATH_site . 'typo3temp/llxml/' .
                                        substr(basename($fileRef), 10, 15) .
                                        '_' . self::shortMD5($hashSource) . '.' . $langKey . '.' . $targetCharset . '.cache';
                                // Check if cache file exists...
                        if (!@is_file($cacheFileName)) { // ... if it doesn't, create content and write it:
                                $LOCAL_LANG = NULL;
                                        // Get PHP data
                                include($fileRef);
                                if (!is_array($LOCAL_LANG)) {
                                        $fileName = substr($fileRef, strlen(PATH_site));
                                        throw new RuntimeException(
                                                'TYPO3 Fatal Error: "' . $fileName . '" is no TYPO3 language file!',
                                                1270853900
                                        );
                                }

                                        // converting the default language (English)
                                        // this needs to be done for a few accented loan words and extension names
                                if (is_array($LOCAL_LANG['default']) && $targetCharset != 'iso-8859-1') {
                                        foreach ($LOCAL_LANG['default'] as &$labelValue) {
                                                $labelValue = $csConvObj->conv($labelValue, 'iso-8859-1', $targetCharset);
                                        }
                                }

                                if ($langKey != 'default' && is_array($LOCAL_LANG[$langKey]) && $sourceCharset != $targetCharset) {
                                        foreach ($LOCAL_LANG[$langKey] as &$labelValue) {
                                                $labelValue = $csConvObj->conv($labelValue, $sourceCharset, $targetCharset);
                                        }
                                }

                                        // Cache the content now:
                                $serContent = array('origFile' => $hashSource, 'LOCAL_LANG' => array('default' => $LOCAL_LANG['default'], $langKey => $LOCAL_LANG[$langKey]));
                                $res = self::writeFileToTypo3tempDir($cacheFileName, serialize($serContent));
                                if ($res) {
                                        throw new RuntimeException(
                                                'TYPO3 Fatal Error: "' . $res,
                                                1270853901
                                        );
                                }
                        } else {
                                        // Get content from cache:
                                $serContent = unserialize(self::getUrl($cacheFileName));
                                $LOCAL_LANG = $serContent['LOCAL_LANG'];
                        }

                        return $LOCAL_LANG;
                }
        }

        public static function readLLXMLfile($fileRef, $langKey, $charset = '') {

                if (is_object($GLOBALS['LANG'])) {
                        $csConvObj = $GLOBALS['LANG']->csConvObj;
                } elseif (is_object($GLOBALS['TSFE'])) {
                        $csConvObj = $GLOBALS['TSFE']->csConvObj;
                } else {
                        $csConvObj = self::makeInstance('t3lib_cs');
                }

                $LOCAL_LANG = NULL;
                if (@is_file($fileRef) && $langKey) {

                                // Set charset:
                        if ($charset) {
                                $targetCharset = $csConvObj->parse_charset($charset);
                        } elseif ($GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset']) {
                                        // when forceCharset is set, we store ALL labels in this charset!!!
                                $targetCharset = $csConvObj->parse_charset($GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset']);
                        } else {
                                $targetCharset = $csConvObj->parse_charset($csConvObj->charSetArray[$langKey] ? $csConvObj->charSetArray[$langKey] : 'iso-8859-1');
                        }

                                // Cache file name:
                        $hashSource = substr($fileRef, strlen(PATH_site)) . '|' . date('d-m-Y H:i:s', filemtime($fileRef)) . '|version=2.3';
                        $cacheFileName = PATH_site . 'typo3temp/llxml/' .
                                        substr(basename($fileRef), 10, 15) .
                                        '_' . self::shortMD5($hashSource) . '.' . $langKey . '.' . $targetCharset . '.cache';

                                // Check if cache file exists...
                        if (!@is_file($cacheFileName)) { // ... if it doesn't, create content and write it:

                                        // Read XML, parse it.
                                $xmlString = self::getUrl($fileRef);
                                $xmlContent = self::xml2array($xmlString);
                                if (!is_array($xmlContent)) {
                                        $fileName = substr($fileRef, strlen(PATH_site));
                                        throw new RuntimeException(
                                                'TYPO3 Fatal Error: The file "' . $fileName . '" is no TYPO3 language file!',
                                                1270853902
                                        );
                                }

                                        // Set default LOCAL_LANG array content:
                                $LOCAL_LANG = array();
                                $LOCAL_LANG['default'] = $xmlContent['data']['default'];

                                        // converting the default language (English)
                                        // this needs to be done for a few accented loan words and extension names
                                        // NOTE: no conversion is done when in UTF-8 mode!
                                if (is_array($LOCAL_LANG['default']) && $targetCharset != 'utf-8') {
                                        foreach ($LOCAL_LANG['default'] as &$labelValue) {
                                                $labelValue = $csConvObj->utf8_decode($labelValue, $targetCharset);
                                        }
                                        unset($labelValue);
                                }

                                        // converting other languages to their "native" charsets
                                        // NOTE: no conversion is done when in UTF-8 mode!
                                if ($langKey != 'default') {

                                                // If no entry is found for the language key, then force a value depending on meta-data setting. By default an automated filename will be used:
                                        $LOCAL_LANG[$langKey] = self::llXmlAutoFileName($fileRef, $langKey);
                                        $localized_file = self::getFileAbsFileName($LOCAL_LANG[$langKey]);
                                        if (!@is_file($localized_file) && isset($xmlContent['data'][$langKey])) {
                                                $LOCAL_LANG[$langKey] = $xmlContent['data'][$langKey];
                                        }

                                                // Checking if charset should be converted.
                                        if (is_array($LOCAL_LANG[$langKey]) && $targetCharset != 'utf-8') {
                                                foreach ($LOCAL_LANG[$langKey] as $labelKey => $labelValue) {
                                                        $LOCAL_LANG[$langKey][$labelKey] = $csConvObj->utf8_decode($labelValue, $targetCharset);
                                                }
                                        }
                                }

                                        // Cache the content now:
                                $serContent = array('origFile' => $hashSource, 'LOCAL_LANG' => array('default' => $LOCAL_LANG['default'], $langKey => $LOCAL_LANG[$langKey]));
                                $res = self::writeFileToTypo3tempDir($cacheFileName, serialize($serContent));
                                if ($res) {
                                        throw new RuntimeException(
                                                'TYPO3 Fatal Error: ' . $res,
                                                1270853903
                                        );
                                }
                        } else {
                                        // Get content from cache:
                                $serContent = unserialize(self::getUrl($cacheFileName));
                                $LOCAL_LANG = $serContent['LOCAL_LANG'];
                        }

                                // Checking for EXTERNAL file for non-default language:
                        if ($langKey != 'default' && is_string($LOCAL_LANG[$langKey]) && strlen($LOCAL_LANG[$langKey])) {

                                        // Look for localized file:
                                $localized_file = self::getFileAbsFileName($LOCAL_LANG[$langKey]);
                                if ($localized_file && @is_file($localized_file)) {

                                                // Cache file name:
                                        $hashSource = substr($localized_file, strlen(PATH_site)) . '|' . date('d-m-Y H:i:s', filemtime($localized_file)) . '|version=2.3';
                                        $cacheFileName = PATH_site . 'typo3temp/llxml/EXT_' .
                                                        substr(basename($localized_file), 10, 15) .
                                                        '_' . self::shortMD5($hashSource) . '.' . $langKey . '.' . $targetCharset . '.cache';

                                                // Check if cache file exists...
                                        if (!@is_file($cacheFileName)) { // ... if it doesn't, create content and write it:

                                                        // Read and parse XML content:
                                                $local_xmlString = self::getUrl($localized_file);
                                                $local_xmlContent = self::xml2array($local_xmlString);
                                                if (!is_array($local_xmlContent)) {
                                                        $fileName = substr($localized_file, strlen(PATH_site));
                                                        throw new RuntimeException(
                                                                'TYPO3 Fatal Error: The file "' . $fileName . '" is no TYPO3 language file!',
                                                                1270853904
                                                        );
                                                }
                                                $LOCAL_LANG[$langKey] = is_array($local_xmlContent['data'][$langKey]) ? $local_xmlContent['data'][$langKey] : array();

                                                        // Checking if charset should be converted.
                                                if (is_array($LOCAL_LANG[$langKey]) && $targetCharset != 'utf-8') {
                                                        foreach ($LOCAL_LANG[$langKey] as $labelKey => $labelValue) {
                                                                $LOCAL_LANG[$langKey][$labelKey] = $csConvObj->utf8_decode($labelValue, $targetCharset);
                                                        }
                                                }

                                                        // Cache the content now:
                                                $serContent = array('extlang' => $langKey, 'origFile' => $hashSource, 'EXT_DATA' => $LOCAL_LANG[$langKey]);
                                                $res = self::writeFileToTypo3tempDir($cacheFileName, serialize($serContent));
                                                if ($res) {
                                                        throw new RuntimeException(
                                                                'TYPO3 Fatal Error: ' . $res,
                                                                1270853905
                                                        );
                                                }
                                        } else {
                                                        // Get content from cache:
                                                $serContent = unserialize(self::getUrl($cacheFileName));
                                                $LOCAL_LANG[$langKey] = $serContent['EXT_DATA'];
                                        }
                                } else {
                                        $LOCAL_LANG[$langKey] = array();
                                }
                        }

                        return $LOCAL_LANG;
                }
        }

        public static function llXmlAutoFileName($fileRef, $language) {
                        // Analyse file reference:
                $location = 'typo3conf/l10n/' . $language . '/'; // Default location of translations
                if (self::isFirstPartOfStr($fileRef, PATH_typo3 . 'sysext/')) { // Is system:
                        $validatedPrefix = PATH_typo3 . 'sysext/';
                        #$location = 'EXT:csh_'.$language.'/';  // For system extensions translations are found in "csh_*" extensions (language packs)
                } 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.
                        return $location .
                                        $file_extKey . '/' .
                                        ($file_extPath ? $file_extPath . '/' : '') .
                                        $language . '.' . $file_fileName;
                } else {
                        return NULL;
                }
        }


        public static function loadTCA($table) {
                global $TCA;

                if (isset($TCA[$table])) {
                        $tca = &$TCA[$table];
                        if (!$tca['columns']) {
                                $dcf = $tca['ctrl']['dynamicConfigFile'];
                                if ($dcf) {
                                        if (!strcmp(substr($dcf, 0, 6), 'T3LIB:')) {
                                                include(PATH_t3lib . 'stddb/' . substr($dcf, 6));
                                        } elseif (self::isAbsPath($dcf) && @is_file($dcf)) { // Absolute path...
                                                include($dcf);
                                        } else {
                                                include(PATH_typo3conf . $dcf);
                                        }
                                }
                        }
                }
        }

        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.
                        $sheet = 'sDEF'; // Default sheet
                }
                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 = 'user_', $errorMode = 0) {
                global $TYPO3_CONF_VARS;
                $content = FALSE;

                        // Check persistent object and if found, call directly and exit.
                if (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 (substr($funcRef, 0, 1) == '&') {
                        $funcRef = substr($funcRef, 1);
                        $storePersistentObject = TRUE;
                } else {
                        $storePersistentObject = FALSE;
                }

                        // Check prefix is valid:
                if ($checkPrefix && !self::hasValidClassPrefix($funcRef, array($checkPrefix))) {
                        $errorMsg = "Function/class '$funcRef' was not prepended with '$checkPrefix'";
                        if ($errorMode == 2) {
                                throw new Exception($errorMsg);
                        } elseif (!$errorMode) {
                                debug($errorMsg, 't3lib_div::callUserFunction');
                        }
                        return 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 = "<strong>ERROR:</strong> No method name '" . $parts[1] . "' in class " . $parts[0];
                                        if ($errorMode == 2) {
                                                throw new Exception($errorMsg);
                                        } elseif (!$errorMode) {
                                                debug($errorMsg, 't3lib_div::callUserFunction');
                                        }
                                }
                        } else {
                                $errorMsg = "<strong>ERROR:</strong> No class named: " . $parts[0];
                                if ($errorMode == 2) {
                                        throw new Exception($errorMsg);
                                } elseif (!$errorMode) {
                                        debug($errorMsg, 't3lib_div::callUserFunction');
                                }
                        }
                } else { // Function
                        if (function_exists($funcRef)) {
                                $content = call_user_func_array($funcRef, array(&$params, &$ref));
                        } else {
                                $errorMsg = "<strong>ERROR:</strong> No function named: " . $funcRef;
                                if ($errorMode == 2) {
                                        throw new Exception($errorMsg);
                                } elseif (!$errorMode) {
                                        debug($errorMsg, 't3lib_div::callUserFunction');
                                }
                        }
                }
                return $content;
        }

        public static function getUserObj($classRef, $checkPrefix = 'user_', $silent = FALSE) {
                global $TYPO3_CONF_VARS;
                        // 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 (substr($class, 0, 1) == '&') {
                                $class = substr($class, 1);
                                $storePersistentObject = TRUE;
                        } else {
                                $storePersistentObject = FALSE;
                        }

                                // Check prefix is valid:
                        if ($checkPrefix && !self::hasValidClassPrefix($class, array($checkPrefix))) {
                                if (!$silent) {
                                        debug("Class '" . $class . "' was not prepended with '" . $checkPrefix . "'", 't3lib_div::getUserObj');
                                }
                                return 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;
                        } else {
                                if (!$silent) {
                                        debug("<strong>ERROR:</strong> No class named: " . $class, 't3lib_div::getUserObj');
                                }
                        }
                }
        }

        public static function hasValidClassPrefix($classRef, array $additionalPrefixes = array()) {
                $hasValidPrefix = FALSE;
                $validPrefixes = array('tx_', 'Tx_', $GLOBALS['TYPO3_CONF_VARS']['FE']['userFuncClassPrefix']);
                $classRef = trim($classRef);

                if (count($additionalPrefixes)) {
                        $validPrefixes = array_merge($validPrefixes, $additionalPrefixes);
                }

                foreach ($validPrefixes as $prefixToCheck) {
                        if (self::isFirstPartOfStr($classRef, $prefixToCheck)) {
                                $hasValidPrefix = TRUE;
                                break;
                        }
                }

                return $hasValidPrefix;
        }

        public static function makeInstance($className) {
                if ($className === '') {
                        throw new InvalidArgumentException('$classname must not be empty.', 1288965219);
                }

                        // Determine final class name which must be instantiated, this takes XCLASS handling
                        // into account. Cache in a local array to save some cycles for consecutive calls.
                if (!isset(self::$finalClassNameRegister[$className])) {
                        self::$finalClassNameRegister[$className] = self::getClassName($className);
                }
                $finalClassName = self::$finalClassNameRegister[$className];

                        // 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
                if (func_num_args() > 1) {
                        $constructorArguments = func_get_args();
                        array_shift($constructorArguments);

                        $reflectedClass = new ReflectionClass($finalClassName);
                        $instance = $reflectedClass->newInstanceArgs($constructorArguments);
                } else {
                        $instance = new $finalClassName;
                }

                        // Register new singleton instance
                if ($instance instanceof t3lib_Singleton) {
                        self::$singletonInstances[$finalClassName] = $instance;
                }

                return $instance;
        }

        public static function makeInstanceClassName($className) {
                self::logDeprecatedFunction();

                return (class_exists($className) && class_exists('ux_' . $className, FALSE) ? self::makeInstanceClassName('ux_' . $className) : $className);
        }

        protected function getClassName($className) {
                if (class_exists($className)) {
                        while (class_exists('ux_' . $className, FALSE)) {
                                $className = 'ux_' . $className;
                        }
                }

                return $className;
        }

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

        public static function addInstance($className, $instance) {
                self::checkInstanceClassName($className, $instance);

                if ($instance instanceof t3lib_Singleton) {
                        throw new InvalidArgumentException(
                                '$instance must not be an instance of t3lib_Singleton. ' .
                                        '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 makeInstanceService($serviceType, $serviceSubType = '', $excludeServiceKeys = array()) {
                global $T3_SERVICES, $T3_VAR, $TYPO3_CONF_VARS;

                $error = FALSE;

                if (!is_array($excludeServiceKeys)) {
                        $excludeServiceKeys = self::trimExplode(',', $excludeServiceKeys, 1);
                }
                while ($info = t3lib_extMgm::findService($serviceType, $serviceSubType, $excludeServiceKeys)) {

                                // Check persistent object and if found, call directly and exit.
                        if (is_object($GLOBALS['T3_VAR']['makeInstanceService'][$info['className']])) {
                                        // reset service and return object
                                $T3_VAR['makeInstanceService'][$info['className']]->reset();
                                return $GLOBALS['T3_VAR']['makeInstanceService'][$info['className']];

                                // include file and create object
                        } else {
                                $requireFile = self::getFileAbsFileName($info['classFile']);
                                if (@is_file($requireFile)) {
                                        self::requireOnce($requireFile);
                                        $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:' . t3lib_utility_Debug::viewArray($info));
                                                }
                                                $obj->info = $info;
                                                if ($obj->init()) { // service available?

                                                                // create persistent object
                                                        $T3_VAR['makeInstanceService'][$info['className']] = $obj;

                                                                // needed to delete temp files
                                                        register_shutdown_function(array(&$obj, '__destruct'));

                                                        return $obj; // object is passed as reference by function definition
                                                }
                                                $error = $obj->getLastErrorArray();
                                                unset($obj);
                                        }
                                }
                        }
                                // deactivate the service
                        t3lib_extMgm::deactivateService($info['serviceType'], $info['serviceKey']);
                }
                return $error;
        }

        public static function requireOnce($requireFile) {
                global $T3_SERVICES, $T3_VAR, $TYPO3_CONF_VARS;

                require_once ($requireFile);
        }

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

        public static function plainMailEncoded($email, $subject, $message, $headers = '', $encoding = 'quoted-printable', $charset = '', $dontEncodeHeader = FALSE) {
                if (!$charset) {
                        $charset = $GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'] ? $GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'] : 'ISO-8859-1';
                }

                $email = self::normalizeMailAddress($email);
                if (!$dontEncodeHeader) {
                                // Mail headers must be ASCII, therefore we convert the whole header to either base64 or quoted_printable
                        $newHeaders = array();
                        foreach (explode(LF, $headers) as $line) { // Split the header in lines and convert each line separately
                                $parts = explode(': ', $line, 2); // Field tags must not be encoded
                                if (count($parts) == 2) {
                                        if (0 == strcasecmp($parts[0], 'from')) {
                                                $parts[1] = self::normalizeMailAddress($parts[1]);
                                        }
                                        $parts[1] = self::encodeHeader($parts[1], $encoding, $charset);
                                        $newHeaders[] = implode(': ', $parts);
                                } else {
                                        $newHeaders[] = $line; // Should never happen - is such a mail header valid? Anyway, just add the unchanged line...
                                }
                        }
                        $headers = implode(LF, $newHeaders);
                        unset($newHeaders);

                        $email = self::encodeHeader($email, $encoding, $charset); // Email address must not be encoded, but it could be appended by a name which should be so (e.g. "Kasper Skårhøj <kasperYYYY@typo3.com>")
                        $subject = self::encodeHeader($subject, $encoding, $charset);
                }

                switch ((string) $encoding) {
                        case 'base64':
                                $headers = trim($headers) . LF .
                                                'Mime-Version: 1.0' . LF .
                                                'Content-Type: text/plain; charset="' . $charset . '"' . LF .
                                                'Content-Transfer-Encoding: base64';

                                $message = trim(chunk_split(base64_encode($message . LF))) . LF; // Adding LF because I think MS outlook 2002 wants it... may be removed later again.
                                break;
                        case '8bit':
                                $headers = trim($headers) . LF .
                                                'Mime-Version: 1.0' . LF .
                                                'Content-Type: text/plain; charset=' . $charset . LF .
                                                'Content-Transfer-Encoding: 8bit';
                                break;
                        case 'quoted-printable':
                        default:
                                $headers = trim($headers) . LF .
                                                'Mime-Version: 1.0' . LF .
                                                'Content-Type: text/plain; charset=' . $charset . LF .
                                                'Content-Transfer-Encoding: quoted-printable';

                                $message = self::quoted_printable($message);
                                break;
                }

                        // Headers must be separated by CRLF according to RFC 2822, not just LF.
                        // But many servers (Gmail, for example) behave incorectly and want only LF.
                        // So we stick to LF in all cases.
                $headers = trim(implode(LF, self::trimExplode(LF, $headers, TRUE))); // Make sure no empty lines are there.


                return t3lib_utility_Mail::mail($email, $subject, $message, $headers);
        }

        public static function quoted_printable($string, $maxlen = 76) {
                        // Make sure the string contains only Unix linebreaks
                $string = str_replace(CRLF, LF, $string); // Replace Windows breaks (\r\n)
                $string = str_replace(CR, LF, $string); // Replace Mac breaks (\r)

                $linebreak = LF; // Default line break for Unix systems.
                if (TYPO3_OS == 'WIN') {
                        $linebreak = CRLF; // Line break for Windows. This is needed because PHP on Windows systems send mails via SMTP instead of using sendmail, and thus the linebreak needs to be \r\n.
                }

                $newString = '';
                $theLines = explode(LF, $string); // Split lines
                foreach ($theLines as $val) {
                        $newVal = '';
                        $theValLen = strlen($val);
                        $len = 0;
                        for ($index = 0; $index < $theValLen; $index++) { // Walk through each character of this line
                                $char = substr($val, $index, 1);
                                $ordVal = ord($char);
                                if ($len > ($maxlen - 4) || ($len > ($maxlen - 14) && $ordVal == 32)) {
                                        $newVal .= '=' . $linebreak; // Add a line break
                                        $len = 0; // Reset the length counter
                                }
                                if (($ordVal >= 33 && $ordVal <= 60) || ($ordVal >= 62 && $ordVal <= 126) || $ordVal == 9 || $ordVal == 32) {
                                        $newVal .= $char; // This character is ok, add it to the message
                                        $len++;
                                } else {
                                        $newVal .= sprintf('=%02X', $ordVal); // Special character, needs to be encoded
                                        $len += 3;
                                }
                        }
                        $newVal = preg_replace('/' . chr(32) . '$/', '=20', $newVal); // Replaces a possible SPACE-character at the end of a line
                        $newVal = preg_replace('/' . TAB . '$/', '=09', $newVal); // Replaces a possible TAB-character at the end of a line
                        $newString .= $newVal . $linebreak;
                }
                return preg_replace('/' . $linebreak . '$/', '', $newString); // Remove last newline
        }

        public static function encodeHeader($line, $enc = 'quoted-printable', $charset = 'iso-8859-1') {
                        // 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;
                        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 . '?=';
                                        }
                                        break;
                        }
                        $line = str_replace($oldPart, $part, $line);
                }
                $line = preg_replace('/###(.+?)###/', '$1', $line); // Remove the wrappers

                return $line;
        }

        public static function substUrlsInPlainText($message, $urlmode = '76', $index_script_url = '') {
                        // Substitute URLs with shorter links:
                foreach (array('http', 'https') as $protocol) {
                        $urlSplit = explode($protocol . '://', $message);
                        foreach ($urlSplit as $c => &$v) {
                                if ($c) {
                                        $newParts = preg_split('/\s|[<>"{}|\\\^`()\']/', $v, 2);
                                        $newURL = $protocol . '://' . $newParts[0];

                                        switch ((string) $urlmode) {
                                                case 'all':
                                                        $newURL = self::makeRedirectUrl($newURL, 0, $index_script_url);
                                                        break;
                                                case '76':
                                                        $newURL = self::makeRedirectUrl($newURL, 76, $index_script_url);
                                                        break;
                                        }
                                        $v = $newURL . substr($v, strlen($newParts[0]));
                                }
                        }
                        $message = implode('', $urlSplit);
                }

                return $message;
        }

        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($font_size) {
                $dpi = intval($GLOBALS['TYPO3_CONF_VARS']['GFX']['TTFdpi']);
                if ($dpi != 72) {
                        $font_size = $font_size / $dpi * 72;
                }
                return $font_size;
        }

        public static function initSysLog() {
                global $TYPO3_CONF_VARS;

                        // 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) {
                        $TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] = self::getHostname($requestHost = FALSE) . ':' . PATH_site;
                }
                        // for Web logging name is <protocol>://<request-hostame>/<site-path>
                else {
                        $TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] = self::getIndpEnv('TYPO3_SITE_URL');
                }

                        // init custom logging
                if (is_array($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'])) {
                        $params = array('initLog' => TRUE);
                        $fakeThis = FALSE;
                        foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'] as $hookMethod) {
                                self::callUserFunction($hookMethod, $params, $fakeThis);
                        }
                }

                        // init TYPO3 logging
                foreach (explode(';', $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($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'], LOG_ODELAY, $facility);
                        }
                }

                $TYPO3_CONF_VARS['SYS']['systemLogLevel'] = self::intInRange($TYPO3_CONF_VARS['SYS']['systemLogLevel'], 0, 4);
                $TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogInit'] = TRUE;
        }

        public static function sysLog($msg, $extKey, $severity = 0) {
                global $TYPO3_CONF_VARS;

                $severity = self::intInRange($severity, 0, 4);

                        // is message worth logging?
                if (intval($TYPO3_CONF_VARS['SYS']['systemLogLevel']) > $severity) {
                        return;
                }

                        // initialize logging
                if (!$TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogInit']) {
                        self::initSysLog();
                }

                        // do custom logging
                if (isset($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog']) &&
                                is_array($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 ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'] as $hookMethod) {
                                self::callUserFunction($hookMethod, $params, $fakeThis);
                        }
                }

                        // TYPO3 logging enabled?
                if (!$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(';', $TYPO3_CONF_VARS['SYS']['systemLog'], 2) as $log) {
                        list($type, $destination, $level) = explode(',', $log, 4);

                                // is message worth logging for this log type?
                        if (intval($level) > $severity) {
                                continue;
                        }

                        $msgLine = ' - ' . $extKey . ': ' . $msg;

                                // write message to a file
                        if ($type == 'file') {
                                $file = fopen($destination, 'a');
                                if ($file) {
                                        flock($file, LOCK_EX); // try locking, but ignore if not available (eg. on NFS and FAT)
                                        fwrite($file, date($dateFormat . ' ' . $timeFormat) . $msgLine . LF);
                                        flock($file, LOCK_UN); // release the lock
                                        fclose($file);
                                        self::fixPermissions($destination);
                                }
                        }
                                // send message per mail
                        elseif ($type == 'mail') {
                                list($to, $from) = explode('/', $destination);
                                if (!t3lib_div::validEmail($from)) {
                                        $from = t3lib_utility_Mail::getSystemFrom();
                                }
                                $mail = t3lib_div::makeInstance('t3lib_mail_Message');
                                $mail->setTo($to)
                                                ->setFrom($from)
                                                ->setSubject('Warning - error in TYPO3 installation')
                                                ->setBody('Host: ' . $TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] . LF .
                                                                'Extension: ' . $extKey . LF .
                                                                'Severity: ' . $severity . LF .
                                                                LF . $msg
                                );
                                $mail->send();
                        }
                                // use the PHP error log
                        elseif ($type == 'error_log') {
                                error_log($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] . $msgLine, 0);
                        }
                                // use the system log
                        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) {
                global $TYPO3_CONF_VARS;

                if (is_array($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['devLog'])) {
                        $params = array('msg' => $msg, 'extKey' => $extKey, 'severity' => $severity, 'dataVar' => $dataVar);
                        $fakeThis = FALSE;
                        foreach ($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;
                }

                $log = $GLOBALS['TYPO3_CONF_VARS']['SYS']['enableDeprecationLog'];
                $date = date($GLOBALS['TYPO3_CONF_VARS']['SYS']['ddmmyy'] . ' ' . $GLOBALS['TYPO3_CONF_VARS']['SYS']['hhmm'] . ': ');

                        // legacy values (no strict comparison, $log can be boolean, string or int)
                if ($log === TRUE || $log == '1') {
                        $log = 'file';
                }

                if (stripos($log, 'file') !== FALSE) {
                                // write a longer message to the deprecation log
                        $destination = self::getDeprecationLogFileName();
                        $file = @fopen($destination, 'a');
                        if ($file) {
                                flock($file, LOCK_EX); // try locking, but ignore if not available (eg. on NFS and FAT)
                                @fwrite($file, $date . $msg . LF);
                                flock($file, LOCK_UN); // release the lock
                                @fclose($file);
                                self::fixPermissions($destination);
                        }
                }

                if (stripos($log, 'devlog') !== FALSE) {
                                // copy message also to the developer log
                        self::devLog($msg, 'Core', self::SYSLOG_SEVERITY_WARNING);
                }

                        // do not use console in login screen
                if (stripos($log, 'console') !== FALSE && isset($GLOBALS['BE_USER']->user['uid'])) {
                        t3lib_utility_Debug::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];
                }

                        // trigger PHP error with a short message: <function> is deprecated (called from <source>, defined in <source>)
                $errorMsg = 'Function ' . $trail[1]['function'];
                if ($trail[1]['class']) {
                        $errorMsg .= ' of class ' . $trail[1]['class'];
                }
                $errorMsg .= ' is deprecated (called from ' . $trail[1]['file'] . '#' . $trail[1]['line'] . ', defined in ' . $function->getFileName() . '#' . $function->getStartLine() . ')';

                        // write a longer message to the deprecation log: <function> <annotion> - <trace> (<source>)
                $logMsg = $trail[1]['class'] . $trail[1]['type'] . $trail[1]['function'];
                $logMsg .= '() - ' . $msg.' - ' . t3lib_utility_Debug::debugTrail();
                $logMsg .= ' (' . substr($function->getFileName(), strlen(PATH_site)) . '#' . $function->getStartLine() . ')';
                self::deprecationLog($logMsg);
        }

        public static function arrayToLogString(array $arr, $valueList = array(), $valueLength = 20) {
                $str = '';
                if (!is_array($valueList)) {
                        $valueList = self::trimExplode(',', $valueList, 1);
                }
                $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 t3lib_utility_Command::imageMagickCommand($command, $parameters, $path);
        }

        public static function unQuoteFilenames($parameters, $unQuote = FALSE) {
                $paramsArr = explode(' ', trim($parameters));

                $quoteActive = -1; // 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.
                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)) {
                                unset($paramsArr[$k]); // Remove empty elements

                        } 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);

                        }
                }
                        // return reindexed array
                return array_values($paramsArr);
        }


        static public function quoteJSvalue($value, $withinCData = FALSE) {
                $escapedValue = addcslashes(
                        $value, '\'' . '"' . '\\' . TAB . LF . CR
                );
                if (!$withinCData) {
                        $escapedValue = htmlspecialchars($escapedValue);
                }
                return '\'' . $escapedValue . '\'';
        }


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


        public static function flushOutputBuffers() {
                $obContent = '';

                while ($obContent .= ob_get_clean()) {
                        ;
                }

                        // 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;
        }
}

?>