1 <?php

2 namespace TYPO3\CMS\Core\Utility;

3 

31 class GeneralUtility {

32 

33  // Severity constants used by \TYPO3\CMS\Core\Utility\GeneralUtility::sysLog()

34  const SYSLOG_SEVERITY_INFO = 0;

35  const SYSLOG_SEVERITY_NOTICE = 1;

36  const SYSLOG_SEVERITY_WARNING = 2;

37  const SYSLOG_SEVERITY_ERROR = 3;

38  const SYSLOG_SEVERITY_FATAL = 4;

39 

40  const ENV_TRUSTED_HOSTS_PATTERN_ALLOW_ALL = '.*';

41  const ENV_TRUSTED_HOSTS_PATTERN_SERVER_NAME = 'SERVER_NAME';

42 

49  static protected $allowHostHeaderValue = FALSE;

50 

57  static protected $singletonInstances = array();

58 

64  static protected $nonSingletonInstances = array();

65 

71  static protected $finalClassNameCache = array();

72 

78  static protected $applicationContext = NULL;

79 

85  static protected $idnaStringCache = array();

86 

92  static protected $idnaConverter = NULL;

93 

99  static protected $supportedCgiServerApis = array(

100  'fpm-fcgi',

101  'cgi',

102  'isapi',

103  'cgi-fcgi',

104  'srv', // HHVM with fastcgi

105  );

106 

107  /*************************

108  *

109  * GET/POST Variables

110  *

111  * Background:

112  * Input GET/POST variables in PHP may have their quotes escaped with "\" or not depending on configuration.

113  * TYPO3 has always converted quotes to BE escaped if the configuration told that they would not be so.

114  * But the clean solution is that quotes are never escaped and that is what the functions below offers.

115  * Eventually TYPO3 should provide this in the global space as well.

116  * In the transitional phase (or forever..?) we need to encourage EVERY to read and write GET/POST vars through the API functions below.

117  *

118  *************************/

128  static public function _GP($var) {

129  if (empty($var)) {

130  return;

131  }

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

133  if (isset($value)) {

134  if (is_array($value)) {

135  self::stripSlashesOnArray($value);

136  } else {

137  $value = stripslashes($value);

138  }

139  }

140  return $value;

141  }

142 

149  static public function _GPmerged($parameter) {

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

151  $getParameter = isset($_GET[$parameter]) && is_array($_GET[$parameter]) ? $_GET[$parameter] : array();

152  $mergedParameters = $getParameter;

153  ArrayUtility::mergeRecursiveWithOverrule($mergedParameters, $postParameter);

154  self::stripSlashesOnArray($mergedParameters);

155  return $mergedParameters;

156  }

157 

166  static public function _GET($var = NULL) {

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

168  // Removes slashes since TYPO3 has added them regardless of magic_quotes setting.

169  if (isset($value)) {

170  if (is_array($value)) {

171  self::stripSlashesOnArray($value);

172  } else {

173  $value = stripslashes($value);

174  }

175  }

176  return $value;

177  }

178 

187  static public function _POST($var = NULL) {

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

189  // Removes slashes since TYPO3 has added them regardless of magic_quotes setting.

190  if (isset($value)) {

191  if (is_array($value)) {

192  self::stripSlashesOnArray($value);

193  } else {

194  $value = stripslashes($value);

195  }

196  }

197  return $value;

198  }

199 

207  static public function _GETset($inputGet, $key = '') {

208  // Adds slashes since TYPO3 standard currently is that slashes

209  // must be applied (regardless of magic_quotes setting)

210  if (is_array($inputGet)) {

211  self::addSlashesOnArray($inputGet);

212  } else {

213  $inputGet = addslashes($inputGet);

214  }

215  if ($key != '') {

216  if (strpos($key, '|') !== FALSE) {

217  $pieces = explode('|', $key);

218  $newGet = array();

219  $pointer = &$newGet;

220  foreach ($pieces as $piece) {

221  $pointer = &$pointer[$piece];

222  }

223  $pointer = $inputGet;

224  $mergedGet = $_GET;

225  ArrayUtility::mergeRecursiveWithOverrule($mergedGet, $newGet);

226  $_GET = $mergedGet;

227  $GLOBALS['HTTP_GET_VARS'] = $mergedGet;

228  } else {

229  $_GET[$key] = $inputGet;

230  $GLOBALS['HTTP_GET_VARS'][$key] = $inputGet;

231  }

232  } elseif (is_array($inputGet)) {

233  $_GET = $inputGet;

234  $GLOBALS['HTTP_GET_VARS'] = $inputGet;

235  }

236  }

237 

247  static public function removeXSS($string) {

248  require_once PATH_typo3 . 'contrib/RemoveXSS/RemoveXSS.php';

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

250  return $string;

251  }

252 

253  /*************************

254  *

255  * IMAGE FUNCTIONS

256  *

257  *************************/

276  static public function gif_compress($theFile, $type) {

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

278  $returnCode = '';

279  // GIF...

280  if ($gfxConf['gif_compress'] && strtolower(substr($theFile, -4, 4)) == '.gif') {

281  // IM

282  if (($type == 'IM' || !$type) && $gfxConf['im'] && $gfxConf['im_path_lzw']) {

283  // Use temporary file to prevent problems with read and write lock on same file on network file systems

284  $temporaryName = dirname($theFile) . '/' . md5(uniqid('', TRUE)) . '.gif';

285  // Rename could fail, if a simultaneous thread is currently working on the same thing

286  if (@rename($theFile, $temporaryName)) {

287  $cmd = self::imageMagickCommand('convert', '"' . $temporaryName . '" "' . $theFile . '"', $gfxConf['im_path_lzw']);

288  \TYPO3\CMS\Core\Utility\CommandUtility::exec($cmd);

289  unlink($temporaryName);

290  }

291  $returnCode = 'IM';

292  if (@is_file($theFile)) {

293  self::fixPermissions($theFile);

294  }

295  } elseif (($type == 'GD' || !$type) && $gfxConf['gdlib'] && !$gfxConf['gdlib_png']) {

296  // GD

297  $tempImage = imageCreateFromGif($theFile);

298  imageGif($tempImage, $theFile);

299  imageDestroy($tempImage);

300  $returnCode = 'GD';

301  if (@is_file($theFile)) {

302  self::fixPermissions($theFile);

303  }

304  }

305  }

306  return $returnCode;

307  }

308 

316  static public function png_to_gif_by_imagemagick($theFile) {

317  if ($GLOBALS['TYPO3_CONF_VARS']['FE']['png_to_gif'] && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im'] && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw'] && strtolower(substr($theFile, -4, 4)) == '.png' && @is_file($theFile)) {

318  // IM

319  $newFile = substr($theFile, 0, -4) . '.gif';

320  $cmd = self::imageMagickCommand('convert', '"' . $theFile . '" "' . $newFile . '"', $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw']);

321  \TYPO3\CMS\Core\Utility\CommandUtility::exec($cmd);

322  $theFile = $newFile;

323  if (@is_file($newFile)) {

324  self::fixPermissions($newFile);

325  }

326  }

327  return $theFile;

328  }

329 

338  static public function read_png_gif($theFile, $output_png = FALSE) {

339  if ($GLOBALS['TYPO3_CONF_VARS']['GFX']['im'] && @is_file($theFile)) {

340  $ext = strtolower(substr($theFile, -4, 4));

341  if ((string) $ext == '.png' && $output_png || (string) $ext == '.gif' && !$output_png) {

342  return $theFile;

343  } else {

344  $newFile = PATH_site . 'typo3temp/readPG_' . md5(($theFile . '|' . filemtime($theFile))) . ($output_png ? '.png' : '.gif');

345  $cmd = self::imageMagickCommand('convert', '"' . $theFile . '" "' . $newFile . '"', $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path']);

346  \TYPO3\CMS\Core\Utility\CommandUtility::exec($cmd);

347  if (@is_file($newFile)) {

348  self::fixPermissions($newFile);

349  return $newFile;

350  }

351  }

352  }

353  }

354 

355  /*************************

356  *

357  * STRING FUNCTIONS

358  *

359  *************************/

368  static public function fixed_lgd_cs($string, $chars, $appendString = '...') {

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

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

371  } elseif (is_object($GLOBALS['TSFE']) && is_object($GLOBALS['TSFE']->csConvObj)) {

372  $charSet = $GLOBALS['TSFE']->renderCharset != '' ? $GLOBALS['TSFE']->renderCharset : $GLOBALS['TSFE']->defaultCharSet;

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

374  } else {

375  // This case should not happen

376  $csConvObj = self::makeInstance('TYPO3\\CMS\\Core\\Charset\\CharsetConverter');

377  return $csConvObj->crop('utf-8', $string, $chars, $appendString);

378  }

379  }

380 

389  static public function cmpIP($baseIP, $list) {

390  $list = trim($list);

391  if ($list === '') {

392  return FALSE;

393  } elseif ($list === '*') {

394  return TRUE;

395  }

396  if (strpos($baseIP, ':') !== FALSE && self::validIPv6($baseIP)) {

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

398  } else {

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

400  }

401  }

402 

410  static public function cmpIPv4($baseIP, $list) {

411  $IPpartsReq = explode('.', $baseIP);

412  if (count($IPpartsReq) == 4) {

413  $values = self::trimExplode(',', $list, TRUE);

414  foreach ($values as $test) {

415  $testList = explode('/', $test);

416  if (count($testList) == 2) {

417  list($test, $mask) = $testList;

418  } else {

419  $mask = FALSE;

420  }

421  if ((int)$mask) {

422  // "192.168.3.0/24"

423  $lnet = ip2long($test);

424  $lip = ip2long($baseIP);

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

426  $firstpart = substr($binnet, 0, $mask);

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

428  $firstip = substr($binip, 0, $mask);

429  $yes = $firstpart === $firstip;

430  } else {

431  // "192.168.*.*"

432  $IPparts = explode('.', $test);

433  $yes = 1;

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

435  $val = trim($val);

436  if ($val !== '*' && $IPpartsReq[$index] !== $val) {

437  $yes = 0;

438  }

439  }

440  }

441  if ($yes) {

442  return TRUE;

443  }

444  }

445  }

446  return FALSE;

447  }

