TYPO3 Core

<?php

/***************************************************************

/**

* Contains the reknown class "t3lib_div" with general purpose functions

*

*

* 232: class t3lib_div

*

*

*

*

*

*

*

*

*

*

* TOTAL FUNCTIONS: 138

* (This index is automatically created/updated by the extension "extdeveval")

* @param string GET/POST var to return

* @return mixed POST var named $var and if not set, the GET var of the same name.

*/

$value = isset($_POST[$var]) ? $_POST[$var] : $_GET[$var];

return $value;

}

*/

public static function _GPmerged($parameter) {

$postParameter = (isset($_POST[$parameter]) && is_array($_POST[$parameter])) ? $_POST[$parameter] : array();

$mergedParameters = self::array_merge_recursive_overrule($getParameter, $postParameter);

self::stripSlashesOnArray($mergedParameters);

* @return mixed If $var is set it returns the value of $_GET[$var]. If $var is NULL (default), returns $_GET itself. In any case *slashes are stipped from the output!*

* @see _POST(), _GP(), _GETset()

*/

$value = ($var === NULL) ? $_GET : (empty($var) ? NULL : $_GET[$var]);

return $value;

}

* @return mixed If $var is set it returns the value of $_POST[$var]. If $var is NULL (default), returns $_POST itself. In any case *slashes are stipped from the output!*

* @see _GET(), _GP()

*/

$value = ($var === NULL) ? $_POST : (empty($var) ? NULL : $_POST[$var]);

return $value;

}

* Usage: 2

*

* @param mixed $inputGet

* @param string $key

*

* @return void

*/

* @deprecated since TYPO3 3.6, will be removed in TYPO3 4.6 - Use t3lib_div::_GP instead (ALWAYS delivers a value with un-escaped values!)

* @see _GP()

*/

self::logDeprecatedFunction();

$value = isset($_POST[$var]) ? $_POST[$var] : $_GET[$var];

return $value;

}

* @deprecated since TYPO3 3.7, will be removed in TYPO3 4.6 - Use t3lib_div::_GPmerged instead

* @see _GP()

*/

self::logDeprecatedFunction();

return self::_GPmerged($var);

* @param string Input string

* @return string Input string with potential XSS code removed

*/

$string = RemoveXSS::process($string);

return $string;

}

/*************************

*

* IMAGE FUNCTIONS

* Compressing a GIF file if not already LZW compressed.

* 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)

*

*

* Usage: 9

*

* @param string Filepath

* @param string See description of function

* @return string Returns "GD" if GD was used, otherwise "IM" if ImageMagick was used. If nothing done at all, it returns empty string.

*/

$gfxConf = $GLOBALS['TYPO3_CONF_VARS']['GFX'];

exec($cmd);

$tempImage = imageCreateFromGif($theFile);

imageGif($tempImage, $theFile);

imageDestroy($tempImage);

}

}

return $returnCode;

* @param string $theFile the filename with path

* @return string new filename

*/

if ($GLOBALS['TYPO3_CONF_VARS']['FE']['png_to_gif']

}

return $theFile;

}

* @param boolean If set, then input file is converted to PNG, otherwise to GIF

* @return string If the new image file exists, it's filepath is returned

*/

if (

return $theFile;

} else {

exec($cmd);

/*************************

*

* STRING FUNCTIONS

* @deprecated since TYPO3 4.1, will be removed in TYPO3 4.6 - Works ONLY for single-byte charsets! Use t3lib_div::fixed_lgd_cs() instead

* @see fixed_lgd_pre()

*/

self::logDeprecatedFunction();

$chars = abs($origChars);

return $origChars < 0 ?

}

}

return $string;

* @deprecated since TYPO3 4.1, will be removed in TYPO3 4.6 - Use t3lib_div::fixed_lgd_cs() instead (with negative input value for $chars)

* @see fixed_lgd()

*/

self::logDeprecatedFunction();

}

/**

* @param string appendix to the truncated string

* @return string cropped string

*/

