t3lib/class.t3lib_div.php

   1 <?php
   2 /***************************************************************
   3 *  Copyright notice
   4 *
   5 *  (c) 1999-2004 Kasper Skaarhoj (kasper@typo3.com)
   6 *  All rights reserved
   7 *
   8 *  This script is part of the TYPO3 project. The TYPO3 project is
   9 *  free software; you can redistribute it and/or modify
  10 *  it under the terms of the GNU General Public License as published by
  11 *  the Free Software Foundation; either version 2 of the License, or
  12 *  (at your option) any later version.
  13 *
  14 *  The GNU General Public License can be found at
  15 *  http://www.gnu.org/copyleft/gpl.html.
  16 *  A copy is found in the textfile GPL.txt and important notices to the license
  17 *  from the author is found in LICENSE.txt distributed with these scripts.
  18 *
  19 *
  20 *  This script is distributed in the hope that it will be useful,
  21 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23 *  GNU General Public License for more details.
  24 *
  25 *  This copyright notice MUST APPEAR in all copies of the script!
  26 ***************************************************************/
  27 /**
  28  * Contains the reknown class "t3lib_div" with general purpose functions
  29  *
  30  * $Id$
  31  * Revised for TYPO3 3.6 July/2003 by Kasper Skaarhoj
  32  * XHTML compliant
  33  * Usage counts are based on search 22/2 2003 through whole source including tslib/
  34  *
  35  * @author      Kasper Skaarhoj <kasper@typo3.com>
  36  */
  37 /**
  38  * [CLASS/FUNCTION INDEX of SCRIPT]
  39  *
  40  *
  41  *
  42  *  207: class t3lib_div
  43  *
  44  *              SECTION: GET/POST Variables
  45  *  237:     function _GP($var)
  46  *  254:     function _GET($var='')
  47  *  269:     function _POST($var='')
  48  *  283:     function _GETset($inputGet,$key='')
  49  *  306:     function GPvar($var,$strip=0)
  50  *  322:     function setGPvars($list,$strip=0)
  51  *  338:     function GParrayMerged($var)
  52  *
  53  *              SECTION: IMAGE FUNCTIONS
  54  *  382:     function gif_compress($theFile, $type)
  55  *  408:     function png_to_gif_by_imagemagick($theFile)
  56  *  432:     function read_png_gif($theFile,$output_png=0)
  57  *
  58  *              SECTION: STRING FUNCTIONS
  59  *  481:     function fixed_lgd($string,$origChars,$preStr='...')
  60  *  506:     function fixed_lgd_pre($string,$chars)
  61  *  520:     function fixed_lgd_cs($string,$chars)
  62  *  537:     function breakTextForEmail($str,$implChar="\n",$charWidth=76)
  63  *  556:     function breakLinesForEmail($str,$implChar="\n",$charWidth=76)
  64  *  591:     function cmpIP($baseIP, $list)
  65  *  633:     function cmpFQDN($baseIP, $list)
  66  *  663:     function inList($in_list,$item)
  67  *  675:     function rmFromList($element,$list)
  68  *  693:     function intInRange($theInt,$min,$max=2000000000,$zeroValue=0)
  69  *  709:     function intval_positive($theInt)
  70  *  722:     function int_from_ver($verNumberStr)
  71  *  734:     function md5int($str)
  72  *  747:     function shortMD5($input, $len=10)
  73  *  758:     function uniqueList()
  74  *  778:     function split_fileref($fileref)
  75  *  815:     function dirname($path)
  76  *  831:     function modifyHTMLColor($color,$R,$G,$B)
  77  *  851:     function modifyHTMLColorAll($color,$all)
  78  *  862:     function rm_endcomma($string)
  79  *  875:     function danish_strtoupper($string)
  80  *  890:     function convUmlauts($str)
  81  *  903:     function testInt($var)
  82  *  915:     function isFirstPartOfStr($str,$partStr)
  83  *  931:     function formatSize($sizeInBytes,$labels='')
  84  *  966:     function convertMicrotime($microtime)
  85  *  980:     function splitCalc($string,$operators)
  86  * 1002:     function calcPriority($string)
  87  * 1042:     function calcParenthesis($string)
  88  * 1068:     function htmlspecialchars_decode($value)
  89  * 1083:     function deHSCentities($str)
  90  * 1096:     function slashJS($string,$extended=0,$char="'")
  91  * 1109:     function rawUrlEncodeJS($str)
  92  * 1121:     function rawUrlEncodeFP($str)
  93  * 1132:     function validEmail($email)
  94  * 1147:     function formatForTextarea($content)
  95  *
  96  *              SECTION: ARRAY FUNCTIONS
  97  * 1178:     function inArray($in_array,$item)
  98  * 1195:     function intExplode($delim, $string)
  99  * 1214:     function revExplode($delim, $string, $count=0)
 100  * 1234:     function trimExplode($delim, $string, $onlyNonEmptyValues=0)
 101  * 1259:     function uniqueArray($valueArray)
 102  * 1281:     function removeArrayEntryByValue($array,$cmpValue)
 103  * 1309:     function implodeArrayForUrl($name,$theArray,$str='',$skipBlank=0,$rawurlencodeParamName=0)
 104  * 1336:     function compileSelectedGetVarsFromArray($varList,$getArray,$GPvarAlt=1)
 105  * 1359:     function addSlashesOnArray(&$theArray)
 106  * 1383:     function stripSlashesOnArray(&$theArray)
 107  * 1405:     function slashArray($arr,$cmd)
 108  * 1421:     function array_merge_recursive_overrule($arr0,$arr1,$notAddKeys=0)
 109  * 1450:     function array_merge($arr1,$arr2)
 110  * 1463:     function csvValues($row,$delim=',',$quote='"')
 111  *
 112  *              SECTION: HTML/XML PROCESSING
 113  * 1505:     function get_tag_attributes($tag)
 114  * 1542:     function split_tag_attributes($tag)
 115  * 1576:     function implodeParams($arr,$xhtmlSafe=FALSE,$dontOmitBlankAttribs=FALSE)
 116  * 1604:     function wrapJS($string, $linebreak=TRUE)
 117  * 1634:     function xml2tree($string,$depth=999)
 118  * 1720:     function array2xml($array,$NSprefix='',$level=0,$docTag='phparray',$spaceInd=0, $options=array(),$parentTagName='')
 119  * 1803:     function xml2array($string,$NSprefix='')
 120  * 1891:     function xmlRecompileFromStructValArray($vals)
 121  * 1935:     function xmlGetHeaderAttribs($xmlData)
 122  *
 123  *              SECTION: FILES FUNCTIONS
 124  * 1967:     function getURL($url)
 125  * 2009:     function writeFile($file,$content)
 126  * 2030:     function mkdir($theNewFolder)
 127  * 2046:     function get_dirs($path)
 128  * 2071:     function getFilesInDir($path,$extensionList='',$prependPath=0,$order='')
 129  * 2125:     function getAllFilesAndFoldersInPath($fileArr,$path,$extList='',$regDirs=0,$recursivityLevels=99)
 130  * 2148:     function removePrefixPathFromList($fileArr,$prefixToRemove)
 131  * 2164:     function fixWindowsFilePath($theFile)
 132  * 2175:     function resolveBackPath($pathStr)
 133  * 2202:     function locationHeaderUrl($path)
 134  *
 135  *              SECTION: DEBUG helper FUNCTIONS
 136  * 2242:     function debug_ordvalue($string,$characters=100)
 137  * 2259:     function view_array($array_in)
 138  * 2287:     function print_array($array_in)
 139  * 2302:     function debug($var="",$brOrHeader=0)
 140  *
 141  *              SECTION: SYSTEM INFORMATION
 142  * 2371:     function getThisUrl()
 143  * 2387:     function linkThisScript($getParams=array())
 144  * 2411:     function linkThisUrl($url,$getParams=array())
 145  * 2436:     function getIndpEnv($getEnvName)
 146  * 2626:     function milliseconds()
 147  * 2638:     function clientInfo($useragent='')
 148  *
 149  *              SECTION: TYPO3 SPECIFIC FUNCTIONS
 150  * 2726:     function getFileAbsFileName($filename,$onlyRelative=1,$relToTYPO3_mainDir=0)
 151  * 2761:     function validPathStr($theFile)
 152  * 2772:     function isAbsPath($path)
 153  * 2783:     function isAllowedAbsPath($path)
 154  * 2800:     function verifyFilenameAgainstDenyPattern($filename)
 155  * 2818:     function upload_copy_move($source,$destination)
 156  * 2847:     function upload_to_tempfile($uploadedFileName)
 157  * 2865:     function unlink_tempfile($uploadedTempFileName)
 158  * 2881:     function tempnam($filePrefix)
 159  * 2894:     function stdAuthCode($uid_or_record,$fields='')
 160  * 2928:     function loadTCA($table)
 161  * 2948:     function resolveSheetDefInDS($dataStructArray,$sheet='sDEF')
 162  * 2976:     function resolveAllSheetsInDS($dataStructArray)
 163  * 3005:     function callUserFunction($funcName,&$params,&$ref,$checkPrefix='user_',$silent=0)
 164  * 3103:     function &getUserObj($classRef,$checkPrefix='user_',$silent=0)
 165  * 3161:     function &makeInstance($className)
 166  * 3173:     function makeInstanceClassName($className)
 167  * 3187:     function makeInstanceService($serviceType, $serviceSubType='', $excludeServiceKeys='')
 168  * 3232:     function plainMailEncoded($email,$subject,$message,$headers='',$enc='',$charset='ISO-8859-1',$dontEncodeSubject=0)
 169  * 3277:     function quoted_printable($string,$maxlen=76)
 170  * 3319:     function substUrlsInPlainText($message,$urlmode='76',$index_script_url='')
 171  * 3353:     function makeRedirectUrl($inUrl,$l=0,$index_script_url='')
 172  * 3380:     function freetypeDpiComp($font_size)
 173  * 3399:     function devLog($msg, $extKey, $severity=0, $dataVar=FALSE)
 174  *
 175  * TOTAL FUNCTIONS: 113
 176  * (This index is automatically created/updated by the extension "extdeveval")
 177  *
 178  */
 179
 180
 181
 182
 183
 184
 185
 186
 187
 188
 189
 190
 191 /**
 192  * The legendary "t3lib_div" class - Miscellaneous functions for general purpose.
 193  * Most of the functions does not relate specifically to TYPO3
 194  * However a section of functions requires certain TYPO3 features available
 195  * See comments in the source.
 196  * You are encouraged to use this library in your own scripts!
 197  *
 198  * USE:
 199  * The class is intended to be used without creating an instance of it.
 200  * So: Don't instantiate - call functions with "t3lib_div::" prefixed the function name.
 201  * So use t3lib_div::[method-name] to refer to the functions, eg. 't3lib_div::milliseconds()'
 202  *
 203  * @author      Kasper Skaarhoj <kasper@typo3.com>
 204  * @package TYPO3
 205  * @subpackage t3lib
 206  */
 207 class t3lib_div {
 208
 209
 210
 211
 212
 213         /*************************
 214          *
 215          * GET/POST Variables
 216          *
 217          * Background:
 218          * Input GET/POST variables in PHP may have their quotes escaped with "\" or not depending on configuration.
 219          * TYPO3 has always converted quotes to BE escaped if the configuration told that they would not be so.
 220          * But the clean solution is that quotes are never escaped and that is what the functions below offers.
 221          * Eventually TYPO3 should provide this in the global space as well.
 222          * In the transitional phase (or forever..?) we need to encourage EVERY to read and write GET/POST vars through the API functions below.
 223          *
 224          *************************/
 225
 226         /**
 227          * Returns the 'GLOBAL' value of incoming data from POST or GET, with priority to POST (that is equalent to 'GP' order)
 228          * Strips slashes from all output, both strings and arrays.
 229          * This function substitutes t3lib_div::GPvar()
 230          * To enhancement security in your scripts, please consider using t3lib_div::_GET or t3lib_div::_POST if you already know by which method your data is arriving to the scripts!
 231          * Usage: 537
 232          *
 233          * @param       string          GET/POST var to return
 234          * @return      mixed           POST var named $var and if not set, the GET var of the same name.
 235          * @see GPvar()
 236          */
 237         function _GP($var)      {
 238                 if(empty($var)) return;
 239                 $value = isset($GLOBALS['HTTP_POST_VARS'][$var]) ? $GLOBALS['HTTP_POST_VARS'][$var] : $GLOBALS['HTTP_GET_VARS'][$var];
 240                 if (isset($value))      {
 241                         if (is_array($value))   { t3lib_div::stripSlashesOnArray($value); } else { $value = stripslashes($value); }
 242                 }
 243                 return $value;
 244         }
 245
 246         /**
 247          * Returns the global GET array (or value from) normalized to contain un-escaped values.
 248          * ALWAYS use this API function to acquire the GET variables!
 249          * Usage: 27
 250          *
 251          * @param       string          Optional pointer to value in GET array (basically name of GET var)
 252          * @return      mixed           If $var is set it returns the value of $HTTP_GET_VARS[$var]. If $var is NULL (default), returns $HTTP_GET_VARS itself. In any case *slashes are stipped from the output!*
 253          * @see _POST(), _GP(), _GETset()
 254          */
 255         function _GET($var=NULL)        {
 256                 $value = ($var === NULL) ? $GLOBALS['HTTP_GET_VARS'] : (empty($var) ? NULL : $GLOBALS['HTTP_GET_VARS'][$var]);
 257                 if (isset($value))      {       // Removes slashes since TYPO3 has added them regardless of magic_quotes setting.
 258                         if (is_array($value))   { t3lib_div::stripSlashesOnArray($value); } else { $value = stripslashes($value); }
 259                 }
 260                 return $value;
 261         }
 262
 263         /**
 264          * Returns the global POST array (or value from) normalized to contain un-escaped values.
 265          * ALWAYS use this API function to acquire the POST variables!
 266          * Usage: 41
 267          *
 268          * @param       string          Optional pointer to value in POST array (basically name of POST var)
 269          * @return      mixed           If $var is set it returns the value of $HTTP_POST_VARS[$var]. If $var is NULL (default), returns $HTTP_POST_VARS itself. In any case *slashes are stipped from the output!*
 270          * @see _GET(), _GP()
 271          */
 272         function _POST($var=NULL)       {
 273                 $value = ($var === NULL) ? $GLOBALS['HTTP_POST_VARS'] : (empty($var) ? NULL : $GLOBALS['HTTP_POST_VARS'][$var]);
 274                 if (isset($value))      {       // Removes slashes since TYPO3 has added them regardless of magic_quotes setting.
 275                         if (is_array($value))   { t3lib_div::stripSlashesOnArray($value); } else { $value = stripslashes($value); }
 276                 }
 277                 return $value;
 278         }
 279
 280         /**
 281          * Writes input value to $HTTP_GET_VARS / $_GET
 282          * Usage: 2
 283          *
 284          * @param       array           Array to write to $HTTP_GET_VARS / $_GET. Values should NOT be escaped at input time (but will be escaped before writing according to TYPO3 standards).
 285          * @param       string          Alternative key; If set, this will not set the WHOLE GET array, but only the key in it specified by this value!
 286          * @return      void
 287          */
 288         function _GETset($inputGet,$key='')     {
 289                         // ADDS slashes since TYPO3 standard currently is that slashes MUST be applied (regardless of magic_quotes setting).
 290                 if (strcmp($key,''))    {
 291                         if (is_array($inputGet))        { t3lib_div::addSlashesOnArray($inputGet); } else { $inputGet = addslashes($inputGet); }
 292                         $GLOBALS['HTTP_GET_VARS'][$key] = $_GET[$key] = $inputGet;
 293                 } elseif (is_array($inputGet)){
 294                         t3lib_div::addSlashesOnArray($inputGet);
 295                         $GLOBALS['HTTP_GET_VARS'] = $_GET = $inputGet;
 296                 }
 297         }
 298
 299         /**
 300          * GET/POST variable
 301          * Returns the 'GLOBAL' value of incoming data from POST or GET, with priority to POST (that is equalent to 'GP' order)
 302          * Strips slashes of string-outputs, but not arrays UNLESS $strip is set. If $strip is set all output will have escaped characters unescaped.
 303          * Usage: 2
 304          *
 305          * @param       string          GET/POST var to return
 306          * @param       boolean         If set, values are stripped of return values that are *arrays!* - string/integer values returned are always strip-slashed()
 307          * @return      mixed           POST var named $var and if not set, the GET var of the same name.
 308          * @deprecated          Use t3lib_div::_GP instead (ALWAYS delivers a value with un-escaped values!)
 309          * @see _GP()
 310          */
 311         function GPvar($var,$strip=0)   {
 312                 if(empty($var)) return;
 313                 $value = isset($GLOBALS['HTTP_POST_VARS'][$var]) ? $GLOBALS['HTTP_POST_VARS'][$var] : $GLOBALS['HTTP_GET_VARS'][$var];
 314                 if (isset($value) && is_string($value)) { $value = stripslashes($value); }      // Originally check '&& get_magic_quotes_gpc() ' but the values of HTTP_GET_VARS 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.
 315                 if ($strip && isset($value) && is_array($value)) { t3lib_div::stripSlashesOnArray($value); }
 316                 return $value;
 317         }
 318
 319         /**
 320          * Sets global variables from HTTP_POST_VARS or HTTP_GET_VARS
 321          * Usage: 0
 322          *
 323          * @param       string          List of GET/POST var keys to set globally
 324          * @param       boolean         If set, values are passed through stripslashes()
 325          * @return      void
 326          * @deprecated
 327          */
 328         function setGPvars($list,$strip=0)      {
 329                 $vars = t3lib_div::trimExplode(',',$list,1);
 330                 while(list(,$var)=each($vars))  {
 331                         $GLOBALS[$var] = t3lib_div::GPvar($var,$strip);
 332                 }
 333         }
 334
 335         /**
 336          * Returns the GET/POST global arrays merged with POST taking precedence.
 337          * Usage: 1
 338          *
 339          * @param       string          Key (variable name) from GET or POST vars
 340          * @return      array           Returns the GET vars merged recursively onto the POST vars.
 341          * @ignore
 342          * @deprecated
 343          */
 344         function GParrayMerged($var)    {
 345                 $postA = is_array($GLOBALS['HTTP_POST_VARS'][$var]) ? $GLOBALS['HTTP_POST_VARS'][$var] : array();
 346                 $getA = is_array($GLOBALS['HTTP_GET_VARS'][$var]) ? $GLOBALS['HTTP_GET_VARS'][$var] : array();
 347                 $mergedA = t3lib_div::array_merge_recursive_overrule($getA,$postA);
 348                 t3lib_div::stripSlashesOnArray($mergedA);
 349                 return $mergedA;
 350         }
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361         /*************************
 362          *
 363          * IMAGE FUNCTIONS
 364          *
 365          *************************/
 366
 367
 368         /**
 369          * Compressing a GIF file if not already LZW compressed
 370          * This function is a workaround for the fact that ImageMagick and/or GD does not compress GIF-files to their minimun size (that is RLE or no compression used)
 371          *
 372          *              The function takes a file-reference, $theFile, and saves it again through GD or ImageMagick in order to compress the file
 373          *              GIF:
 374          *              If $type is not set, the compression is done with ImageMagick (provided that $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw'] is pointing to the path of a lzw-enabled version of 'convert') else with GD (should be RLE-enabled!)
 375          *              If $type is set to either 'IM' or 'GD' the compression is done with ImageMagick and GD respectively
 376          *              PNG:
 377          *              No changes.
 378          *
 379          *              $theFile is expected to be a valid GIF-file!
 380          *              The function returns a code for the operation.
 381          * Usage: 9
 382          *
 383          * @param       string          Filepath
 384          * @param       string          See description of function
 385          * @return      string          Returns "GD" if GD was used, otherwise "IM" if ImageMagick was used. If nothing done at all, it returns empty string.
 386          * @internal
 387          */
 388         function gif_compress($theFile, $type)  {
 389                 $gfxConf = $GLOBALS['TYPO3_CONF_VARS']['GFX'];
 390                 $returnCode='';
 391                 if ($gfxConf['gif_compress'] && strtolower(substr($theFile,-4,4))=='.gif')      {       // GIF...
 392                         if (($type=='IM' || !$type) && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im'] && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw'])   {       // IM
 393                                 exec($GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw'].'convert "'.$theFile.'" "'.$theFile.'"');
 394                                 $returnCode='IM';
 395                         } elseif (($type=='GD' || !$type) && $gfxConf['gdlib'] && !$gfxConf['gdlib_png'])       {       // GD
 396                                 $tempImage = imageCreateFromGif($theFile);
 397                                 imageGif($tempImage, $theFile);
 398                                 imageDestroy($tempImage);
 399                                 $returnCode='GD';
 400                         }
 401                 }
 402                 return $returnCode;
 403         }
 404
 405         /**
 406          * Converts a png file to gif
 407          * This converts a png file to gif IF the FLAG $GLOBALS['TYPO3_CONF_VARS']['FE']['png_to_gif'] is set true.
 408          * Usage: 5
 409          *
 410          * @param       string          $theFile        the filename with path
 411          * @return      string          new filename
 412          * @internal
 413          */
 414         function png_to_gif_by_imagemagick($theFile)    {
 415                 if ($GLOBALS['TYPO3_CONF_VARS']['FE']['png_to_gif']
 416                         && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im']
 417                         && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw']
 418                         && strtolower(substr($theFile,-4,4))=='.png'
 419                         && @is_file($theFile))  {       // IM
 420                                 $newFile = substr($theFile,0,-4).'.gif';
 421                                 exec($GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw'].'convert "'.$theFile.'" "'.$newFile.'"');
 422                                 $theFile = $newFile;
 423                                         // 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!!
 424                 }
 425                 return $theFile;
 426         }
 427
 428         /**
 429          * Returns filename of the png/gif version of the input file (which can be png or gif).
 430          * If input file type does not match the wanted output type a conversion is made and temp-filename returned.
 431          * Usage: 2
 432          *
 433          * @param       string          Filepath of image file
 434          * @param       boolean         If set, then input file is converted to PNG, otherwise to GIF
 435          * @return      string          If the new image file exists, it's filepath is returned
 436          * @internal
 437          */
 438         function read_png_gif($theFile,$output_png=0)   {
 439                 if ($GLOBALS['TYPO3_CONF_VARS']['GFX']['im'] && @is_file($theFile))     {
 440                         $ext = strtolower(substr($theFile,-4,4));
 441                         if (
 442                                         ((string)$ext=='.png' && $output_png)   ||
 443                                         ((string)$ext=='.gif' && !$output_png)
 444                                 )       {
 445                                 return $theFile;
 446                         } else {
 447                                 $newFile = PATH_site.'typo3temp/readPG_'.md5($theFile.'|'.filemtime($theFile)).($output_png?'.png':'.gif');
 448                                 exec($GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path'].'convert "'.$theFile.'" "'.$newFile.'"');
 449                                 if (@is_file($newFile)) return $newFile;
 450                         }
 451                 }
 452         }
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468         /*************************
 469          *
 470          * STRING FUNCTIONS
 471          *
 472          *************************/
 473
 474         /**
 475          * Truncate string
 476          * Returns a new string of max. $chars length.
 477          * If the string is longer, it will be truncated and appended with '...'.
 478          * DEPRECIATED. Works ONLY for single-byte charsets! USE t3lib_div::fixed_lgd_cs() instead
 479          * Usage: 39
 480          *
 481          * @param       string          $string         string to truncate
 482          * @param       integer         $chars  must be an integer with an absolute value of at least 4. if negative the string is cropped from the right end.
 483          * @param       string          String to append to the the output if it is truncated, default is '...'
 484          * @return      string          new string
 485          * @see fixed_lgd_pre()
 486          */
 487         function fixed_lgd($string,$origChars,$preStr='...')    {
 488                 $chars = abs($origChars);
 489                 if ($chars >= 4)        {
 490                         if(strlen($string)>$chars)  {
 491                                 return $origChars < 0 ?
 492                                         $preStr.trim(substr($string, -($chars-3))) :
 493                                         trim(substr($string, 0, $chars-3)).$preStr;
 494                         }
 495                 }
 496                 return $string;
 497         }
 498
 499         /**
 500          * Truncate string
 501          * Returns a new string of max. $chars length.
 502          * If the string is longer, it will be truncated and prepended with '...'.
 503          * This works like fixed_lgd, but is truncated in the start of the string instead of the end
 504          * DEPRECIATED. Use either fixed_lgd() or fixed_lgd_cs() (with negative input value for $chars)
 505          * Usage: 6
 506          *
 507          * @param       string          $string         string to truncate
 508          * @param       integer         $chars  must be an integer of at least 4
 509          * @return      string          new string
 510          * @see fixed_lgd()
 511          */
 512         function fixed_lgd_pre($string,$chars)  {
 513                 return strrev(t3lib_div::fixed_lgd(strrev($string),$chars));
 514         }
 515
 516         /**
 517          * Truncates a string with appended/prepended "..." and takes backend character set into consideration
 518          * Use only from backend!
 519          * Usage: 75
 520          *
 521          * @param       string          $string         string to truncate
 522          * @param       integer         $chars  must be an integer with an absolute value of at least 4. if negative the string is cropped from the right end.
 523          * @return      string          New string
 524          * @see fixed_lgd()
 525          */
 526         function fixed_lgd_cs($string,$chars)   {
 527                 if (is_object($GLOBALS['LANG']))        {
 528                         return $GLOBALS['LANG']->csConvObj->crop($GLOBALS['LANG']->charSet,$string,$chars,'...');
 529                 } else {
 530                         return t3lib_div::fixed_lgd($string, $chars);
 531                 }
 532         }
 533
 534         /**
 535          * Breaks up the text for emails
 536          * Usage: 1
 537          *
 538          * @param       string          The string to break up
 539          * @param       string          The string to implode the broken lines with (default/typically \n)
 540          * @param       integer         The line length
 541          * @return      string
 542          */
 543         function breakTextForEmail($str,$implChar="\n",$charWidth=76)   {
 544                 $lines = explode(chr(10),$str);
 545                 $outArr=array();
 546                 while(list(,$lStr)=each($lines))        {
 547                         $outArr = array_merge($outArr,t3lib_div::breakLinesForEmail($lStr,$implChar,$charWidth));
 548                 }
 549                 return implode(chr(10),$outArr);
 550         }
 551
 552         /**
 553          * Breaks up a single line of text for emails
 554          * Usage: 5
 555          *
 556          * @param       string          The string to break up
 557          * @param       string          The string to implode the broken lines with (default/typically \n)
 558          * @param       integer         The line length
 559          * @return      string
 560          * @see breakTextForEmail()
 561          */
 562         function breakLinesForEmail($str,$implChar="\n",$charWidth=76)  {
 563                 $lines=array();
 564                 $l=$charWidth;
 565                 $p=0;
 566                 while(strlen($str)>$p)  {
 567                         $substr=substr($str,$p,$l);
 568                         if (strlen($substr)==$l)        {
 569                                 $count = count(explode(' ',trim(strrev($substr))));
 570                                 if ($count>1)   {       // OK...
 571                                         $parts = explode(' ',strrev($substr),2);
 572                                         $theLine = strrev($parts[1]);
 573                                 } else {
 574                                         $afterParts = explode(' ',substr($str,$l+$p),2);
 575                                         $theLine = $substr.$afterParts[0];
 576                                 }
 577                                 if (!strlen($theLine))  {break; }       // Error, because this would keep us in an endless loop.
 578                         } else {
 579                                 $theLine=$substr;
 580                         }
 581
 582                         $lines[]=trim($theLine);
 583                         $p+=strlen($theLine);
 584                         if (!trim(substr($str,$p,$l)))  break;  // added...
 585                 }
 586                 return implode($implChar,$lines);
 587         }
 588
 589         /**
 590          * Match IP number with list of numbers with wildcard
 591          * Usage: 10
 592          *
 593          * @param       string          $baseIP is the current remote IP address for instance, typ. REMOTE_ADDR
 594          * @param       string          $list is a comma-list of IP-addresses to match with. *-wildcard allowed instead of number, plus leaving out parts in the IP number is accepted as wildcard (eg. 192.168.*.* equals 192.168)
 595          * @return      boolean         True if an IP-mask from $list matches $baseIP
 596          */
 597         function cmpIP($baseIP, $list)  {
 598                 $IPpartsReq = explode('.',$baseIP);
 599                 if (count($IPpartsReq)==4)      {
 600                         $values = t3lib_div::trimExplode(',',$list,1);
 601
 602                         foreach($values as $test)       {
 603                                 list($test,$mask) = explode('/',$test);
 604
 605                                 if(intval($mask)) {
 606                                                 // "192.168.3.0/24"
 607                                         $lnet = ip2long($test);
 608                                         $lip = ip2long($baseIP);
 609                                         $binnet = str_pad( decbin($lnet),32,'0','STR_PAD_LEFT');
 610                                         $firstpart = substr($binnet,0,$mask);
 611                                         $binip = str_pad( decbin($lip),32,'0','STR_PAD_LEFT');
 612                                         $firstip = substr($binip,0,$mask);
 613                                         $yes = (strcmp($firstpart,$firstip)==0);
 614                                 } else {
 615                                                 // "192.168.*.*"
 616                                         $IPparts = explode('.',$test);
 617                                         $yes = 1;
 618                                         reset($IPparts);
 619                                         while(list($index,$val)=each($IPparts)) {
 620                                                 $val = trim($val);
 621                                                 if (strcmp($val,'*') && strcmp($IPpartsReq[$index],$val))       {
 622                                                         $yes=0;
 623                                                 }
 624                                         }
 625                                 }
 626                                 if ($yes) return true;
 627                         }
 628                 }
 629                 return false;
 630         }
 631
 632         /**
 633          * Match fully qualified domain name with list of strings with wildcard
 634          *
 635          * @param       string          $baseIP is the current remote IP address for instance, typ. REMOTE_ADDR
 636          * @param       string          $list is a comma-list of domain names to match with. *-wildcard allowed but cannot be part of a string, so it must match the full host name (eg. myhost.*.com => correct, myhost.*domain.com => wrong)
 637          * @return      boolean         True if a domain name mask from $list matches $baseIP
 638          */
 639         function cmpFQDN($baseIP, $list)        {
 640                 if (count(explode('.',$baseIP))==4)     {
 641                         $resolvedHostName = explode('.', gethostbyaddr($baseIP));
 642                         $values = t3lib_div::trimExplode(',',$list,1);
 643
 644                         foreach($values as $test)       {
 645                                 $hostNameParts = explode('.',$test);
 646                                 $yes = 1;
 647
 648                                 foreach($hostNameParts as $index => $val)       {
 649                                         $val = trim($val);
 650                                         if (strcmp($val,'*') && strcmp($resolvedHostName[$index],$val)) {
 651                                                 $yes=0;
 652                                         }
 653                                 }
 654                                 if ($yes) return true;
 655                         }
 656                 }
 657                 return false;
 658         }
 659
 660         /**
 661          * Check for item in list
 662          * Check if an item exists in a comma-separated list of items.
 663          * Usage: 163
 664          *
 665          * @param       string          $in_list        comma-separated list of items (string)
 666          * @param       string          $item   item to check for
 667          * @return      boolean         true if $item is in $in_list
 668          */
 669         function inList($in_list,$item) {
 670                 return strstr(','.$in_list.',', ','.$item.',');
 671         }
 672
 673         /**
 674          * Removes an item from a comma-separated list of items.
 675          * Usage: 1
 676          *
 677          * @param       string          $element        element to remove
 678          * @param       string          $list   comma-separated list of items (string)
 679          * @return      string          new comma-separated list of items
 680          */
 681         function rmFromList($element,$list)     {
 682                 $items = explode(',',$list);
 683                 while(list($k,$v)=each($items)) {
 684                         if ($v==$element)       {unset($items[$k]);}
 685                 }
 686                 return implode(',',$items);
 687         }
 688
 689         /**
 690          * Forces the integer $theInt into the boundaries of $min and $max. If the $theInt is 'false' then the $zeroValue is applied.
 691          * Usage: 224
 692          *
 693          * @param       integer         Input value
 694          * @param       integer         Lower limit
 695          * @param       integer         Higher limit
 696          * @param       integer         Default value if input is false.
 697          * @return      integer         The input value forced into the boundaries of $min and $max
 698          */
 699         function intInRange($theInt,$min,$max=2000000000,$zeroValue=0)  {
 700                 // Returns $theInt as an integer in the integerspace from $min to $max
 701                 $theInt = intval($theInt);
 702                 if ($zeroValue && !$theInt)     {$theInt=$zeroValue;}   // If the input value is zero after being converted to integer, zeroValue may set another default value for it.
 703                 if ($theInt<$min){$theInt=$min;}
 704                 if ($theInt>$max){$theInt=$max;}
 705                 return $theInt;
 706         }
 707
 708         /**
 709          * Returns the $integer if greater than zero, otherwise returns zero.
 710          * Usage: 1
 711          *
 712          * @param       integer         Integer string to process
 713          * @return      integer
 714          */
 715         function intval_positive($theInt)       {
 716                 $theInt = intval($theInt);
 717                 if ($theInt<0){$theInt=0;}
 718                 return $theInt;
 719         }
 720
 721         /**
 722          * Returns an integer from a three part version number, eg '4.12.3' -> 4012003
 723          * Usage: 2
 724          *
 725          * @param       string          Version number on format x.x.x
 726          * @return      integer         Integer version of version number (where each part can count to 999)
 727          */
 728         function int_from_ver($verNumberStr)    {
 729                 $verParts = explode('.',$verNumberStr);
 730                 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));
 731         }
 732
 733         /**
 734          * Makes a positive integer hash out of the first 7 chars from the md5 hash of the input
 735          * Usage: 5
 736          *
 737          * @param       string          String to md5-hash
 738          * @return      integer         Returns 28bit integer-hash
 739          */
 740         function md5int($str)   {
 741                 return hexdec(substr(md5($str),0,7));
 742         }
 743
 744         /**
 745          * Returns the first 10 positions of the MD5-hash               (changed from 6 to 10 recently)
 746          *
 747          * Usage: 37
 748          *
 749          * @param       string          Input string to be md5-hashed
 750          * @param       integer         The string-length of the output
 751          * @return      string          Substring of the resulting md5-hash, being $len chars long (from beginning)
 752          */
 753         function shortMD5($input, $len=10)      {
 754                 return substr(md5($input),0,$len);
 755         }
 756
 757         /**
 758          * Takes comma-separated lists and arrays and removes all duplicates
 759          * Usage: 16
 760          *
 761          * @param       string          Accept multiple parameters wich can be comma-separated lists of values and arrays.
 762          * @return      string          Returns the list without any duplicates of values, space around values are trimmed
 763          */
 764         function uniqueList()   {
 765                 $listArray = array();
 766
 767                 $arg_list = func_get_args();
 768                 foreach ($arg_list as $in_list) {
 769                         if (!is_array($in_list))        {
 770                                 $in_list = explode(',',$in_list);
 771                         }
 772                         $listArray = array_merge($listArray,$in_list);
 773                 }
 774                 return implode(',',t3lib_div::uniqueArray($listArray));
 775         }
 776
 777         /**
 778          * Splits a reference to a file in 5 parts
 779          * Usage: 43
 780          *
 781          * @param       string          Filename/filepath to be analysed
 782          * @return      array           Contains keys [path], [file], [filebody], [fileext], [realFileext]
 783          */
 784         function split_fileref($fileref)        {
 785                 if (    ereg('(.*/)(.*)$',$fileref,$reg)        )       {
 786                         $info['path'] = $reg[1];
 787                         $info['file'] = $reg[2];
 788                 } else {
 789                         $info['path'] = '';
 790                         $info['file'] = $fileref;
 791                 }
 792                 $reg='';
 793                 if (    ereg('(.*)\.([^\.]*$)',$info['file'],$reg)      )       {
 794                         $info['filebody'] = $reg[1];
 795                         $info['fileext'] = strtolower($reg[2]);
 796                         $info['realFileext'] = $reg[2];
 797                 } else {
 798                         $info['filebody'] = $info['file'];
 799                         $info['fileext'] = '';
 800                 }
 801                 reset($info);
 802                 return $info;
 803         }
 804
 805         /**
 806          * Returns the directory part of a path without trailing slash
 807          * If there is no dir-part, then an empty string is returned.
 808          * Behaviour:
 809          *
 810          * '/dir1/dir2/script.php' => '/dir1/dir2'
 811          * '/dir1/' => '/dir1'
 812          * 'dir1/script.php' => 'dir1'
 813          * 'd/script.php' => 'd'
 814          * '/script.php' => ''
 815          * '' => ''
 816          * Usage: 5
 817          *
 818          * @param       string          Directory name / path
 819          * @return      string          Processed input value. See function description.
 820          */
 821         function dirname($path) {
 822                 $p=t3lib_div::revExplode('/',$path,2);
 823                 return count($p)==2?$p[0]:'';
 824         }
 825
 826         /**
 827          * Modifies a HTML Hex color by adding/subtracting $R,$G and $B integers
 828          * Usage: 11
 829          *
 830          * @param       string          A hexadecimal color code, #xxxxxx
 831          * @param       integer         Offset value 0-255
 832          * @param       integer         Offset value 0-255
 833          * @param       integer         Offset value 0-255
 834          * @return      string          A hexadecimal color code, #xxxxxx, modified according to input vars
 835          * @see modifyHTMLColorAll()
 836          */
 837         function modifyHTMLColor($color,$R,$G,$B)       {
 838                 // This takes a hex-color (# included!) and adds $R, $G and $B to the HTML-color (format: #xxxxxx) and returns the new color
 839                 $nR = t3lib_div::intInRange(hexdec(substr($color,1,2))+$R,0,255);
 840                 $nG = t3lib_div::intInRange(hexdec(substr($color,3,2))+$G,0,255);
 841                 $nB = t3lib_div::intInRange(hexdec(substr($color,5,2))+$B,0,255);
 842                 return '#'.
 843                         substr('0'.dechex($nR),-2).
 844                         substr('0'.dechex($nG),-2).
 845                         substr('0'.dechex($nB),-2);
 846         }
 847
 848         /**
 849          * Modifies a HTML Hex color by adding/subtracting $all integer from all R/G/B channels
 850          * Usage: 6
 851          *
 852          * @param       string          A hexadecimal color code, #xxxxxx
 853          * @param       integer         Offset value 0-255 for all three channels.
 854          * @return      string          A hexadecimal color code, #xxxxxx, modified according to input vars
 855          * @see modifyHTMLColor()
 856          */
 857         function modifyHTMLColorAll($color,$all)        {
 858                 return t3lib_div::modifyHTMLColor($color,$all,$all,$all);
 859         }
 860
 861         /**
 862          * Removes comma (if present) in the end of string
 863          * Usage: 2
 864          *
 865          * @param       string          String from which the comma in the end (if any) will be removed.
 866          * @return      string
 867          */
 868         function rm_endcomma($string)   {
 869                 return ereg_replace(',$','',$string);
 870         }
 871
 872         /**
 873          * strtoupper which converts danish (and other characters) characters as well
 874          * (DEPRECIATED, use t3lib_cs::conv_case() instead or for HTML output, wrap your content in <span class="uppercase">...</span>)
 875          * Usage: 0
 876          *
 877          * @param       string          String to process
 878          * @return      string
 879          * @ignore
 880          */
 881         function danish_strtoupper($string)     {
 882                 $value = strtoupper($string);
 883                 return strtr($value, 'áéúíâêûôîæøåäöü', 'ÁÉÚÍÄËÜÖÏÆØÅÄÖÜ');
 884         }
 885
 886         /**
 887          * Change umlaut characters to plain ASCII with normally two character target
 888          * Only known characters will be converted, so don't expect a result for any character.
 889          * (DEPRECIATED: Works only for western europe single-byte charsets! Use t3lib_cs::specCharsToASCII() instead!)
 890          *
 891          * ä => ae, Ö => Oe
 892          *
 893          * @param       string          String to convert.
 894          * @return      string
 895          */
 896         function convUmlauts($str)      {
 897                 $pat  = array ( '/ä/',  '/Ä/',  '/ö/',  '/Ö/',  '/ü/',  '/Ü/',  '/ß/',  '/å/',  '/Å/',  '/ø/',  '/Ø/',  '/æ/',  '/Æ/'   );
 898                 $repl = array ( 'ae',   'Ae',   'oe',   'Oe',   'ue',   'Ue',   'ss',   'aa',   'AA',   'oe',   'OE',   'ae',   'AE'    );
 899                 return preg_replace($pat,$repl,$str);
 900         }
 901
 902         /**
 903          * Tests if the input is an integer.
 904          * Usage: 77
 905          *
 906          * @param       mixed           Any input variable to test.
 907          * @return      boolean         Returns true if string is an integer
 908          */
 909         function testInt($var)  {
 910                 return !strcmp($var,intval($var));
 911         }
 912
 913         /**
 914          * Returns true if the first part of $str matches the string $partStr
 915          * Usage: 59
 916          *
 917          * @param       string          Full string to check
 918          * @param       string          Reference string which must be found as the "first part" of the full string
 919          * @return      boolean         True if $partStr was found to be equal to the first part of $str
 920          */
 921         function isFirstPartOfStr($str,$partStr)        {
 922                 // Returns true, if the first part of a $str equals $partStr and $partStr is not ''
 923                 $psLen = strlen($partStr);
 924                 if ($psLen)     {
 925                         return substr($str,0,$psLen)==(string)$partStr;
 926                 } else return false;
 927         }
 928
 929         /**
 930          * Formats the input integer $sizeInBytes as bytes/kilobytes/megabytes (-/K/M)
 931          * Usage: 53
 932          *
 933          * @param       integer         Number of bytes to format.
 934          * @param       string          Labels for bytes, kilo, mega and giga separated by vertical bar (|) and possibly encapsulated in "". Eg: " | K| M| G" (which is the default value)
 935          * @return      string          Formatted representation of the byte number, for output.
 936          */
 937         function formatSize($sizeInBytes,$labels='')    {
 938
 939                         // Set labels:
 940                 if (strlen($labels) == 0) {
 941                     $labels = ' | K| M| G';
 942                 } else {
 943                     $labels = str_replace('"','',$labels);
 944                 }
 945                 $labelArr = explode('|',$labels);
 946
 947                         // Find size:
 948                 if ($sizeInBytes>900)   {
 949                         if ($sizeInBytes>900000000)     {       // GB
 950                                 $val = $sizeInBytes/(1024*1024*1024);
 951                                 return number_format($val, (($val<20)?1:0), '.', '').$labelArr[3];
 952                         }
 953                         elseif ($sizeInBytes>900000)    {       // MB
 954                                 $val = $sizeInBytes/(1024*1024);
 955                                 return number_format($val, (($val<20)?1:0), '.', '').$labelArr[2];
 956                         } else {        // KB
 957                                 $val = $sizeInBytes/(1024);
 958                                 return number_format($val, (($val<20)?1:0), '.', '').$labelArr[1];
 959                         }
 960                 } else {        // Bytes
 961                         return $sizeInBytes.$labelArr[0];
 962                 }
 963         }
 964
 965         /**
 966          * Returns microtime input to milliseconds
 967          * Usage: 2
 968          *
 969          * @param       string          Microtime
 970          * @return      integer         Microtime input string converted to an integer (milliseconds)
 971          */
 972         function convertMicrotime($microtime)   {
 973                 $parts = explode(' ',$microtime);
 974                 return round(($parts[0]+$parts[1])*1000);
 975         }
 976
 977         /**
 978          * This splits a string by the chars in $operators (typical /+-*) and returns an array with them in
 979          * Usage: 2
 980          *
 981          * @param       string          Input string, eg "123 + 456 / 789 - 4"
 982          * @param       string          Operators to split by, typically "/+-*"
 983          * @return      array           Array with operators and operands separated.
 984          * @see tslib_cObj::calc(), tslib_gifBuilder::calcOffset()
 985          */
 986         function splitCalc($string,$operators)  {
 987                 $res = Array();
 988                 $sign='+';
 989                 while($string)  {
 990                         $valueLen=strcspn($string,$operators);
 991                         $value=substr($string,0,$valueLen);
 992                         $res[] = Array($sign,trim($value));
 993                         $sign=substr($string,$valueLen,1);
 994                         $string=substr($string,$valueLen+1);
 995                 }
 996                 reset($res);
 997                 return $res;
 998         }
 999
1000         /**
1001          * Calculates the input by +,-,*,/,%,^ with priority to + and -
1002          * Usage: 1
1003          *
1004          * @param       string          Input string, eg "123 + 456 / 789 - 4"
1005          * @return      integer         Calculated value. Or error string.
1006          * @see calcParenthesis()
1007          */
1008         function calcPriority($string)  {
1009                 $string=ereg_replace('[[:space:]]*','',$string);        // removing all whitespace
1010                 $string='+'.$string;    // Ensuring an operator for the first entrance
1011                 $qm='\*\/\+-^%';
1012                 $regex = '(['.$qm.'])(['.$qm.']?[0-9\.]*)';
1013                         // split the expression here:
1014                 preg_match_all('/'.$regex.'/',$string,$reg);
1015
1016                 reset($reg[2]);
1017                 $number=0;
1018                 $Msign='+';
1019                 $err='';
1020                 $buffer=doubleval(current($reg[2]));
1021                 next($reg[2]);  // Advance pointer
1022                 while(list($k,$v)=each($reg[2]))        {
1023                         $v=doubleval($v);
1024                         $sign = $reg[1][$k];
1025                         if ($sign=='+' || $sign=='-')   {
1026                                 $number = $Msign=='-' ? $number-=$buffer : $number+=$buffer;
1027                                 $Msign = $sign;
1028                                 $buffer=$v;
1029                         } else {
1030                                 if ($sign=='/') {if ($v) $buffer/=$v; else $err='dividing by zero';}
1031                                 if ($sign=='%') {if ($v) $buffer%=$v; else $err='dividing by zero';}
1032                                 if ($sign=='*') {$buffer*=$v;}
1033                                 if ($sign=='^') {$buffer=pow($buffer,$v);}
1034                         }
1035                 }
1036                 $number = $Msign=='-' ? $number-=$buffer : $number+=$buffer;
1037                 return $err ? 'ERROR: '.$err : $number;
1038         }
1039
1040         /**
1041          * Calculates the input with parenthesis levels
1042          * Usage: 2
1043          *
1044          * @param       string          Input string, eg "(123 + 456) / 789 - 4"
1045          * @return      integer         Calculated value. Or error string.
1046          * @see calcPriority(), tslib_cObj::stdWrap()
1047          */
1048         function calcParenthesis($string)       {
1049                 $securC=100;
1050                 do {
1051                         $valueLenO=strcspn($string,'(');
1052                         $valueLenC=strcspn($string,')');
1053                         if ($valueLenC==strlen($string) || $valueLenC < $valueLenO)     {
1054                                 $value = t3lib_div::calcPriority(substr($string,0,$valueLenC));
1055                                 $string = $value.substr($string,$valueLenC+1);
1056                                 return $string;
1057                         } else {
1058                                 $string = substr($string,0,$valueLenO).t3lib_div::calcParenthesis(substr($string,$valueLenO+1));
1059                         }
1060                                 // Security:
1061                         $securC--;
1062                         if ($securC<=0) break;
1063                 } while($valueLenO<strlen($string));
1064                 return $string;
1065         }
1066
1067         /**
1068          * Inverse version of htmlspecialchars()
1069          * Usage: 4
1070          *
1071          * @param       string          Value where &gt;, &lt;, &quot; and &amp; should be converted to regular chars.
1072          * @return      string          Converted result.
1073          */
1074         function htmlspecialchars_decode($value)        {
1075                 $value = str_replace('&gt;','>',$value);
1076                 $value = str_replace('&lt;','<',$value);
1077                 $value = str_replace('&quot;','"',$value);
1078                 $value = str_replace('&amp;','&',$value);
1079                 return $value;
1080         }
1081
1082         /**
1083          * Re-converts HTML entities if they have been converted by htmlspecialchars()
1084          * Usage: 10
1085          *
1086          * @param       string          String which contains eg. "&amp;amp;" which should stay "&amp;". Or "&amp;#1234;" to "&#1234;". Or "&amp;#x1b;" to "&#x1b;"
1087          * @return      string          Converted result.
1088          */
1089         function deHSCentities($str)    {
1090                 return ereg_replace('&amp;([#[:alnum:]]*;)','&\1',$str);
1091         }
1092
1093         /**
1094          * This function is used to escape any ' -characters when transferring text to JavaScript!
1095          * Usage: 3
1096          *
1097          * @param       string          String to escape
1098          * @param       boolean         If set, also backslashes are escaped.
1099          * @param       string          The character to escape, default is ' (single-quote)
1100          * @return      string          Processed input string
1101          */
1102         function slashJS($string,$extended=0,$char="'") {
1103                 if ($extended)  {$string = str_replace ("\\", "\\\\", $string);}
1104                 return str_replace ($char, "\\".$char, $string);
1105         }
1106
1107         /**
1108          * Version of rawurlencode() where all spaces (%20) are re-converted to space-characters.
1109          * Usefull when passing text to JavaScript where you simply url-encode it to get around problems with syntax-errors, linebreaks etc.
1110          * Usage: 4
1111          *
1112          * @param       string          String to raw-url-encode with spaces preserved
1113          * @return      string          Rawurlencoded result of input string, but with all %20 (space chars) converted to real spaces.
1114          */
1115         function rawUrlEncodeJS($str)   {
1116                 return str_replace('%20',' ',rawurlencode($str));
1117         }
1118
1119         /**
1120          * rawurlencode which preserves "/" chars
1121          * Usefull when filepaths should keep the "/" chars, but have all other special chars encoded.
1122          * Usage: 5
1123          *
1124          * @param       string          Input string
1125          * @return      string          Output string
1126          */
1127         function rawUrlEncodeFP($str)   {
1128                 return str_replace('%2F','/',rawurlencode($str));
1129         }
1130
1131         /**
1132          * Checking syntax of input email address
1133          * Usage: 5
1134          *
1135          * @param       string          Input string to evaluate
1136          * @return      boolean         Returns true if the $email address (input string) is valid; Has a "@", domain name with at least one period and only allowed a-z characters.
1137          */
1138         function validEmail($email)     {
1139                 $email = trim ($email);
1140                 if (strstr($email,' '))  return FALSE;
1141                 return ereg('^[A-Za-z0-9\._-]+[@][A-Za-z0-9\._-]+[\.].[A-Za-z0-9]+$',$email) ? TRUE : FALSE;
1142         }
1143
1144         /**
1145          * Formats a string for output between <textarea>-tags
1146          * All content outputted in a textarea form should be passed through this function
1147          * Not only is the content htmlspecialchar'ed on output but there is also a single newline added in the top. The newline is necessary because browsers will ignore the first newline after <textarea> if that is the first character. Therefore better set it!
1148          * Usage: 23
1149          *
1150          * @param       string          Input string to be formatted.
1151          * @return      string          Formatted for <textarea>-tags
1152          */
1153         function formatForTextarea($content)    {
1154                 return chr(10).htmlspecialchars($content);
1155         }
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168         /*************************
1169          *
1170          * ARRAY FUNCTIONS
1171          *
1172          *************************/
1173
1174         /**
1175          * Check if an item exists in an array
1176          * Please note that the order of parameters is reverse compared to the php4-function in_array()!!!
1177          * Usage: 3
1178          *
1179          * @param       array           $in_array               one-dimensional array of items
1180          * @param       string          $item   item to check for
1181          * @return      boolean         true if $item is in the one-dimensional array $in_array
1182          * @internal
1183          */
1184         function inArray($in_array,$item)       {
1185                 if (is_array($in_array))        {
1186                         while (list(,$val)=each($in_array))     {
1187                                 if (!is_array($val) && !strcmp($val,$item)) return true;
1188                         }
1189                 }
1190         }
1191
1192         /**
1193          * Explodes a $string delimited by $delim and passes each item in the array through intval().
1194          * Corresponds to explode(), but with conversion to integers for all values.
1195          * Usage: 76
1196          *
1197          * @param       string          Delimiter string to explode with
1198          * @param       string          The string to explode
1199          * @return      array           Exploded values, all converted to integers
1200          */
1201         function intExplode($delim, $string)    {
1202                 $temp = explode($delim,$string);
1203                 while(list($key,$val)=each($temp))      {
1204                         $temp[$key]=intval($val);
1205                 }
1206                 reset($temp);
1207                 return $temp;
1208         }
1209
1210         /**
1211          * Reverse explode which explodes the string counting from behind.
1212          * Thus t3lib_div::revExplode(':','my:words:here',2) will return array('my:words','here')
1213          * Usage: 8
1214          *
1215          * @param       string          Delimiter string to explode with
1216          * @param       string          The string to explode
1217          * @param       integer         Number of array entries
1218          * @return      array           Exploded values
1219          */
1220         function revExplode($delim, $string, $count=0)  {
1221                 $temp = explode($delim,strrev($string),$count);
1222                 while(list($key,$val)=each($temp))      {
1223                         $temp[$key]=strrev($val);
1224                 }
1225                 $temp=array_reverse($temp);
1226                 reset($temp);
1227                 return $temp;
1228         }
1229
1230         /**
1231          * Explodes a string and trims all values for whitespace in the ends.
1232          * If $onlyNonEmptyValues is set, then all blank ('') values are removed.
1233          * Usage: 256
1234          *
1235          * @param       string          Delimiter string to explode with
1236          * @param       string          The string to explode
1237          * @param       boolean         If set, all empty values (='') will NOT be set in output
1238          * @return      array           Exploded values
1239          */
1240         function trimExplode($delim, $string, $onlyNonEmptyValues=0)    {
1241                 $temp = explode($delim,$string);
1242                 $newtemp=array();
1243                 while(list($key,$val)=each($temp))      {
1244                         if (!$onlyNonEmptyValues || strcmp('',trim($val)))      {
1245                                 $newtemp[]=trim($val);
1246                         }
1247                 }
1248                 reset($newtemp);
1249                 return $newtemp;
1250         }
1251
1252         /**
1253          * Takes a one-dimensional array and returns an array where the values are unique
1254          * The keys in the array are substituted with some md5-hashes
1255          * If the value is trim(empty), the value is ignored.
1256          * Values are trimmed
1257          * (Deprecated, use PHP function array_unique instead)
1258          * Usage: 1
1259          *
1260          * @param       array           Array of values to make unique
1261          * @return      array
1262          * @ignore
1263          * @deprecated
1264          */
1265         function uniqueArray($valueArray)       {
1266                 $array_out=array();
1267                 if (is_array($valueArray))      {
1268                         while (list($key,$val)=each($valueArray)) {
1269                                 $val=trim($val);
1270                                 if ((string)$val!='')   {
1271                                         $array_out[md5($val)]=$val;
1272                                 }
1273                         }
1274                 }
1275                 reset($array_out);
1276                 return $array_out;
1277         }
1278
1279         /**
1280          * Removes the value $cmpValue from the $array if found there. Returns the modified array
1281          * Usage: 3
1282          *
1283          * @param       array           Array containing the values
1284          * @param       string          Value to search for and if found remove array entry where found.
1285          * @return      array           Output array with entries removed if search string is found
1286          */
1287         function removeArrayEntryByValue($array,$cmpValue)      {
1288                 if (is_array($array))   {
1289                         reset($array);
1290                         while(list($k,$v)=each($array)) {
1291                                 if (is_array($v))       {
1292                                         $array[$k] = t3lib_div::removeArrayEntryByValue($v,$cmpValue);
1293                                 } else {
1294                                         if (!strcmp($v,$cmpValue))      {
1295                                                 unset($array[$k]);
1296                                         }
1297                                 }
1298                         }
1299                 }
1300                 reset($array);
1301                 return $array;
1302         }
1303
1304         /**
1305          * Implodes a multidim-array into GET-parameters (eg. &param[key][key2]=value2&param[key][key3]=value3)
1306          * Usage: 24
1307          *
1308          * @param       string          Name prefix for entries. Set to blank if you wish none.
1309          * @param       array           The (multidim) array to implode
1310          * @param       boolean         If set, all values that are blank (='') will NOT be imploded
1311          * @param       boolean         If set, parameters which were blank strings would be removed.
1312          * @param       boolean         If set, the param name itselt (for example "param[key][key2]") would be rawurlencoded as well.
1313          * @return      string          Imploded result, fx. &param[key][key2]=value2&param[key][key3]=value3
1314          */
1315         function implodeArrayForUrl($name,$theArray,$str='',$skipBlank=0,$rawurlencodeParamName=0)      {
1316                 if (is_array($theArray))        {
1317                         foreach($theArray as $Akey => $AVal)    {
1318                                 $thisKeyName = $name ? $name.'['.$Akey.']' : $Akey;
1319                                 if (is_array($AVal))    {
1320                                         $str = t3lib_div::implodeArrayForUrl($thisKeyName,$AVal,$str,$skipBlank,$rawurlencodeParamName);
1321                                 } else {
1322                                         if (!$skipBlank || strcmp($AVal,''))    {
1323                                                 $str.='&'.($rawurlencodeParamName ? rawurlencode($thisKeyName) : $thisKeyName).
1324                                                         '='.rawurlencode($AVal);        // strips slashes because HTTP_POST_VARS / GET_VARS input is with slashes...
1325                                         }
1326                                 }
1327                         }
1328                 }
1329                 return $str;
1330         }
1331
1332         /**
1333          * Returns an array with selected keys from incoming data.
1334          * (Better read source code if you want to find out...)
1335          * Usage: 3
1336          *
1337          * @param       string          List of variable/key names
1338          * @param       array           Array from where to get values based on the keys in $varList
1339          * @param       boolean         If set, then t3lib_div::_GP() is used to fetch the value if not found (isset) in the $getArray
1340          * @return      array           Output array with selected variables.
1341          */
1342         function compileSelectedGetVarsFromArray($varList,$getArray,$GPvarAlt=1)        {
1343                 $keys = t3lib_div::trimExplode(',',$varList,1);
1344                 $outArr=array();
1345                 foreach($keys as $v)    {
1346                         if (isset($getArray[$v]))       {
1347                                 $outArr[$v]=$getArray[$v];
1348                         } elseif ($GPvarAlt) {
1349                                 $outArr[$v]=t3lib_div::_GP($v);
1350                         }
1351                 }
1352                 return $outArr;
1353         }
1354
1355         /**
1356          * AddSlash array
1357          * This function traverses a multidimentional array and adds slashes to the values.
1358          * NOTE that the input array is and argument by reference.!!
1359          * Twin-function to stripSlashesOnArray
1360          * Usage: 8
1361          *
1362          * @param       array           Multidimensional input array, (REFERENCE!)
1363          * @return      array
1364          */
1365         function addSlashesOnArray(&$theArray)  {
1366                 if (is_array($theArray))        {
1367                         reset($theArray);
1368                         while(list($Akey,$AVal)=each($theArray))        {
1369                                 if (is_array($AVal))    {
1370                                         t3lib_div::addSlashesOnArray($theArray[$Akey]);
1371                                 } else {
1372                                         $theArray[$Akey] = addslashes($AVal);
1373                                 }
1374                         }
1375                         reset($theArray);
1376                 }
1377         }
1378
1379         /**
1380          * StripSlash array
1381          * This function traverses a multidimentional array and strips slashes to the values.
1382          * NOTE that the input array is and argument by reference.!!
1383          * Twin-function to addSlashesOnArray
1384          * Usage: 10
1385          *
1386          * @param       array           Multidimensional input array, (REFERENCE!)
1387          * @return      array
1388          */
1389         function stripSlashesOnArray(&$theArray)        {
1390                 if (is_array($theArray))        {
1391                         reset($theArray);
1392                         while(list($Akey,$AVal)=each($theArray))        {
1393                                 if (is_array($AVal))    {
1394                                         t3lib_div::stripSlashesOnArray($theArray[$Akey]);
1395                                 } else {
1396                                         $theArray[$Akey] = stripslashes($AVal);
1397                                 }
1398                         }
1399                         reset($theArray);
1400                 }
1401         }
1402
1403         /**
1404          * Either slashes ($cmd=add) or strips ($cmd=strip) array $arr depending on $cmd
1405          * Usage: 0
1406          *
1407          * @param       array           Multidimensional input array
1408          * @param       string          "add" or "strip", depending on usage you wish.
1409          * @return      array
1410          */
1411         function slashArray($arr,$cmd)  {
1412                 if ($cmd=='strip')      t3lib_div::stripSlashesOnArray($arr);
1413                 if ($cmd=='add')        t3lib_div::addSlashesOnArray($arr);
1414                 return $arr;
1415         }
1416
1417         /**
1418          * Merges two arrays recursively and "binary safe" (integer keys are overridden as well), overruling similar the values in the first array ($arr0) with the values of the second array ($arr1)
1419          * In case of identical keys, ie. keeping the values of the second.
1420          * Usage: 0
1421          *
1422          * @param       array           First array
1423          * @param       array           Second array, overruling the first array
1424          * @param       boolean         If set, keys that are NOT found in $arr0 (first array) will not be set. Thus only existing value can/will be overruled from second array.
1425          * @param       boolean         If set, values from $arr1 will overrule if they are empty. Default: true
1426          * @return      array           Resulting array where $arr1 values has overruled $arr0 values
1427          */
1428         function array_merge_recursive_overrule($arr0,$arr1,$notAddKeys=0,$includeEmtpyValues=true) {
1429                 reset($arr1);
1430                 while(list($key,$val) = each($arr1)) {
1431                         if(is_array($arr0[$key])) {
1432                                 if (is_array($arr1[$key]))      {
1433                                         $arr0[$key] = t3lib_div::array_merge_recursive_overrule($arr0[$key],$arr1[$key],$notAddKeys);
1434                                 }
1435                         } else {
1436                                 if ($notAddKeys) {
1437                                         if (isset($arr0[$key])) {
1438                                                 if ($includeEmtpyValues OR $val) {
1439                                                         $arr0[$key] = $val;
1440                                                 }
1441                                         }
1442                                 } else {
1443                                         if ($includeEmtpyValues OR $val) {
1444                                                 $arr0[$key] = $val;
1445                                         }
1446                                 }
1447                         }
1448                 }
1449                 reset($arr0);
1450                 return $arr0;
1451         }
1452
1453         /**
1454          * An array_merge function where the keys are NOT renumbered as they happen to be with the real php-array_merge function. It is "binary safe" in the sense that integer keys are overridden as well.
1455          * Usage: 16
1456          *
1457          * @param       array           First array
1458          * @param       array           Second array
1459          * @return      array           Merged result.
1460          */
1461         function array_merge($arr1,$arr2)       {
1462                 return $arr2+$arr1;
1463         }
1464
1465         /**
1466          * Takes a row and returns a CSV string of the values with $delim (default is ,) and $quote (default is ") as separator chars.
1467          * Usage: 5
1468          *
1469          * @param       array           Input array of values
1470          * @param       string          Delimited, default is comman
1471          * @param       string          Quote-character to wrap around the values.
1472          * @return      string          A single line of CSV
1473          */
1474         function csvValues($row,$delim=',',$quote='"')  {
1475                 reset($row);
1476                 $out=array();
1477                 while(list(,$value)=each($row)) {
1478                         list($valPart) = explode(chr(10),$value);
1479                         $valPart = trim($valPart);
1480                         $out[]=str_replace($quote,$quote.$quote,$valPart);
1481                 }
1482                 $str = $quote.implode($quote.$delim.$quote,$out).$quote;
1483                 return $str;
1484         }
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501         /*************************
1502          *
1503          * HTML/XML PROCESSING
1504          *
1505          *************************/
1506
1507         /**
1508          * Returns an array with all attributes of the input HTML tag as key/value pairs. Attributes are only lowercase a-z
1509          * $tag is either a whole tag (eg '<TAG OPTION ATTRIB=VALUE>') or the parameterlist (ex ' OPTION ATTRIB=VALUE>')
1510          * If a attribute is empty (I call it 'an option'), then the value for the key is empty. You can check if it existed with isset()
1511          * Usage: 8
1512          *
1513          * @param       string          HTML-tag string (or attributes only)
1514          * @return      array           Array with the attribute values.
1515          */
1516         function get_tag_attributes($tag)       {
1517                 $components = t3lib_div::split_tag_attributes($tag);
1518                 $name = '';      // attribute name is stored here
1519                 $valuemode = '';
1520                 if (is_array($components))      {
1521                         while (list($key,$val) = each ($components))    {
1522                                 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
1523                                         if ($valuemode) {
1524                                                 if ($name)      {
1525                                                         $attributes[$name] = $val;
1526                                                         $name = '';
1527                                                 }
1528                                         } else {
1529                                                 if ($key = strtolower(ereg_replace('[^a-zA-Z0-9]','',$val)))    {
1530                                                         $attributes[$key] = '';
1531                                                         $name = $key;
1532                                                 }
1533                                         }
1534                                         $valuemode = '';
1535                                 } else {
1536                                         $valuemode = 'on';
1537                                 }
1538                         }
1539                         if (is_array($attributes))      reset($attributes);
1540                         return $attributes;
1541                 }
1542         }
1543
1544         /**
1545          * Returns an array with the 'components' from an attribute list from an HTML tag. The result is normally analyzed by get_tag_attributes
1546          * Removes tag-name if found
1547          * Usage: 2
1548          *
1549          * @param       string          HTML-tag string (or attributes only)
1550          * @return      array           Array with the attribute values.
1551          * @internal
1552          */
1553         function split_tag_attributes($tag)     {
1554                 $tag_tmp = trim(eregi_replace ('^<[^[:space:]]*','',trim($tag)));
1555                         // Removes any > in the end of the string
1556                 $tag_tmp = trim(eregi_replace ('>$','',$tag_tmp));
1557
1558                 while (strcmp($tag_tmp,''))     {       // Compared with empty string instead , 030102
1559                         $firstChar=substr($tag_tmp,0,1);
1560                         if (!strcmp($firstChar,'"') || !strcmp($firstChar,"'")) {
1561                                 $reg=explode($firstChar,$tag_tmp,3);
1562                                 $value[]=$reg[1];
1563                                 $tag_tmp=trim($reg[2]);
1564                         } elseif (!strcmp($firstChar,'=')) {
1565                                 $value[] = '=';
1566                                 $tag_tmp = trim(substr($tag_tmp,1));            // Removes = chars.
1567                         } else {
1568                                         // There are '' around the value. We look for the next ' ' or '>'
1569                                 $reg = split('[[:space:]=]',$tag_tmp,2);
1570                                 $value[] = trim($reg[0]);
1571                                 $tag_tmp = trim(substr($tag_tmp,strlen($reg[0]),1).$reg[1]);
1572                         }
1573                 }
1574                 if (is_array($value))   reset($value);
1575                 return $value;
1576         }
1577
1578         /**
1579          * Implodes attributes in the array $arr for an attribute list in eg. and HTML tag (with quotes)
1580          * Usage: 14
1581          *
1582          * @param       array           Array with attribute key/value pairs, eg. "bgcolor"=>"red", "border"=>0
1583          * @param       boolean         If set the resulting attribute list will have a) all attributes in lowercase (and duplicates weeded out, first entry taking precedence) and b) all values htmlspecialchar()'ed. It is recommended to use this switch!
1584          * @param       boolean         If true, don't check if values are blank. Default is to omit attributes with blank values.
1585          * @return      string          Imploded attributes, eg. 'bgcolor="red" border="0"'
1586          */
1587         function implodeAttributes($arr,$xhtmlSafe=FALSE,$dontOmitBlankAttribs=FALSE)   {
1588                 if (is_array($arr))     {
1589                         if ($xhtmlSafe) {
1590                                 $newArr=array();
1591                                 foreach($arr as $p => $v)       {
1592                                         if (!isset($newArr[strtolower($p)])) $newArr[strtolower($p)] = htmlspecialchars($v);
1593                                 }
1594                                 $arr = $newArr;
1595                         }
1596                         $list = array();
1597                         foreach($arr as $p => $v)       {
1598                                 if (strcmp($v,'') || $dontOmitBlankAttribs)     {$list[]=$p.'="'.$v.'"';}
1599                         }
1600                         return implode(' ',$list);
1601                 }
1602         }
1603
1604         /**
1605          * Implodes attributes in the array $arr for an attribute list in eg. and HTML tag (with quotes)
1606          *
1607          * @param       array           See implodeAttributes()
1608          * @param       boolean         See implodeAttributes()
1609          * @param       boolean         See implodeAttributes()
1610          * @return      string          See implodeAttributes()
1611          * @deprecated  Name was changed into implodeAttributes
1612          * @see implodeAttributes()
1613          */
1614         function implodeParams($arr,$xhtmlSafe=FALSE,$dontOmitBlankAttribs=FALSE)       {
1615                 return t3lib_div::implodeAttributes($arr,$xhtmlSafe,$dontOmitBlankAttribs);
1616         }
1617
1618         /**
1619          * Wraps JavaScript code XHTML ready with <script>-tags
1620          * Automatic re-identing of the JS code is done by using the first line as ident reference.
1621          * This is nice for identing JS code with PHP code on the same level.
1622          *
1623          * @param       string          JavaScript code
1624          * @param       boolean         Wrap script element in linebreaks? Default is TRUE.
1625          * @return      string          The wrapped JS code, ready to put into a XHTML page
1626          * @author      Ingmar Schlecht <ingmars@web.de>
1627          * @author      René Fritz <r.fritz@colorcube.de>
1628          */
1629         function wrapJS($string, $linebreak=TRUE) {
1630                 if(trim($string)) {
1631                                 // <script wrapped in nl?
1632                         $cr = $linebreak? "\n" : '';
1633
1634                                 // remove nl from the beginning
1635                         $string = preg_replace ('/^\n+/', '', $string);
1636                                 // re-ident to one tab using the first line as reference
1637                         if(preg_match('/^(\t+)/',$string,$match)) {
1638                                 $string = str_replace($match[1],"\t", $string);
1639                         }
1640                         $string = $cr.'<script type="text/javascript">
1641 /*<![CDATA[*/
1642 '.$string.'
1643 /*]]>*/
1644 </script>'.$cr;
1645                 }
1646                 return trim($string);
1647         }
1648
1649
1650         /**
1651          * Parses XML input into a PHP array with associative keys
1652          * Usage: 0
1653          *
1654          * @param       string          XML data input
1655          * @param       integer         Number of element levels to resolve the XML into an array. Any further structure will be set as XML.
1656          * @return      mixed           The array with the parsed structure unless the XML parser returns with an error in which case the error message string is returned.
1657          * @author bisqwit at iki dot fi dot not dot for dot ads dot invalid / http://dk.php.net/xml_parse_into_struct + kasper@typo3.com
1658          */
1659         function xml2tree($string,$depth=999) {
1660                 $parser = xml_parser_create();
1661                 $vals = array();
1662                 $index = array();
1663
1664                 xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
1665                 xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 0);
1666                 xml_parse_into_struct($parser, $string, $vals, $index);
1667
1668                 if (xml_get_error_code($parser))        return 'Line '.xml_get_current_line_number($parser).': '.xml_error_string(xml_get_error_code($parser));
1669                 xml_parser_free($parser);
1670
1671                 $stack = array( array() );
1672                 $stacktop = 0;
1673                 $startPoint=0;
1674
1675                 unset($tagi);
1676                 foreach($vals as $key => $val) {
1677                         $type = $val['type'];
1678
1679                                 // open tag:
1680                         if ($type=='open' || $type=='complete') {
1681                                 $stack[$stacktop++] = $tagi;
1682
1683                                 if ($depth==$stacktop)  {
1684                                         $startPoint=$key;
1685                                 }
1686
1687                                 $tagi = array('tag' => $val['tag']);
1688
1689                                 if(isset($val['attributes']))  $tagi['attrs'] = $val['attributes'];
1690                                 if(isset($val['value']))        $tagi['values'][] = $val['value'];
1691                         }
1692                                 // finish tag:
1693                         if ($type=='complete' || $type=='close')        {
1694                                 $oldtagi = $tagi;
1695                                 $tagi = $stack[--$stacktop];
1696                                 $oldtag = $oldtagi['tag'];
1697                                 unset($oldtagi['tag']);
1698
1699                                 if ($depth==($stacktop+1))      {
1700                                         if ($key-$startPoint > 0)       {
1701                                                 $partArray = array_slice(
1702                                                         $vals,
1703                                                         $startPoint+1,
1704                                                         $key-$startPoint-1
1705                                                 );
1706                                                 #$oldtagi=array('XMLvalue'=>t3lib_div::xmlRecompileFromStructValArray($partArray));
1707                                                 $oldtagi['XMLvalue']=t3lib_div::xmlRecompileFromStructValArray($partArray);
1708                                         } else {
1709                                                 $oldtagi['XMLvalue']=$oldtagi['values'][0];
1710                                         }
1711                                 }
1712
1713                                 $tagi['ch'][$oldtag][] = $oldtagi;
1714                                 unset($oldtagi);
1715                         }
1716                                 // cdata
1717                         if($type=='cdata') {
1718                                 $tagi['values'][] = $val['value'];
1719                         }
1720                 }
1721                 return $tagi['ch'];
1722         }
1723
1724         /**
1725          * Converts a PHP array into an XML string.
1726          * The XML output is optimized for readability since associative keys are used as tagnames.
1727          * This also means that only alphanumeric characters are allowed in the tag names AND only keys NOT starting with numbers (so watch your usage of keys!). However there are options you can set to avoid this problem.
1728          * Numeric keys are stored with the default tagname "numIndex" but can be overridden to other formats)
1729          * The function handles input values from the PHP array in a binary-safe way; All characters below 32 (except 9,10,13) will trigger the content to be converted to a base64-string
1730          * The PHP variable type of the data IS preserved as long as the types are strings, arrays, integers and booleans. Strings are the default type unless the "type" attribute is set.
1731          * The output XML has been tested with the PHP XML-parser and parses OK under all tested circumstances.
1732          * However using MSIE to read the XML output didn't always go well: One reason could be that the character encoding is not observed in the PHP data. The other reason may be if the tag-names are invalid in the eyes of MSIE. Also using the namespace feature will make MSIE break parsing. There might be more reasons...
1733          * Usage: 5
1734          *
1735          * @param       array           The input PHP array with any kind of data; text, binary, integers. Not objects though.
1736          * @param       string          tag-prefix, eg. a namespace prefix like "T3:"
1737          * @param       integer         Current recursion level. Don't change, stay at zero!
1738          * @param       string          Alternative document tag. Default is "phparray".
1739          * @param       integer         If set, the number of spaces corresponding to this number is used for indenting, otherwise a single chr(9) (TAB) is used
1740          * @param       array           Options for the compilation. Key "useNindex" => 0/1 (boolean: whether to use "n0, n1, n2" for num. indexes); Key "useIndexTagForNum" => "[tag for numerical indexes]"; Key "useIndexTagForAssoc" => "[tag for associative indexes"; Key "parentTagMap" => array('parentTag' => 'thisLevelTag')
1741          * @param       string          Parent tag name. Don't touch.
1742          * @return      string          An XML string made from the input content in the array.
1743          * @see xml2array()
1744          */
1745         function array2xml($array,$NSprefix='',$level=0,$docTag='phparray',$spaceInd=0, $options=array(),$parentTagName='')     {
1746                         // 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
1747                 $binaryChars = chr(0).chr(1).chr(2).chr(3).chr(4).chr(5).chr(6).chr(7).chr(8).
1748                                                 chr(11).chr(12).chr(14).chr(15).chr(16).chr(17).chr(18).chr(19).
1749                                                 chr(20).chr(21).chr(22).chr(23).chr(24).chr(25).chr(26).chr(27).chr(28).chr(29).
1750                                                 chr(30).chr(31);
1751                         // Set indenting mode:
1752                 $indentChar = $spaceInd ? ' ' : chr(9);
1753                 $indentN = $spaceInd>0 ? $spaceInd : 1;
1754
1755                         // Init output variable:
1756                 $output='';
1757
1758                         // Traverse the input array
1759                 foreach($array as $k=>$v)       {
1760                         $attr = '';
1761                         $tagName = $k;
1762
1763                                 // Construct the tag name.
1764                         if (!strcmp(intval($tagName),$tagName)) {       // If integer...;
1765                                 if ($options['useNindex']) {    // If numeric key, prefix "n"
1766                                         $tagName = 'n'.$tagName;
1767                                 } else {        // Use special tag for num. keys:
1768                                         $attr.=' index="'.$tagName.'"';
1769                                         $tagName = $options['useIndexTagForNum'] ? $options['useIndexTagForNum'] : 'numIndex';
1770                                 }
1771                         } elseif($options['useIndexTagForAssoc']) {             // Use tag for all associative keys:
1772                                 $attr.=' index="'.htmlspecialchars($tagName).'"';
1773                                 $tagName = $options['useIndexTagForAssoc'];
1774                         } elseif(isset($options['parentTagMap'][$parentTagName])) {             // Use tag based on parent tag name:
1775                                 $attr.=' index="'.htmlspecialchars($tagName).'"';
1776                                 $tagName = (string)$options['parentTagMap'][$parentTagName];
1777                         }
1778
1779                                 // The tag name is cleaned up so only alphanumeric chars (plus - and _) are in there and not longer than 100 chars either.
1780                         $tagName = substr(ereg_replace('[^[:alnum:]_-]','',$tagName),0,100);
1781
1782                                 // If the value is an array then we will call this function recursively:
1783                         if (is_array($v))       {
1784                                 // Sub elements:
1785                                 $content = chr(10).t3lib_div::array2xml($v,$NSprefix,$level+1,'',$spaceInd,$options,$tagName).
1786                                                         str_pad('',($level+1)*$indentN,$indentChar);
1787                                 $attr.=' type="array"';
1788                         } else {        // Just a value:
1789
1790                                         // Look for binary chars:
1791                                 if (strcspn($v,$binaryChars) != strlen($v))     {       // Go for base64 encoding if the initial segment NOT matching any binary char has the same length as the whole string!
1792                                                 // If the value contained binary chars then we base64-encode it an set an attribute to notify this situation:
1793                                         $content = chr(10).chunk_split(base64_encode($v));
1794                                         $attr.=' base64="1"';
1795                                 } else {
1796                                                 // Otherwise, just htmlspecialchar the stuff:
1797                                         $content = htmlspecialchars($v);
1798                                         $dType = gettype($v);
1799                                         if ($dType!='string')   { $attr.=' type="'.$dType.'"'; }
1800                                 }
1801                         }
1802
1803                                 // Add the element to the output string:
1804                         $output.=str_pad('',($level+1)*$indentN,$indentChar).'<'.$NSprefix.$tagName.$attr.'>'.$content.'</'.$NSprefix.$tagName.'>'.chr(10);
1805                 }
1806
1807                         // If we are at the outer-most level, then we finally wrap it all in the document tags and return that as the value:
1808                 if (!$level)    {
1809                         $output =
1810                                 '<'.$docTag.'>'.chr(10).
1811                                 $output.
1812                                 '</'.$docTag.'>';
1813                 }
1814
1815                 return $output;
1816         }
1817
1818         /**
1819          * Converts an XML string to a PHP array.
1820          * This is the reverse function of array2xml()
1821          * Usage: 17
1822          *
1823          * @param       string          XML content to convert into an array
1824          * @param       string          The tag-prefix resolve, eg. a namespace like "T3:"
1825          * @return      mixed           If the parsing had errors, a string with the error message is returned. Otherwise an array with the content.
1826          * @see array2xml()
1827          */
1828         function xml2array($string,$NSprefix='') {
1829
1830                         // Create parser:
1831                 $parser = xml_parser_create();
1832                 $vals = array();
1833                 $index = array();
1834
1835                 xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
1836                 xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 0);
1837                 xml_parse_into_struct($parser, $string, $vals, $index);
1838
1839                         // If error, return error message:
1840                 if (xml_get_error_code($parser))        return 'Line '.xml_get_current_line_number($parser).': '.xml_error_string(xml_get_error_code($parser));
1841                 xml_parser_free($parser);
1842
1843                         // Init vars:
1844                 $stack = array(array());
1845                 $stacktop = 0;
1846                 $current=array();
1847                 $tagName='';
1848
1849                         // Traverse the parsed XML structure:
1850                 foreach($vals as $key => $val) {
1851
1852                                 // First, process the tag-name (which is used in both cases, whether "complete" or "close")
1853                         $tagName = $val['tag'];
1854
1855                                 // Test for name space:
1856                         $tagName = ($NSprefix && substr($tagName,0,strlen($NSprefix))==$NSprefix) ? substr($tagName,strlen($NSprefix)) : $tagName;
1857
1858                                 // Test for numeric tag, encoded on the form "nXXX":
1859                         $testNtag = substr($tagName,1); // Closing tag.
1860                         $tagName = (substr($tagName,0,1)=='n' && !strcmp(intval($testNtag),$testNtag)) ? intval($testNtag) : $tagName;
1861
1862                                 // Test for alternative index value:
1863                         if (strlen($val['attributes']['index']))        { $tagName = $val['attributes']['index']; }
1864
1865                                 // Setting tag-values, manage stack:
1866                         switch($val['type'])    {
1867                                 case 'open':            // If open tag it means there is an array stored in sub-elements. Therefore increase the stackpointer and reset the accumulation array:
1868                                         $current[$tagName] = array();   // Setting blank place holder
1869                                         $stack[$stacktop++] = $current;
1870                                         $current = array();
1871                                 break;
1872                                 case 'close':   // If the tag is "close" then it is an array which is closing and we decrease the stack pointer.
1873                                         $oldCurrent = $current;
1874                                         $current = $stack[--$stacktop];
1875                                         end($current);  // Going to the end of array to get placeholder key, key($current), and fill in array next:
1876                                         $current[key($current)] = $oldCurrent;
1877                                         unset($oldCurrent);
1878                                 break;
1879                                 case 'complete':        // If "complete", then it's a value. If the attribute "base64" is set, then decode the value, otherwise just set it.
1880                                         if ($val['attributes']['base64'])       {
1881                                                 $current[$tagName] = base64_decode($val['value']);
1882                                         } else {
1883                                                 $current[$tagName] = (string)$val['value']; // Had to cast it as a string - otherwise it would be evaluate false if tested with isset()!!
1884
1885                                                         // Cast type:
1886                                                 switch((string)$val['attributes']['type'])      {
1887                                                         case 'integer':
1888                                                                 $current[$tagName] = (integer)$current[$tagName];
1889                                                         break;
1890                                                         case 'double':
1891                                                                 $current[$tagName] = (double)$current[$tagName];
1892                                                         break;
1893                                                         case 'boolean':
1894                                                                 $current[$tagName] = (bool)$current[$tagName];
1895                                                         break;
1896                                                         case 'array':
1897                                                                 $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...
1898                                                         break;
1899                                                 }
1900                                         }
1901                                 break;
1902                         }
1903                 }
1904
1905                         // Finally return the content of the document tag.
1906                 return $current[$tagName];
1907         }
1908
1909         /**
1910          * This implodes an array of XML parts (made with xml_parse_into_struct()) into XML again.
1911          * Usage: 2
1912          *
1913          * @param       array           A array of XML parts, see xml2tree
1914          * @return      string          Re-compiled XML data.
1915          */
1916         function xmlRecompileFromStructValArray($vals)  {
1917                 $XMLcontent='';
1918
1919                 foreach($vals as $val) {
1920                         $type = $val['type'];
1921
1922                                 // open tag:
1923                         if ($type=='open' || $type=='complete') {
1924                                 $XMLcontent.='<'.$val['tag'];
1925                                 if(isset($val['attributes']))  {
1926                                         foreach($val['attributes'] as $k => $v) {
1927                                                 $XMLcontent.=' '.$k.'="'.htmlspecialchars($v).'"';
1928                                         }
1929                                 }
1930                                 if ($type=='complete')  {
1931                                         if(isset($val['value']))        {
1932                                                 $XMLcontent.='>'.htmlspecialchars($val['value']).'</'.$val['tag'].'>';
1933                                         } else $XMLcontent.='/>';
1934                                 } else $XMLcontent.='>';
1935
1936                                 if ($type=='open' && isset($val['value']))      {
1937                                         $XMLcontent.=htmlspecialchars($val['value']);
1938                                 }
1939                         }
1940                                 // finish tag:
1941                         if ($type=='close')     {
1942                                 $XMLcontent.='</'.$val['tag'].'>';
1943                         }
1944                                 // cdata
1945                         if($type=='cdata') {
1946                                 $XMLcontent.=htmlspecialchars($val['value']);
1947                         }
1948                 }
1949
1950                 return $XMLcontent;
1951         }
1952
1953         /**
1954          * Extract the encoding scheme as found in the first line of an XML document (typically)
1955          * Usage: 1
1956          *
1957          * @param       string          XML data
1958          * @return      string          Encoding scheme (lowercase), if found.
1959          */
1960         function xmlGetHeaderAttribs($xmlData)  {
1961                 $xmlHeader = substr(trim($xmlData),0,200);
1962                 $reg=array();
1963                 if (eregi('^<\?xml([^>]*)\?\>',$xmlHeader,$reg))        {
1964                         return t3lib_div::get_tag_attributes($reg[1]);
1965                 }
1966         }
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978         /*************************
1979          *
1980          * FILES FUNCTIONS
1981          *
1982          *************************/
1983
1984         /**
1985          * Reads the file or url $url and returns the content
1986          * If you are having trouble with proxys when reading URLs you can configure your way out of that with settings like $TYPO3_CONF_VARS['SYS']['curlUse'] etc.
1987          * Usage: 83
1988          *
1989          * @param       string          Filepath/URL to read
1990          * @return      string          The content from the resource given as input.
1991          */
1992         function getURL($url)   {
1993                 $content = '';
1994
1995                         // (Proxy support implemented by Arco <arco@appeltaart.mine.nu>)
1996                 if((substr($url,0,7)=='http://') && ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlUse']=='1'))       {
1997                         //external URL without error checking.
1998                         $ch = curl_init();
1999                         curl_setopt ($ch,CURLOPT_URL, $url);
2000                         curl_setopt ($ch,CURLOPT_HEADER, 0);
2001                         curl_setopt ($ch,CURLOPT_RETURNTRANSFER, 1);
2002
2003                         if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyServer']) {
2004                                 curl_setopt ($ch, CURLOPT_PROXY, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyServer']);
2005
2006                                 // I don't know if it will be needed
2007                                 if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyTunnel']) {
2008                                         curl_setopt ($ch, CURLOPT_HTTPPROXYTUNNEL, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyTunnel'] );
2009                                 }
2010                                 if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyUserPass']) {
2011                                         curl_setopt ($ch, CURLOPT_PROXYUSERPWD, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyUserPass'] );
2012                                 }
2013                         }
2014                         $content=curl_exec ($ch);
2015                         curl_close ($ch);
2016                         return $content;
2017                 } elseif($fd = fopen($url,'rb'))    {
2018                         while (!feof($fd))      {
2019                                 $content.=fread($fd, 5000);
2020                         }
2021                         fclose($fd);
2022                         return $content;
2023                 }
2024         }
2025
2026         /**
2027          * Writes $content to the file $file
2028          * Usage: 30
2029          *
2030          * @param       string          Filepath to write to
2031          * @param       string          Content to write
2032          * @return      boolean         True if the file was successfully opened and written to.
2033          */
2034         function writeFile($file,$content)      {
2035                 if($fd = fopen($file,'wb'))     {
2036                         fwrite( $fd, $content);
2037                         fclose( $fd );
2038
2039                                 // Setting file system mode & group ownership of file:
2040                         if (@is_file($file) && TYPO3_OS!='WIN') {
2041                                 @chmod($file, octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['fileCreateMask']));             // "@" is there because file is not necessarily OWNED by the user
2042                                 if($GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup'])    {       // skip this if createGroup is empty
2043                                         @chgrp($file, $GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup']);                // "@" is there because file is not necessarily OWNED by the user
2044                                 }
2045                         }
2046
2047                         return true;
2048                 }
2049         }
2050
2051         /**
2052          * Writes $content to a filename in the typo3temp/ folder (and possibly a subfolder...)
2053          * Accepts an additional subdirectory in the file path!
2054          *
2055          * @param       string          Absolute filepath to write to inside "typo3temp/". First part of this string must match PATH_site."typo3temp/"
2056          * @param       string          Content string to write
2057          * @return      string          Returns false on success, otherwise an error string telling about the problem.
2058          */
2059         function writeFileToTypo3tempDir($filepath,$content)    {
2060
2061                         // Parse filepath into directory and basename:
2062                 $fI = pathinfo($filepath);
2063                 $fI['dirname'].= '/';
2064
2065                         // Check parts:
2066                 if (t3lib_div::validPathStr($filepath) && $fI['basename'] && strlen($fI['basename'])<60)        {
2067                         if (defined('PATH_site'))       {
2068                                 $dirName = PATH_site.'typo3temp/';      // Setting main temporary directory name (standard)
2069                                 if (@is_dir($dirName))  {
2070                                         if (t3lib_div::isFirstPartOfStr($fI['dirname'],$dirName))       {
2071
2072                                                         // Checking if the "subdir" is found:
2073                                                 $subdir = substr($fI['dirname'],strlen($dirName));
2074                                                 if ($subdir)    {
2075                                                         if (ereg('^[[:alnum:]_]+\/$',$subdir))  {
2076                                                                 $dirName.= $subdir;
2077                                                                 if (!@is_dir($dirName)) {
2078                                                                         t3lib_div::mkdir($dirName);
2079                                                                 }
2080                                                         } else return 'Subdir, "'.$subdir.'", was NOT on the form "[a-z]/"';
2081                                                 }
2082                                                         // Checking dir-name again (sub-dir might have been created):
2083                                                 if (@is_dir($dirName))  {
2084                                                         if ($filepath == $dirName.$fI['basename'])      {
2085                                                                 t3lib_div::writeFile($filepath, $content);
2086                                                                 if (!@is_file($filepath))       return 'File not written to disk! Write permission error in filesystem?';
2087                                                         } else return 'Calculated filelocation didn\'t match input $filepath!';
2088                                                 } else return '"'.$dirName.'" is not a directory!';
2089                                         } else return '"'.$fI['dirname'].'" was not within directory PATH_site + "typo3temp/"';
2090                                 } else return 'PATH_site + "typo3temp/" was not a directory!';
2091                         } else return 'PATH_site constant was NOT defined!';
2092                 } else return 'Input filepath "'.$filepath.'" was generally invalid!';
2093         }
2094
2095         /**
2096          * Wrapper function for mkdir, setting folder permissions according to $GLOBALS['TYPO3_CONF_VARS']['BE']['folderCreateMask'] and group ownership according to $GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup']
2097          * Usage: 6
2098          *
2099          * @param       string          Absolute path to folder, see PHP mkdir() function. Removes trailing slash internally.
2100          * @return      boolean         TRUE if @mkdir went well!
2101          */
2102         function mkdir($theNewFolder)   {
2103                 $theNewFolder = ereg_replace('\/$','',$theNewFolder);
2104                 if (mkdir($theNewFolder, octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['folderCreateMask']))){
2105                         chmod($theNewFolder, octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['folderCreateMask'])); //added this line, because the mode at 'mkdir' has a strange behaviour sometimes
2106
2107                         if($GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup'])    {       // skip this if createGroup is empty
2108                                 chgrp($theNewFolder, $GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup']);
2109                         }
2110                         return TRUE;
2111                 }
2112         }
2113
2114         /**
2115          * Returns an array with the names of folders in a specific path
2116          * Will return 'error' (string) if there were an error with reading directory content.
2117          * Usage: 11
2118          *
2119          * @param       string          Path to list directories from
2120          * @return      array           Returns an array with the directory entries as values. If no path, the return value is nothing.
2121          */
2122         function get_dirs($path)        {
2123                 if ($path)      {
2124                         $d = @dir($path);
2125                         if (is_object($d))      {
2126                                 while($entry=$d->read()) {
2127                                         if (@is_dir($path.'/'.$entry) && $entry!= '..' && $entry!= '.') {
2128                                             $filearray[]=$entry;
2129                                         }
2130                                 }
2131                                 $d->close();
2132                         } else return 'error';
2133                         return $filearray;
2134                 }
2135         }
2136
2137         /**
2138          * Returns an array with the names of files in a specific path
2139          * Usage: 18
2140          *
2141          * @param       string          $path: Is the path to the file
2142          * @param       string          $extensionList is the comma list of extensions to read only (blank = all)
2143          * @param       boolean         If set, then the path is prepended the filenames. Otherwise only the filenames are returned in the array
2144          * @param       string          $order is sorting: 1= sort alphabetically, 'mtime' = sort by modification time.
2145          * @return      array           Array of the files found
2146          */
2147         function getFilesInDir($path,$extensionList='',$prependPath=0,$order='')        {
2148
2149                         // Initialize variabels:
2150                 $filearray = array();
2151                 $sortarray = array();
2152                 $path = ereg_replace('\/$','',$path);
2153
2154                         // Find files+directories:
2155                 if (@is_dir($path))     {
2156                         $extensionList = strtolower($extensionList);
2157                         $d = dir($path);
2158                         if (is_object($d))      {
2159                                 while($entry=$d->read()) {
2160                                         if (@is_file($path.'/'.$entry)) {
2161                                                 $fI = pathinfo($entry);
2162                                                 $key = md5($path.'/'.$entry);
2163                                                 if (!$extensionList || t3lib_div::inList($extensionList,strtolower($fI['extension'])))  {
2164                                                     $filearray[$key]=($prependPath?$path.'/':'').$entry;
2165                                                         if ($order=='mtime') {$sortarray[$key]=filemtime($path.'/'.$entry);}
2166                                                                 elseif ($order) {$sortarray[$key]=$entry;}
2167                                                 }
2168                                         }
2169                                 }
2170                                 $d->close();
2171                         } else return 'error opening path: "'.$path.'"';
2172                 }
2173
2174                         // Sort them:
2175                 if ($order) {
2176                         asort($sortarray);
2177                         reset($sortarray);
2178                         $newArr=array();
2179                         while(list($k,$v)=each($sortarray))     {
2180                                 $newArr[$k]=$filearray[$k];
2181                         }
2182                         $filearray=$newArr;
2183                 }
2184
2185                         // Return result
2186                 reset($filearray);
2187                 return $filearray;
2188         }
2189
2190         /**
2191          * Recursively gather all files and folders of a path.
2192          * Usage: 5
2193          *
2194          * @param       array           $fileArr: Empty input array (will have files added to it)
2195          * @param       string          $path: The path to read recursively from (absolute) (include trailing slash!)
2196          * @param       string          $extList: Comma list of file extensions: Only files with extensions in this list (if applicable) will be selected.
2197          * @param       boolean         $regDirs: If set, directories are also included in output.
2198          * @param       integer         $recursivityLevels: The number of levels to dig down...
2199          * @return      array           An array with the found files/directories.
2200          */
2201         function getAllFilesAndFoldersInPath($fileArr,$path,$extList='',$regDirs=0,$recursivityLevels=99)       {
2202                 if ($regDirs)   $fileArr[] = $path;
2203                 $fileArr = array_merge($fileArr, t3lib_div::getFilesInDir($path,$extList,1,1));
2204
2205                 $dirs = t3lib_div::get_dirs($path);
2206                 if (is_array($dirs) && $recursivityLevels>0)    {
2207                         foreach ($dirs as $subdirs)     {
2208                                 if ((string)$subdirs!='')       {
2209                                         $fileArr = t3lib_div::getAllFilesAndFoldersInPath($fileArr,$path.$subdirs.'/',$extList,$regDirs,$recursivityLevels-1);
2210                                 }
2211                         }
2212                 }
2213                 return $fileArr;
2214         }
2215
2216         /**
2217          * Removes the absolute part of all files/folders in fileArr
2218          * Usage: 2
2219          *
2220          * @param       array           $fileArr: The file array to remove the prefix from
2221          * @param       string          $prefixToRemove: The prefix path to remove (if found as first part of string!)
2222          * @return      array           The input $fileArr processed.
2223          */
2224         function removePrefixPathFromList($fileArr,$prefixToRemove)     {
2225                 foreach($fileArr as $k => $absFileRef)  {
2226                         if(t3lib_div::isFirstPartOfStr($absFileRef,$prefixToRemove))    {
2227                                 $fileArr[$k] = substr($absFileRef,strlen($prefixToRemove));
2228                         } else return 'ERROR: One or more of the files was NOT prefixed with the prefix-path!';
2229                 }
2230                 return $fileArr;
2231         }
2232
2233         /**
2234          * Fixes a path for windows-backslashes and reduces double-slashes to single slashes
2235          * Usage: 2
2236          *
2237          * @param       string          File path to process
2238          * @return      string
2239          */
2240         function fixWindowsFilePath($theFile)   {
2241                 return str_replace('//','/', str_replace('\\','/', $theFile));
2242         }
2243
2244         /**
2245          * Resolves "../" sections in the input path string.
2246          * For example "fileadmin/directory/../other_directory/" will be resolved to "fileadmin/other_directory/"
2247          * Usage: 2
2248          *
2249          * @param       string          File path in which "/../" is resolved
2250          * @return      string
2251          */
2252         function resolveBackPath($pathStr)      {
2253                 $parts = explode('/',$pathStr);
2254                 $output=array();
2255                 foreach($parts as $pV)  {
2256                         if ($pV=='..')  {
2257                                 if ($c) {
2258                                         array_pop($output);
2259                                         $c--;
2260                                 } else $output[]=$pV;
2261                         } else {
2262                                 $c++;
2263                                 $output[]=$pV;
2264                         }
2265                 }
2266                 return implode('/',$output);
2267         }
2268
2269         /**
2270          * Prefixes a URL used with 'header-location' with 'http://...' depending on whether it has it already.
2271          * - If already having a scheme, nothing is prepended
2272          * - If having REQUEST_URI slash '/', then prefixing 'http://[host]' (relative to host)
2273          * - Otherwise prefixed with TYPO3_REQUEST_DIR (relative to current dir / TYPO3_REQUEST_DIR)
2274          * Usage: 30
2275          *
2276          * @param       string          URL / path to prepend full URL addressing to.
2277          * @return      string
2278          */
2279         function locationHeaderUrl($path)       {
2280                 $uI = parse_url($path);
2281                 if (substr($path,0,1)=='/')     { // relative to HOST
2282                         $path = t3lib_div::getIndpEnv('TYPO3_REQUEST_HOST').$path;
2283                 } elseif (!$uI['scheme'])       { // No scheme either
2284                         $path = t3lib_div::getIndpEnv('TYPO3_REQUEST_DIR').$path;
2285                 }
2286                 return $path;
2287         }
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304         /*************************
2305          *
2306          * DEBUG helper FUNCTIONS
2307          *
2308          *************************/
2309
2310         /**
2311          * Returns a string with a list of ascii-values for the first $characters characters in $string
2312          * Usage: 0
2313          *
2314          * @param       string          String to show ASCII value for
2315          * @param       integer         Number of characters to show
2316          * @return      string          The string with ASCII values in separated by a space char.
2317          * @internal
2318          */
2319         function debug_ordvalue($string,$characters=100)        {
2320                 if(strlen($string) < $characters)       $characters = strlen($string);
2321                 for ($i=0; $i<$characters; $i++)        {
2322                         $valuestring.=' '.ord(substr($string,$i,1));
2323                 }
2324                 return trim($valuestring);
2325         }
2326
2327         /**
2328          * Returns HTML-code, which is a visual representation of a multidimensional array
2329          * use t3lib_div::print_array() in order to print an array
2330          * Returns false if $array_in is not an array
2331          * Usage: 31
2332          *
2333          * @param       array           Array to view
2334          * @return      string          HTML output
2335          */
2336         function view_array($array_in)  {
2337                 if (is_array($array_in))        {
2338                         $result='<table border="1" cellpadding="1" cellspacing="0" bgcolor="white">';
2339                         if (!count($array_in))  {$result.= '<tr><td><font face="Verdana,Arial" size="1"><b>'.htmlspecialchars("EMPTY!").'</b></font></td></tr>';}
2340                         while (list($key,$val)=each($array_in)) {
2341                                 $result.= '<tr><td><font face="Verdana,Arial" size="1">'.htmlspecialchars((string)$key).'</font></td><td>';
2342                                 if (is_array($array_in[$key]))  {
2343                                         $result.=t3lib_div::view_array($array_in[$key]);
2344                                 } else
2345                                         $result.= '<font face="Verdana,Arial" size="1" color="red">'.nl2br(htmlspecialchars((string)$val)).'<br /></font>';
2346                                 $result.= '</td></tr>';
2347                         }
2348                         $result.= '</table>';
2349                 } else  {
2350                         $result  = false;
2351                 }
2352                 return $result;
2353         }
2354
2355         /**
2356          * Prints an array
2357          * Usage: 6
2358          *
2359          * @param       array           Array to print visually (in a table).
2360          * @return      void
2361          * @internal
2362          * @see view_array()
2363          */
2364         function print_array($array_in) {
2365                 echo t3lib_div::view_array($array_in);
2366         }
2367
2368         /**
2369          * Makes debug output
2370          * Prints $var in bold between two vertical lines
2371          * If not $var the word 'debug' is printed
2372          * If $var is an array, the array is printed by t3lib_div::print_array()
2373          * Usage: 8
2374          *
2375          * @param       mixed           Variable to print
2376          * @param       mixed           If the parameter is a string it will be used as header. Otherwise number of break tags to apply after (positive integer) or before (negative integer) the output.
2377          * @return      void
2378          */
2379         function debug($var="",$brOrHeader=0)   {
2380                 if ($brOrHeader && !t3lib_div::testInt($brOrHeader)) {
2381                         echo '<table border="0" cellpadding="0" cellspacing="0" bgcolor="white" style="border:0px; margin-top:3px; margin-bottom:3px;"><tr><td style="background-color:#bbbbbb; font-family: verdana,arial; font-weight: bold; font-size: 10px;">'.htmlspecialchars((string)$brOrHeader).'</td></tr><td>';
2382                 } elseif ($brOrHeader<0) {
2383                         for($a=0;$a<abs(intval($brOrHeader));$a++){echo '<br />';}
2384                 }
2385
2386                 if (is_array($var))     {
2387                         t3lib_div::print_array($var);
2388                 } elseif (is_object($var))      {
2389                         echo '<b>|Object:<pre>';
2390                         print_r($var);
2391                         echo '</pre>|</b>';
2392                 } elseif ((string)$var!='') {
2393                         echo '<b>|'.htmlspecialchars((string)$var).'|</b>';
2394                 } else {
2395                         echo '<b>| debug |</b>';
2396                 }
2397
2398                 if ($brOrHeader && !t3lib_div::testInt($brOrHeader)) {
2399                         echo '</td></tr></table>';
2400                 } elseif ($brOrHeader>0) {
2401                         for($a=0;$a<intval($brOrHeader);$a++){echo '<br />';}
2402                 }
2403         }
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436         /*************************
2437          *
2438          * SYSTEM INFORMATION
2439          *
2440          *************************/
2441
2442         /**
2443          * Returns the HOST+DIR-PATH of the current script (The URL, but without 'http://' and without script-filename)
2444          * Usage: 1
2445          *
2446          * @return      string
2447          */
2448         function getThisUrl()   {
2449                 $p=parse_url(t3lib_div::getIndpEnv('TYPO3_REQUEST_SCRIPT'));            // Url of this script
2450                 $dir=t3lib_div::dirname($p['path']).'/';        // Strip file
2451                 $url = str_replace('//','/',$p['host'].($p['port']?':'.$p['port']:'').$dir);
2452                 return $url;
2453         }
2454
2455         /**
2456          * Returns the link-url to the current script.
2457          * In $getParams you can set associative keys corresponding to the GET-vars you wish to add to the URL. If you set them empty, they will remove existing GET-vars from the current URL.
2458          * REMEMBER to always htmlspecialchar() content in href-properties to ampersands get converted to entities (XHTML requirement and XSS precaution)
2459          * Usage: 52
2460          *
2461          * @param       array           Array of GET parameters to include
2462          * @return      string
2463          */
2464         function linkThisScript($getParams=array())     {
2465                 $parts = t3lib_div::getIndpEnv('SCRIPT_NAME');
2466                 $params = t3lib_div::_GET();
2467
2468                 foreach($getParams as $k => $v) {
2469                         if (strcmp($v,''))      {
2470                                 $params[$k]=$v;
2471                         } else unset($params[$k]);
2472                 }
2473
2474                 $pString = t3lib_div::implodeArrayForUrl('',$params);
2475
2476                 return $pString ? $parts.'?'.ereg_replace('^&','',$pString) : $parts;
2477         }
2478
2479         /**
2480          * Takes a full URL, $url, possibly with a querystring and overlays the $getParams arrays values onto the quirystring, packs it all together and returns the URL again.
2481          * So basically it adds the parameters in $getParams to an existing URL, $url
2482          * Usage: 2
2483          *
2484          * @param       string          URL string
2485          * @param       array           Array of key/value pairs for get parameters to add/overrule with. Can be multidimensional.
2486          * @return      string          Output URL with added getParams.
2487          */
2488         function linkThisUrl($url,$getParams=array())   {
2489                 $parts = parse_url($url);
2490                 if ($parts['query'])    {
2491                         parse_str($parts['query'],$getP);
2492                 } else {
2493                         $getP = array();
2494                 }
2495
2496                 $getP = t3lib_div::array_merge_recursive_overrule($getP,$getParams);
2497                 $uP = explode('?',$url);
2498
2499                 $params = t3lib_div::implodeArrayForUrl('',$getP);
2500                 $outurl = $uP[0].($params ? '?'.substr($params, 1) : '');
2501
2502                 return $outurl;
2503         }
2504
2505         /**
2506          * Abstraction method which returns System Environment Variables regardless of server OS, CGI/MODULE version etc. Basically this is SERVER variables for most of them.
2507          * This should be used instead of getEnv() and HTTP_SERVER_VARS/ENV_VARS to get reliable values for all situations.
2508          * Usage: 221
2509          *
2510          * @param       string          Name of the "environment variable"/"server variable" you wish to use. Valid values are SCRIPT_NAME, SCRIPT_FILENAME, REQUEST_URI, PATH_INFO, REMOTE_ADDR, REMOTE_HOST, HTTP_REFERER, HTTP_HOST, HTTP_USER_AGENT, HTTP_ACCEPT_LANGUAGE, QUERY_STRING, TYPO3_DOCUMENT_ROOT, TYPO3_HOST_ONLY, TYPO3_HOST_ONLY, TYPO3_REQUEST_HOST, TYPO3_REQUEST_URL, TYPO3_REQUEST_SCRIPT, TYPO3_REQUEST_DIR, TYPO3_SITE_URL, _ARRAY
2511          * @return      string          Value based on the input key, independent of server/os environment.
2512          */
2513         function getIndpEnv($getEnvName)        {
2514                 global $HTTP_SERVER_VARS;
2515                 /*
2516                         Conventions:
2517                         output from parse_url():
2518                         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
2519                             [scheme] => 'http'
2520                             [user] => 'username'
2521                             [pass] => 'password'
2522                             [host] => '192.168.1.4'
2523                                 [port] => '8080'
2524                             [path] => '/typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/'
2525                             [query] => 'arg1,arg2,arg3&p1=parameter1&p2[key]=value'
2526                             [fragment] => 'link1'
2527
2528                                 Further definition: [path_script] = '/typo3/32/temp/phpcheck/index.php'
2529                                                                         [path_dir] = '/typo3/32/temp/phpcheck/'
2530                                                                         [path_info] = '/arg1/arg2/arg3/'
2531                                                                         [path] = [path_script/path_dir][path_info]
2532
2533
2534                         Keys supported:
2535
2536                         URI______:
2537                                 REQUEST_URI             =       [path]?[query]          = /typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/?arg1,arg2,arg3&p1=parameter1&p2[key]=value
2538                                 HTTP_HOST               =       [host][:[port]]         = 192.168.1.4:8080
2539                                 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')!
2540                                 PATH_INFO               =       [path_info]                     = /arg1/arg2/arg3/
2541                                 QUERY_STRING    =       [query]                         = arg1,arg2,arg3&p1=parameter1&p2[key]=value
2542                                 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
2543                                                                                 (Notice: NO username/password + NO fragment)
2544
2545                         CLIENT____:
2546                                 REMOTE_ADDR             =       (client IP)
2547                                 REMOTE_HOST             =       (client host)
2548                                 HTTP_USER_AGENT =       (client user agent)
2549                                 HTTP_ACCEPT_LANGUAGE    = (client accept language)
2550
2551                         SERVER____:
2552                                 SCRIPT_FILENAME =       Absolute filename of script             (Differs between windows/unix). On windows 'C:\\blabla\\blabl\\' will be converted to 'C:/blabla/blabl/'
2553
2554                         Special extras:
2555                                 TYPO3_HOST_ONLY =               [host]                  = 192.168.1.4
2556                                 TYPO3_PORT              =               [port]                  = 8080 (blank if 80, taken from host value)
2557                                 TYPO3_REQUEST_HOST =    [scheme]://[host][:[port]]
2558                                 TYPO3_REQUEST_URL =             [scheme]://[host][:[port]][path]?[query]        (sheme will by default be 'http' until we can detect if it's https -
2559                                 TYPO3_REQUEST_SCRIPT =  [scheme]://[host][:[port]][path_script]
2560                                 TYPO3_REQUEST_DIR =             [scheme]://[host][:[port]][path_dir]
2561                                 TYPO3_SITE_URL =                [scheme]://[host][:[port]][path_dir] of the TYPO3 website frontend
2562                                 TYPO3_SITE_SCRIPT =     [script / Speaking URL] of the TYPO3 website
2563                                 TYPO3_DOCUMENT_ROOT     =       Absolute path of root of documents:     TYPO3_DOCUMENT_ROOT.SCRIPT_NAME = SCRIPT_FILENAME (typically)
2564
2565                         Notice: [fragment] is apparently NEVER available to the script!
2566
2567
2568                         Testing suggestions:
2569                         - Output all the values.
2570                         - 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
2571                         - ALSO TRY the script from the ROOT of a site (like 'http://www.mytest.com/' and not 'http://www.mytest.com/test/' !!)
2572
2573                 */
2574
2575 #               if ($getEnvName=='HTTP_REFERER')        return '';
2576                 switch((string)$getEnvName)     {
2577                         case 'SCRIPT_NAME':
2578                                 return (php_sapi_name()=='cgi'||php_sapi_name()=='cgi-fcgi')&&($HTTP_SERVER_VARS['ORIG_PATH_INFO']?$HTTP_SERVER_VARS['ORIG_PATH_INFO']:$HTTP_SERVER_VARS['PATH_INFO']) ? ($HTTP_SERVER_VARS['ORIG_PATH_INFO']?$HTTP_SERVER_VARS['ORIG_PATH_INFO']:$HTTP_SERVER_VARS['PATH_INFO']) : ($HTTP_SERVER_VARS['ORIG_SCRIPT_NAME']?$HTTP_SERVER_VARS['ORIG_SCRIPT_NAME']:$HTTP_SERVER_VARS['SCRIPT_NAME']);
2579                         break;
2580                         case 'SCRIPT_FILENAME':
2581                                 return str_replace('//','/', str_replace('\\','/', (php_sapi_name()=='cgi'||php_sapi_name()=='isapi' ||php_sapi_name()=='cgi-fcgi')&&($HTTP_SERVER_VARS['ORIG_PATH_TRANSLATED']?$HTTP_SERVER_VARS['ORIG_PATH_TRANSLATED']:$HTTP_SERVER_VARS['PATH_TRANSLATED'])? ($HTTP_SERVER_VARS['ORIG_PATH_TRANSLATED']?$HTTP_SERVER_VARS['ORIG_PATH_TRANSLATED']:$HTTP_SERVER_VARS['PATH_TRANSLATED']):($HTTP_SERVER_VARS['ORIG_SCRIPT_FILENAME']?$HTTP_SERVER_VARS['ORIG_SCRIPT_FILENAME']:$HTTP_SERVER_VARS['SCRIPT_FILENAME'])));
2582                         break;
2583                         case 'REQUEST_URI':
2584                                 // Typical application of REQUEST_URI is return urls, forms submitting to itselt etc. Eg:       returnUrl='.rawurlencode(t3lib_div::getIndpEnv('REQUEST_URI'))
2585                                 if (!$HTTP_SERVER_VARS['REQUEST_URI'])  {       // This is for ISS/CGI which does not have the REQUEST_URI available.
2586                                         return '/'.ereg_replace('^/','',t3lib_div::getIndpEnv('SCRIPT_NAME')).
2587                                                 ($HTTP_SERVER_VARS['QUERY_STRING']?'?'.$HTTP_SERVER_VARS['QUERY_STRING']:'');
2588                                 } else return $HTTP_SERVER_VARS['REQUEST_URI'];
2589                         break;
2590                         case 'PATH_INFO':
2591                                         // $HTTP_SERVER_VARS['PATH_INFO']!=$HTTP_SERVER_VARS['SCRIPT_NAME'] is necessary because some servers (Windows/CGI) are seen to set PATH_INFO equal to script_name
2592                                         // Further, there must be at least one '/' in the path - else the PATH_INFO value does not make sense.
2593                                         // IF 'PATH_INFO' never works for our purpose in TYPO3 with CGI-servers, then 'php_sapi_name()=='cgi'' might be a better check. Right now strcmp($HTTP_SERVER_VARS['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_name()=='cgi' (see above)
2594 //                              if (strcmp($HTTP_SERVER_VARS['PATH_INFO'],t3lib_div::getIndpEnv('SCRIPT_NAME')) && count(explode('/',$HTTP_SERVER_VARS['PATH_INFO']))>1)        {
2595                                 if (php_sapi_name()!='cgi'&&php_sapi_name()!='cgi-fcgi')        {
2596                                         return $HTTP_SERVER_VARS['PATH_INFO'];
2597                                 } else return '';
2598                         break;
2599                                 // These are let through without modification
2600                         case 'REMOTE_ADDR':
2601                         case 'REMOTE_HOST':
2602                         case 'HTTP_REFERER':
2603                         case 'HTTP_HOST':
2604                         case 'HTTP_USER_AGENT':
2605                         case 'HTTP_ACCEPT_LANGUAGE':
2606                         case 'QUERY_STRING':
2607                                 return $HTTP_SERVER_VARS[$getEnvName];
2608                         break;
2609                         case 'TYPO3_DOCUMENT_ROOT':
2610                                 // 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.
2611                                 // Therefore the DOCUMENT_ROOT is now always calculated as the SCRIPT_FILENAME minus the end part shared with SCRIPT_NAME.
2612                                 $SFN = t3lib_div::getIndpEnv('SCRIPT_FILENAME');
2613                                 $SN_A = explode('/',strrev(t3lib_div::getIndpEnv('SCRIPT_NAME')));
2614                                 $SFN_A = explode('/',strrev($SFN));
2615                                 $acc = array();
2616                                 while(list($kk,$vv)=each($SN_A))        {
2617                                         if (!strcmp($SFN_A[$kk],$vv))   {
2618                                                 $acc[] = $vv;
2619                                         } else break;
2620                                 }
2621                                 $commonEnd=strrev(implode('/',$acc));
2622                                 if (strcmp($commonEnd,''))              $DR = substr($SFN,0,-(strlen($commonEnd)+1));
2623                                 return $DR;
2624                         break;
2625                         case 'TYPO3_HOST_ONLY':
2626                                 $p = explode(':',$HTTP_SERVER_VARS['HTTP_HOST']);
2627                                 return $p[0];
2628                         break;
2629                         case 'TYPO3_PORT':
2630                                 $p = explode(':',$HTTP_SERVER_VARS['HTTP_HOST']);
2631                                 return $p[1];
2632                         break;
2633                         case 'TYPO3_REQUEST_HOST':
2634                                 return (t3lib_div::getIndpEnv('TYPO3_SSL') ? 'https://' : 'http://').
2635                                         $HTTP_SERVER_VARS['HTTP_HOST'];
2636                         break;
2637                         case 'TYPO3_REQUEST_URL':
2638                                 return t3lib_div::getIndpEnv('TYPO3_REQUEST_HOST').t3lib_div::getIndpEnv('REQUEST_URI');
2639                         break;
2640                         case 'TYPO3_REQUEST_SCRIPT':
2641                                 return t3lib_div::getIndpEnv('TYPO3_REQUEST_HOST').t3lib_div::getIndpEnv('SCRIPT_NAME');
2642                         break;
2643                         case 'TYPO3_REQUEST_DIR':
2644                                 return t3lib_div::getIndpEnv('TYPO3_REQUEST_HOST').t3lib_div::dirname(t3lib_div::getIndpEnv('SCRIPT_NAME')).'/';
2645                         break;
2646                         case 'TYPO3_SITE_URL':
2647                                 if (defined('PATH_thisScript') && defined('PATH_site')) {
2648                                         $lPath = substr(dirname(PATH_thisScript),strlen(PATH_site)).'/';
2649                                         $url = t3lib_div::getIndpEnv('TYPO3_REQUEST_DIR');
2650                                         $siteUrl = substr($url,0,-strlen($lPath));
2651                                         if (substr($siteUrl,-1)!='/')   $siteUrl.='/';
2652                                         return $siteUrl;
2653                                 } else return '';
2654                         break;
2655                         case 'TYPO3_SITE_SCRIPT':
2656                                 return substr(t3lib_div::getIndpEnv('TYPO3_REQUEST_URL'),strlen(t3lib_div::getIndpEnv('TYPO3_SITE_URL')));
2657                         break;
2658                         case 'TYPO3_SSL':
2659                                 return $HTTP_SERVER_VARS['SSL_SESSION_ID'] || !strcmp($HTTP_SERVER_VARS['HTTPS'],'on') ? TRUE : FALSE;
2660                         break;
2661                         case '_ARRAY':
2662                                 $out = array();
2663                                         // Here, list ALL possible keys to this function for debug display.
2664                                 $envTestVars = t3lib_div::trimExplode(',','
2665                                         HTTP_HOST,
2666                                         TYPO3_HOST_ONLY,
2667                                         TYPO3_PORT,
2668                                         PATH_INFO,
2669                                         QUERY_STRING,
2670                                         REQUEST_URI,
2671                                         HTTP_REFERER,
2672                                         TYPO3_REQUEST_HOST,
2673                                         TYPO3_REQUEST_URL,
2674                                         TYPO3_REQUEST_SCRIPT,
2675                                         TYPO3_REQUEST_DIR,
2676                                         TYPO3_SITE_URL,
2677                                         TYPO3_SITE_SCRIPT,
2678                                         TYPO3_SSL,
2679                                         SCRIPT_NAME,
2680                                         TYPO3_DOCUMENT_ROOT,
2681                                         SCRIPT_FILENAME,
2682                                         REMOTE_ADDR,
2683                                         REMOTE_HOST,
2684                                         HTTP_USER_AGENT,
2685                                         HTTP_ACCEPT_LANGUAGE',1);
2686                                 reset($envTestVars);
2687                                 while(list(,$v)=each($envTestVars))     {
2688                                         $out[$v]=t3lib_div::getIndpEnv($v);
2689                                 }
2690                                 reset($out);
2691                                 return $out;
2692                         break;
2693                 }
2694         }
2695
2696         /**
2697          * milliseconds
2698          * microtime recalculated to t3lib_div::milliseconds(1/1000 sec)
2699          * Usage: 20
2700          *
2701          * @return      integer
2702          */
2703         function milliseconds() {
2704                 $p=explode(' ',microtime());
2705                 return round(($p[0]+$p[1])*1000);
2706         }
2707
2708         /**
2709          * Client Browser Information
2710          * Usage: 4
2711          *
2712          * @param       string          Alternative User Agent string (if empty, t3lib_div::getIndpEnv('HTTP_USER_AGENT') is used)
2713          * @return      array           Parsed information about the HTTP_USER_AGENT in categories BROWSER, VERSION, SYSTEM and FORMSTYLE
2714          */
2715         function clientInfo($useragent='')      {
2716                 if (!$useragent) $useragent=t3lib_div::getIndpEnv('HTTP_USER_AGENT');
2717
2718                 $bInfo=array();
2719                         // Which browser?
2720                 if (strstr($useragent,'Konqueror'))     {
2721                         $bInfo['BROWSER']= 'konqu';
2722                 } elseif (strstr($useragent,'Opera'))   {
2723                         $bInfo['BROWSER']= 'opera';
2724                 } elseif (strstr($useragent,'MSIE 4') || strstr($useragent,'MSIE 5') || strstr($useragent,'MSIE 6'))    {
2725                         $bInfo['BROWSER']= 'msie';
2726                 } elseif (strstr($useragent,'Mozilla/4') || strstr($useragent,'Mozilla/5'))     {
2727                         $bInfo['BROWSER']='net';
2728                 }
2729                 if ($bInfo['BROWSER'])  {
2730                                 // Browser version
2731                         switch($bInfo['BROWSER'])       {
2732                                 case 'net':
2733                                         $bInfo['VERSION']= doubleval(substr($useragent,8));
2734                                         if (strstr($useragent,'Netscape6/')) {$bInfo['VERSION']=doubleval(substr(strstr($useragent,'Netscape6/'),10));}
2735                                         if (strstr($useragent,'Netscape/7')) {$bInfo['VERSION']=doubleval(substr(strstr($useragent,'Netscape/7'),9));}
2736                                 break;
2737                                 case 'msie':
2738                                         $tmp = strstr($useragent,'MSIE');
2739                                         $bInfo['VERSION'] = doubleval(ereg_replace('^[^0-9]*','',substr($tmp,4)));
2740                                 break;
2741                                 case 'opera':
2742                                         $tmp = strstr($useragent,'Opera');
2743                                         $bInfo['VERSION'] = doubleval(ereg_replace('^[^0-9]*','',substr($tmp,5)));
2744                                 break;
2745                                 case 'konqu':
2746                                         $tmp = strstr($useragent,'Konqueror/');
2747                                         $bInfo['VERSION'] = doubleval(substr($tmp,10));
2748                                 break;
2749                         }
2750                                 // Client system
2751                         if (strstr($useragent,'Win'))   {
2752                                 $bInfo['SYSTEM'] = 'win';
2753                         } elseif (strstr($useragent,'Mac'))     {
2754                                 $bInfo['SYSTEM'] = 'mac';
2755                         } elseif (strstr($useragent,'Linux') || strstr($useragent,'X11') || strstr($useragent,'SGI') || strstr($useragent,' SunOS ') || strstr($useragent,' HP-UX '))   {
2756                                 $bInfo['SYSTEM'] = 'unix';
2757                         }
2758                 }
2759                         // Is true if the browser supports css to format forms, especially the width
2760                 $bInfo['FORMSTYLE']=($bInfo['BROWSER']=='msie' || ($bInfo['BROWSER']=='net'&&$bInfo['VERSION']>=5) || $bInfo['BROWSER']=='opera' || $bInfo['BROWSER']=='konqu');
2761
2762                 return $bInfo;
2763         }
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787         /*************************
2788          *
2789          * TYPO3 SPECIFIC FUNCTIONS
2790          *
2791          *************************/
2792
2793         /**
2794          * Returns the absolute filename of a relative reference, resolves the "EXT:" prefix (way of referring to files inside extensions) and checks that the file is inside the PATH_site of the TYPO3 installation and implies a check with t3lib_div::validPathStr(). Returns false if checks failed. Does not check if the file exists.
2795          * Usage: 24
2796          *
2797          * @param       string          The input filename/filepath to evaluate
2798          * @param       boolean         If $onlyRelative is set (which it is by default), then only return values relative to the current PATH_site is accepted.
2799          * @param       boolean         If $relToTYPO3_mainDir is set, then relative paths are relative to PATH_typo3 constant - otherwise (default) they are relative to PATH_site
2800          * @return      string          Returns the absolute filename of $filename IF valid, otherwise blank string.
2801          */
2802         function getFileAbsFileName($filename,$onlyRelative=1,$relToTYPO3_mainDir=0)    {
2803                 if (!strcmp($filename,''))              return '';
2804
2805                 if ($relToTYPO3_mainDir)        {
2806                         if (!defined('PATH_typo3'))     return '';
2807                         $relPathPrefix = PATH_typo3;
2808                 } else {
2809                         $relPathPrefix = PATH_site;
2810                 }
2811                 if (substr($filename,0,4)=='EXT:')      {       // extension
2812                         list($extKey,$local) = explode('/',substr($filename,4),2);
2813                         $filename='';
2814                         if (strcmp($extKey,'') && t3lib_extMgm::isLoaded($extKey) && strcmp($local,'')) {
2815                                 $filename = t3lib_extMgm::extPath($extKey).$local;
2816                         }
2817                 } elseif (!t3lib_div::isAbsPath($filename))     {       // relative. Prepended with $relPathPrefix
2818                         $filename=$relPathPrefix.$filename;
2819                 } elseif ($onlyRelative && !t3lib_div::isFirstPartOfStr($filename,$relPathPrefix)) {    // absolute, but set to blank if not allowed
2820                         $filename='';
2821                 }
2822                 if (strcmp($filename,'') && t3lib_div::validPathStr($filename)) {       // checks backpath.
2823                         return $filename;
2824                 }
2825         }
2826
2827         /**
2828          * Checks for malicious file paths.
2829          * Returns true if no '//', '..' or '\' is in the $theFile
2830          * This should make sure that the path is not pointing 'backwards' and further doesn't contain double/back slashes.
2831          * So it's compatible with the UNIX style path strings valid for TYPO3 internally.
2832          * Usage: 14
2833          *
2834          * @param       string          Filepath to evaluate
2835          * @return      boolean         True, if no '//', '..' or '\' is in the $theFile
2836          * @todo        Possible improvement: Should it rawurldecode the string first to check if any of these characters is encoded ?
2837          */
2838         function validPathStr($theFile) {
2839                 if (!strstr($theFile,'//') && !strstr($theFile,'..') && !strstr($theFile,'\\')) return true;
2840         }
2841
2842         /**
2843          * Checks if the $path is absolute or relative (detecting either '/' or 'x:/' as first part of string) and returns true if so.
2844          * Usage: 8
2845          *
2846          * @param       string          Filepath to evaluate
2847          * @return      boolean
2848          */
2849         function isAbsPath($path)       {
2850                 return TYPO3_OS=='WIN' ? substr($path,1,2)==':/' :  substr($path,0,1)=='/';
2851         }
2852
2853         /**
2854          * Returns true if the path is absolute, without backpath '..' and within the PATH_site OR within the lockRootPath
2855          * Usage: 5
2856          *
2857          * @param       string          Filepath to evaluate
2858          * @return      boolean
2859          */
2860         function isAllowedAbsPath($path)        {
2861                 if (t3lib_div::isAbsPath($path) &&
2862                         t3lib_div::validPathStr($path) &&
2863                                 (       t3lib_div::isFirstPartOfStr($path,PATH_site)
2864                                         ||
2865                                         ($GLOBALS['TYPO3_CONF_VARS']['BE']['lockRootPath'] && t3lib_div::isFirstPartOfStr($path,$GLOBALS['TYPO3_CONF_VARS']['BE']['lockRootPath']))
2866                                 )
2867                         )       return true;
2868         }
2869
2870         /**
2871          * Verifies the input filename againts the 'fileDenyPattern'. Returns true if OK.
2872          * Usage: 2
2873          *
2874          * @param       string          Filepath to evaluate
2875          * @return      boolean
2876          */
2877         function verifyFilenameAgainstDenyPattern($filename)    {
2878                 if (strcmp($filename,'') && strcmp($GLOBALS['TYPO3_CONF_VARS']['BE']['fileDenyPattern'],''))    {
2879                         $result = eregi($GLOBALS['TYPO3_CONF_VARS']['BE']['fileDenyPattern'],$filename);
2880                         if ($result)    return false;   // so if a matching filename is found, return false;
2881                 }
2882                 return true;
2883         }
2884
2885         /**
2886          * Moves $source file to $destination if uploaded, otherwise try to make a copy
2887          * Usage: 4
2888          *
2889          * @param       string          Source file, absolute path
2890          * @param       string          Destination file, absolute path
2891          * @return      boolean         Returns true if the file was moved.
2892          * @coauthor    Dennis Petersen <fessor@software.dk>
2893          * @see upload_to_tempfile()
2894          */
2895         function upload_copy_move($source,$destination) {
2896                 if (is_uploaded_file($source))  {
2897                         $uploaded = TRUE;
2898                         // 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:
2899                         $uploadedResult = move_uploaded_file($source, $destination);
2900                 } else {
2901                         $uploaded = FALSE;
2902                         @copy($source,$destination);
2903                 }
2904
2905                         // Setting file system mode & group ownership of file:
2906                 if (@is_file($destination) && TYPO3_OS!='WIN')  {
2907                         chmod($destination, octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['fileCreateMask']));
2908                         if($GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup'])    {       // skip this if createGroup is empty
2909                                 chgrp($destination, $GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup']);
2910                         }
2911                 }
2912
2913                         // 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
2914                 return $uploaded ? $uploadedResult : FALSE;
2915         }
2916
2917         /**
2918          * Will move an uploaded file (normally in "/tmp/xxxxx") to a temporary filename in PATH_site."typo3temp/" from where TYPO3 can use it under safe_mode.
2919          * Use this function to move uploaded files to where you can work on them.
2920          * REMEMBER to use t3lib_div::unlink_tempfile() afterwards - otherwise temp-files will build up! They are NOT automatically deleted in PATH_site."typo3temp/"!
2921          * Usage: 6
2922          *
2923          * @param       string          The temporary uploaded filename, eg. $GLOBALS['HTTP_POST_FILES']['[upload field name here]']['tmp_name']
2924          * @return      string          If a new file was successfully created, return its filename, otherwise blank string.
2925          * @see unlink_tempfile(), upload_copy_move()
2926          */
2927         function upload_to_tempfile($uploadedFileName)  {
2928                 if (is_uploaded_file($uploadedFileName))        {
2929                         $tempFile = t3lib_div::tempnam('upload_temp_');
2930                         move_uploaded_file($uploadedFileName, $tempFile);
2931                         return @is_file($tempFile) ? $tempFile : '';
2932                 }
2933         }
2934
2935         /**
2936          * Deletes (unlink) a temporary filename in 'PATH_site."typo3temp/"' given as input.
2937          * The function will check that the file exists, is in PATH_site."typo3temp/" and does not contain back-spaces ("../") so it should be pretty safe.
2938          * Use this after upload_to_tempfile() or tempnam() from this class!
2939          * Usage: 9
2940          *
2941          * @param       string          Filepath for a file in PATH_site."typo3temp/". Must be absolute.
2942          * @return      boolean         Returns true if the file was unlink()'ed
2943          * @see upload_to_tempfile(), tempnam()
2944          */
2945         function unlink_tempfile($uploadedTempFileName) {
2946                 if ($uploadedTempFileName && t3lib_div::validPathStr($uploadedTempFileName) && t3lib_div::isFirstPartOfStr($uploadedTempFileName,PATH_site.'typo3temp/') && @is_file($uploadedTempFileName))    {
2947                         if (unlink($uploadedTempFileName))      return TRUE;
2948                 }
2949         }
2950
2951         /**
2952          * Create temporary filename (Create file with unique file name)
2953          * This function should be used for getting temporary filenames - will make your applications safe for open_basedir = on
2954          * REMEMBER to delete the temporary files after use! This is done by t3lib_div::unlink_tempfile()
2955          * Usage: 7
2956          *
2957          * @param       string          Prefix to temp file (which will have no extension btw)
2958          * @return      string          result from PHP function tempnam() with PATH_site.'typo3temp/' set for temp path.
2959          * @see unlink_tempfile(), upload_to_tempfile()
2960          */
2961         function tempnam($filePrefix)   {
2962                 return tempnam(PATH_site.'typo3temp/',$filePrefix);
2963         }
2964
2965         /**
2966          * standard authentication code - can't remember what it's used for.
2967          * Usage: 2
2968          *
2969          * @param       mixed           Uid (integer) or record (array)
2970          * @param       string          List of fields from the record if that is given.
2971          * @return      string          MD5 hash of 8 chars.
2972          * @internal
2973          */
2974         function stdAuthCode($uid_or_record,$fields='') {
2975                 if (is_array($uid_or_record))   {
2976                         $recCopy_temp=array();
2977                         if ($fields)    {
2978                                 $fieldArr = t3lib_div::trimExplode(',',$fields,1);
2979                                 reset($fieldArr);
2980                                 while(list($k,$v)=each($fieldArr))      {
2981                                         $recCopy_temp[$k]=$recCopy[$v];
2982                                 }
2983                         } else {
2984                                 $recCopy_temp=$recCopy;
2985                         }
2986                         $preKey = implode('|',$recCopy_temp);
2987                 } else {
2988                         $preKey = $uid_or_record;
2989                 }
2990
2991                 $authCode = $preKey.'||'.$GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'];
2992                 $authCode = substr(md5($authCode),0,8);
2993                 return $authCode;
2994         }
2995
2996         /**
2997          * Loads the $TCA (Table Configuration Array) for the $table
2998          *
2999          * Requirements:
3000          * 1) must be configured table (the ctrl-section configured),
3001          * 2) columns must not be an array (which it is always if whole table loaded), and
3002          * 3) there is a value for dynamicConfigFile (filename in typo3conf)
3003          * Usage: 84
3004          *
3005          * @param       string          Table name for which to load the full TCA array part into the global $TCA
3006          * @return      void
3007          */
3008         function loadTCA($table)        {
3009                 global $TCA,$LANG_GENERAL_LABELS;
3010                 if (isset($TCA[$table]) && !is_array($TCA[$table]['columns']) && $TCA[$table]['ctrl']['dynamicConfigFile'])     {
3011                         if (!strcmp(substr($TCA[$table]['ctrl']['dynamicConfigFile'],0,6),'T3LIB:'))    {
3012                                 include(PATH_t3lib.'stddb/'.substr($TCA[$table]['ctrl']['dynamicConfigFile'],6));
3013                         } elseif (t3lib_div::isAbsPath($TCA[$table]['ctrl']['dynamicConfigFile']) && @is_file($TCA[$table]['ctrl']['dynamicConfigFile']))       {       // Absolute path...
3014                                 include($TCA[$table]['ctrl']['dynamicConfigFile']);
3015                         } else include(PATH_typo3conf.$TCA[$table]['ctrl']['dynamicConfigFile']);
3016                 }
3017         }
3018
3019         /**
3020          * Looks for a sheet-definition in the input data structure array. If found it will return the data structure for the sheet given as $sheet (if found).
3021          * If the sheet definition is in an external file that file is parsed and the data structure inside of that is returned.
3022          * Usage: 5
3023          *
3024          * @param       array           Input data structure, possibly with a sheet-definition and references to external data source files.
3025          * @param       string          The sheet to return, preferably.
3026          * @return      array           An array with two num. keys: key0: The data structure is returned in this key (array) UNLESS an error happend in which case an error string is returned (string). key1: The used sheet key value!
3027          */
3028         function resolveSheetDefInDS($dataStructArray,$sheet='sDEF')    {
3029                 if (is_array($dataStructArray['sheets']))       {
3030                         if (!isset($dataStructArray['sheets'][$sheet])) {
3031                                 $sheet='sDEF';
3032                         }
3033                         $dataStruct =  $dataStructArray['sheets'][$sheet];
3034
3035                                 // If not an array, but still set, then regard it as a relative reference to a file:
3036                         if ($dataStruct && !is_array($dataStruct))      {
3037                                 $file = t3lib_div::getFileAbsFileName($dataStruct);
3038                                 if ($file && @is_file($file))   {
3039                                         $dataStruct = t3lib_div::xml2array(t3lib_div::getUrl($file));
3040                                 }
3041                         }
3042                 } else {
3043                         $dataStruct = $dataStructArray;
3044                         $sheet = 'sDEF';        // Default sheet
3045                 }
3046                 return array($dataStruct,$sheet);
3047         }
3048
3049         /**
3050          * Resolves ALL sheet definitions in dataStructArray
3051          * If no sheet is found, then the default "sDEF" will be created with the dataStructure inside.
3052          *
3053          * @param       array           Input data structure, possibly with a sheet-definition and references to external data source files.
3054          * @return      array           Output data structure with all sheets resolved as arrays.
3055          */
3056         function resolveAllSheetsInDS($dataStructArray) {
3057                 if (is_array($dataStructArray['sheets']))       {
3058                         $out=array('sheets'=>array());
3059                         foreach($dataStructArray['sheets'] as $sheetId => $sDat)        {
3060                                 list($ds,$aS) = t3lib_div::resolveSheetDefInDS($dataStructArray,$sheetId);
3061                                 if ($sheetId==$aS)      {
3062                                         $out['sheets'][$aS]=$ds;
3063                                 }
3064                         }
3065                 } else {
3066                         list($ds) = t3lib_div::resolveSheetDefInDS($dataStructArray);
3067                         $out = array('sheets' => array('sDEF' => $ds));
3068                 }
3069                 return $out;
3070         }
3071
3072         /**
3073          * Calls a userdefined function/method in class
3074          * Such a function/method should look like this: "function proc(&$params, &$ref)        {...}"
3075          * Usage: 17
3076          *
3077          * @param       string          Function/Method reference, '[file-reference":"]["&"]class/function["->"method-name]'. You can prefix this reference with "[file-reference]:" and t3lib_div::getFileAbsFileName() will then be used to resolve the filename and subsequently include it by "require_once()" which means you don't have to worry about including the class file either! Example: "EXT:realurl/class.tx_realurl.php:&tx_realurl->encodeSpURL". Finally; you can prefix the class name with "&" if you want to reuse a former instance of the same object call.
3078          * @param       mixed           Parameters to be pass along (typically an array) (REFERENCE!)
3079          * @param       mixed           Reference to be passed along (typically "$this" - being a reference to the calling object) (REFERENCE!)
3080          * @param       string          Required prefix of class or function name
3081          * @param       boolean         If set, no debug() error message is shown if class/function is not present.
3082          * @return      mixed           Content from method/function call
3083          * @see getUserObj()
3084          */
3085         function callUserFunction($funcName,&$params,&$ref,$checkPrefix='user_',$silent=0)      {
3086                 global $TYPO3_CONF_VARS;
3087
3088                         // Check persistent object and if found, call directly and exit.
3089                 if (is_array($GLOBALS['T3_VAR']['callUserFunction'][$funcName]))        {
3090                         return call_user_method(
3091                                                 $GLOBALS['T3_VAR']['callUserFunction'][$funcName]['method'],
3092                                                 $GLOBALS['T3_VAR']['callUserFunction'][$funcName]['obj'],
3093                                                 $params,
3094                                                 $ref
3095                                         );
3096                 }
3097
3098                         // Check file-reference prefix; if found, require_once() the file (should be library of code)
3099                 if (strstr($funcName,':'))      {
3100                         list($file,$funcRef) = t3lib_div::revExplode(':',$funcName,2);
3101                         $requireFile = t3lib_div::getFileAbsFileName($file);
3102                         if ($requireFile) require_once($requireFile);
3103                 } else {
3104                         $funcRef = $funcName;
3105                 }
3106
3107                         // Check for persistent object token, "&"
3108                 if (substr($funcRef,0,1)=='&')  {
3109                         $funcRef = substr($funcRef,1);
3110                         $storePersistentObject = TRUE;
3111                 } else {
3112                         $storePersistentObject = FALSE;
3113                 }
3114
3115                         // Check prefix is valid:
3116                 if ($checkPrefix &&
3117                         !t3lib_div::isFirstPartOfStr(trim($funcRef),$checkPrefix) &&
3118                         !t3lib_div::isFirstPartOfStr(trim($funcRef),'tx_')
3119                         )       {
3120                         if (!$silent)   debug("Function/Class '".$funcRef."' was not prepended with '".$checkPrefix."'",1);
3121                         return FALSE;
3122                 }
3123
3124                         // Call function or method:
3125                 $parts = explode('->',$funcRef);
3126                 if (count($parts)==2)   {       // Class
3127
3128                                 // Check if class/method exists:
3129                         if (class_exists($parts[0]))    {
3130
3131                                         // Get/Create object of class:
3132                                 if ($storePersistentObject)     {       // Get reference to current instance of class:
3133                                         if (!is_object($GLOBALS['T3_VAR']['callUserFunction_classPool'][$parts[0]]))    {
3134                                                 $GLOBALS['T3_VAR']['callUserFunction_classPool'][$parts[0]] = &t3lib_div::makeInstance($parts[0]);
3135                                         }
3136                                         $classObj = &$GLOBALS['T3_VAR']['callUserFunction_classPool'][$parts[0]];
3137                                 } else {        // Create new object:
3138                                         $classObj = &t3lib_div::makeInstance($parts[0]);
3139                                 }
3140
3141                                 if (method_exists($classObj, $parts[1]))        {
3142
3143                                                 // If persistent object should be created, set reference:
3144                                         if ($storePersistentObject)     {
3145                                                 $GLOBALS['T3_VAR']['callUserFunction'][$funcName] = array (
3146                                                         'method' => $parts[1],
3147                                                         'obj' => &$classObj
3148                                                 );
3149                                         }
3150                                                 // Call method:
3151                                         $content = call_user_method(
3152                                                 $parts[1],
3153                                                 $classObj,
3154                                                 $params,
3155                                                 $ref
3156                                         );
3157                                 } else {
3158                                         if (!$silent)   debug("<strong>ERROR:</strong> No method name '".$parts[1]."' in class ".$parts[0],1);
3159                                 }
3160                         } else {
3161                                 if (!$silent)   debug("<strong>ERROR:</strong> No class named: ".$parts[0],1);
3162                         }
3163                 } else {        // Function
3164                         if (function_exists($funcRef))  {
3165                                 $content = call_user_func($funcRef, $params, $ref);
3166                         } else {
3167                                 if (!$silent)   debug("<strong>ERROR:</strong> No function named: ".$funcRef,1);
3168                         }
3169                 }
3170                 return $content;
3171         }
3172
3173         /**
3174          * Creates and returns reference to a user defined object.
3175          * This function can return an object reference if you like. Just prefix the function call with "&": "$objRef = &t3lib_div::getUserObj('EXT:myext/class.tx_myext_myclass.php:&tx_myext_myclass');". This will work ONLY if you prefix the class name with "&" as well. See description of function arguments.
3176          * Usage: 5
3177          *
3178          * @param       string          Class reference, '[file-reference":"]["&"]class-name'. You can prefix the class name with "[file-reference]:" and t3lib_div::getFileAbsFileName() will then be used to resolve the filename and subsequently include it by "require_once()" which means you don't have to worry about including the class file either! Example: "EXT:realurl/class.tx_realurl.php:&tx_realurl". Finally; for the class name you can prefix it with "&" and you will reuse the previous instance of the object identified by the full reference string (meaning; if you ask for the same $classRef later in another place in the code you will get a reference to the first created one!).
3179          * @param       string          Required prefix of class name. By default "tx_" is allowed.
3180          * @param       boolean         If set, no debug() error message is shown if class/function is not present.
3181          * @return      object          The instance of the class asked for. Instance is created with t3lib_div::makeInstance
3182          * @see callUserFunction()
3183          */
3184         function &getUserObj($classRef,$checkPrefix='user_',$silent=0)  {
3185                 global $TYPO3_CONF_VARS;
3186                         // Check persistent object and if found, call directly and exit.
3187                 if (is_object($GLOBALS['T3_VAR']['getUserObj'][$classRef]))     {
3188                         return $GLOBALS['T3_VAR']['getUserObj'][$classRef];
3189                 } else {
3190
3191                                 // Check file-reference prefix; if found, require_once() the file (should be library of code)
3192                         if (strstr($classRef,':'))      {
3193                                 list($file,$class) = t3lib_div::revExplode(':',$classRef,2);
3194                                 $requireFile = t3lib_div::getFileAbsFileName($file);
3195                                 if ($requireFile)       require_once($requireFile);
3196                         } else {
3197                                 $class = $classRef;
3198                         }
3199
3200                                 // Check for persistent object token, "&"
3201                         if (substr($class,0,1)=='&')    {
3202                                 $class = substr($class,1);
3203                                 $storePersistentObject = TRUE;
3204                         } else {
3205                                 $storePersistentObject = FALSE;
3206                         }
3207
3208                                 // Check prefix is valid:
3209                         if ($checkPrefix &&
3210                                 !t3lib_div::isFirstPartOfStr(trim($class),$checkPrefix) &&
3211                                 !t3lib_div::isFirstPartOfStr(trim($class),'tx_')
3212                                 )       {
3213                                 if (!$silent)   debug("Class '".$class."' was not prepended with '".$checkPrefix."'",1);
3214                                 return FALSE;
3215                         }
3216
3217                                 // Check if class exists:
3218                         if (class_exists($class))       {
3219                                 $classObj = &t3lib_div::makeInstance($class);
3220
3221                                         // If persistent object should be created, set reference:
3222                                 if ($storePersistentObject)     {
3223                                         $GLOBALS['T3_VAR']['getUserObj'][$classRef] = &$classObj;
3224                                 }
3225
3226                                 return $classObj;
3227                         } else {
3228                                 if (!$silent)   debug("<strong>ERROR:</strong> No class named: ".$class,1);
3229                         }
3230                 }
3231         }
3232
3233         /**
3234          * Make instance of class
3235          * Takes the class-extensions API of TYPO3 into account
3236          * Please USE THIS instead of the PHP "new" keyword. Eg. "$obj = new myclass;" should be "$obj = t3lib_div::makeInstance("myclass")" instead!
3237          * Usage: 447
3238          *
3239          * @param       string          Class name to instantiate
3240          * @return      object          The object
3241          */
3242         function &makeInstance($className)      {
3243                 return class_exists('ux_'.$className) ? t3lib_div::makeInstance('ux_'.$className) : new $className;
3244         }
3245
3246         /**
3247          * Return classname for new instance
3248          * Takes the class-extensions API of TYPO3 into account
3249          * Usage: 17
3250          *
3251          * @param       string          Base Class name to evaluate
3252          * @return      string          Final class name to instantiate with "new [classname]"
3253          */
3254         function makeInstanceClassName($className)      {
3255                 return class_exists('ux_'.$className) ? t3lib_div::makeInstanceClassName('ux_'.$className) : $className;
3256         }
3257
3258         /**
3259          * Find the best service and check if it works.
3260          * Returns object of the service class.
3261          *
3262          * @param       string          Type of service (service key).
3263