448 

456  static public function cmpIPv6($baseIP, $list) {

457  // Policy default: Deny connection

458  $success = FALSE;

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

460  $values = self::trimExplode(',', $list, TRUE);

461  foreach ($values as $test) {

462  $testList = explode('/', $test);

463  if (count($testList) == 2) {

464  list($test, $mask) = $testList;

465  } else {

466  $mask = FALSE;

467  }

468  if (self::validIPv6($test)) {

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

470  $maskInt = (int)$mask ?: 128;

471  // Special case; /0 is an allowed mask - equals a wildcard

472  if ($mask === '0') {

473  $success = TRUE;

474  } elseif ($maskInt == 128) {

475  $success = $test === $baseIP;

476  } else {

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

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

479  $success = TRUE;

480  // Modulo is 0 if this is a 8-bit-boundary

481  $maskIntModulo = $maskInt % 8;

482  $numFullCharactersUntilBoundary = (int)($maskInt / 8);

483  if (substr($testBin, 0, $numFullCharactersUntilBoundary) !== substr($baseIPBin, 0, $numFullCharactersUntilBoundary)) {

484  $success = FALSE;

485  } elseif ($maskIntModulo > 0) {

486  // If not an 8-bit-boundary, check bits of last character

487  $testLastBits = str_pad(decbin(ord(substr($testBin, $numFullCharactersUntilBoundary, 1))), 8, '0', STR_PAD_LEFT);

488  $baseIPLastBits = str_pad(decbin(ord(substr($baseIPBin, $numFullCharactersUntilBoundary, 1))), 8, '0', STR_PAD_LEFT);

489  if (strncmp($testLastBits, $baseIPLastBits, $maskIntModulo) != 0) {

490  $success = FALSE;

491  }

492  }

493  }

494  }

495  if ($success) {

496  return TRUE;

497  }

498  }

499  return FALSE;

500  }

501 

509  static public function IPv6Hex2Bin($hex) {

510  return inet_pton($hex);

511  }

512 

520  static public function IPv6Bin2Hex($bin) {

521  return inet_ntop($bin);

522  }

523 

531  static public function normalizeIPv6($address) {

532  $normalizedAddress = '';

533  $stageOneAddress = '';

534  // According to RFC lowercase-representation is recommended

535  $address = strtolower($address);

536  // Normalized representation has 39 characters (0000:0000:0000:0000:0000:0000:0000:0000)

537  if (strlen($address) == 39) {

538  // Already in full expanded form

539  return $address;

540  }

541  // Count 2 if if address has hidden zero blocks

542  $chunks = explode('::', $address);

543  if (count($chunks) == 2) {

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

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

546  $left = count($chunksLeft);

547  $right = count($chunksRight);

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

549  if ($left == 1 && strlen($chunksLeft[0]) == 0) {

550  $left = 0;

551  }

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

553  $hiddenPart = '';

554  $h = 0;

555  while ($h < $hiddenBlocks) {

556  $hiddenPart .= '0000:';

557  $h++;

558  }

559  if ($left == 0) {

560  $stageOneAddress = $hiddenPart . $chunks[1];

561  } else {

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

563  }

564  } else {

565  $stageOneAddress = $address;

566  }

567  // Normalize the blocks:

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

569  $divCounter = 0;

570  foreach ($blocks as $block) {

571  $tmpBlock = '';

572  $i = 0;

573  $hiddenZeros = 4 - strlen($block);

574  while ($i < $hiddenZeros) {

575  $tmpBlock .= '0';

576  $i++;

577  }

578  $normalizedAddress .= $tmpBlock . $block;

579  if ($divCounter < 7) {

580  $normalizedAddress .= ':';

581  $divCounter++;

582  }

583  }

584  return $normalizedAddress;

585  }

586 

594  static public function compressIPv6($address) {

595  return inet_ntop(inet_pton($address));

596  }

597 

606  static public function validIP($ip) {

607  return filter_var($ip, FILTER_VALIDATE_IP) !== FALSE;

608  }

609 

618  static public function validIPv4($ip) {

619  return filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) !== FALSE;

620  }

621 

630  static public function validIPv6($ip) {

631  return filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) !== FALSE;

632  }

633 

641  static public function cmpFQDN($baseHost, $list) {

642  $baseHost = trim($baseHost);

643  if (empty($baseHost)) {

644  return FALSE;

645  }

646  if (self::validIPv4($baseHost) || self::validIPv6($baseHost)) {

647  // Resolve hostname

648  // Note: this is reverse-lookup and can be randomly set as soon as somebody is able to set

649  // the reverse-DNS for his IP (security when for example used with REMOTE_ADDR)

650  $baseHostName = gethostbyaddr($baseHost);

651  if ($baseHostName === $baseHost) {

652  // Unable to resolve hostname

653  return FALSE;

654  }

655  } else {

656  $baseHostName = $baseHost;

657  }

658  $baseHostNameParts = explode('.', $baseHostName);

659  $values = self::trimExplode(',', $list, TRUE);

660  foreach ($values as $test) {

661  $hostNameParts = explode('.', $test);

662  // To match hostNameParts can only be shorter (in case of wildcards) or equal

663  if (count($hostNameParts) > count($baseHostNameParts)) {

664  continue;

665  }

666  $yes = TRUE;

667  foreach ($hostNameParts as $index => $val) {

668  $val = trim($val);

669  if ($val === '*') {

670  // Wildcard valid for one or more hostname-parts

671  $wildcardStart = $index + 1;

672  // Wildcard as last/only part always matches, otherwise perform recursive checks

673  if ($wildcardStart < count($hostNameParts)) {

674  $wildcardMatched = FALSE;

675  $tempHostName = implode('.', array_slice($hostNameParts, $index + 1));

676  while ($wildcardStart < count($baseHostNameParts) && !$wildcardMatched) {

677  $tempBaseHostName = implode('.', array_slice($baseHostNameParts, $wildcardStart));

678  $wildcardMatched = self::cmpFQDN($tempBaseHostName, $tempHostName);

679  $wildcardStart++;

680  }

681  if ($wildcardMatched) {

682  // Match found by recursive compare

683  return TRUE;

684  } else {

685  $yes = FALSE;

686  }

687  }

688  } elseif ($baseHostNameParts[$index] !== $val) {

689  // In case of no match

690  $yes = FALSE;

691  }

692  }

693  if ($yes) {

694  return TRUE;

695  }

696  }

697  return FALSE;

698  }

699 

707  static public function isOnCurrentHost($url) {

708  return stripos($url . '/', self::getIndpEnv('TYPO3_REQUEST_HOST') . '/') === 0;

709  }

710 

719  static public function inList($list, $item) {

720  return strpos(',' . $list . ',', ',' . $item . ',') !== FALSE;

721  }

722 

733  static public function rmFromList($element, $list) {

734  $items = explode(',', $list);

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

736  if ($v == $element) {

737  unset($items[$k]);

738  }

739  }

740  return implode(',', $items);

741  }

742 

750  static public function expandList($list) {

751  $items = explode(',', $list);

752  $list = array();

753  foreach ($items as $item) {

754  $range = explode('-', $item);

755  if (isset($range[1])) {

756  $runAwayBrake = 1000;

757  for ($n = $range[0]; $n <= $range[1]; $n++) {

758  $list[] = $n;

759  $runAwayBrake--;

760  if ($runAwayBrake <= 0) {

761  break;

762  }

763  }

764  } else {

765  $list[] = $item;

766  }

767  }

768  return implode(',', $list);

769  }

770 

778  static public function int_from_ver($verNumberStr) {

779  self::logDeprecatedFunction();

780  return VersionNumberUtility::convertVersionNumberToInteger($verNumberStr);

781  }

782 

791  static public function compat_version($verNumberStr) {

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

793  if (\TYPO3\CMS\Core\Utility\VersionNumberUtility::convertVersionNumberToInteger($currVersionStr) < \TYPO3\CMS\Core\Utility\VersionNumberUtility::convertVersionNumberToInteger($verNumberStr)) {

794  return FALSE;

795  } else {

796  return TRUE;

797  }

798  }

799 

806  static public function md5int($str) {

807  return hexdec(substr(md5($str), 0, 7));

808  }

809 

817  static public function shortMD5($input, $len = 10) {

818  return substr(md5($input), 0, $len);

819  }

820 