if (is_object($GLOBALS['LANG'])) {

return $GLOBALS['LANG']->csConvObj->crop($GLOBALS['LANG']->charSet, $string, $chars, $appendString);

} elseif (is_object($GLOBALS['TSFE'])) {

* @deprecated since TYPO3 4.1, will be removed in TYPO3 4.6 - Use PHP function wordwrap()

* @return string

*/

self::logDeprecatedFunction();

foreach ($lines as $lStr) {

}

}

/**

* @return string

* @see breakTextForEmail()

*/

$theLine = strrev($parts[1]);

} else {

}

} else {

}

}

}

/**

* @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). If list is "*" no check is done and the function returns TRUE immediately. An empty list always returns FALSE.

* @return boolean True if an IP-mask from $list matches $baseIP

*/

$list = trim($list);

}

return self::cmpIPv6($baseIP, $list);

} else {

return self::cmpIPv4($baseIP, $list);

* @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)

* @return boolean True if an IP-mask from $list matches $baseIP

*/

// "192.168.3.0/24"

$lnet = ip2long($test);

$lip = ip2long($baseIP);

$binnet = str_pad(decbin($lnet), 32, '0', STR_PAD_LEFT);

$binip = str_pad(decbin($lip), 32, '0', STR_PAD_LEFT);

} else {

// "192.168.*.*"

$yes = 1;

foreach ($IPparts as $index => $val) {

$val = trim($val);

}

}

}

/**

* Match IPv6 address with a list of IPv6 prefixes

* @param string $list is a comma-list of IPv6 prefixes, could also contain IPv4 addresses

* @return boolean True if an baseIP matches any prefix

*/

$baseIP = self::normalizeIPv6($baseIP);

$test = self::normalizeIPv6($test);

case '48':

$testBin = substr(self::IPv6Hex2Bin($test), 0, 48);

$baseIPBin = substr(self::IPv6Hex2Bin($baseIP), 0, 48);

case '64':

$testBin = substr(self::IPv6Hex2Bin($test), 0, 64);

$baseIPBin = substr(self::IPv6Hex2Bin($baseIP), 0, 64);

default:

}

} else {

$testBin = self::IPv6Hex2Bin($test);

$baseIPBin = self::IPv6Hex2Bin($baseIP);

}

}

}

/**

* [Describe function...]

* @param [type] $hex: ...

* @return [type] ...

*/

$bin = '';

}

return $bin;

}

* @param string Given IPv6 address

* @return string Normalized address

*/

$normalizedAddress = '';

$stageOneAddress = '';

$chunksLeft = explode(':', $chunks[0]);

$chunksRight = explode(':', $chunks[1]);

$left = count($chunksLeft);

$right = count($chunksRight);

// Special case: leading zero-only blocks count to 1, should be 0

$hiddenBlocks = 8 - ($left + $right);

$hiddenPart = '';

$hiddenPart .= '0000:';

$h++;

}

} else {

$stageOneAddress = $chunks[0] . ':' . $hiddenPart . $chunks[1];

}

// normalize the blocks:

$blocks = explode(':', $stageOneAddress);

$divCounter = 0;

$tmpBlock = '';

$i = 0;

$hiddenZeros = 4 - strlen($block);

$tmpBlock .= '0';

$i++;

}

$normalizedAddress .= $tmpBlock . $block;

$normalizedAddress .= ':';

$divCounter++;

}

* @return boolean True if $ip is either of IPv4 or IPv6 format.

*/

public static function validIP($ip) {

}

/**

* @return boolean True if $ip is of IPv4 format.

*/

public static function validIPv4($ip) {

}

/**

* @param string IP address to be tested

* @return boolean True if $ip is of IPv6 format.

*/

}

/**

* @param string 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)

* @return boolean True if a domain name mask from $list matches $baseIP

*/

$resolvedHostName = explode('.', gethostbyaddr($baseIP));

$yes = 1;

$val = trim($val);

}

}

/**

* Checks if a given URL matches the host that currently handles this HTTP request.

* @param string item to check for

* @return boolean true if $item is in $list

*/

}

/**

* @param string comma-separated list of items (string)

* @return string new comma-separated list of items

*/

foreach ($items as $k => $v) {

unset($items[$k]);

}

}

}

/**

* @return string new comma-separated list of items

* @author Martin Kutschker <martin.kutschker@activesolution.at>

*/

$list = array();