828  static public function hmac($input, $additionalSecret = '') {

829  $hashAlgorithm = 'sha1';

830  $hashBlocksize = 64;

831  $hmac = '';

832  $secret = $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'] . $additionalSecret;

833  if (extension_loaded('hash') && function_exists('hash_hmac') && function_exists('hash_algos') && in_array($hashAlgorithm, hash_algos())) {

834  $hmac = hash_hmac($hashAlgorithm, $input, $secret);

835  } else {

836  // Outer padding

837  $opad = str_repeat(chr(92), $hashBlocksize);

838  // Inner padding

839  $ipad = str_repeat(chr(54), $hashBlocksize);

840  if (strlen($secret) > $hashBlocksize) {

841  // Keys longer than block size are shorten

842  $key = str_pad(pack('H*', call_user_func($hashAlgorithm, $secret)), $hashBlocksize, chr(0));

843  } else {

844  // Keys shorter than block size are zero-padded

845  $key = str_pad($secret, $hashBlocksize, chr(0));

846  }

847  $hmac = call_user_func($hashAlgorithm, ($key ^ $opad) . pack('H*', call_user_func($hashAlgorithm, (($key ^ $ipad) . $input))));

848  }

849  return $hmac;

850  }

851 

860  static public function uniqueList($in_list, $secondParameter = NULL) {

861  if (is_array($in_list)) {

862  throw new \InvalidArgumentException('TYPO3 Fatal Error: TYPO3\\CMS\\Core\\Utility\\GeneralUtility::uniqueList() does NOT support array arguments anymore! Only string comma lists!', 1270853885);

863  }

864  if (isset($secondParameter)) {

865  throw new \InvalidArgumentException('TYPO3 Fatal Error: TYPO3\\CMS\\Core\\Utility\\GeneralUtility::uniqueList() does NOT support more than a single argument value anymore. You have specified more than one!', 1270853886);

866  }

867  return implode(',', array_unique(self::trimExplode(',', $in_list, TRUE)));

868  }

869 

876  static public function split_fileref($fileNameWithPath) {

877  $reg = array();

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

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

880  $info['file'] = $reg[2];

881  } else {

882  $info['path'] = '';

883  $info['file'] = $fileNameWithPath;

884  }

885  $reg = '';

886  // If open_basedir is set and the fileName was supplied without a path the is_dir check fails

887  if (!is_dir($fileNameWithPath) && preg_match('/(.*)\\.([^\\.]*$)/', $info['file'], $reg)) {

888  $info['filebody'] = $reg[1];

889  $info['fileext'] = strtolower($reg[2]);

890  $info['realFileext'] = $reg[2];

891  } else {

892  $info['filebody'] = $info['file'];

893  $info['fileext'] = '';

894  }

895  reset($info);

896  return $info;

897  }

898 

914  static public function dirname($path) {

915  $p = self::revExplode('/', $path, 2);

916  return count($p) == 2 ? $p[0] : '';

917  }

918 

929  static public function modifyHTMLColor($color, $R, $G, $B) {

930  // This takes a hex-color (# included!) and adds $R, $G and $B to the HTML-color (format: #xxxxxx) and returns the new color

931  $nR = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange(hexdec(substr($color, 1, 2)) + $R, 0, 255);

932  $nG = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange(hexdec(substr($color, 3, 2)) + $G, 0, 255);

933  $nB = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange(hexdec(substr($color, 5, 2)) + $B, 0, 255);

934  return '#' . substr(('0' . dechex($nR)), -2) . substr(('0' . dechex($nG)), -2) . substr(('0' . dechex($nB)), -2);

935  }

936 

945  static public function modifyHTMLColorAll($color, $all) {

946  return self::modifyHTMLColor($color, $all, $all, $all);

947  }

948 

956  static public function isFirstPartOfStr($str, $partStr) {

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

958  }

959 

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

968  // Set labels:

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

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

971  } else {

972  $labels = str_replace('"', '', $labels);

973  }

974  $labelArr = explode('|', $labels);

975  // Find size:

976  if ($sizeInBytes > 900) {

977  // GB

978  if ($sizeInBytes > 900000000) {

979  $val = $sizeInBytes / (1024 * 1024 * 1024);

980  return number_format($val, ($val < 20 ? 1 : 0), '.', '') . $labelArr[3];

981  } elseif ($sizeInBytes > 900000) {

982  // MB

983  $val = $sizeInBytes / (1024 * 1024);

984  return number_format($val, ($val < 20 ? 1 : 0), '.', '') . $labelArr[2];

985  } else {

986  // KB

987  $val = $sizeInBytes / 1024;

988  return number_format($val, ($val < 20 ? 1 : 0), '.', '') . $labelArr[1];

989  }

990  } else {

991  // Bytes

992  return $sizeInBytes . $labelArr[0];

993  }

994  }

995 

1002  static public function convertMicrotime($microtime) {

1003  $parts = explode(' ', $microtime);

1004  return round(($parts[0] + $parts[1]) * 1000);

1005  }

1006 

1015  static public function splitCalc($string, $operators) {

1016  $res = array();

1017  $sign = '+';

1018  while ($string) {

1019  $valueLen = strcspn($string, $operators);

1020  $value = substr($string, 0, $valueLen);

1021  $res[] = array($sign, trim($value));

1022  $sign = substr($string, $valueLen, 1);

1023  $string = substr($string, $valueLen + 1);

1024  }

1025  reset($res);

1026  return $res;

1027  }

1028 

1037  static public function htmlspecialchars_decode($value) {

1038  self::logDeprecatedFunction();

1039  return htmlspecialchars_decode($value);

1040  }

1041 

1051  static public function deHSCentities($str) {

1052  return preg_replace('/&amp;([#[:alnum:]]*;)/', '&\\1', $str);

1053  }

1054 

1063  static public function slashJS($string, $extended = FALSE, $char = '\'') {

1064  if ($extended) {

1065  $string = str_replace('\\', '\\\\', $string);

1066  }

1067  return str_replace($char, '\\' . $char, $string);

1068  }

1069 

1077  static public function rawUrlEncodeJS($str) {

1078  return str_replace('%20', ' ', rawurlencode($str));

1079  }

1080 

1088  static public function rawUrlEncodeFP($str) {

1089  return str_replace('%2F', '/', rawurlencode($str));

1090  }

1091 

1110  static public function validEmail($email) {

1111  // Early return in case input is not a string

1112  if (!is_string($email)) {

1113  return FALSE;

1114  }

1115  $atPosition = strrpos($email, '@');

1116  if (!$atPosition || $atPosition + 1 === strlen($email)) {

1117  // Return if no @ found or it is placed at the very beginning or end of the email

1118  return FALSE;

1119  }

1120  $domain = substr($email, $atPosition + 1);

1121  $user = substr($email, 0, $atPosition);

1122  if (!preg_match('/^[a-z0-9.\\-]*$/i', $domain)) {

1123  $domain = self::idnaEncode($domain);

1124  }

1125  return filter_var($user . '@' . $domain, FILTER_VALIDATE_EMAIL) !== FALSE;

1126  }

1127 

1140  static public function isBrokenEmailEnvironment() {

1141  return TYPO3_OS == 'WIN' || FALSE !== strpos(ini_get('sendmail_path'), 'mini_sendmail');

1142  }

1143 

1150  static public function normalizeMailAddress($address) {

1151  if (self::isBrokenEmailEnvironment() && FALSE !== ($pos1 = strrpos($address, '<'))) {

1152  $pos2 = strpos($address, '>', $pos1);

1153  $address = substr($address, $pos1 + 1, ($pos2 ? $pos2 : strlen($address)) - $pos1 - 1);

1154  }

1155  return $address;

1156  }

1157 

1166  static public function formatForTextarea($content) {

1167  return LF . htmlspecialchars($content);

1168  }

1169 

1179  static public function strtoupper($str) {

1180  return strtr((string) $str, 'abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');

1181  }

1182 

1192  static public function strtolower($str) {

1193  return strtr((string) $str, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz');

1194  }

1195 

1207  static public function generateRandomBytes($bytesToReturn) {

1208  // Cache 4k of the generated bytestream.

1209  static $bytes = '';

1210  $bytesToGenerate = max(4096, $bytesToReturn);

1211  // if we have not enough random bytes cached, we generate new ones

1212  if (!isset($bytes[($bytesToReturn - 1)])) {

1213  if (TYPO3_OS === 'WIN') {

1214  // Openssl seems to be deadly slow on Windows, so try to use mcrypt

1215  $bytes .= self::generateRandomBytesMcrypt($bytesToGenerate);

1216  } else {

1217  // Try to use native PHP functions first, precedence has openssl

1218  $bytes .= self::generateRandomBytesOpenSsl($bytesToGenerate);

1219  if (!isset($bytes[($bytesToReturn - 1)])) {

1220  $bytes .= self::generateRandomBytesMcrypt($bytesToGenerate);

1221  }

1222  // If openssl and mcrypt failed, try /dev/urandom

1223  if (!isset($bytes[($bytesToReturn - 1)])) {

1224  $bytes .= self::generateRandomBytesUrandom($bytesToGenerate);

1225  }

1226  }

1227  // Fall back if other random byte generation failed until now

1228  if (!isset($bytes[($bytesToReturn - 1)])) {

1229  $bytes .= self::generateRandomBytesFallback($bytesToReturn);

1230  }

1231  }

1232  // get first $bytesToReturn and remove it from the byte cache

1233  $output = substr($bytes, 0, $bytesToReturn);

1234  $bytes = substr($bytes, $bytesToReturn);

1235  return $output;

1236  }

1237 

1244  static protected function generateRandomBytesOpenSsl($bytesToGenerate) {

1245  if (!function_exists('openssl_random_pseudo_bytes')) {

1246  return '';

1247  }

1248  $isStrong = NULL;

1249  return (string) openssl_random_pseudo_bytes($bytesToGenerate, $isStrong);

1250  }

1251 

1258  static protected function generateRandomBytesMcrypt($bytesToGenerate) {

1259  if (!function_exists('mcrypt_create_iv')) {

1260  return '';

1261  }

1262  return (string)(@mcrypt_create_iv($bytesToGenerate, MCRYPT_DEV_URANDOM));

1263  }

1264 

1271  static protected function generateRandomBytesUrandom($bytesToGenerate) {

1272  $bytes = '';

1273  $fh = @fopen('/dev/urandom', 'rb');

1274  if ($fh) {

1275  // PHP only performs buffered reads, so in reality it will always read

1276  // at least 4096 bytes. Thus, it costs nothing extra to read and store

1277  // that much so as to speed any additional invocations.

1278  $bytes = fread($fh, $bytesToGenerate);

1279  fclose($fh);

1280  }

1281  return $bytes;

1282  }

1283 

1290  static protected function generateRandomBytesFallback($bytesToReturn) {

1291  $bytes = '';

1292  // We initialize with somewhat random.

1293  $randomState = $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'] . base_convert(memory_get_usage() % pow(10, 6), 10, 2) . microtime() . uniqid('', TRUE) . getmypid();

1294  while (!isset($bytes[($bytesToReturn - 1)])) {

1295  $randomState = sha1(microtime() . mt_rand() . $randomState);

1296  $bytes .= sha1(mt_rand() . $randomState, TRUE);

1297  }

1298  return $bytes;

1299  }

1300 

1307  static public function idnaEncode($value) {

1308  if (isset(self::$idnaStringCache[$value])) {

1309  return self::$idnaStringCache[$value];

1310  } else {

1311  if (!self::$idnaConverter) {

1312  require_once PATH_typo3 . 'contrib/idna/idna_convert.class.php';

1313  self::$idnaConverter = new \idna_convert(array('idn_version' => 2008));

1314  }

1315  self::$idnaStringCache[$value] = self::$idnaConverter->encode($value);

1316  return self::$idnaStringCache[$value];

1317  }

1318  }

1319 

1326  static public function getRandomHexString($count) {

1327  return substr(bin2hex(self::generateRandomBytes((int)(($count + 1) / 2))), 0, $count);

1328  }

1329 

1337  static public function underscoredToUpperCamelCase($string) {

1338  $upperCamelCase = str_replace(' ', '', ucwords(str_replace('_', ' ', self::strtolower($string))));

1339  return $upperCamelCase;

1340  }

1341 

1349  static public function underscoredToLowerCamelCase($string) {

1350  $upperCamelCase = str_replace(' ', '', ucwords(str_replace('_', ' ', self::strtolower($string))));

1351  $lowerCamelCase = self::lcfirst($upperCamelCase);

1352  return $lowerCamelCase;

1353  }

1354 

1362  static public function camelCaseToLowerCaseUnderscored($string) {

1363  return self::strtolower(preg_replace('/(?<=\\w)([A-Z])/', '_\\1', $string));

1364  }

1365 

1373  static public function lcfirst($string) {

1374  return self::strtolower($string[0]) . substr($string, 1);

1375  }

1376 

1401  static public function isValidUrl($url) {

1402  $parsedUrl = parse_url($url);

1403  if (!$parsedUrl || !isset($parsedUrl['scheme'])) {

1404  return FALSE;

1405  }

1406  // HttpUtility::buildUrl() will always build urls with <scheme>://

1407  // our original $url might only contain <scheme>: (e.g. mail:)

1408  // so we convert that to the double-slashed version to ensure

1409  // our check against the $recomposedUrl is proper

1410  if (!self::isFirstPartOfStr($url, $parsedUrl['scheme'] . '://')) {

1411  $url = str_replace($parsedUrl['scheme'] . ':', $parsedUrl['scheme'] . '://', $url);

1412  }

1413  $recomposedUrl = HttpUtility::buildUrl($parsedUrl);

1414  if ($recomposedUrl !== $url) {

1415  // The parse_url() had to modify characters, so the URL is invalid

1416  return FALSE;

1417  }

1418  if (isset($parsedUrl['host']) && !preg_match('/^[a-z0-9.\\-]*$/i', $parsedUrl['host'])) {

1419  $parsedUrl['host'] = self::idnaEncode($parsedUrl['host']);

1420  }

1421  return filter_var(HttpUtility::buildUrl($parsedUrl), FILTER_VALIDATE_URL) !== FALSE;

1422  }

1423 

1424  /*************************

1425  *

1426  * ARRAY FUNCTIONS

1427  *

1428  *************************/

1451  static public function inArray(array $in_array, $item) {

1452  foreach ($in_array as $val) {

1453  if (!is_array($val) && (string)$val === (string)$item) {

1454  return TRUE;

1455  }

1456  }

1457  return FALSE;

1458  }

1459 

1470  static public function intExplode($delimiter, $string, $removeEmptyValues = FALSE, $limit = 0) {

1471  $result = explode($delimiter, $string);

1472  foreach ($result as $key => &$value) {

1473  if ($removeEmptyValues && ($value === '' || trim($value) === '')) {

1474  unset($result[$key]);

1475  } else {

1476  $value = (int)$value;

1477  }

1478  }

1479  unset($value);

1480  if ($limit !== 0) {

1481  if ($limit < 0) {

1482  $result = array_slice($result, 0, $limit);

1483  } elseif (count($result) > $limit) {

1484  $lastElements = array_slice($result, $limit - 1);

1485  $result = array_slice($result, 0, $limit - 1);

1486  $result[] = implode($delimiter, $lastElements);

1487  }

1488  }

1489  return $result;

1490  }

1491 

1506  static public function revExplode($delimiter, $string, $count = 0) {

1507  // 2 is the (currently, as of 2014-02) most-used value for $count in the core, therefore we check it first

1508  if ($count === 2) {

1509  $position = strrpos($string, strrev($delimiter));

1510  if ($position !== FALSE) {

1511  return array(substr($string, 0, $position), substr($string, $position + strlen($delimiter)));

1512  } else {

1513  return array($string);

1514  }

1515  } elseif ($count <= 1) {

1516  return array($string);

1517  } else {

1518  $explodedValues = explode($delimiter, strrev($string), $count);

1519  $explodedValues = array_map('strrev', $explodedValues);

1520  return array_reverse($explodedValues);

1521  }

1522  }

1523 

1536  static public function trimExplode($delim, $string, $removeEmptyValues = FALSE, $limit = 0) {

1537  $result = explode($delim, $string);

1538  if ($removeEmptyValues) {

1539  $temp = array();

1540  foreach ($result as $value) {

1541  if (trim($value) !== '') {

1542  $temp[] = $value;

1543  }

1544  }

1545  $result = $temp;

1546  }

1547  if ($limit > 0 && count($result) > $limit) {

1548  $lastElements = array_slice($result, $limit - 1);

1549  $result = array_slice($result, 0, $limit - 1);

1550  $result[] = implode($delim, $lastElements);

1551  } elseif ($limit < 0) {

1552  $result = array_slice($result, 0, $limit);

1553  }

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

1555  return $result;

1556  }

1557 

1565  static public function removeArrayEntryByValue(array $array, $cmpValue) {

1566  foreach ($array as $k => $v) {

1567  if (is_array($v)) {

1568  $array[$k] = self::removeArrayEntryByValue($v, $cmpValue);

1569  } elseif ((string)$v === (string)$cmpValue) {

1570  unset($array[$k]);

1571  }

1572  }

1573  return $array;

1574  }

1575 

1599  static public function keepItemsInArray(array $array, $keepItems, $getValueFunc = NULL) {

1600  if ($array) {

1601  // Convert strings to arrays:

1602  if (is_string($keepItems)) {

1603  $keepItems = self::trimExplode(',', $keepItems);

1604  }

1605  // Check if valueFunc can be executed:

1606  if (!is_callable($getValueFunc)) {

1607  $getValueFunc = NULL;

1608  }

1609  // Do the filtering:

1610  if (is_array($keepItems) && count($keepItems)) {

1611  foreach ($array as $key => $value) {

1612  // Get the value to compare by using the callback function:

1613  $keepValue = isset($getValueFunc) ? call_user_func($getValueFunc, $value) : $value;

1614  if (!in_array($keepValue, $keepItems)) {

1615  unset($array[$key]);

1616  }

1617  }

1618  }

1619  }

1620  return $array;

1621  }

1622 

1634  static public function implodeArrayForUrl($name, array $theArray, $str = '', $skipBlank = FALSE, $rawurlencodeParamName = FALSE) {

1635  foreach ($theArray as $Akey => $AVal) {

1636  $thisKeyName = $name ? $name . '[' . $Akey . ']' : $Akey;

1637  if (is_array($AVal)) {

1638  $str = self::implodeArrayForUrl($thisKeyName, $AVal, $str, $skipBlank, $rawurlencodeParamName);

1639  } else {

1640  if (!$skipBlank || (string)$AVal !== '') {

1641  $str .= '&' . ($rawurlencodeParamName ? rawurlencode($thisKeyName) : $thisKeyName) . '=' . rawurlencode($AVal);

1642  }

1643  }

1644  }

1645  return $str;

1646  }

1647 

1656  static public function explodeUrl2Array($string, $multidim = FALSE) {

1657  $output = array();

1658  if ($multidim) {

1659  parse_str($string, $output);

1660  } else {

1661  $p = explode('&', $string);

1662  foreach ($p as $v) {

1663  if (strlen($v)) {

1664  list($pK, $pV) = explode('=', $v, 2);

1665  $output[rawurldecode($pK)] = rawurldecode($pV);

1666  }

1667  }

1668  }

1669  return $output;

1670  }

1671 

1681  static public function compileSelectedGetVarsFromArray($varList, array $getArray, $GPvarAlt = TRUE) {

1682  $keys = self::trimExplode(',', $varList, TRUE);

1683  $outArr = array();

1684  foreach ($keys as $v) {

1685  if (isset($getArray[$v])) {

1686  $outArr[$v] = $getArray[$v];

1687  } elseif ($GPvarAlt) {

1688  $outArr[$v] = self::_GP($v);

1689  }

1690  }

1691  return $outArr;

1692  }

1693 

1703  static public function addSlashesOnArray(array &$theArray) {

1704  foreach ($theArray as &$value) {

1705  if (is_array($value)) {

1706  self::addSlashesOnArray($value);

1707  } else {

1708  $value = addslashes($value);

1709  }

1710  }

1711  unset($value);

1712  reset($theArray);

1713  }

1714 

1724  static public function stripSlashesOnArray(array &$theArray) {

1725  foreach ($theArray as &$value) {

1726  if (is_array($value)) {

1727  self::stripSlashesOnArray($value);

1728  } else {

1729  $value = stripslashes($value);

1730  }

1731  }

1732  unset($value);

1733  reset($theArray);

1734  }

1735 

1743  static public function slashArray(array $arr, $cmd) {

1744  if ($cmd == 'strip') {

1745  self::stripSlashesOnArray($arr);

1746  }

1747  if ($cmd == 'add') {

1748  self::addSlashesOnArray($arr);

1749  }

1750  return $arr;

1751  }

1752 

1759  static public function remapArrayKeys(&$array, $mappingTable) {

1760  if (is_array($mappingTable)) {

1761  foreach ($mappingTable as $old => $new) {

1762  if ($new && isset($array[$old])) {

1763  $array[$new] = $array[$old];

1764  unset($array[$old]);

1765  }

1766  }

1767  }

1768  }

1769 

1784  static public function array_merge_recursive_overrule(array $arr0, array $arr1, $notAddKeys = FALSE, $includeEmptyValues = TRUE, $enableUnsetFeature = TRUE) {

1785  self::logDeprecatedFunction();

1786  ArrayUtility::mergeRecursiveWithOverrule($arr0, $arr1, !$notAddKeys, $includeEmptyValues, $enableUnsetFeature);

1787  // Our local $arr0 has been modified now, so return it as result

1788  return $arr0;

1789  }

1790 

1798  static public function array_merge(array $arr1, array $arr2) {

1799  return $arr2 + $arr1;

1800  }

1801 

1810  static public function arrayDiffAssocRecursive(array $array1, array $array2) {

1811  $differenceArray = array();

1812  foreach ($array1 as $key => $value) {

1813  if (!array_key_exists($key, $array2)) {

1814  $differenceArray[$key] = $value;

1815  } elseif (is_array($value)) {

1816  if (is_array($array2[$key])) {

1817  $differenceArray[$key] = self::arrayDiffAssocRecursive($value, $array2[$key]);

1818  }

1819  }

1820  }

1821  return $differenceArray;

1822  }

1823 

1832  static public function csvValues(array $row, $delim = ',', $quote = '"') {

1833  $out = array();

1834  foreach ($row as $value) {

1835  $out[] = str_replace($quote, $quote . $quote, $value);

1836  }

1837  $str = $quote . implode(($quote . $delim . $quote), $out) . $quote;

1838  return $str;

1839  }

1840 

1848  static public function removeDotsFromTS(array $ts) {

1849  $out = array();

1850  foreach ($ts as $key => $value) {

1851  if (is_array($value)) {

1852  $key = rtrim($key, '.');

1853  $out[$key] = self::removeDotsFromTS($value);

1854  } else {

1855  $out[$key] = $value;

1856  }

1857  }

1858  return $out;

1859  }

1860 

1867  static public function naturalKeySortRecursive(&$array) {

1868  if (!is_array($array)) {

1869  return FALSE;

1870  }

1871  uksort($array, 'strnatcasecmp');

1872  foreach ($array as $key => $value) {

1873  self::naturalKeySortRecursive($array[$key]);

1874  }

1875  return TRUE;

1876  }

1877 

1878  /*************************

1879  *

1880  * HTML/XML PROCESSING

1881  *

1882  *************************/

1891  static public function get_tag_attributes($tag) {

1892  $components = self::split_tag_attributes($tag);

1893  // Attribute name is stored here

1894  $name = '';

1895  $valuemode = FALSE;

1896  $attributes = array();

1897  foreach ($components as $key => $val) {

1898  // 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

1899  if ($val != '=') {

1900  if ($valuemode) {

1901  if ($name) {

1902  $attributes[$name] = $val;

1903  $name = '';

1904  }

1905  } else {

1906  if ($key = strtolower(preg_replace('/[^[:alnum:]_\\:\\-]/', '', $val))) {

1907  $attributes[$key] = '';

1908  $name = $key;

1909  }

1910  }

1911  $valuemode = FALSE;

1912  } else {

1913  $valuemode = TRUE;

1914  }

1915  }

1916  return $attributes;

1917  }

1918 

1926  static public function split_tag_attributes($tag) {

1927  $tag_tmp = trim(preg_replace('/^<[^[:space:]]*/', '', trim($tag)));

1928  // Removes any > in the end of the string

1929  $tag_tmp = trim(rtrim($tag_tmp, '>'));

1930  $value = array();

1931  // Compared with empty string instead , 030102

1932  while ($tag_tmp !== '') {

1933  $firstChar = $tag_tmp[0];

1934  if ($firstChar === '"' || $firstChar === '\'') {

1935  $reg = explode($firstChar, $tag_tmp, 3);

1936  $value[] = $reg[1];

1937  $tag_tmp = trim($reg[2]);

1938  } elseif ($firstChar === '=') {

1939  $value[] = '=';

1940  // Removes = chars.

1941  $tag_tmp = trim(substr($tag_tmp, 1));

1942  } else {

1943  // There are '' around the value. We look for the next ' ' or '>'

1944  $reg = preg_split('/[[:space:]=]/', $tag_tmp, 2);

1945  $value[] = trim($reg[0]);

1946  $tag_tmp = trim(substr($tag_tmp, strlen($reg[0]), 1) . $reg[1]);

1947  }

1948  }

1949  reset($value);

1950  return $value;

1951  }

1952 

1961  static public function implodeAttributes(array $arr, $xhtmlSafe = FALSE, $dontOmitBlankAttribs = FALSE) {

1962  if ($xhtmlSafe) {

1963  $newArr = array();

1964  foreach ($arr as $p => $v) {

1965  if (!isset($newArr[strtolower($p)])) {

1966  $newArr[strtolower($p)] = htmlspecialchars($v);

1967  }

1968  }

1969  $arr = $newArr;

1970  }

1971  $list = array();

1972  foreach ($arr as $p => $v) {

1973  if ((string)$v !== '' || $dontOmitBlankAttribs) {

1974  $list[] = $p . '="' . $v . '"';

1975  }

1976  }

1977  return implode(' ', $list);

1978  }

1979 

1989  static public function wrapJS($string, $linebreak = TRUE) {

1990  if (trim($string)) {

1991  // <script wrapped in nl?

1992  $cr = $linebreak ? LF : '';

1993  // remove nl from the beginning

1994  $string = preg_replace('/^\\n+/', '', $string);

1995  // re-ident to one tab using the first line as reference

1996  $match = array();

1997  if (preg_match('/^(\\t+)/', $string, $match)) {

1998  $string = str_replace($match[1], TAB, $string);

1999  }

2000  $string = $cr . '<script type="text/javascript">

2001 /*<![CDATA[*/

2002 ' . $string . '

2003 /*]]>*/

2004 </script>' . $cr;

2005  }

2006  return trim($string);

2007  }

2008 

2017  static public function xml2tree($string, $depth = 999) {

2018  // Disables the functionality to allow external entities to be loaded when parsing the XML, must be kept

2019  $previousValueOfEntityLoader = libxml_disable_entity_loader(TRUE);

2020  $parser = xml_parser_create();

2021  $vals = array();

2022  $index = array();

2023  xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);

2024  xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 0);