foreach ($items as $item) {

$runAwayBrake = 1000;

$list[] = $n;

$runAwayBrake--;

} else {

$list[] = $item;

}

}

}

/**

* @param integer Default value if input is false.

* @return integer The input value forced into the boundaries of $min and $max

*/

$theInt = intval($theInt);

return $theInt;

}

* @param integer Integer string to process

* @return integer

*/

$theInt = intval($theInt);

return $theInt;

}

* @param string Version number on format x.x.x

* @return integer Integer version of version number (where each part can count to 999)

*/

}

/**

* @return boolean Returns true if this setup is compatible with the provided version number

* @todo Still needs a function to convert versions to branches

*/

global $TYPO3_CONF_VARS;

$currVersionStr = $TYPO3_CONF_VARS['SYS']['compat_version'] ? $TYPO3_CONF_VARS['SYS']['compat_version'] : TYPO3_branch;

return FALSE;

} else {

return TRUE;

* @param string String to md5-hash

* @return integer Returns 28bit integer-hash

*/

}

/**

* @param integer The string-length of the output

* @return string Substring of the resulting md5-hash, being $len chars long (from beginning)

*/

}

/**

* Returns a proper HMAC on a given input string and secret TYPO3 encryption key.

*

*/

public static function hmac($input) {

$hashAlgorithm = 'sha1';

// keys shorter than blocksize are zero-padded

$key = str_pad($GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'], $hashBlocksize, chr(0x00));

}

}

return $hmac;

}

* @param mixed $secondParameter: Dummy field, which if set will show a warning!

* @return string Returns the list without any duplicates of values, space around values are trimmed

*/

if (is_array($in_list)) {

throw new InvalidArgumentException(

'TYPO3 Fatal Error: t3lib_div::uniqueList() does NOT support array arguments anymore! Only string comma lists!',

);

}

}

/**

* @param string Filename/filepath to be analysed

* @return array Contains keys [path], [file], [filebody], [fileext], [realFileext]

*/

$reg = array();

if (preg_match('/(.*\/)(.*)$/', $fileref, $reg)) {

$info['path'] = $reg[1];

* @param string Directory name / path

* @return string Processed input value. See function description.

*/

}

/**

* @return string A hexadecimal color code, #xxxxxx, modified according to input vars

* @see modifyHTMLColorAll()

*/

}

/**

* @return string A hexadecimal color code, #xxxxxx, modified according to input vars

* @see modifyHTMLColor()

*/

}

/**

* @return string

* @deprecated since TYPO3 4.5, will be removed in TYPO3 4.7 - Use rtrim() directly

*/

self::logDeprecatedFunction();

return rtrim($string, ',');

* @deprecated since TYPO3 3.5, will be removed in TYPO3 4.6 - Use t3lib_cs::conv_case() instead or for HTML output, wrap your content in <span class="uppercase">...</span>)

* @ignore

*/

self::logDeprecatedFunction();

$value = strtoupper($string);

* @deprecated since TYPO3 4.1, will be removed in TYPO3 4.6 - Works only for western europe single-byte charsets! Use t3lib_cs::specCharsToASCII() instead!

* @return string

*/

self::logDeprecatedFunction();

return str_replace($pattern, $replace, $str);

}

if ($var === '') {

return FALSE;

}

}

/**

* @param string Reference string which must be found as the "first part" of the full string

* @return boolean True if $partStr was found to be equal to the first part of $str

*/

return $partStr != '' && strpos((string) $str, (string) $partStr, 0) === 0;

}

* @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)

* @return string Formatted representation of the byte number, for output.

*/

// Set labels:

if (strlen($labels) == 0) {

$labels = ' | K| M| G';

} else {

}

// Find size:

}

}

}

}

* @param string Microtime

* @return integer Microtime input string converted to an integer (milliseconds)

*/

}

/**

* @return array Array with operators and operands separated.

* @see tslib_cObj::calc(), tslib_gifBuilder::calcOffset()

*/

$res = Array();

}

reset($res);

return $res;

* @return integer Calculated value. Or error string.

* @see calcParenthesis()

*/

// split the expression here:

$reg = array();

reset($reg[2]);

$sign = $reg[1][$k];

$Msign = $sign;

} else {