2025  xml_parse_into_struct($parser, $string, $vals, $index);

2026  libxml_disable_entity_loader($previousValueOfEntityLoader);

2027  if (xml_get_error_code($parser)) {

2028  return 'Line ' . xml_get_current_line_number($parser) . ': ' . xml_error_string(xml_get_error_code($parser));

2029  }

2030  xml_parser_free($parser);

2031  $stack = array(array());

2032  $stacktop = 0;

2033  $startPoint = 0;

2034  $tagi = array();

2035  foreach ($vals as $key => $val) {

2036  $type = $val['type'];

2037  // open tag:

2038  if ($type == 'open' || $type == 'complete') {

2039  $stack[$stacktop++] = $tagi;

2040  if ($depth == $stacktop) {

2041  $startPoint = $key;

2042  }

2043  $tagi = array('tag' => $val['tag']);

2044  if (isset($val['attributes'])) {

2045  $tagi['attrs'] = $val['attributes'];

2046  }

2047  if (isset($val['value'])) {

2048  $tagi['values'][] = $val['value'];

2049  }

2050  }

2051  // finish tag:

2052  if ($type == 'complete' || $type == 'close') {

2053  $oldtagi = $tagi;

2054  $tagi = $stack[--$stacktop];

2055  $oldtag = $oldtagi['tag'];

2056  unset($oldtagi['tag']);

2057  if ($depth == $stacktop + 1) {

2058  if ($key - $startPoint > 0) {

2059  $partArray = array_slice($vals, $startPoint + 1, $key - $startPoint - 1);

2060  $oldtagi['XMLvalue'] = self::xmlRecompileFromStructValArray($partArray);

2061  } else {

2062  $oldtagi['XMLvalue'] = $oldtagi['values'][0];

2063  }

2064  }

2065  $tagi['ch'][$oldtag][] = $oldtagi;

2066  unset($oldtagi);

2067  }

2068  // cdata

2069  if ($type == 'cdata') {

2070  $tagi['values'][] = $val['value'];

2071  }

2072  }

2073  return $tagi['ch'];

2074  }

2075 

2086  static public function array2xml_cs(array $array, $docTag = 'phparray', array $options = array(), $charset = '') {

2087  // Set default charset unless explicitly specified

2088  $charset = $charset ?: 'utf-8';

2089  // Return XML:

2090  return '<?xml version="1.0" encoding="' . htmlspecialchars($charset) . '" standalone="yes" ?>' . LF . self::array2xml($array, '', 0, $docTag, 0, $options);

2091  }

2092 

2115  static public function array2xml(array $array, $NSprefix = '', $level = 0, $docTag = 'phparray', $spaceInd = 0, array $options = array(), array $stackData = array()) {

2116  // 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

2117  $binaryChars = chr(0) . chr(1) . chr(2) . chr(3) . chr(4) . chr(5) . chr(6) . chr(7) . chr(8) . chr(11) . chr(12) . chr(14) . chr(15) . chr(16) . chr(17) . chr(18) . chr(19) . chr(20) . chr(21) . chr(22) . chr(23) . chr(24) . chr(25) . chr(26) . chr(27) . chr(28) . chr(29) . chr(30) . chr(31);

2118  // Set indenting mode:

2119  $indentChar = $spaceInd ? ' ' : TAB;

2120  $indentN = $spaceInd > 0 ? $spaceInd : 1;

2121  $nl = $spaceInd >= 0 ? LF : '';

2122  // Init output variable:

2123  $output = '';

2124  // Traverse the input array

2125  foreach ($array as $k => $v) {

2126  $attr = '';

2127  $tagName = $k;

2128  // Construct the tag name.

2129  // Use tag based on grand-parent + parent tag name

2130  if (isset($options['grandParentTagMap'][$stackData['grandParentTagName'] . '/' . $stackData['parentTagName']])) {

2131  $attr .= ' index="' . htmlspecialchars($tagName) . '"';

2132  $tagName = (string) $options['grandParentTagMap'][($stackData['grandParentTagName'] . '/' . $stackData['parentTagName'])];

2133  } elseif (isset($options['parentTagMap'][$stackData['parentTagName'] . ':_IS_NUM']) && \TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($tagName)) {

2134  // Use tag based on parent tag name + if current tag is numeric

2135  $attr .= ' index="' . htmlspecialchars($tagName) . '"';

2136  $tagName = (string) $options['parentTagMap'][($stackData['parentTagName'] . ':_IS_NUM')];

2137  } elseif (isset($options['parentTagMap'][$stackData['parentTagName'] . ':' . $tagName])) {

2138  // Use tag based on parent tag name + current tag

2139  $attr .= ' index="' . htmlspecialchars($tagName) . '"';

2140  $tagName = (string) $options['parentTagMap'][($stackData['parentTagName'] . ':' . $tagName)];

2141  } elseif (isset($options['parentTagMap'][$stackData['parentTagName']])) {

2142  // Use tag based on parent tag name:

2143  $attr .= ' index="' . htmlspecialchars($tagName) . '"';

2144  $tagName = (string) $options['parentTagMap'][$stackData['parentTagName']];

2145  } elseif (MathUtility::canBeInterpretedAsInteger($tagName)) {

2146  // If integer...;

2147  if ($options['useNindex']) {

2148  // If numeric key, prefix "n"

2149  $tagName = 'n' . $tagName;

2150  } else {

2151  // Use special tag for num. keys:

2152  $attr .= ' index="' . $tagName . '"';

2153  $tagName = $options['useIndexTagForNum'] ?: 'numIndex';

2154  }

2155  } elseif ($options['useIndexTagForAssoc']) {

2156  // Use tag for all associative keys:

2157  $attr .= ' index="' . htmlspecialchars($tagName) . '"';

2158  $tagName = $options['useIndexTagForAssoc'];

2159  }

2160  // The tag name is cleaned up so only alphanumeric chars (plus - and _) are in there and not longer than 100 chars either.

2161  $tagName = substr(preg_replace('/[^[:alnum:]_-]/', '', $tagName), 0, 100);

2162  // If the value is an array then we will call this function recursively:

2163  if (is_array($v)) {

2164  // Sub elements:

2165  if ($options['alt_options'][$stackData['path'] . '/' . $tagName]) {

2166  $subOptions = $options['alt_options'][$stackData['path'] . '/' . $tagName];

2167  $clearStackPath = $subOptions['clearStackPath'];

2168  } else {

2169  $subOptions = $options;

2170  $clearStackPath = FALSE;

2171  }

2172  if (empty($v)) {

2173  $content = '';

2174  } else {

2175  $content = $nl . self::array2xml($v, $NSprefix, ($level + 1), '', $spaceInd, $subOptions, array(

2176  'parentTagName' => $tagName,

2177  'grandParentTagName' => $stackData['parentTagName'],

2178  'path' => ($clearStackPath ? '' : $stackData['path'] . '/' . $tagName)

2179  )) . ($spaceInd >= 0 ? str_pad('', ($level + 1) * $indentN, $indentChar) : '');

2180  }

2181  // Do not set "type = array". Makes prettier XML but means that empty arrays are not restored with xml2array

2182  if ((int)$options['disableTypeAttrib'] != 2) {

2183  $attr .= ' type="array"';

2184  }

2185  } else {

2186  // Just a value:

2187  // Look for binary chars:

2188  // Check for length, because PHP 5.2.0 may crash when first argument of strcspn is empty

2189  $vLen = strlen($v);

2190  // Go for base64 encoding if the initial segment NOT matching any binary char has the same length as the whole string!

2191  if ($vLen && strcspn($v, $binaryChars) != $vLen) {

2192  // If the value contained binary chars then we base64-encode it an set an attribute to notify this situation:

2193  $content = $nl . chunk_split(base64_encode($v));

2194  $attr .= ' base64="1"';

2195  } else {

2196  // Otherwise, just htmlspecialchar the stuff:

2197  $content = htmlspecialchars($v);

2198  $dType = gettype($v);

2199  if ($dType == 'string') {

2200  if ($options['useCDATA'] && $content != $v) {

2201  $content = '<![CDATA[' . $v . ']]>';

2202  }

2203  } elseif (!$options['disableTypeAttrib']) {

2204  $attr .= ' type="' . $dType . '"';

2205  }

2206  }

2207  }

2208  if ((string)$tagName !== '') {

2209  // Add the element to the output string:

2210  $output .= ($spaceInd >= 0 ? str_pad('', ($level + 1) * $indentN, $indentChar) : '')

2211  . '<' . $NSprefix . $tagName . $attr . '>' . $content . '</' . $NSprefix . $tagName . '>' . $nl;

2212  }

2213  }

2214  // If we are at the outer-most level, then we finally wrap it all in the document tags and return that as the value:

2215  if (!$level) {

2216  $output = '<' . $docTag . '>' . $nl . $output . '</' . $docTag . '>';

2217  }

2218  return $output;

2219  }

2220 

2232  static public function xml2array($string, $NSprefix = '', $reportDocTag = FALSE) {

2233  static $firstLevelCache = array();

2234  $identifier = md5($string . $NSprefix . ($reportDocTag ? '1' : '0'));

2235  // Look up in first level cache

2236  if (!empty($firstLevelCache[$identifier])) {

2237  $array = $firstLevelCache[$identifier];

2238  } else {

2239  // Look up in second level cache

2240  $array = \TYPO3\CMS\Frontend\Page\PageRepository::getHash($identifier, 0);

2241  if (!is_array($array)) {

2242  $array = self::xml2arrayProcess($string, $NSprefix, $reportDocTag);

2243  \TYPO3\CMS\Frontend\Page\PageRepository::storeHash($identifier, $array, 'ident_xml2array');

2244  }

2245  // Store content in first level cache

2246  $firstLevelCache[$identifier] = $array;

2247  }

2248  return $array;

2249  }

2250 

2261  static protected function xml2arrayProcess($string, $NSprefix = '', $reportDocTag = FALSE) {

2262  // Disables the functionality to allow external entities to be loaded when parsing the XML, must be kept

2263  $previousValueOfEntityLoader = libxml_disable_entity_loader(TRUE);

2264  // Create parser:

2265  $parser = xml_parser_create();

2266  $vals = array();

2267  $index = array();

2268  xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);

2269  xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 0);

2270  // Default output charset is UTF-8, only ASCII, ISO-8859-1 and UTF-8 are supported!!!

2271  $match = array();

2272  preg_match('/^[[:space:]]*<\\?xml[^>]*encoding[[:space:]]*=[[:space:]]*"([^"]*)"/', substr($string, 0, 200), $match);

2273  $theCharset = $match[1] ?: 'utf-8';

2274  // us-ascii / utf-8 / iso-8859-1

2275  xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, $theCharset);

2276  // Parse content:

2277  xml_parse_into_struct($parser, $string, $vals, $index);

2278  libxml_disable_entity_loader($previousValueOfEntityLoader);

2279  // If error, return error message:

2280  if (xml_get_error_code($parser)) {

2281  return 'Line ' . xml_get_current_line_number($parser) . ': ' . xml_error_string(xml_get_error_code($parser));

2282  }

2283  xml_parser_free($parser);

2284  // Init vars:

2285  $stack = array(array());

2286  $stacktop = 0;

2287  $current = array();

2288  $tagName = '';

2289  $documentTag = '';

2290  // Traverse the parsed XML structure:

2291  foreach ($vals as $key => $val) {

2292  // First, process the tag-name (which is used in both cases, whether "complete" or "close")

2293  $tagName = $val['tag'];

2294  if (!$documentTag) {

2295  $documentTag = $tagName;

2296  }

2297  // Test for name space:

2298  $tagName = $NSprefix && substr($tagName, 0, strlen($NSprefix)) == $NSprefix ? substr($tagName, strlen($NSprefix)) : $tagName;

2299  // Test for numeric tag, encoded on the form "nXXX":

2300  $testNtag = substr($tagName, 1);

2301  // Closing tag.

2302  $tagName = $tagName[0] === 'n' && MathUtility::canBeInterpretedAsInteger($testNtag) ? (int)$testNtag : $tagName;

2303  // Test for alternative index value:

2304  if (strlen($val['attributes']['index'])) {

2305  $tagName = $val['attributes']['index'];

2306  }

2307  // Setting tag-values, manage stack:

2308  switch ($val['type']) {

2309  case 'open':

2310  // If open tag it means there is an array stored in sub-elements. Therefore increase the stackpointer and reset the accumulation array:

2311  // Setting blank place holder

2312  $current[$tagName] = array();

2313  $stack[$stacktop++] = $current;

2314  $current = array();

2315  break;

2316  case 'close':

2317  // If the tag is "close" then it is an array which is closing and we decrease the stack pointer.

2318  $oldCurrent = $current;

2319  $current = $stack[--$stacktop];

2320  // Going to the end of array to get placeholder key, key($current), and fill in array next:

2321  end($current);

2322  $current[key($current)] = $oldCurrent;

2323  unset($oldCurrent);

2324  break;

2325  case 'complete':

2326  // If "complete", then it's a value. If the attribute "base64" is set, then decode the value, otherwise just set it.

2327  if ($val['attributes']['base64']) {

2328  $current[$tagName] = base64_decode($val['value']);

2329  } else {

2330  // Had to cast it as a string - otherwise it would be evaluate FALSE if tested with isset()!!

2331  $current[$tagName] = (string) $val['value'];

2332  // Cast type:

2333  switch ((string) $val['attributes']['type']) {

2334  case 'integer':

2335  $current[$tagName] = (int)$current[$tagName];

2336  break;

2337  case 'double':

2338  $current[$tagName] = (double) $current[$tagName];

2339  break;

2340  case 'boolean':

2341  $current[$tagName] = (bool) $current[$tagName];

2342  break;

2343  case 'NULL':

2344  $current[$tagName] = NULL;

2345  break;

2346  case 'array':

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

2348  $current[$tagName] = array();

2349  break;

2350  }

2351  }

2352  break;

2353  }

2354  }

2355  if ($reportDocTag) {

2356  $current[$tagName]['_DOCUMENT_TAG'] = $documentTag;

2357  }

2358  // Finally return the content of the document tag.

2359  return $current[$tagName];

2360  }

2361 

2368  static public function xmlRecompileFromStructValArray(array $vals) {

2369  $XMLcontent = '';

2370  foreach ($vals as $val) {

2371  $type = $val['type'];

2372  // Open tag:

2373  if ($type == 'open' || $type == 'complete') {

2374  $XMLcontent .= '<' . $val['tag'];

2375  if (isset($val['attributes'])) {

2376  foreach ($val['attributes'] as $k => $v) {

2377  $XMLcontent .= ' ' . $k . '="' . htmlspecialchars($v) . '"';

2378  }

2379  }

2380  if ($type == 'complete') {

2381  if (isset($val['value'])) {

2382  $XMLcontent .= '>' . htmlspecialchars($val['value']) . '</' . $val['tag'] . '>';

2383  } else {

2384  $XMLcontent .= '/>';

2385  }

2386  } else {

2387  $XMLcontent .= '>';

2388  }

2389  if ($type == 'open' && isset($val['value'])) {

2390  $XMLcontent .= htmlspecialchars($val['value']);

2391  }

2392  }

2393  // Finish tag:

2394  if ($type == 'close') {

2395  $XMLcontent .= '</' . $val['tag'] . '>';

2396  }

2397  // Cdata

2398  if ($type == 'cdata') {

2399  $XMLcontent .= htmlspecialchars($val['value']);

2400  }

2401  }

2402  return $XMLcontent;

2403  }

2404 

2411  static public function xmlGetHeaderAttribs($xmlData) {

2412  $match = array();

2413  if (preg_match('/^\\s*<\\?xml([^>]*)\\?\\>/', $xmlData, $match)) {

2414  return self::get_tag_attributes($match[1]);

2415  }

2416  }

2417 

2425  static public function minifyJavaScript($script, &$error = '') {

2426  if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['minifyJavaScript'])) {

2427  $fakeThis = FALSE;

2428  foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['minifyJavaScript'] as $hookMethod) {

2429  try {

2430  $parameters = array('script' => $script);

2431  $script = static::callUserFunction($hookMethod, $parameters, $fakeThis);

2432  } catch (\Exception $e) {

2433  $errorMessage = 'Error minifying java script: ' . $e->getMessage();

2434  $error .= $errorMessage;

2435  static::devLog($errorMessage, 'TYPO3\\CMS\\Core\\Utility\\GeneralUtility', 2, array(

2436  'JavaScript' => $script,

2437  'Stack trace' => $e->getTrace(),

2438  'hook' => $hookMethod

2439  ));

2440  }

2441  }

2442  }

2443  return $script;

2444  }

2445 

2446  /*************************

2447  *

2448  * FILES FUNCTIONS

2449  *

2450  *************************/

2461  static public function getUrl($url, $includeHeader = 0, $requestHeaders = FALSE, &$report = NULL) {

2462  $content = FALSE;

2463  if (isset($report)) {

2464  $report['error'] = 0;

2465  $report['message'] = '';

2466  }

2467  // Use cURL for: http, https, ftp, ftps, sftp and scp

2468  if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlUse'] == '1' && preg_match('/^(?:http|ftp)s?|s(?:ftp|cp):/', $url)) {

2469  if (isset($report)) {

2470  $report['lib'] = 'cURL';

2471  }

2472  // External URL without error checking.

2473  if (!function_exists('curl_init') || !($ch = curl_init())) {

2474  if (isset($report)) {

2475  $report['error'] = -1;

2476  $report['message'] = 'Couldn\'t initialize cURL.';

2477  }

2478  return FALSE;

2479  }

2480 

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

2482 

2483  $curlIncludeHeaders = !$followLocationSucceeded || $includeHeader;

2484  curl_setopt($ch, CURLOPT_URL, $url);

2485  curl_setopt($ch, CURLOPT_HEADER, $curlIncludeHeaders ? 1 : 0);

2486  curl_setopt($ch, CURLOPT_NOBODY, $includeHeader == 2 ? 1 : 0);

2487  curl_setopt($ch, CURLOPT_HTTPGET, $includeHeader == 2 ? 'HEAD' : 'GET');

2488  curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

2489  curl_setopt($ch, CURLOPT_FAILONERROR, 1);

2490  curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, max(0, (int)$GLOBALS['TYPO3_CONF_VARS']['SYS']['curlTimeout']));

2491 

2492  if (is_array($requestHeaders)) {

2493  curl_setopt($ch, CURLOPT_HTTPHEADER, $requestHeaders);

2494  }

2495  // (Proxy support implemented by Arco <arco@appeltaart.mine.nu>)

2496  if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyServer']) {

2497  curl_setopt($ch, CURLOPT_PROXY, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyServer']);

2498  if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyNTLM']) {

2499  curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_NTLM);

2500  }

2501  if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyTunnel']) {

2502  curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyTunnel']);

2503  }

2504  if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyUserPass']) {

2505  curl_setopt($ch, CURLOPT_PROXYUSERPWD, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyUserPass']);

2506  }

2507  }

2508  $content = curl_exec($ch);

2509  $curlInfo = curl_getinfo($ch);

2510 

2511  // Remove additional proxy header block, when proxy is used for https request and CURL_HEADER is enabled.

2512  // Most HTTPS proxies add a second header before the actual server headers in their response, as a

2513  // response to the CONNECT message sent by the client to the proxy. cURL does not strip this since 2005,

2514  // so there are two headers arriving here, of which the first is not of interest to us—therefore, we can

2515  // safely strip it.

2516  // Detecting two linebreaks followed by a "HTTP/" (as done here) is the only reliable way to detect the

2517  // proxy headers, as the relevant RFCs do not specify the exact status code (it might be any of 2xx) or

2518  // the status message. Therefore, we check if there is a second HTTP headers block and then strip the

2519  // first one.

2520  if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyServer']

2521  && $curlIncludeHeaders

2522  && preg_match('/^https:/', $url)

2523  && strpos($content, "\r\n\r\nHTTP/") !== false

2524  ) {

2525  $content = self::stripHttpHeaders($content);

2526  }

2527 

2528  if (!$followLocationSucceeded) {

2529  // Check if we need to do redirects

2530  if ($curlInfo['http_code'] >= 300 && $curlInfo['http_code'] < 400) {

2531  $locationUrl = $curlInfo['redirect_url'];

2532  if (!$locationUrl) {

2533  // Some curllib versions do not return redirect_url. Examine headers.

2534  $locationUrl = self::getRedirectUrlFromHttpHeaders($content);

2535  }

2536  if ($locationUrl) {

2537  $content = self::getUrl($locationUrl, $includeHeader, $requestHeaders, $report);

2538  $followLocationSucceeded = TRUE;

2539  } else {

2540  // Failure: we got a redirection status code but not the URL to redirect to.

2541  $content = FALSE;

2542  }

2543  }

2544  if ($content && !$includeHeader) {

2545  $content = self::stripHttpHeaders($content);

2546  }

2547  }

2548 

2549  if (isset($report)) {

2550  if (!$followLocationSucceeded && $curlInfo['http_code'] >= 300 && $curlInfo['http_code'] < 400) {

2551  $report['http_code'] = $curlInfo['http_code'];

2552  $report['content_type'] = $curlInfo['content_type'];

2553  $report['error'] = CURLE_GOT_NOTHING;

2554  $report['message'] = 'Expected "Location" header but got nothing.';

2555  } elseif ($content === FALSE) {

2556  $report['error'] = curl_errno($ch);

2557  $report['message'] = curl_error($ch);

2558  } elseif ($includeHeader) {

2559  // Set only for $includeHeader to work exactly like PHP variant

2560  $report['http_code'] = $curlInfo['http_code'];

2561  $report['content_type'] = $curlInfo['content_type'];

2562  }

2563  }

2564  curl_close($ch);

2565  } elseif ($includeHeader) {

2566  if (isset($report)) {

2567  $report['lib'] = 'socket';

2568  }

2569  $parsedURL = parse_url($url);

2570  if (!preg_match('/^https?/', $parsedURL['scheme'])) {

2571  if (isset($report)) {

2572  $report['error'] = -1;

2573  $report['message'] = 'Reading headers is not allowed for this protocol.';

2574  }

2575  return FALSE;

2576  }

2577  $port = (int)$parsedURL['port'];

2578  if ($port < 1) {

2579  if ($parsedURL['scheme'] == 'http') {

2580  $port = $port > 0 ? $port : 80;

2581  $scheme = '';

2582  } else {

2583  $port = $port > 0 ? $port : 443;

2584  $scheme = 'ssl://';

2585  }

2586  }

2587  $errno = 0;

2588  $fp = @fsockopen(($scheme . $parsedURL['host']), $port, $errno, $errstr, 2.0);

2589  if (!$fp || $errno > 0) {

2590  if (isset($report)) {

2591  $report['error'] = $errno ?: -1;

2592  $report['message'] = $errno ? ($errstr ?: 'Socket error.') : 'Socket initialization error.';

2593  }

2594  return FALSE;

2595  }

2596  $method = $includeHeader == 2 ? 'HEAD' : 'GET';

2597  $msg = $method . ' ' . (isset($parsedURL['path']) ? $parsedURL['path'] : '/')

2598  . ($parsedURL['query'] ? '?' . $parsedURL['query'] : '') . ' HTTP/1.0' . CRLF

2599  . 'Host: ' . $parsedURL['host'] . CRLF

2600  . 'Connection: close' . CRLF;

2601  if (is_array($requestHeaders)) {

2602  $msg .= implode(CRLF, $requestHeaders) . CRLF;

2603  }

2604  $msg .= CRLF;

2605  fputs($fp, $msg);

2606  while (!feof($fp)) {

2607  $line = fgets($fp, 2048);

2608  if (isset($report)) {

2609  if (preg_match('|^HTTP/\\d\\.\\d +(\\d+)|', $line, $status)) {

2610  $report['http_code'] = $status[1];

2611  } elseif (preg_match('/^Content-Type: *(.*)/i', $line, $type)) {

2612  $report['content_type'] = $type[1];

2613  }

2614  }

2615  $content .= $line;

2616  if (!strlen(trim($line))) {

2617  // Stop at the first empty line (= end of header)

2618  break;

2619  }

2620  }

2621  if ($includeHeader != 2) {

2622  $content .= stream_get_contents($fp);

2623  }

2624  fclose($fp);

2625  } elseif (is_array($requestHeaders)) {

2626  if (isset($report)) {

2627  $report['lib'] = 'file/context';

2628  }

2629  $parsedURL = parse_url($url);

2630  if (!preg_match('/^https?/', $parsedURL['scheme'])) {

2631  if (isset($report)) {

2632  $report['error'] = -1;

2633  $report['message'] = 'Sending request headers is not allowed for this protocol.';

2634  }

2635  return FALSE;

2636  }

2637  $ctx = stream_context_create(array(

2638  'http' => array(

2639  'header' => implode(CRLF, $requestHeaders)

2640  )

2641  ));

2642  $content = @file_get_contents($url, FALSE, $ctx);

2643  if ($content === FALSE && isset($report)) {

2644  $report['error'] = -1;

2645  $report['message'] = 'Couldn\'t get URL: ' . (isset($http_response_header) ? implode(LF, $http_response_header) : $url);

2646  }

2647  } else {

2648  if (isset($report)) {

2649  $report['lib'] = 'file';

2650  }

2651  $content = @file_get_contents($url);

2652  if ($content === FALSE && isset($report)) {

2653  $report['error'] = -1;

2654  $report['message'] = 'Couldn\'t get URL: ' . (isset($http_response_header) ? implode(LF, $http_response_header) : $url);

2655  }

2656  }

2657  return $content;

2658  }

2659 

2667  static protected function getRedirectUrlFromHttpHeaders($content) {

2668  $result = '';

2669  $headers = explode("\r\n", $content);

2670  foreach ($headers as $header) {

2671  if ($header == '') {

2672  break;

2673  }

2674  if (preg_match('/^\s*Location\s*:/i', $header)) {

2675  list(, $result) = self::trimExplode(':', $header, FALSE, 2);

2676  if ($result) {

2677  $result = self::locationHeaderUrl($result);

2678  }

2679  break;

2680  }

2681  }

2682  return $result;

2683  }

2684 

2691  static protected function stripHttpHeaders($content) {

2692  $headersEndPos = strpos($content, "\r\n\r\n");

2693  if ($headersEndPos) {

2694  $content = substr($content, $headersEndPos + 4);

2695  }

2696  return $content;

2697  }

2698 

2707  static public function writeFile($file, $content, $changePermissions = FALSE) {

2708  if (!@is_file($file)) {

2709  $changePermissions = TRUE;

2710  }

2711  if ($fd = fopen($file, 'wb')) {

2712  $res = fwrite($fd, $content);

2713  fclose($fd);

2714  if ($res === FALSE) {

2715  return FALSE;

2716  }

2717  // Change the permissions only if the file has just been created

2718  if ($changePermissions) {

2719  self::fixPermissions($file);

2720  }

2721  return TRUE;

2722  }

2723  return FALSE;

2724  }

2725 

2733  static public function fixPermissions($path, $recursive = FALSE) {

2734  if (TYPO3_OS != 'WIN') {

2735  $result = FALSE;

2736  // Make path absolute

2737  if (!self::isAbsPath($path)) {

2738  $path = self::getFileAbsFileName($path, FALSE);

2739  }

2740  if (self::isAllowedAbsPath($path)) {

2741  if (@is_file($path)) {

2742  $targetFilePermissions = isset($GLOBALS['TYPO3_CONF_VARS']['BE']['fileCreateMask'])

2743  ? octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['fileCreateMask'])

2744  : octdec('0644');

2745  // "@" is there because file is not necessarily OWNED by the user

2746  $result = @chmod($path, $targetFilePermissions);

2747  } elseif (@is_dir($path)) {

2748  $targetDirectoryPermissions = isset($GLOBALS['TYPO3_CONF_VARS']['BE']['folderCreateMask'])

2749  ? octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['folderCreateMask'])

2750  : octdec('0755');

2751  // "@" is there because file is not necessarily OWNED by the user

2752  $result = @chmod($path, $targetDirectoryPermissions);

2753  }

2754  // Set createGroup if not empty

2755  if (

2756  isset($GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup'])

2757  && strlen($GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup']) > 0

2758  ) {

2759  // "@" is there because file is not necessarily OWNED by the user

2760  $changeGroupResult = @chgrp($path, $GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup']);

2761  $result = $changeGroupResult ? $result : FALSE;

2762  }

2763  // Call recursive if recursive flag if set and $path is directory

2764  if ($recursive && @is_dir($path)) {

2765  $handle = opendir($path);

2766  while (($file = readdir($handle)) !== FALSE) {

2767  $recursionResult = NULL;

2768  if ($file !== '.' && $file !== '..') {

2769  if (@is_file(($path . '/' . $file))) {

2770  $recursionResult = self::fixPermissions($path . '/' . $file);

2771  } elseif (@is_dir(($path . '/' . $file))) {

2772  $recursionResult = self::fixPermissions($path . '/' . $file, TRUE);

2773  }

2774  if (isset($recursionResult) && !$recursionResult) {

2775  $result = FALSE;

2776  }

2777  }

2778  }

2779  closedir($handle);

2780  }

2781  }

2782  } else {

2783  $result = TRUE;

2784  }

2785  return $result;

2786  }

2787 

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

2797  // Parse filepath into directory and basename:

2798  $fI = pathinfo($filepath);

2799  $fI['dirname'] .= '/';

2800  // Check parts:

2801  if (self::validPathStr($filepath) && $fI['basename'] && strlen($fI['basename']) < 60) {