| blob | 3a3ba92019761f228163758e290105558ef9f0c6 |
1 <?php
2 /***************************************************************
3 * Copyright notice
4 *
5 * (c) 1999-2011 Kasper Skårhøj (kasperYYYY@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 ***************************************************************/
28 // a tabulator
30 // a linefeed
32 // a carriage return
34 // a CR-LF combination
37 /**
38 * The legendary "t3lib_div" class - Miscellaneous functions for general purpose.
39 * Most of the functions do not relate specifically to TYPO3
40 * However a section of functions requires certain TYPO3 features available
41 * See comments in the source.
42 * You are encouraged to use this library in your own scripts!
43 *
44 * USE:
45 * The class is intended to be used without creating an instance of it.
46 * So: Don't instantiate - call functions with "t3lib_div::" prefixed the function name.
47 * So use t3lib_div::[method-name] to refer to the functions, eg. 't3lib_div::milliseconds()'
48 *
49 * @author Kasper Skårhøj <kasperYYYY@typo3.com>
50 * @package TYPO3
51 * @subpackage t3lib
52 */
55 // Severity constants used by t3lib_div::sysLog()
62 /**
63 * Singleton instances returned by makeInstance, using the class names as
64 * array keys
65 *
66 * @var array<t3lib_Singleton>
67 */
70 /**
71 * Instances returned by makeInstance, using the class names as array keys
72 *
73 * @var array<array><object>
74 */
77 /**
78 * Register for makeInstance with given class name and final class names to reduce number of class_exists() calls
79 *
80 * @var array Given class name => final class name
81 */
84 /*************************
85 *
86 * GET/POST Variables
87 *
88 * Background:
89 * Input GET/POST variables in PHP may have their quotes escaped with "\" or not depending on configuration.
90 * TYPO3 has always converted quotes to BE escaped if the configuration told that they would not be so.
91 * But the clean solution is that quotes are never escaped and that is what the functions below offers.
92 * Eventually TYPO3 should provide this in the global space as well.
93 * In the transitional phase (or forever..?) we need to encourage EVERY to read and write GET/POST vars through the API functions below.
94 *
95 *************************/
97 /**
98 * Returns the 'GLOBAL' value of incoming data from POST or GET, with priority to POST (that is equalent to 'GP' order)
99 * Strips slashes from all output, both strings and arrays.
100 * To enhancement security in your scripts, please consider using t3lib_div::_GET or t3lib_div::_POST if you already
101 * know by which method your data is arriving to the scripts!
102 *
103 * @param string $var GET/POST var to return
104 * @return mixed POST var named $var and if not set, the GET var of the same name.
105 */
109 }
116 }
117 }
119 }
121 /**
122 * Returns the global arrays $_GET and $_POST merged with $_POST taking precedence.
123 *
124 * @param string $parameter Key (variable name) from GET or POST vars
125 * @return array Returns the GET vars merged recursively onto the POST vars.
126 */
128 $postParameter = (isset($_POST[$parameter]) && is_array($_POST[$parameter])) ? $_POST[$parameter] : array();
129 $getParameter = (isset($_GET[$parameter]) && is_array($_GET[$parameter])) ? $_GET[$parameter] : array();
135 }
137 /**
138 * Returns the global $_GET array (or value from) normalized to contain un-escaped values.
139 * ALWAYS use this API function to acquire the GET variables!
140 *
141 * @param string $var Optional pointer to value in GET array (basically name of GET var)
142 * @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!*
143 * @see _POST(), _GP(), _GETset()
144 */
147 if (isset($value)) { // Removes slashes since TYPO3 has added them regardless of magic_quotes setting.
152 }
153 }
155 }
157 /**
158 * Returns the global $_POST array (or value from) normalized to contain un-escaped values.
159 * ALWAYS use this API function to acquire the $_POST variables!
160 *
161 * @param string $var Optional pointer to value in POST array (basically name of POST var)
162 * @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!*
163 * @see _GET(), _GP()
164 */
167 if (isset($value)) { // Removes slashes since TYPO3 has added them regardless of magic_quotes setting.
172 }
173 }
175 }
177 /**
178 * Writes input value to $_GET.
179 *
180 * @param mixed $inputGet
181 * array or single value to write to $_GET. Values should NOT be
182 * escaped at input time (but will be escaped before writing
183 * according to TYPO3 standards).
184 * @param string $key
185 * alternative key; If set, this will not set the WHOLE GET array,
186 * but only the key in it specified by this value!
187 * You can specify to replace keys on deeper array levels by
188 * separating the keys with a pipe.
189 * Example: 'parentKey|childKey' will result in
190 * array('parentKey' => array('childKey' => $inputGet))
191 *
192 * @return void
193 */
195 // adds slashes since TYPO3 standard currently is that slashes
196 // must be applied (regardless of magic_quotes setting)
201 }
210 }
214 );
221 }
225 }
226 }
228 /**
229 * Wrapper for the RemoveXSS function.
230 * Removes potential XSS code from an input string.
231 *
232 * Using an external class by Travis Puderbaugh <kallahar@quickwired.com>
233 *
234 * @param string $string Input string
235 * @return string Input string with potential XSS code removed
236 */
241 }
244 /*************************
245 *
246 * IMAGE FUNCTIONS
247 *
248 *************************/
251 /**
252 * Compressing a GIF file if not already LZW compressed.
253 * 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)
254 *
255 * The function takes a file-reference, $theFile, and saves it again through GD or ImageMagick in order to compress the file
256 * GIF:
257 * 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!)
258 * If $type is set to either 'IM' or 'GD' the compression is done with ImageMagick and GD respectively
259 * PNG:
260 * No changes.
261 *
262 * $theFile is expected to be a valid GIF-file!
263 * The function returns a code for the operation.
264 *
265 * @param string $theFile Filepath
266 * @param string $type See description of function
267 * @return string Returns "GD" if GD was used, otherwise "IM" if ImageMagick was used. If nothing done at all, it returns empty string.
268 */
274 // use temporary file to prevent problems with read and write lock on same file on network file systems
276 // rename could fail, if a simultaneous thread is currently working on the same thing
278 $cmd = self::imageMagickCommand('convert', '"' . $temporaryName . '" "' . $theFile . '"', $gfxConf['im_path_lzw']);
281 }
286 }
294 }
295 }
296 }
298 }
300 /**
301 * Converts a png file to gif.
302 * This converts a png file to gif IF the FLAG $GLOBALS['TYPO3_CONF_VARS']['FE']['png_to_gif'] is set TRUE.
303 *
304 * @param string $theFile the filename with path
305 * @return string new filename
306 */
314 $cmd = self::imageMagickCommand('convert', '"' . $theFile . '" "' . $newFile . '"', $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw']);
319 }
320 // unlink old file?? May be bad idea because TYPO3 would then recreate the file every time as
321 // TYPO3 thinks the file is not generated because it's missing!! So do not unlink $theFile here!!
322 }
324 }
326 /**
327 * Returns filename of the png/gif version of the input file (which can be png or gif).
328 * If input file type does not match the wanted output type a conversion is made and temp-filename returned.
329 *
330 * @param string $theFile Filepath of image file
331 * @param boolean $output_png If set, then input file is converted to PNG, otherwise to GIF
332 * @return string If the new image file exists, its filepath is returned
333 */
340 ) {
343 $newFile = PATH_site . 'typo3temp/readPG_' . md5($theFile . '|' . filemtime($theFile)) . ($output_png ? '.png' : '.gif');
344 $cmd = self::imageMagickCommand('convert', '"' . $theFile . '" "' . $newFile . '"', $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path']);
349 }
350 }
351 }
352 }
355 /*************************
356 *
357 * STRING FUNCTIONS
358 *
359 *************************/
361 /**
362 * Truncates a string with appended/prepended "..." and takes current character set into consideration.
363 *
364 * @param string $string string to truncate
365 * @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.
366 * @param string $appendString appendix to the truncated string
367 * @return string cropped string
368 */
371 return $GLOBALS['LANG']->csConvObj->crop($GLOBALS['LANG']->charSet, $string, $chars, $appendString);
373 $charSet = ($GLOBALS['TSFE']->renderCharset != '' ? $GLOBALS['TSFE']->renderCharset : $GLOBALS['TSFE']->defaultCharSet);
376 // this case should not happen
379 }
380 }
382 /**
383 * Breaks up a single line of text for emails
384 *
385 * @param string $str The string to break up
386 * @param string $newlineChar The string to implode the broken lines with (default/typically \n)
387 * @param integer $lineWidth The line width
388 * @return string reformatted text
389 * @deprecated since TYPO3 4.6, will be removed in TYPO3 6.0 - Use t3lib_utility_Mail::breakLinesForEmail()
390 */
394 }
396 /**
397 * Match IP number with list of numbers with wildcard
398 * Dispatcher method for switching into specialised IPv4 and IPv6 methods.
399 *
400 * @param string $baseIP is the current remote IP address for instance, typ. REMOTE_ADDR
401 * @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.
402 * @return boolean TRUE if an IP-mask from $list matches $baseIP
403 */
410 }
415 }
416 }
418 /**
419 * Match IPv4 number with list of numbers with wildcard
420 *
421 * @param string $baseIP is the current remote IP address for instance, typ. REMOTE_ADDR
422 * @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), could also contain IPv6 addresses
423 * @return boolean TRUE if an IP-mask from $list matches $baseIP
424 */
436 }
439 // "192.168.3.0/24"
448 // "192.168.*.*"
455 }
456 }
457 }
460 }
461 }
462 }
464 }
466 /**
467 * Match IPv6 address with a list of IPv6 prefixes
468 *
469 * @param string $baseIP is the current remote IP address for instance
470 * @param string $list is a comma-list of IPv6 prefixes, could also contain IPv4 addresses
471 * @return boolean TRUE if an baseIP matches any prefix
472 */
484 }
498 // modulo is 0 if this is a 8-bit-boundary
502 if (substr($testBin, 0, $numFullCharactersUntilBoundary) !== substr($baseIPBin, 0, $numFullCharactersUntilBoundary)) {
505 // if not an 8-bit-boundary, check bits of last character
506 $testLastBits = str_pad(decbin(ord(substr($testBin, $numFullCharactersUntilBoundary, 1))), 8, '0', STR_PAD_LEFT);
507 $baseIPLastBits = str_pad(decbin(ord(substr($baseIPBin, $numFullCharactersUntilBoundary, 1))), 8, '0', STR_PAD_LEFT);
510 }
511 }
512 }
513 }
516 }
517 }
519 }
521 /**
522 * Transform a regular IPv6 address from hex-representation into binary
523 *
524 * @param string $hex IPv6 address in hex-presentation
525 * @return string Binary representation (16 characters, 128 characters)
526 * @see IPv6Bin2Hex()
527 */
529 // use PHP-function if PHP was compiled with IPv6-support
536 }
538 }
540 /**
541 * Transform an IPv6 address from binary to hex-representation
542 *
543 * @param string $bin IPv6 address in hex-presentation
544 * @return string Binary representation (16 characters, 128 characters)
545 * @see IPv6Hex2Bin()
546 */
548 // use PHP-function if PHP was compiled with IPv6-support
554 // strip last colon (from chunk_split)
556 // IPv6 is now in normalized form
557 // compress it for easier handling and to match result from inet_ntop()
559 }
562 }
564 /**
565 * Normalize an IPv6 address to full length
566 *
567 * @param string $address Given IPv6 address
568 * @return string Normalized address
569 * @see compressIPv6()
570 */
575 // according to RFC lowercase-representation is recommended
578 // normalized representation has 39 characters (0000:0000:0000:0000:0000:0000:0000:0000)
580 // already in full expanded form
582 }
591 // Special case: leading zero-only blocks count to 1, should be 0
594 }
602 }
608 }
611 }
613 // normalize the blocks:
623 }
628 }
629 }
631 }
634 /**
635 * Compress an IPv6 address to the shortest notation
636 *
637 * @param string $address Given IPv6 address
638 * @return string Compressed address
639 * @see normalizeIPv6()
640 */
642 // use PHP-function if PHP was compiled with IPv6-support
649 // append one colon for easier handling
650 // will be removed later
653 // according to IPv6-notation the longest match
654 // of a package of '0000:' may be replaced with ':'
655 // (resulting in something like '1234::abcd')
661 }
662 }
664 // up to 3 zeros in the first part may be removed
666 // up to 3 zeros at the beginning of other parts may be removed
669 // strip last colon (from chunk_split)
671 }
673 }
675 /**
676 * Validate a given IP address.
677 *
678 * Possible format are IPv4 and IPv6.
679 *
680 * @param string $ip IP address to be tested
681 * @return boolean TRUE if $ip is either of IPv4 or IPv6 format.
682 */
685 }
687 /**
688 * Validate a given IP address to the IPv4 address format.
689 *
690 * Example for possible format: 10.0.45.99
691 *
692 * @param string $ip IP address to be tested
693 * @return boolean TRUE if $ip is of IPv4 format.
694 */
697 }
699 /**
700 * Validate a given IP address to the IPv6 address format.
701 *
702 * Example for possible format: 43FB::BB3F:A0A0:0 | ::1
703 *
704 * @param string $ip IP address to be tested
705 * @return boolean TRUE if $ip is of IPv6 format.
706 */
709 }
711 /**
712 * Match fully qualified domain name with list of strings with wildcard
713 *
714 * @param string $baseHost A hostname or an IPv4/IPv6-address (will by reverse-resolved; typically REMOTE_ADDR)
715 * @param string $list 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)
716 * @return boolean TRUE if a domain name mask from $list matches $baseIP
717 */
722 }
724 // resolve hostname
725 // note: this is reverse-lookup and can be randomly set as soon as somebody is able to set
726 // the reverse-DNS for his IP (security when for example used with REMOTE_ADDR)
729 // unable to resolve hostname
731 }
734 }
742 // to match hostNameParts can only be shorter (in case of wildcards) or equal
745 }
751 // wildcard valid for one or more hostname-parts
754 // wildcard as last/only part always matches, otherwise perform recursive checks
762 }
764 // match found by recursive compare
768 }
769 }
771 // in case of no match
773 }
774 }
777 }
778 }
780 }
782 /**
783 * Checks if a given URL matches the host that currently handles this HTTP request.
784 * Scheme, hostname and (optional) port of the given URL are compared.
785 *
786 * @param string $url: URL to compare with the TYPO3 request host
787 * @return boolean Whether the URL matches the TYPO3 request host
788 */
791 }
793 /**
794 * Check for item in list
795 * Check if an item exists in a comma-separated list of items.
796 *
797 * @param string $list comma-separated list of items (string)
798 * @param string $item item to check for
799 * @return boolean TRUE if $item is in $list
800 */
803 }
805 /**
806 * Removes an item from a comma-separated list of items.
807 *
808 * @param string $element element to remove
809 * @param string $list comma-separated list of items (string)
810 * @return string new comma-separated list of items
811 */
817 }
818 }
820 }
822 /**
823 * Expand a comma-separated list of integers with ranges (eg 1,3-5,7 becomes 1,3,4,5,7).
824 * Ranges are limited to 1000 values per range.
825 *
826 * @param string $list comma-separated list of integers with ranges (string)
827 * @return string new comma-separated list of items
828 */
842 }
843 }
846 }
847 }
849 }
851 /**
852 * Forces the integer $theInt into the boundaries of $min and $max. If the $theInt is 'FALSE' then the $zeroValue is applied.
853 *
854 * @param integer $theInt Input value
855 * @param integer $min Lower limit
856 * @param integer $max Higher limit
857 * @param integer $zeroValue Default value if input is FALSE.
858 * @return integer The input value forced into the boundaries of $min and $max
859 * @deprecated since TYPO3 4.6, will be removed in TYPO3 6.0 - Use t3lib_utility_Math::forceIntegerInRange() instead
860 */
864 }
866 /**
867 * Returns the $integer if greater than zero, otherwise returns zero.
868 *
869 * @param integer $theInt Integer string to process
870 * @return integer
871 * @deprecated since TYPO3 4.6, will be removed in TYPO3 6.0 - Use t3lib_utility_Math::convertToPositiveInteger() instead
872 */
876 }
878 /**
879 * Returns an integer from a three part version number, eg '4.12.3' -> 4012003
880 *
881 * @param string $verNumberStr Version number on format x.x.x
882 * @return integer Integer version of version number (where each part can count to 999)
883 * @deprecated since TYPO3 4.6, will be removed in TYPO3 6.1 - Use t3lib_utility_VersionNumber::convertVersionNumberToInteger() instead
884 */
886 // Deprecation log is activated only for TYPO3 4.7 and above
889 }
891 }
893 /**
894 * Returns TRUE if the current TYPO3 version (or compatibility version) is compatible to the input version
895 * Notice that this function compares branches, not versions (4.0.1 would be > 4.0.0 although they use the same compat_version)
896 *
897 * @param string $verNumberStr Minimum branch number required (format x.y / e.g. "4.0" NOT "4.0.0"!)
898 * @return boolean Returns TRUE if this setup is compatible with the provided version number
899 * @todo Still needs a function to convert versions to branches
900 */
902 $currVersionStr = $GLOBALS['TYPO3_CONF_VARS']['SYS']['compat_version'] ? $GLOBALS['TYPO3_CONF_VARS']['SYS']['compat_version'] : TYPO3_branch;
904 if (t3lib_utility_VersionNumber::convertVersionNumberToInteger($currVersionStr) < t3lib_utility_VersionNumber::convertVersionNumberToInteger($verNumberStr)) {
908 }
909 }
911 /**
912 * Makes a positive integer hash out of the first 7 chars from the md5 hash of the input
913 *
914 * @param string $str String to md5-hash
915 * @return integer Returns 28bit integer-hash
916 */
919 }
921 /**
922 * Returns the first 10 positions of the MD5-hash (changed from 6 to 10 recently)
923 *
924 * @param string $input Input string to be md5-hashed
925 * @param integer $len The string-length of the output
926 * @return string Substring of the resulting md5-hash, being $len chars long (from beginning)
927 */
930 }
932 /**
933 * Returns a proper HMAC on a given input string and secret TYPO3 encryption key.
934 *
935 * @param string $input Input string to create HMAC from
936 * @param string $additionalSecret additionalSecret to prevent hmac beeing used in a different context
937 * @return string resulting (hexadecimal) HMAC currently with a length of 40 (HMAC-SHA-1)
938 */
944 if (extension_loaded('hash') && function_exists('hash_hmac') && function_exists('hash_algos') && in_array($hashAlgorithm, hash_algos())) {
947 // outer padding
949 // inner padding
952 // keys longer than block size are shorten
955 // keys shorter than block size are zero-padded
957 }
958 $hmac = call_user_func($hashAlgorithm, ($key ^ $opad) . pack('H*', call_user_func($hashAlgorithm, ($key ^ $ipad) . $input)));
959 }
961 }
963 /**
964 * Takes comma-separated lists and arrays and removes all duplicates
965 * If a value in the list is trim(empty), the value is ignored.
966 *
967 * @param string $in_list Accept multiple parameters which can be comma-separated lists of values and arrays.
968 * @param mixed $secondParameter: Dummy field, which if set will show a warning!
969 * @return string Returns the list without any duplicates of values, space around values are trimmed
970 */
974 'TYPO3 Fatal Error: t3lib_div::uniqueList() does NOT support array arguments anymore! Only string comma lists!',
975 1270853885
976 );
977 }
980 'TYPO3 Fatal Error: t3lib_div::uniqueList() does NOT support more than a single argument value anymore. You have specified more than one!',
981 1270853886
982 );
983 }
986 }
988 /**
989 * Splits a reference to a file in 5 parts
990 *
991 * @param string $fileref Filename/filepath to be analysed
992 * @return array Contains keys [path], [file], [filebody], [fileext], [realFileext]
993 */
1002 }
1012 }
1015 }
1017 /**
1018 * Returns the directory part of a path without trailing slash
1019 * If there is no dir-part, then an empty string is returned.
1020 * Behaviour:
1021 *
1022 * '/dir1/dir2/script.php' => '/dir1/dir2'
1023 * '/dir1/' => '/dir1'
1024 * 'dir1/script.php' => 'dir1'
1025 * 'd/script.php' => 'd'
1026 * '/script.php' => ''
1027 * '' => ''
1028 *
1029 * @param string $path Directory name / path
1030 * @return string Processed input value. See function description.
1031 */
1035 }
1037 /**
1038 * Modifies a HTML Hex color by adding/subtracting $R,$G and $B integers
1039 *
1040 * @param string $color A hexadecimal color code, #xxxxxx
1041 * @param integer $R Offset value 0-255
1042 * @param integer $G Offset value 0-255
1043 * @param integer $B Offset value 0-255
1044 * @return string A hexadecimal color code, #xxxxxx, modified according to input vars
1045 * @see modifyHTMLColorAll()
1046 */
1048 // This takes a hex-color (# included!) and adds $R, $G and $B to the HTML-color (format: #xxxxxx) and returns the new color
1056 }
1058 /**
1059 * Modifies a HTML Hex color by adding/subtracting $all integer from all R/G/B channels
1060 *
1061 * @param string $color A hexadecimal color code, #xxxxxx
1062 * @param integer $all Offset value 0-255 for all three channels.
1063 * @return string A hexadecimal color code, #xxxxxx, modified according to input vars
1064 * @see modifyHTMLColor()
1065 */
1068 }
1070 /**
1071 * Tests if the input can be interpreted as integer.
1072 *
1073 * @param mixed $var Any input variable to test
1074 * @return boolean Returns TRUE if string is an integer
1075 * @deprecated since TYPO3 4.6, will be removed in TYPO3 6.0 - Use t3lib_utility_Math::canBeInterpretedAsInteger() instead
1076 */
1081 }
1083 /**
1084 * Returns TRUE if the first part of $str matches the string $partStr
1085 *
1086 * @param string $str Full string to check
1087 * @param string $partStr Reference string which must be found as the "first part" of the full string
1088 * @return boolean TRUE if $partStr was found to be equal to the first part of $str
1089 */
1092 }
1094 /**
1095 * Formats the input integer $sizeInBytes as bytes/kilobytes/megabytes (-/K/M)
1096 *
1097 * @param integer $sizeInBytes Number of bytes to format.
1098 * @param string $labels Labels for bytes, kilo, mega and giga separated by vertical bar (|) and possibly encapsulated in "". Eg: " | K| M| G" (which is the default value)
1099 * @return string Formatted representation of the byte number, for output.
1100 */
1103 // Set labels:
1108 }
1111 // Find size:
1116 }
1123 }
1126 }
1127 }
1129 /**
1130 * Returns microtime input to milliseconds
1131 *
1132 * @param string $microtime Microtime
1133 * @return integer Microtime input string converted to an integer (milliseconds)
1134 */
1138 }
1140 /**
1141 * This splits a string by the chars in $operators (typical /+-*) and returns an array with them in
1142 *
1143 * @param string $string Input string, eg "123 + 456 / 789 - 4"
1144 * @param string $operators Operators to split by, typically "/+-*"
1145 * @return array Array with operators and operands separated.
1146 * @see tslib_cObj::calc(), tslib_gifBuilder::calcOffset()
1147 */
1157 }
1160 }
1162 /**
1163 * Calculates the input by +,-,*,/,%,^ with priority to + and -
1164 *
1165 * @param string $string Input string, eg "123 + 456 / 789 - 4"
1166 * @return integer Calculated value. Or error string.
1167 * @see calcParenthesis()
1168 * @deprecated since TYPO3 4.6, will be removed in TYPO3 6.0 - Use t3lib_utility_Math::calculateWithPriorityToAdditionAndSubtraction() instead
1169 */
1174 }
1176 /**
1177 * Calculates the input with parenthesis levels
1178 *
1179 * @param string $string Input string, eg "(123 + 456) / 789 - 4"
1180 * @return integer Calculated value. Or error string.
1181 * @see calcPriority(), tslib_cObj::stdWrap()
1182 * @deprecated since TYPO3 4.6, will be removed in TYPO3 6.0 - Use t3lib_utility_Math::calculateWithParentheses() instead
1183 */
1188 }
1190 /**
1191 * Inverse version of htmlspecialchars()
1192 *
1193 * @param string $value Value where >, <, " and & should be converted to regular chars.
1194 * @return string Converted result.
1195 */
1202 }
1204 /**
1205 * Re-converts HTML entities if they have been converted by htmlspecialchars()
1206 *
1207 * @param string $str String which contains eg. "&amp;" which should stay "&". Or "&#1234;" to "Ӓ". Or "&#x1b;" to ""
1208 * @return string Converted result.
1209 */
1212 }
1214 /**
1215 * This function is used to escape any ' -characters when transferring text to JavaScript!
1216 *
1217 * @param string $string String to escape
1218 * @param boolean $extended If set, also backslashes are escaped.
1219 * @param string $char The character to escape, default is ' (single-quote)
1220 * @return string Processed input string
1221 */
1225 }
1227 }
1229 /**
1230 * Version of rawurlencode() where all spaces (%20) are re-converted to space-characters.
1231 * Useful when passing text to JavaScript where you simply url-encode it to get around problems with syntax-errors, linebreaks etc.
1232 *
1233 * @param string $str String to raw-url-encode with spaces preserved
1234 * @return string Rawurlencoded result of input string, but with all %20 (space chars) converted to real spaces.
1235 */
1238 }
1240 /**
1241 * rawurlencode which preserves "/" chars
1242 * Useful when file paths should keep the "/" chars, but have all other special chars encoded.
1243 *
1244 * @param string $str Input string
1245 * @return string Output string
1246 */
1249 }
1251 /**
1252 * Checking syntax of input email address
1253 *
1254 * @param string $email Input string to evaluate
1255 * @return boolean Returns TRUE if the $email address (input string) is valid
1256 */
1258 // enforce maximum length to prevent libpcre recursion crash bug #52929 in PHP
1259 // fixed in PHP 5.3.4; length restriction per SMTP RFC 2821
1262 }
1267 }
1269 /**
1270 * Checks if current e-mail sending method does not accept recipient/sender name
1271 * in a call to PHP mail() function. Windows version of mail() and mini_sendmail
1272 * program are known not to process such input correctly and they cause SMTP
1273 * errors. This function will return TRUE if current mail sending method has
1274 * problem with recipient name in recipient/sender argument for mail().
1275 *
1276 * TODO: 4.3 should have additional configuration variable, which is combined
1277 * by || with the rest in this function.
1278 *
1279 * @return boolean TRUE if mail() does not accept recipient name
1280 */
1283 }
1285 /**
1286 * Changes from/to arguments for mail() function to work in any environment.
1287 *
1288 * @param string $address Address to adjust
1289 * @return string Adjusted address
1290 * @see t3lib_::isBrokenEmailEnvironment()
1291 */
1296 }
1298 }
1300 /**
1301 * Formats a string for output between <textarea>-tags
1302 * All content outputted in a textarea form should be passed through this function
1303 * 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!
1304 *
1305 * @param string $content Input string to be formatted.
1306 * @return string Formatted for <textarea>-tags
1307 */
1310 }
1312 /**
1313 * Converts string to uppercase
1314 * The function converts all Latin characters (a-z, but no accents, etc) to
1315 * uppercase. It is safe for all supported character sets (incl. utf-8).
1316 * Unlike strtoupper() it does not honour the locale.
1317 *
1318 * @param string $str Input string
1319 * @return string Uppercase String
1320 */
1323 }
1325 /**
1326 * Converts string to lowercase
1327 * The function converts all Latin characters (A-Z, but no accents, etc) to
1328 * lowercase. It is safe for all supported character sets (incl. utf-8).
1329 * Unlike strtolower() it does not honour the locale.
1330 *
1331 * @param string $str Input string
1332 * @return string Lowercase String
1333 */
1336 }
1338 /**
1339 * Returns a string of highly randomized bytes (over the full 8-bit range).
1340 *
1341 * Note: Returned values are not guaranteed to be crypto-safe,
1342 * most likely they are not, depending on the used retrieval method.
1343 *
1344 * @param integer $bytesToReturn Number of characters (bytes) to return
1345 * @return string Random Bytes
1346 * @see http://bugs.php.net/bug.php?id=52523
1347 * @see http://www.php-security.org/2010/05/09/mops-submission-04-generating-unpredictable-session-ids-and-hashes/index.html
1348 */
1350 // Cache 4k of the generated bytestream.
1354 // if we have not enough random bytes cached, we generate new ones
1357 // Openssl seems to be deadly slow on Windows, so try to use mcrypt
1358 // Windows PHP versions have a bug when using urandom source (see #24410)
1361 // Try to use native PHP functions first, precedence has openssl
1366 }
1368 // If openssl and mcrypt failed, try /dev/urandom
1371 }
1372 }
1374 // Fall back if other random byte generation failed until now
1377 }
1378 }
1380 // get first $bytesToReturn and remove it from the byte cache
1385 }
1387 /**
1388 * Generate random bytes using openssl if available
1389 *
1390 * @param string $bytesToGenerate
1391 * @return string
1392 */
1396 }
1399 }
1401 /**
1402 * Generate random bytes using mcrypt if available
1403 *
1404 * @param $bytesToGenerate
1405 * @param $randomSource
1406 * @return string
1407 */
1411 }
1413 }
1415 /**
1416 * Read random bytes from /dev/urandom if it is accessible
1417 *
1418 * @param $bytesToGenerate
1419 * @return string
1420 */
1425 // PHP only performs buffered reads, so in reality it will always read
1426 // at least 4096 bytes. Thus, it costs nothing extra to read and store
1427 // that much so as to speed any additional invocations.
1430 }
1433 }
1435 /**
1436 * Generate pseudo random bytes as last resort
1437 *
1438 * @param $bytesToReturn
1439 * @return string
1440 */
1443 // We initialize with somewhat random.
1444 $randomState = $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'] . base_convert(memory_get_usage() % pow(10, 6), 10, 2) . microtime() . uniqid('') . getmypid();
1448 }
1450 }
1452 /**
1453 * Returns a hex representation of a random byte string.
1454 *
1455 * @param integer $count Number of hex characters to return
1456 * @return string Random Bytes
1457 */
1460 }
1462 /**
1463 * Returns a given string with underscores as UpperCamelCase.
1464 * Example: Converts blog_example to BlogExample
1465 *
1466 * @param string $string: String to be converted to camel case
1467 * @return string UpperCamelCasedWord
1468 */
1470 $upperCamelCase = str_replace(' ', '', ucwords(str_replace('_', ' ', self::strtolower($string))));
1472 }
1474 /**
1475 * Returns a given string with underscores as lowerCamelCase.
1476 * Example: Converts minimal_value to minimalValue
1477 *
1478 * @param string $string: String to be converted to camel case
1479 * @return string lowerCamelCasedWord
1480 */
1482 $upperCamelCase = str_replace(' ', '', ucwords(str_replace('_', ' ', self::strtolower($string))));
1485 }
1487 /**
1488 * Returns a given CamelCasedString as an lowercase string with underscores.
1489 * Example: Converts BlogExample to blog_example, and minimalValue to minimal_value
1490 *
1491 * @param string $string String to be converted to lowercase underscore
1492 * @return string lowercase_and_underscored_string
1493 */
1496 }
1498 /**
1499 * Converts the first char of a string to lowercase if it is a latin character (A-Z).
1500 * Example: Converts "Hello World" to "hello World"
1501 *
1502 * @param string $string The string to be used to lowercase the first character
1503 * @return string The string with the first character as lowercase
1504 */
1507 }
1509 /**
1510 * Checks if a given string is a Uniform Resource Locator (URL).
1511 *
1512 * @param string $url The URL to be validated
1513 * @return boolean Whether the given URL is valid
1514 */
1519 return (filter_var($IDN->encode($url), FILTER_VALIDATE_URL, FILTER_FLAG_SCHEME_REQUIRED) !== FALSE);
1520 }
1523 /*************************
1524 *
1525 * ARRAY FUNCTIONS
1526 *
1527 *************************/
1529 /**
1530 * Check if an string item exists in an array.
1531 * Please note that the order of function parameters is reverse compared to the PHP function in_array()!!!
1532 *
1533 * Comparison to PHP in_array():
1534 * -> $array = array(0, 1, 2, 3);
1535 * -> variant_a := t3lib_div::inArray($array, $needle)
1536 * -> variant_b := in_array($needle, $array)
1537 * -> variant_c := in_array($needle, $array, TRUE)
1538 * +---------+-----------+-----------+-----------+
1539 * | $needle | variant_a | variant_b | variant_c |
1540 * +---------+-----------+-----------+-----------+
1541 * | '1a' | FALSE | TRUE | FALSE |
1542 * | '' | FALSE | TRUE | FALSE |
1543 * | '0' | TRUE | TRUE | FALSE |
1544 * | 0 | TRUE | TRUE | TRUE |
1545 * +---------+-----------+-----------+-----------+
1546 *
1547 * @param array $in_array one-dimensional array of items
1548 * @param string $item item to check for
1549 * @return boolean TRUE if $item is in the one-dimensional array $in_array
1550 */
1555 }
1556 }
1558 }
1560 /**
1561 * Explodes a $string delimited by $delim and passes each item in the array through intval().
1562 * Corresponds to t3lib_div::trimExplode(), but with conversion to integers for all values.
1563 *
1564 * @param string $delimiter Delimiter string to explode with
1565 * @param string $string The string to explode
1566 * @param boolean $onlyNonEmptyValues If set, all empty values (='') will NOT be set in output
1567 * @param integer $limit If positive, the result will contain a maximum of limit elements,
1568 * if negative, all components except the last -limit are returned,
1569 * if zero (default), the result is not limited at all
1570 * @return array Exploded values, all converted to integers
1571 */
1572 public static function intExplode($delimiter, $string, $onlyNonEmptyValues = FALSE, $limit = 0) {
1575 }
1577 /**
1578 * Reverse explode which explodes the string counting from behind.
1579 * Thus t3lib_div::revExplode(':','my:words:here',2) will return array('my:words','here')
1580 *
1581 * @param string $delimiter Delimiter string to explode with
1582 * @param string $string The string to explode
1583 * @param integer $count Number of array entries
1584 * @return array Exploded values
1585 */
1590 }
1592 /**
1593 * Explodes a string and trims all values for whitespace in the ends.
1594 * If $onlyNonEmptyValues is set, then all blank ('') values are removed.
1595 *
1596 * @param string $delim Delimiter string to explode with
1597 * @param string $string The string to explode
1598 * @param boolean $removeEmptyValues If set, all empty values will be removed in output
1599 * @param integer $limit If positive, the result will contain a maximum of
1600 * $limit elements, if negative, all components except
1601 * the last -$limit are returned, if zero (default),
1602 * the result is not limited at all. Attention though
1603 * that the use of this parameter can slow down this
1604 * function.
1605 * @return array Exploded values
1606 */
1617 }
1618 }
1620 }
1629 }
1630 }
1633 }
1635 /**
1636 * Removes the value $cmpValue from the $array if found there. Returns the modified array
1637 *
1638 * @param array $array Array containing the values
1639 * @param string $cmpValue Value to search for and if found remove array entry where found.
1640 * @return array Output array with entries removed if search string is found
1641 */
1648 }
1649 }
1651 }
1653 /**
1654 * Filters an array to reduce its elements to match the condition.
1655 * The values in $keepItems can be optionally evaluated by a custom callback function.
1656 *
1657 * Example (arguments used to call this function):
1658 * $array = array(
1659 * array('aa' => array('first', 'second'),
1660 * array('bb' => array('third', 'fourth'),
1661 * array('cc' => array('fifth', 'sixth'),
1662 * );
1663 * $keepItems = array('third');
1664 * $getValueFunc = create_function('$value', 'return $value[0];');
1665 *
1666 * Returns:
1667 * array(
1668 * array('bb' => array('third', 'fourth'),
1669 * )
1670 *
1671 * @param array $array: The initial array to be filtered/reduced
1672 * @param mixed $keepItems: The items which are allowed/kept in the array - accepts array or csv string
1673 * @param string $getValueFunc: (optional) Unique function name set by create_function() used to get the value to keep
1674 * @return array The filtered/reduced array with the kept items
1675 */
1678 // Convert strings to arrays:
1681 }
1682 // create_function() returns a string:
1685 }
1686 // Do the filtering:
1689 // Get the value to compare by using the callback function:
1693 }
1694 }
1695 }
1696 }
1698 }
1700 /**
1701 * Implodes a multidim-array into GET-parameters (eg. ¶m[key][key2]=value2¶m[key][key3]=value3)
1702 *
1703 * @param string $name Name prefix for entries. Set to blank if you wish none.
1704 * @param array $theArray The (multidimensional) array to implode
1705 * @param string $str (keep blank)
1706 * @param boolean $skipBlank If set, parameters which were blank strings would be removed.
1707 * @param boolean $rawurlencodeParamName If set, the param name itself (for example "param[key][key2]") would be rawurlencoded as well.
1708 * @return string Imploded result, fx. ¶m[key][key2]=value2¶m[key][key3]=value3
1709 * @see explodeUrl2Array()
1710 */
1711 public static function implodeArrayForUrl($name, array $theArray, $str = '', $skipBlank = FALSE, $rawurlencodeParamName = FALSE) {
1715 $str = self::implodeArrayForUrl($thisKeyName, $AVal, $str, $skipBlank, $rawurlencodeParamName);
1720 }
1721 }
1722 }
1724 }
1726 /**
1727 * Explodes a string with GETvars (eg. "&id=1&type=2&ext[mykey]=3") into an array
1728 *
1729 * @param string $string GETvars string
1730 * @param boolean $multidim If set, the string will be parsed into a multidimensional array if square brackets are used in variable names (using PHP function parse_str())
1731 * @return array Array of values. All values AND keys are rawurldecoded() as they properly should be. But this means that any implosion of the array again must rawurlencode it!
1732 * @see implodeArrayForUrl()
1733 */
1744 }
1745 }
1746 }
1748 }
1750 /**
1751 * Returns an array with selected keys from incoming data.
1752 * (Better read source code if you want to find out...)
1753 *
1754 * @param string $varList List of variable/key names
1755 * @param array $getArray Array from where to get values based on the keys in $varList
1756 * @param boolean $GPvarAlt If set, then t3lib_div::_GP() is used to fetch the value if not found (isset) in the $getArray
1757 * @return array Output array with selected variables.
1758 */
1759 public static function compileSelectedGetVarsFromArray($varList, array $getArray, $GPvarAlt = TRUE) {
1767 }
1768 }
1770 }
1772 /**
1773 * AddSlash array
1774 * This function traverses a multidimensional array and adds slashes to the values.
1775 * NOTE that the input array is and argument by reference.!!
1776 * Twin-function to stripSlashesOnArray
1777 *
1778 * @param array $theArray Multidimensional input array, (REFERENCE!)
1779 * @return array
1780 */
1787 }
1788 }
1791 }
1793 /**
1794 * StripSlash array
1795 * This function traverses a multidimensional array and strips slashes to the values.
1796 * NOTE that the input array is and argument by reference.!!
1797 * Twin-function to addSlashesOnArray
1798 *
1799 * @param array $theArray Multidimensional input array, (REFERENCE!)
1800 * @return array
1801 */
1808 }
1809 }
1812 }
1814 /**
1815 * Either slashes ($cmd=add) or strips ($cmd=strip) array $arr depending on $cmd
1816 *
1817 * @param array $arr Multidimensional input array
1818 * @param string $cmd "add" or "strip", depending on usage you wish.
1819 * @return array
1820 */
1824 }
1827 }
1829 }
1831 /**
1832 * Rename Array keys with a given mapping table
1833 *
1834 * @param array $array Array by reference which should be remapped
1835 * @param array $mappingTable Array with remap information, array/$oldKey => $newKey)
1836 */
1843 }
1844 }
1845 }
1846 }
1849 /**
1850 * Merges two arrays recursively and "binary safe" (integer keys are
1851 * overridden as well), overruling similar values in the first array
1852 * ($arr0) with the values of the second array ($arr1)
1853 * In case of identical keys, ie. keeping the values of the second.
1854 *
1855 * @param array $arr0 First array
1856 * @param array $arr1 Second array, overruling the first array
1857 * @param boolean $notAddKeys 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.
1858 * @param boolean $includeEmptyValues If set, values from $arr1 will overrule if they are empty or zero. Default: TRUE
1859 * @param boolean $enableUnsetFeature If set, special values "__UNSET" can be used in the second array in order to unset array keys in the resulting array.
1860 * @return array Resulting array where $arr1 values has overruled $arr0 values
1861 */
1862 public static function array_merge_recursive_overrule(array $arr0, array $arr1, $notAddKeys = FALSE, $includeEmptyValues = TRUE, $enableUnsetFeature = TRUE) {
1867 }
1875 $enableUnsetFeature
1876 );
1877 }
1881 ) {
1883 }
1884 }
1888 }
1890 /**
1891 * 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.
1892 *
1893 * @param array $arr1 First array
1894 * @param array $arr2 Second array
1895 * @return array Merged result.
1896 */
1899 }
1901 /**
1902 * Filters keys off from first array that also exist in second array. Comparison is done by keys.
1903 * This method is a recursive version of php array_diff_assoc()
1904 *
1905 * @param array $array1 Source array
1906 * @param array $array2 Reduce source array by this array
1907 * @return array Source array reduced by keys also present in second array
1908 */
1917 }
1918 }
1919 }
1922 }
1924 /**
1925 * Takes a row and returns a CSV string of the values with $delim (default is ,) and $quote (default is ") as separator chars.
1926 *
1927 * @param array $row Input array of values
1928 * @param string $delim Delimited, default is comma
1929 * @param string $quote Quote-character to wrap around the values.
1930 * @return string A single line of CSV
1931 */
1936 }
1939 }
1941 /**
1942 * Removes dots "." from end of a key identifier of TypoScript styled array.
1943 * array('key.' => array('property.' => 'value')) --> array('key' => array('property' => 'value'))
1944 *
1945 * @param array $ts: TypoScript configuration array
1946 * @return array TypoScript configuration array without dots at the end of all keys
1947 */
1956 }
1957 }
1959 }
1961 /**
1962 * Sorts an array by key recursive - uses natural sort order (aAbB-zZ)
1963 *
1964 * @param array $array array to be sorted recursively, passed by reference
1965 * @return boolean TRUE if param is an array
1966 */
1970 }
1974 }
1976 }
1979 /*************************
1980 *
1981 * HTML/XML PROCESSING
1982 *
1983 *************************/
1985 /**
1986 * Returns an array with all attributes of the input HTML tag as key/value pairs. Attributes are only lowercase a-z
1987 * $tag is either a whole tag (eg '<TAG OPTION ATTRIB=VALUE>') or the parameter list (ex ' OPTION ATTRIB=VALUE>')
1988 * If an attribute is empty, then the value for the key is empty. You can check if it existed with isset()
1989 *
1990 * @param string $tag HTML-tag string (or attributes only)
1991 * @return array Array with the attribute values.
1992 */
1999 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
2004 }
2009 }
2010 }
2014 }
2015 }
2017 }
2019 /**
2020 * Returns an array with the 'components' from an attribute list from an HTML tag. The result is normally analyzed by get_tag_attributes
2021 * Removes tag-name if found
2022 *
2023 * @param string $tag HTML-tag string (or attributes only)
2024 * @return array Array with the attribute values.
2025 */
2028 // Removes any > in the end of the string
2042 // There are '' around the value. We look for the next ' ' or '>'
2046 }
2047 }
2050 }
2052 /**
2053 * Implodes attributes in the array $arr for an attribute list in eg. and HTML tag (with quotes)
2054 *
2055 * @param array $arr Array with attribute key/value pairs, eg. "bgcolor"=>"red", "border"=>0
2056 * @param boolean $xhtmlSafe 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!
2057 * @param boolean $dontOmitBlankAttribs If TRUE, don't check if values are blank. Default is to omit attributes with blank values.
2058 * @return string Imploded attributes, eg. 'bgcolor="red" border="0"'
2059 */
2060 public static function implodeAttributes(array $arr, $xhtmlSafe = FALSE, $dontOmitBlankAttribs = FALSE) {
2066 }
2067 }
2069 }
2074 }
2075 }
2077 }
2079 /**
2080 * Wraps JavaScript code XHTML ready with <script>-tags
2081 * Automatic re-indenting of the JS code is done by using the first line as indent reference.
2082 * This is nice for indenting JS code with PHP code on the same level.
2083 *
2084 * @param string $string JavaScript code
2085 * @param boolean $linebreak Wrap script element in line breaks? Default is TRUE.
2086 * @return string The wrapped JS code, ready to put into a XHTML page
2087 */
2090 // <script wrapped in nl?
2093 // remove nl from the beginning
2095 // re-ident to one tab using the first line as reference
2099 }
2101 /*<![CDATA[*/
2103 /*]]>*/
2105 }
2107 }
2110 /**
2111 * Parses XML input into a PHP array with associative keys
2112 *
2113 * @param string $string XML data input
2114 * @param integer $depth Number of element levels to resolve the XML into an array. Any further structure will be set as XML.
2115 * @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.
2116 * @author bisqwit at iki dot fi dot not dot for dot ads dot invalid / http://dk.php.net/xml_parse_into_struct + kasperYYYY@typo3.com
2117 */
2128 return 'Line ' . xml_get_current_line_number($parser) . ': ' . xml_error_string(xml_get_error_code($parser));
2129 }
2140 // open tag:
2146 }
2152 }
2155 }
2156 }
2157 // finish tag:
2170 );
2174 }
2175 }
2179 }
2180 // cdata
2183 }
2184 }
2186 }
2188 /**
2189 * Turns PHP array into XML. See array2xml()
2190 *
2191 * @param array $array The input PHP array with any kind of data; text, binary, integers. Not objects though.
2192 * @param string $docTag Alternative document tag. Default is "phparray".
2193 * @param array $options Options for the compilation. See array2xml() for description.
2194 * @param string $charset Forced charset to prologue
2195 * @return string An XML string made from the input content in the array.
2196 * @see xml2array(),array2xml()
2197 */
2198 public static function array2xml_cs(array $array, $docTag = 'phparray', array $options = array(), $charset = '') {
2200 // Set default charset unless explicitly specified
2203 // Return XML:
2204 return '<?xml version="1.0" encoding="' . htmlspecialchars($charset) . '" standalone="yes" ?>' . LF .
2206 }
2208 /**
2209 * Deprecated to call directly (unless you are aware of using XML prologues)! Use "array2xml_cs" instead (which adds an XML-prologue)
2210 *
2211 * Converts a PHP array into an XML string.
2212 * The XML output is optimized for readability since associative keys are used as tag names.
2213 * 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.
2214 * Numeric keys are stored with the default tag name "numIndex" but can be overridden to other formats)
2215 * 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
2216 * 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.
2217 * The output XML has been tested with the PHP XML-parser and parses OK under all tested circumstances with 4.x versions. However, with PHP5 there seems to be the need to add an XML prologue a la <?xml version="1.0" encoding="[charset]" standalone="yes" ?> - otherwise UTF-8 is assumed! Unfortunately, many times the output from this function is used without adding that prologue meaning that non-ASCII characters will break the parsing!! This suchs of course! Effectively it means that the prologue should always be prepended setting the right characterset, alternatively the system should always run as utf-8!
2218 * 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...
2219 *
2220 * @param array $array The input PHP array with any kind of data; text, binary, integers. Not objects though.
2221 * @param string $NSprefix tag-prefix, eg. a namespace prefix like "T3:"
2222 * @param integer $level Current recursion level. Don't change, stay at zero!
2223 * @param string $docTag Alternative document tag. Default is "phparray".
2224 * @param integer $spaceInd If greater than zero, then the number of spaces corresponding to this number is used for indenting, if less than zero - no indentation, if zero - a single TAB is used
2225 * @param array $options 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')
2226 * @param array $stackData Stack data. Don't touch.
2227 * @return string An XML string made from the input content in the array.
2228 * @see xml2array()
2229 */
2230 public static function array2xml(array $array, $NSprefix = '', $level = 0, $docTag = 'phparray', $spaceInd = 0, array $options = array(), array $stackData = array()) {
2231 // 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
2232 $binaryChars = chr(0) . chr(1) . chr(2) . chr(3) . chr(4) . chr(5) . chr(6) . chr(7) . chr(8) .
2234 chr(20) . chr(21) . chr(22) . chr(23) . chr(24) . chr(25) . chr(26) . chr(27) . chr(28) . chr(29) .
2236 // Set indenting mode:
2241 // Init output variable:
2244 // Traverse the input array
2249 // Construct the tag name.
2250 if (isset($options['grandParentTagMap'][$stackData['grandParentTagName'] . '/' . $stackData['parentTagName']])) { // Use tag based on grand-parent + parent tag name
2252 $tagName = (string) $options['grandParentTagMap'][$stackData['grandParentTagName'] . '/' . $stackData['parentTagName']];
2253 } elseif (isset($options['parentTagMap'][$stackData['parentTagName'] . ':_IS_NUM']) && t3lib_utility_Math::canBeInterpretedAsInteger($tagName)) { // Use tag based on parent tag name + if current tag is numeric
2256 } elseif (isset($options['parentTagMap'][$stackData['parentTagName'] . ':' . $tagName])) { // Use tag based on parent tag name + current tag
2259 } elseif (isset($options['parentTagMap'][$stackData['parentTagName']])) { // Use tag based on parent tag name:
2268 }
2272 }
2274 // The tag name is cleaned up so only alphanumeric chars (plus - and _) are in there and not longer than 100 chars either.
2277 // If the value is an array then we will call this function recursively:
2280 // Sub elements:
2287 }
2301 )
2302 ) .
2304 if ((int) $options['disableTypeAttrib'] != 2) { // Do not set "type = array". Makes prettier XML but means that empty arrays are not restored with xml2array
2306 }
2309 // Look for binary chars:
2310 $vLen = strlen($v); // check for length, because PHP 5.2.0 may crash when first argument of strcspn is empty
2311 if ($vLen && strcspn($v, $binaryChars) != $vLen) { // Go for base64 encoding if the initial segment NOT matching any binary char has the same length as the whole string!
2312 // If the value contained binary chars then we base64-encode it an set an attribute to notify this situation:
2316 // Otherwise, just htmlspecialchar the stuff:
2322 }
2325 }
2326 }
2327 }
2329 // Add the element to the output string:
2330 $output .= ($spaceInd >= 0 ? str_pad('', ($level + 1) * $indentN, $indentChar) : '') . '<' . $NSprefix . $tagName . $attr . '>' . $content . '</' . $NSprefix . $tagName . '>' . $nl;
2331 }
2333 // If we are at the outer-most level, then we finally wrap it all in the document tags and return that as the value:
2339 }
2342 }
2344 /**
2345 * Converts an XML string to a PHP array.
2346 * This is the reverse function of array2xml()
2347 * This is a wrapper for xml2arrayProcess that adds a two-level cache
2348 *
2349 * @param string $string XML content to convert into an array
2350 * @param string $NSprefix The tag-prefix resolve, eg. a namespace like "T3:"
2351 * @param boolean $reportDocTag If set, the document tag will be set in the key "_DOCUMENT_TAG" of the output array
2352 * @return mixed If the parsing had errors, a string with the error message is returned. Otherwise an array with the content.
2353 * @see array2xml(),xml2arrayProcess()
2354 */
2360 // look up in first level cache
2364 // look up in second level cache
2371 }
2372 // store content in first level cache
2374 }
2376 }
2378 /**
2379 * Converts an XML string to a PHP array.
2380 * This is the reverse function of array2xml()
2381 *
2382 * @param string $string XML content to convert into an array
2383 * @param string $NSprefix The tag-prefix resolve, eg. a namespace like "T3:"
2384 * @param boolean $reportDocTag If set, the document tag will be set in the key "_DOCUMENT_TAG" of the output array
2385 * @return mixed If the parsing had errors, a string with the error message is returned. Otherwise an array with the content.
2386 * @see array2xml()
2387 */
2389 // Create parser:
2397 // default output charset is UTF-8, only ASCII, ISO-8859-1 and UTF-8 are supported!!!
2399 preg_match('/^[[:space:]]*<\?xml[^>]*encoding[[:space:]]*=[[:space:]]*"([^"]*)"/', substr($string, 0, 200), $match);
2401 xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, $theCharset); // us-ascii / utf-8 / iso-8859-1
2403 // Parse content:
2406 // If error, return error message:
2408 return 'Line ' . xml_get_current_line_number($parser) . ': ' . xml_error_string(xml_get_error_code($parser));
2409 }
2412 // Init vars:
2419 // Traverse the parsed XML structure:
2422 // First, process the tag-name (which is used in both cases, whether "complete" or "close")
2426 }
2428 // Test for name space:
2429 $tagName = ($NSprefix && substr($tagName, 0, strlen($NSprefix)) == $NSprefix) ? substr($tagName, strlen($NSprefix)) : $tagName;
2431 // Test for numeric tag, encoded on the form "nXXX":
2433 $tagName = (substr($tagName, 0, 1) == 'n' && !strcmp(intval($testNtag), $testNtag)) ? intval($testNtag) : $tagName;
2435 // Test for alternative index value:
2438 }
2440 // Setting tag-values, manage stack:
2442 case 'open': // If open tag it means there is an array stored in sub-elements. Therefore increase the stackpointer and reset the accumulation array:
2447 case 'close': // If the tag is "close" then it is an array which is closing and we decrease the stack pointer.
2450 end($current); // Going to the end of array to get placeholder key, key($current), and fill in array next:
2454 case 'complete': // If "complete", then it's a value. If the attribute "base64" is set, then decode the value, otherwise just set it.
2458 $current[$tagName] = (string) $val['value']; // Had to cast it as a string - otherwise it would be evaluate FALSE if tested with isset()!!
2460 // Cast type:
2472 $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...
2474 }
2475 }
2477 }
2478 }
2482 }
2484 // Finally return the content of the document tag.
2486 }
2488 /**
2489 * This implodes an array of XML parts (made with xml_parse_into_struct()) into XML again.
2490 *
2491 * @param array $vals An array of XML parts, see xml2tree
2492 * @return string Re-compiled XML data.
2493 */
2500 // open tag:
2506 }
2507 }
2513 }
2516 }
2520 }
2521 }
2522 // finish tag:
2525 }
2526 // cdata
2529 }
2530 }
2533 }
2535 /**
2536 * Extracts the attributes (typically encoding and version) of an XML prologue (header).
2537 *
2538 * @param string $xmlData XML data
2539 * @return array Attributes of the xml prologue (header)
2540 */
2545 }
2546 }
2548 /**
2549 * Minifies JavaScript
2550 *
2551 * @param string $script Script to minify
2552 * @param string $error Error message (if any)
2553 * @return string Minified script or source string if error happened
2554 */
2560 }
2565 }
2567 }
2570 /*************************
2571 *
2572 * FILES FUNCTIONS
2573 *
2574 *************************/
2576 /**
2577 * Reads the file or url $url and returns the content
2578 * If you are having trouble with proxys when reading URLs you can configure your way out of that with settings like $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlUse'] etc.
2579 *
2580 * @param string $url File/URL to read
2581 * @param integer $includeHeader Whether the HTTP header should be fetched or not. 0=disable, 1=fetch header+content, 2=fetch header only
2582 * @param array $requestHeaders HTTP headers to be used in the request
2583 * @param array $report Error code/message and, if $includeHeader is 1, response meta data (HTTP status and content type)
2584 * @return mixed The content from the resource given as input. FALSE if an error has occured.
2585 */
2586 public static function getUrl($url, $includeHeader = 0, $requestHeaders = FALSE, &$report = NULL) {
2592 }
2594 // use cURL for: http, https, ftp, ftps, sftp and scp
2595 if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlUse'] == '1' && preg_match('/^(?:http|ftp)s?|s(?:ftp|cp):/', $url)) {
2598 }
2600 // External URL without error checking.
2605 }
2607 }
2615 curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, max(0, intval($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlTimeout'])));
2621 }
2623 // (Proxy support implemented by Arco <arco@appeltaart.mine.nu>)
2628 curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyTunnel']);
2629 }
2631 curl_setopt($ch, CURLOPT_PROXYUSERPWD, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyUserPass']);
2632 }
2633 }
2641 // We hit a redirection but we couldn't follow it
2644 $report['message'] = 'Couldn\'t follow location redirect (PHP configuration option open_basedir is in effect).';
2646 // Set only for $includeHeader to work exactly like PHP variant
2649 }
2650 }
2651 }
2657 }
2663 }
2665 }
2674 }
2675 }
2677 // $errstr = '';
2682 $report['message'] = $errno ? ($errstr ? $errstr : 'Socket error.') : 'Socket initialization error.';
2683 }
2685 }
2693 }
2702 }
2705 }
2706 }
2710 }
2711 }
2714 }
2720 }
2726 }
2728 }
2732 )
2733 )
2734 );
2741 }
2745 }
2752 }
2753 }
2756 }
2758 /**
2759 * Writes $content to the file $file
2760 *
2761 * @param string $file Filepath to write to
2762 * @param string $content Content to write
2763 * @return boolean TRUE if the file was successfully opened and written to.
2764 */
2768 }
2776 }
2780 }
2783 }
2786 }
2788 /**
2789 * Sets the file system mode and group ownership of a file or a folder.
2790 *
2791 * @param string $path Path of file or folder, must not be escaped. Path can be absolute or relative
2792 * @param boolean $recursive If set, also fixes permissions of files and folders in the folder (if $path is a folder)
2793 * @return mixed TRUE on success, FALSE on error, always TRUE on Windows OS
2794 */
2799 // Make path absolute
2802 }
2806 // "@" is there because file is not necessarily OWNED by the user
2809 // "@" is there because file is not necessarily OWNED by the user
2811 }
2813 // Set createGroup if not empty
2815 // "@" is there because file is not necessarily OWNED by the user
2818 }
2820 // Call recursive if recursive flag if set and $path is directory
2830 }
2833 }
2834 }
2835 }
2837 }
2838 }
2841 }
2843 }
2845 /**
2846 * Writes $content to a filename in the typo3temp/ folder (and possibly one or two subfolders...)
2847 * Accepts an additional subdirectory in the file path!
2848 *
2849 * @param string $filepath Absolute file path to write to inside "typo3temp/". First part of this string must match PATH_site."typo3temp/"
2850 * @param string $content Content string to write
2851 * @return string Returns NULL on success, otherwise an error string telling about the problem.
2852 */
2855 // Parse filepath into directory and basename:
2859 // Check parts:
2866 // Checking if the "subdir" is found:
2869 if (preg_match('/^[[:alnum:]_]+\/$/', $subdir) || preg_match('/^[[:alnum:]_]+\/[[:alnum:]_]+\/$/', $subdir)) {
2873 }
2875 return 'Subdir, "' . $subdir . '", was NOT on the form "[[:alnum:]_]/" or "[[:alnum:]_]/[[:alnum:]_]/"';
2876 }
2877 }
2878 // Checking dir-name again (sub-dir might have been created):
2883 return 'The file was not written to the disk. Please, check that you have write permissions to the typo3temp/ directory.';
2884 }
2887 }
2890 }
2893 }
2896 }
2899 }
2902 }
2903 }
2905 /**
2906 * Wrapper function for mkdir.
2907 * Sets folder permissions according to $GLOBALS['TYPO3_CONF_VARS']['BE']['folderCreateMask']
2908 * and group ownership according to $GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup']
2909 *
2910 * @param string $newFolder Absolute path to folder, see PHP mkdir() function. Removes trailing slash internally.
2911 * @return boolean TRUE if @mkdir went well!
2912 */
2917 }
2919 }
2921 /**
2922 * Creates a directory - including parent directories if necessary and
2923 * sets permissions on newly created directories.
2924 *
2925 * @param string $directory Target directory to create. Must a have trailing slash
2926 * if second parameter is given!
2927 * Example: "/root/typo3site/typo3temp/foo/"
2928 * @param string $deepDirectory Directory to create. This second parameter
2929 * is kept for backwards compatibility since 4.6 where this method
2930 * was split into a base directory and a deep directory to be created.
2931 * Example: "xx/yy/" which creates "/root/typo3site/xx/yy/" if $directory is "/root/typo3site/"
2932 * @return void
2933 * @throws \InvalidArgumentException If $directory or $deepDirectory are not strings
2934 * @throws \RuntimeException If directory could not be created
2935 */
2940 1303662955
2941 );
2942 }
2945 'The specified directory is of type "' . gettype($deepDirectory) . '" but a string is expected.',
2946 1303662956
2947 );
2948 }
2955 }
2956 }
2957 }
2959 /**
2960 * Creates directories for the specified paths if they do not exist. This
2961 * functions sets proper permission mask but does not set proper user and
2962 * group.
2963 *
2964 * @static
2965 * @param string $fullDirectoryPath
2966 * @return string Path to the the first created directory in the hierarchy
2967 * @see t3lib_div::mkdir_deep
2968 * @throws \RuntimeException If directory could not be created
2969 */
2983 throw new \RuntimeException('Could not create directory "' . $fullDirectoryPath . '"!', 1170251400);
2984 }
2985 }
2987 }
2989 /**
2990 * Wrapper function for rmdir, allowing recursive deletion of folders and files
2991 *
2992 * @param string $path Absolute path to folder, see PHP rmdir() function. Removes trailing slash internally.
2993 * @param boolean $removeNonEmpty Allow deletion of non-empty directories
2994 * @return boolean TRUE if @rmdir went well!
2995 */
3008 }
3010 }
3012 }
3015 }
3019 }
3022 }
3025 }
3027 /**
3028 * Returns an array with the names of folders in a specific path
3029 * Will return 'error' (string) if there were an error with reading directory content.
3030 *
3031 * @param string $path Path to list directories from
3032 * @return array Returns an array with the directory entries as values. If no path, the return value is nothing.
3033 */
3042 }
3043 }
3046 }
3047 }
3049 }
3051 /**
3052 * Returns an array with the names of files in a specific path
3053 *
3054 * @param string $path Is the path to the file
3055 * @param string $extensionList is the comma list of extensions to read only (blank = all)
3056 * @param boolean $prependPath If set, then the path is prepended the file names. Otherwise only the file names are returned in the array
3057 * @param string $order is sorting: 1= sort alphabetically, 'mtime' = sort by modification time.
3058 *
3059 * @param string $excludePattern A comma separated list of file names to exclude, no wildcards
3060 * @return array Array of the files found
3061 */
3062 public static function getFilesInDir($path, $extensionList = '', $prependPath = FALSE, $order = '', $excludePattern = '') {
3064 // Initialize variables:
3069 // Find files+directories:
3077 $key = md5($path . '/' . $entry); // Don't change this ever - extensions may depend on the fact that the hash is an md5 of the path! (import/export extension)
3078 if ((!strlen($extensionList) || self::inList($extensionList, strtolower($fI['extension']))) && (!strlen($excludePattern) || !preg_match('/^' . $excludePattern . '$/', $entry))) {
3082 }
3085 }
3086 }
3087 }
3088 }
3092 }
3093 }
3095 // Sort them:
3101 }
3103 }
3105 // Return result
3108 }
3110 /**
3111 * Recursively gather all files and folders of a path.
3112 *
3113 * @param array $fileArr Empty input array (will have files added to it)
3114 * @param string $path The path to read recursively from (absolute) (include trailing slash!)
3115 * @param string $extList Comma list of file extensions: Only files with extensions in this list (if applicable) will be selected.
3116 * @param boolean $regDirs If set, directories are also included in output.
3117 * @param integer $recursivityLevels The number of levels to dig down...
3118 * @param string $excludePattern regex pattern of files/directories to exclude
3119 * @return array An array with the found files/directories.
3120 */
3121 public static function getAllFilesAndFoldersInPath(array $fileArr, $path, $extList = '', $regDirs = FALSE, $recursivityLevels = 99, $excludePattern = '') {
3124 }
3130 if ((string) $subdirs != '' && (!strlen($excludePattern) || !preg_match('/^' . $excludePattern . '$/', $subdirs))) {
3131 $fileArr = self::getAllFilesAndFoldersInPath($fileArr, $path . $subdirs . '/', $extList, $regDirs, $recursivityLevels - 1, $excludePattern);
3132 }
3133 }
3134 }
3136 }
3138 /**
3139 * Removes the absolute part of all files/folders in fileArr
3140 *
3141 * @param array $fileArr: The file array to remove the prefix from
3142 * @param string $prefixToRemove: The prefix path to remove (if found as first part of string!)
3143 * @return array The input $fileArr processed.
3144 */
3151 }
3152 }
3155 }
3157 /**
3158 * Fixes a path for windows-backslashes and reduces double-slashes to single slashes
3159 *
3160 * @param string $theFile File path to process
3161 * @return string
3162 */
3165 }
3167 /**
3168 * Resolves "../" sections in the input path string.
3169 * For example "fileadmin/directory/../other_directory/" will be resolved to "fileadmin/other_directory/"
3170 *
3171 * @param string $pathStr File path in which "/../" is resolved
3172 * @return string
3173 */
3185 }
3189 }
3190 }
3192 }
3194 /**
3195 * Prefixes a URL used with 'header-location' with 'http://...' depending on whether it has it already.
3196 * - If already having a scheme, nothing is prepended
3197 * - If having REQUEST_URI slash '/', then prefixing 'http://[host]' (relative to host)
3198 * - Otherwise prefixed with TYPO3_REQUEST_DIR (relative to current dir / TYPO3_REQUEST_DIR)
3199 *
3200 * @param string $path URL / path to prepend full URL addressing to.
3201 * @return string
3202 */
3209 }
3211 }
3213 /**
3214 * Returns the maximum upload size for a file that is allowed. Measured in KB.
3215 * This might be handy to find out the real upload limit that is possible for this
3216 * TYPO3 installation. The first parameter can be used to set something that overrides
3217 * the maxFileSize, usually for the TCA values.
3218 *
3219 * @param integer $localLimit: the number of Kilobytes (!) that should be used as
3220 * the initial Limit, otherwise $GLOBALS['TYPO3_CONF_VARS']['BE']['maxFileSize'] will be used
3221 * @return integer the maximum size of uploads that are allowed (measured in kilobytes)
3222 */
3224 // don't allow more than the global max file size at all
3225 $t3Limit = (intval($localLimit > 0 ? $localLimit : $GLOBALS['TYPO3_CONF_VARS']['BE']['maxFileSize']));
3226 // as TYPO3 is handling the file size in KB, multiply by 1024 to get bytes
3229 // check for PHP restrictions of the maximum size of one of the $_FILES
3231 // check for PHP restrictions of the maximum $_POST size
3233 // if the total amount of post data is smaller (!) than the upload_max_filesize directive,
3234 // then this is the real limit in PHP
3237 // is the allowed PHP limit (upload_max_filesize) lower than the TYPO3 limit?, also: revert back to KB
3239 }
3241 /**
3242 * Gets the bytes value from a measurement string like "100k".
3243 *
3244 * @param string $measurement: The measurement (e.g. "100k")
3245 * @return integer The bytes value (e.g. 102400)
3246 */
3255 }
3257 }
3259 /**
3260 * Retrieves the maximum path length that is valid in the current environment.
3261 *
3262 * @return integer The maximum available path length
3263 */
3266 }
3269 /**
3270 * Function for static version numbers on files, based on the filemtime
3271 *
3272 * This will make the filename automatically change when a file is
3273 * changed, and by that re-cached by the browser. If the file does not
3274 * exist physically the original file passed to the function is
3275 * returned without the timestamp.
3276 *
3277 * Behaviour is influenced by the setting
3278 * TYPO3_CONF_VARS[TYPO3_MODE][versionNumberInFilename]
3279 * = TRUE (BE) / "embed" (FE) : modify filename
3280 * = FALSE (BE) / "querystring" (FE) : add timestamp as parameter
3281 *
3282 * @param string $file Relative path to file including all potential query parameters (not htmlspecialchared yet)
3283 * @param boolean $forceQueryString If settings would suggest to embed in filename, this parameter allows us to force the versioning to occur in the query string. This is needed for scriptaculous.js which cannot have a different filename in order to load its modules (?load=...)
3284 * @return Relative path with version filename including the timestamp
3285 */
3299 }
3300 }
3303 }
3306 // File not found, return filename unaltered
3311 // If use of .htaccess rule is not configured,
3312 // we use the default query-string method
3317 }
3321 // Change the filename
3327 // append potential query string
3329 }
3330 }
3333 }
3335 /*************************
3336 *
3337 * SYSTEM INFORMATION
3338 *
3339 *************************/
3341 /**
3342 * Returns the HOST+DIR-PATH of the current script (The URL, but without 'http://' and without script-filename)
3343 *
3344 * @return string
3345 */
3351 }
3353 /**
3354 * Returns the link-url to the current script.
3355 * 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.
3356 * REMEMBER to always use htmlspecialchars() for content in href-properties to get ampersands converted to entities (XHTML requirement and XSS precaution)
3357 *
3358 * @param array $getParams Array of GET parameters to include
3359 * @return string
3360 */
3370 }
3371 }
3376 }
3378 /**
3379 * 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.
3380 * So basically it adds the parameters in $getParams to an existing URL, $url
3381 *
3382 * @param string $url URL string
3383 * @param array $getParams Array of key/value pairs for get parameters to add/overrule with. Can be multidimensional.
3384 * @return string Output URL with added getParams.
3385 */
3391 }
3399 }
3401 /**
3402 * Abstraction method which returns System Environment Variables regardless of server OS, CGI/MODULE version etc. Basically this is SERVER variables for most of them.
3403 * This should be used instead of getEnv() and $_SERVER/ENV_VARS to get reliable values for all situations.
3404 *
3405 * @param string $getEnvName 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
3406 * @return string Value based on the input key, independent of server/os environment.
3407 */
3409 /*
3410 Conventions:
3411 output from parse_url():
3412 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
3413 [scheme] => 'http'
3414 [user] => 'username'
3415 [pass] => 'password'
3416 [host] => '192.168.1.4'
3417 [port] => '8080'
3418 [path] => '/typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/'
3419 [query] => 'arg1,arg2,arg3&p1=parameter1&p2[key]=value'
3420 [fragment] => 'link1'
3422 Further definition: [path_script] = '/typo3/32/temp/phpcheck/index.php'
3423 [path_dir] = '/typo3/32/temp/phpcheck/'
3424 [path_info] = '/arg1/arg2/arg3/'
3425 [path] = [path_script/path_dir][path_info]
3427 Keys supported:
3429 URI______:
3430 REQUEST_URI = [path]?[query] = /typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/?arg1,arg2,arg3&p1=parameter1&p2[key]=value
3431 HTTP_HOST = [host][:[port]] = 192.168.1.4:8080
3432 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')!
3433 PATH_INFO = [path_info] = /arg1/arg2/arg3/
3434 QUERY_STRING = [query] = arg1,arg2,arg3&p1=parameter1&p2[key]=value
3435 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
3436 (Notice: NO username/password + NO fragment)
3438 CLIENT____:
3439 REMOTE_ADDR = (client IP)
3440 REMOTE_HOST = (client host)
3441 HTTP_USER_AGENT = (client user agent)
3442 HTTP_ACCEPT_LANGUAGE = (client accept language)
3444 SERVER____:
3445 SCRIPT_FILENAME = Absolute filename of script (Differs between windows/unix). On windows 'C:\\blabla\\blabl\\' will be converted to 'C:/blabla/blabl/'
3447 Special extras:
3448 TYPO3_HOST_ONLY = [host] = 192.168.1.4
3449 TYPO3_PORT = [port] = 8080 (blank if 80, taken from host value)
3450 TYPO3_REQUEST_HOST = [scheme]://[host][:[port]]
3451 TYPO3_REQUEST_URL = [scheme]://[host][:[port]][path]?[query] (scheme will by default be "http" until we can detect something different)
3452 TYPO3_REQUEST_SCRIPT = [scheme]://[host][:[port]][path_script]
3453 TYPO3_REQUEST_DIR = [scheme]://[host][:[port]][path_dir]
3454 TYPO3_SITE_URL = [scheme]://[host][:[port]][path_dir] of the TYPO3 website frontend
3455 TYPO3_SITE_PATH = [path_dir] of the TYPO3 website frontend
3456 TYPO3_SITE_SCRIPT = [script / Speaking URL] of the TYPO3 website
3457 TYPO3_DOCUMENT_ROOT = Absolute path of root of documents: TYPO3_DOCUMENT_ROOT.SCRIPT_NAME = SCRIPT_FILENAME (typically)
3458 TYPO3_SSL = Returns TRUE if this session uses SSL/TLS (https)
3459 TYPO3_PROXY = Returns TRUE if this session runs over a well known proxy
3461 Notice: [fragment] is apparently NEVER available to the script!
3463 Testing suggestions:
3464 - Output all the values.
3465 - 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
3466 - ALSO TRY the script from the ROOT of a site (like 'http://www.mytest.com/' and not 'http://www.mytest.com/test/' !!)
3467 */
3477 // add a prefix if TYPO3 is behind a proxy: ext-domain.com => int-server.com/prefix
3478 if (self::cmpIP($_SERVER['REMOTE_ADDR'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyIP'])) {
3479 if (self::getIndpEnv('TYPO3_SSL') && $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyPrefixSSL']) {
3483 }
3484 }
3488 (PHP_SAPI == 'fpm-fcgi' || PHP_SAPI == 'cgi' || PHP_SAPI == 'isapi' || PHP_SAPI == 'cgi-fcgi') &&
3489 ($_SERVER['ORIG_PATH_TRANSLATED'] ? $_SERVER['ORIG_PATH_TRANSLATED'] : $_SERVER['PATH_TRANSLATED']) ?
3490 ($_SERVER['ORIG_PATH_TRANSLATED'] ? $_SERVER['ORIG_PATH_TRANSLATED'] : $_SERVER['PATH_TRANSLATED']) :
3491 ($_SERVER['ORIG_SCRIPT_FILENAME'] ? $_SERVER['ORIG_SCRIPT_FILENAME'] : $_SERVER['SCRIPT_FILENAME'])));
3495 // Typical application of REQUEST_URI is return urls, forms submitting to itself etc. Example: returnUrl='.rawurlencode(t3lib_div::getIndpEnv('REQUEST_URI'))
3496 if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['requestURIvar']) { // This is for URL rewriters that store the original URI in a server variable (eg ISAPI_Rewriter for IIS: HTTP_X_REWRITE_URL)
3499 } elseif (!$_SERVER['REQUEST_URI']) { // This is for ISS/CGI which does not have the REQUEST_URI available.
3504 }
3505 // add a prefix if TYPO3 is behind a proxy: ext-domain.com => int-server.com/prefix
3506 if (self::cmpIP($_SERVER['REMOTE_ADDR'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyIP'])) {
3507 if (self::getIndpEnv('TYPO3_SSL') && $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyPrefixSSL']) {
3511 }
3512 }
3515 // $_SERVER['PATH_INFO']!=$_SERVER['SCRIPT_NAME'] is necessary because some servers (Windows/CGI) are seen to set PATH_INFO equal to script_name
3516 // Further, there must be at least one '/' in the path - else the PATH_INFO value does not make sense.
3517 // IF 'PATH_INFO' never works for our purpose in TYPO3 with CGI-servers, then 'PHP_SAPI=='cgi'' might be a better check. Right now strcmp($_SERVER['PATH_INFO'],t3lib_div::getIndpEnv('SCRIPT_NAME')) will always return FALSE for CGI-versions, but that is only as long as SCRIPT_NAME is set equal to PATH_INFO because of PHP_SAPI=='cgi' (see above)
3518 // if (strcmp($_SERVER['PATH_INFO'],self::getIndpEnv('SCRIPT_NAME')) && count(explode('/',$_SERVER['PATH_INFO']))>1) {
3521 }
3524 $retVal = self::cmpIP($_SERVER['REMOTE_ADDR'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyIP']);
3528 if (self::cmpIP($_SERVER['REMOTE_ADDR'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyIP'])) {
3530 // choose which IP in list to use
3543 }
3544 }
3547 }
3548 }
3552 if (self::cmpIP($_SERVER['REMOTE_ADDR'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['reverseProxyIP'])) {
3554 // choose which host in list to use
3567 }
3568 }
3571 }
3572 }
3574 // These are let through without modification
3584 // Get the web root (it is not the root of the TYPO3 installation)
3585 // The absolute path of the script can be calculated with TYPO3_DOCUMENT_ROOT + SCRIPT_FILENAME
3586 // 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.
3587 // Therefore the DOCUMENT_ROOT is now always calculated as the SCRIPT_FILENAME minus the end part shared with SCRIPT_NAME.
3597 }
3598 }
3602 }
3609 $retVal = ($httpHostBracketPosition !== FALSE) ? substr($httpHost, 0, ($httpHostBracketPosition + 1)) : array_shift($httpHostParts);
3614 $retVal = (strlen($httpHost) > strlen($httpHostOnly)) ? substr($httpHost, strlen($httpHostOnly) + 1) : '';
3627 $retVal = self::getIndpEnv('TYPO3_REQUEST_HOST') . self::dirname(self::getIndpEnv('SCRIPT_NAME')) . '/';
3636 }
3638 }
3641 $retVal = substr(self::getIndpEnv('TYPO3_SITE_URL'), strlen(self::getIndpEnv('TYPO3_REQUEST_HOST')));
3644 $retVal = substr(self::getIndpEnv('TYPO3_REQUEST_URL'), strlen(self::getIndpEnv('TYPO3_SITE_URL')));
3650 }
3654 $retVal = $_SERVER['SSL_SESSION_ID'] || !strcasecmp($_SERVER['HTTPS'], 'on') || !strcmp($_SERVER['HTTPS'], '1') ? TRUE : FALSE; // see http://bugs.typo3.org/view.php?id=3909
3655 }
3659 // Here, list ALL possible keys to this function for debug display.
3661 HTTP_HOST,
3662 TYPO3_HOST_ONLY,
3663 TYPO3_PORT,
3664 PATH_INFO,
3665 QUERY_STRING,
3666 REQUEST_URI,
3667 HTTP_REFERER,
3668 TYPO3_REQUEST_HOST,
3669 TYPO3_REQUEST_URL,
3670 TYPO3_REQUEST_SCRIPT,
3671 TYPO3_REQUEST_DIR,
3672 TYPO3_SITE_URL,
3673 TYPO3_SITE_SCRIPT,
3674 TYPO3_SSL,
3675 TYPO3_REV_PROXY,
3676 SCRIPT_NAME,
3677 TYPO3_DOCUMENT_ROOT,
3678 SCRIPT_FILENAME,
3679 REMOTE_ADDR,
3680 REMOTE_HOST,
3681 HTTP_USER_AGENT,
3685 }
3689 }
3691 }
3693 /**
3694 * Gets the unixtime as milliseconds.
3695 *
3696 * @return integer The unixtime as milliseconds
3697 */
3700 }
3702 /**
3703 * Client Browser Information
3704 *
3705 * @param string $useragent Alternative User Agent string (if empty, t3lib_div::getIndpEnv('HTTP_USER_AGENT') is used)
3706 * @return array Parsed information about the HTTP_USER_AGENT in categories BROWSER, VERSION, SYSTEM and FORMSTYLE
3707 */
3711 }
3714 // Which browser?
3725 }
3727 // Browser version
3736 }
3739 }
3753 }
3754 // Client system
3759 } elseif (strpos($useragent, 'Linux') !== FALSE || strpos($useragent, 'X11') !== FALSE || strpos($useragent, 'SGI') !== FALSE || strpos($useragent, ' SunOS ') !== FALSE || strpos($useragent, ' HP-UX ') !== FALSE) {
3761 }
3762 }
3763 // Is TRUE if the browser supports css to format forms, especially the width
3764 $bInfo['FORMSTYLE'] = ($bInfo['BROWSER'] == 'msie' || ($bInfo['BROWSER'] == 'net' && $bInfo['VERSION'] >= 5) || $bInfo['BROWSER'] == 'opera' || $bInfo['BROWSER'] == 'konqu');
3767 }
3769 /**
3770 * Get the fully-qualified domain name of the host.
3771 *
3772 * @param boolean $requestHost Use request host (when not in CLI mode).
3773 * @return string The fully-qualified host name.
3774 */
3777 // If not called from the command-line, resolve on getIndpEnv()
3778 // Note that TYPO3_REQUESTTYPE is not used here as it may not yet be defined
3781 }
3783 // will fail for PHP 4.1 and 4.2
3785 // 'n' is ignored in broken installations
3788 }
3789 }
3790 // we have not found a FQDN yet
3793 // we got an IP address
3798 }
3799 }
3800 }
3803 }
3806 }
3809 /*************************
3810 *
3811 * TYPO3 SPECIFIC FUNCTIONS
3812 *
3813 *************************/
3815 /**
3816 * 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.
3817 *
3818 * @param string $filename The input filename/filepath to evaluate
3819 * @param boolean $onlyRelative If $onlyRelative is set (which it is by default), then only return values relative to the current PATH_site is accepted.
3820 * @param boolean $relToTYPO3_mainDir If $relToTYPO3_mainDir is set, then relative paths are relative to PATH_typo3 constant - otherwise (default) they are relative to PATH_site
3821 * @return string Returns the absolute filename of $filename IF valid, otherwise blank string.
3822 */
3823 public static function getFileAbsFileName($filename, $onlyRelative = TRUE, $relToTYPO3_mainDir = FALSE) {
3826 }
3831 }
3835 }
3841 }
3844 } elseif ($onlyRelative && !self::isFirstPartOfStr($filename, $relPathPrefix)) { // absolute, but set to blank if not allowed
3846 }
3849 }
3850 }
3852 /**
3853 * Checks for malicious file paths.
3854 *
3855 * Returns TRUE if no '//', '..', '\' or control characters are found in the $theFile.
3856 * This should make sure that the path is not pointing 'backwards' and further doesn't contain double/back slashes.
3857 * So it's compatible with the UNIX style path strings valid for TYPO3 internally.
3858 *
3859 * @param string $theFile File path to evaluate
3860 * @return boolean TRUE, $theFile is allowed path string, FALSE otherwise
3861 * @see http://php.net/manual/en/security.filesystem.nullbytes.php
3862 * @todo Possible improvement: Should it rawurldecode the string first to check if any of these characters is encoded?
3863 */
3865 if (strpos($theFile, '//') === FALSE && strpos($theFile, '\\') === FALSE && !preg_match('#(?:^\.\.|/\.\./|[[:cntrl:]])#u', $theFile)) {
3867 }
3870 }
3872 /**
3873 * Checks if the $path is absolute or relative (detecting either '/' or 'x:/' as first part of string) and returns TRUE if so.
3874 *
3875 * @param string $path File path to evaluate
3876 * @return boolean
3877 */
3879 // on Windows also a path starting with a drive letter is absolute: X:/
3882 }
3884 // path starting with a / is always absolute, on every system
3886 }
3888 /**
3889 * Returns TRUE if the path is absolute, without backpath '..' and within the PATH_site OR within the lockRootPath
3890 *
3891 * @param string $path File path to evaluate
3892 * @return boolean
3893 */
3898 ||
3899 ($GLOBALS['TYPO3_CONF_VARS']['BE']['lockRootPath'] && self::isFirstPartOfStr($path, $GLOBALS['TYPO3_CONF_VARS']['BE']['lockRootPath']))
3900 )
3901 ) {
3903 }
3904 }
3906 /**
3907 * Verifies the input filename against the 'fileDenyPattern'. Returns TRUE if OK.
3908 *
3909 * @param string $filename File path to evaluate
3910 * @return boolean
3911 */
3913 // Filenames are not allowed to contain control characters
3916 }
3918 if (strcmp($filename, '') && strcmp($GLOBALS['TYPO3_CONF_VARS']['BE']['fileDenyPattern'], '')) {
3919 $result = preg_match('/' . $GLOBALS['TYPO3_CONF_VARS']['BE']['fileDenyPattern'] . '/i', $filename);
3923 }
3925 }
3927 /**
3928 * Checks if a given string is a valid frame URL to be loaded in the
3929 * backend.
3930 *
3931 * @param string $url potential URL to check
3932 * @return string either $url if $url is considered to be harmless, or an
3933 * empty string otherwise
3934 */
3943 );
3945 // Pass if URL is on the current host:
3947 if (self::isOnCurrentHost($decodedUrl) && strpos($decodedUrl, self::getIndpEnv('TYPO3_SITE_URL')) === 0) {
3949 }
3950 // Pass if URL is an absolute file path:
3953 // Pass if URL is absolute and below TYPO3 base directory:
3954 } elseif (strpos($testAbsoluteUrl, self::getIndpEnv('TYPO3_SITE_PATH')) === 0 && substr($decodedUrl, 0, 1) === '/') {
3956 // Pass if URL is relative and below TYPO3 base directory:
3957 } elseif (strpos($testRelativeUrl, self::getIndpEnv('TYPO3_SITE_PATH')) === 0 && substr($decodedUrl, 0, 1) !== '/') {
3959 }
3960 }
3963 self::sysLog('The URL "' . $url . '" is not considered to be local and was denied.', 'Core', self::SYSLOG_SEVERITY_NOTICE);
3964 }
3967 }
3969 /**
3970 * Moves $source file to $destination if uploaded, otherwise try to make a copy
3971 *
3972 * @param string $source Source file, absolute path
3973 * @param string $destination Destination file, absolute path
3974 * @return boolean Returns TRUE if the file was moved.
3975 * @coauthor Dennis Petersen <fessor@software.dk>
3976 * @see upload_to_tempfile()
3977 */
3981 // 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:
3986 }
3990 // 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
3992 }
3994 /**
3995 * Will move an uploaded file (normally in "/tmp/xxxxx") to a temporary filename in PATH_site."typo3temp/" from where TYPO3 can use it.
3996 * Use this function to move uploaded files to where you can work on them.
3997 * REMEMBER to use t3lib_div::unlink_tempfile() afterwards - otherwise temp-files will build up! They are NOT automatically deleted in PATH_site."typo3temp/"!
3998 *
3999 * @param string $uploadedFileName The temporary uploaded filename, eg. $_FILES['[upload field name here]']['tmp_name']
4000 * @return string If a new file was successfully created, return its filename, otherwise blank string.
4001 * @see unlink_tempfile(), upload_copy_move()
4002 */
4008 }
4009 }
4011 /**
4012 * Deletes (unlink) a temporary filename in 'PATH_site."typo3temp/"' given as input.
4013 * 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.
4014 * Use this after upload_to_tempfile() or tempnam() from this class!
4015 *
4016 * @param string $uploadedTempFileName Filepath for a file in PATH_site."typo3temp/". Must be absolute.
4017 * @return boolean Returns TRUE if the file was unlink()'ed
4018 * @see upload_to_tempfile(), tempnam()
4019 */
4023 if (self::validPathStr($uploadedTempFileName) && self::isFirstPartOfStr($uploadedTempFileName, PATH_site . 'typo3temp/') && @is_file($uploadedTempFileName)) {
4026 }
4027 }
4028 }
4029 }
4031 /**
4032 * Create temporary filename (Create file with unique file name)
4033 * This function should be used for getting temporary file names - will make your applications safe for open_basedir = on
4034 * REMEMBER to delete the temporary files after use! This is done by t3lib_div::unlink_tempfile()
4035 *
4036 * @param string $filePrefix Prefix to temp file (which will have no extension btw)
4037 * @return string result from PHP function tempnam() with PATH_site . 'typo3temp/' set for temp path.
4038 * @see unlink_tempfile(), upload_to_tempfile()
4039 */
4042 }
4044 /**
4045 * Standard authentication code (used in Direct Mail, checkJumpUrl and setfixed links computations)
4046 *
4047 * @param mixed $uid_or_record Uid (integer) or record (array)
4048 * @param string $fields List of fields from the record if that is given.
4049 * @param integer $codeLength Length of returned authentication code.
4050 * @return string MD5 hash of 8 chars.
4051 */
4060 }
4063 }
4067 }
4072 }
4074 /**
4075 * Splits the input query-parameters into an array with certain parameters filtered out.
4076 * Used to create the cHash value
4077 *
4078 * @param string $addQueryParams Query-parameters: "&xxx=yyy&zzz=uuu"
4079 * @return array Array with key/value pairs of query-parameters WITHOUT a certain list of variable names (like id, type, no_cache etc.) and WITH a variable, encryptionKey, specific for this server/installation
4080 * @see tslib_fe::makeCacheHash(), tslib_cObj::typoLink(), t3lib_div::calculateCHash()
4081 * @deprecated since TYPO3 4.7 - will be removed in TYPO3 6.1 - use t3lib_cacheHash instead
4082 */
4086 /* @var $cacheHash t3lib_cacheHash */
4090 // Hook: Allows to manipulate the parameters which are taken to build the chash:
4091 if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['cHashParamsHook'])) {
4092 $cHashParamsHook =& $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['cHashParamsHook'];
4098 );
4102 }
4103 }
4104 }
4107 }
4109 /**
4110 * Returns the cHash based on provided query parameters and added values from internal call
4111 *
4112 * @param string $addQueryParams Query-parameters: "&xxx=yyy&zzz=uuu"
4113 * @return string Hash of all the values
4114 * @see t3lib_div::cHashParams(), t3lib_div::calculateCHash()
4115 * @deprecated since TYPO3 4.7 - will be removed in TYPO3 6.1 - use t3lib_cacheHash instead
4116 */
4119 /* @var $cacheHash t3lib_cacheHash */
4122 }
4124 /**
4125 * Calculates the cHash based on the provided parameters
4126 *
4127 * @param array $params Array of key-value pairs
4128 * @return string Hash of all the values
4129 * @deprecated since TYPO3 4.7 - will be removed in TYPO3 6.1 - use t3lib_cacheHash instead
4130 */
4133 /* @var $cacheHash t3lib_cacheHash */
4136 }
4138 /**
4139 * Responds on input localization setting value whether the page it comes from should be hidden if no translation exists or not.
4140 *
4141 * @param integer $l18n_cfg_fieldValue Value from "l18n_cfg" field of a page record
4142 * @return boolean TRUE if the page should be hidden
4143 */
4149 }
4150 }
4152 /**
4153 * Returns true if the "l18n_cfg" field value is not set to hide
4154 * pages in the default language
4155 *
4156 * @param int $localizationConfiguration
4157 * @return boolean
4158 */
4161 }
4163 /**
4164 * Includes a locallang file and returns the $LOCAL_LANG array found inside.
4165 *
4166 * @param string $fileRef Input is a file-reference (see t3lib_div::getFileAbsFileName). That file is expected to be a 'locallang.php' file containing a $LOCAL_LANG array (will be included!) or a 'locallang.xml' file conataining a valid XML TYPO3 language structure.
4167 * @param string $langKey Language key
4168 * @param string $charset Character set (option); if not set, determined by the language key
4169 * @param integer $errorMode Error mode (when file could not be found): 0 - syslog entry, 1 - do nothing, 2 - throw an exception
4170 * @return array Value of $LOCAL_LANG found in the included file. If that array is found it will returned.
4171 * Otherwise an empty array and it is FALSE in error case.
4172 */
4174 /** @var $languageFactory t3lib_l10n_Factory */
4177 }
4179 /**
4180 * Includes a locallang-php file and returns the $LOCAL_LANG array
4181 * Works only when the frontend or backend has been initialized with a charset conversion object. See first code lines.
4182 *
4183 * @param string $fileRef Absolute reference to locallang-PHP file
4184 * @param string $langKey TYPO3 language key, eg. "dk" or "de" or "default"
4185 * @param string $charset Character set (optional)
4186 * @return array LOCAL_LANG array in return.
4187 * @deprecated since TYPO3 4.6, will be removed in TYPO3 6.0 - use t3lib_l10n_parser_Llphp::getParsedData() from now on
4188 */
4198 }
4202 // Set charsets:
4203 $sourceCharset = $csConvObj->parse_charset($csConvObj->charSetArray[$langKey] ? $csConvObj->charSetArray[$langKey] : 'utf-8');
4208 }
4210 // Cache file name:
4211 $hashSource = substr($fileRef, strlen(PATH_site)) . '|' . date('d-m-Y H:i:s', filemtime($fileRef)) . '|version=2.3';
4215 // Check if cache file exists...
4218 // Get PHP data
4224 1270853900
4225 );
4226 }
4228 // converting the default language (English)
4229 // this needs to be done for a few accented loan words and extension names
4233 }
4235 }
4237 if ($langKey != 'default' && is_array($LOCAL_LANG[$langKey]) && $sourceCharset != $targetCharset) {
4240 }
4242 }
4244 // Cache the content now:
4245 $serContent = array('origFile' => $hashSource, 'LOCAL_LANG' => array('default' => $LOCAL_LANG['default'], $langKey => $LOCAL_LANG[$langKey]));
4250 1270853901
4251 );
4252 }
4254 // Get content from cache:
4257 }
4260 }
4261 }
4263 /**
4264 * Includes a locallang-xml file and returns the $LOCAL_LANG array
4265 * Works only when the frontend or backend has been initialized with a charset conversion object. See first code lines.
4266 *
4267 * @param string $fileRef Absolute reference to locallang-XML file
4268 * @param string $langKey TYPO3 language key, eg. "dk" or "de" or "default"
4269 * @param string $charset Character set (optional)
4270 * @return array LOCAL_LANG array in return.
4271 * @deprecated since TYPO3 4.6, will be removed in TYPO3 6.0 - use t3lib_l10n_parser_Llxml::getParsedData() from now on
4272 */
4282 }
4287 // Set charset:
4292 }
4294 // Cache file name:
4295 $hashSource = substr($fileRef, strlen(PATH_site)) . '|' . date('d-m-Y H:i:s', filemtime($fileRef)) . '|version=2.3';
4300 // Check if cache file exists...
4303 // Read XML, parse it.
4310 1270853902
4311 );
4312 }
4314 // Set default LOCAL_LANG array content:
4318 // converting the default language (English)
4319 // this needs to be done for a few accented loan words and extension names
4320 // NOTE: no conversion is done when in UTF-8 mode!
4324 }
4326 }
4328 // converting other languages to their "native" charsets
4329 // NOTE: no conversion is done when in UTF-8 mode!
4332 // If no entry is found for the language key, then force a value depending on meta-data setting. By default an automated filename will be used:
4337 }
4339 // Checking if charset should be converted.
4343 }
4345 }
4346 }
4348 // Cache the content now:
4349 $serContent = array('origFile' => $hashSource, 'LOCAL_LANG' => array('default' => $LOCAL_LANG['default'], $langKey => $LOCAL_LANG[$langKey]));
4354 1270853903
4355 );
4356 }
4358 // Get content from cache:
4361 }
4363 // Checking for EXTERNAL file for non-default language:
4364 if ($langKey != 'default' && is_string($LOCAL_LANG[$langKey]) && strlen($LOCAL_LANG[$langKey])) {
4366 // Look for localized file:
4370 // Cache file name:
4371 $hashSource = substr($localized_file, strlen(PATH_site)) . '|' . date('d-m-Y H:i:s', filemtime($localized_file)) . '|version=2.3';
4376 // Check if cache file exists...
4379 // Read and parse XML content:
4386 1270853904
4387 );
4388 }
4389 $LOCAL_LANG[$langKey] = is_array($local_xmlContent['data'][$langKey]) ? $local_xmlContent['data'][$langKey] : array();
4391 // Checking if charset should be converted.
4395 }
4397 }
4399 // Cache the content now:
4400 $serContent = array('extlang' => $langKey, 'origFile' => $hashSource, 'EXT_DATA' => $LOCAL_LANG[$langKey]);
4405 1270853905
4406 );
4407 }
4409 // Get content from cache:
4412 }
4415 }
4416 }
4418 // Convert the $LOCAL_LANG array to XLIFF structure
4423 ));
4424 }
4426 }
4430 }
4431 }
4433 /**
4434 * Returns auto-filename for locallang-XML localizations.
4435 *
4436 * @param string $fileRef Absolute file reference to locallang-XML file. Must be inside system/global/local extension
4437 * @param string $language Language key
4438 * @param boolean $sameLocation if TRUE, then locallang-XML localization file name will be returned with same directory as $fileRef
4439 * @return string Returns the filename reference for the language unless error occurred (or local mode is used) in which case it will be NULL
4440 */
4446 }
4448 // Analyse file reference:
4451 #$location = 'EXT:csh_'.$language.'/'; // For system extensions translations are found in "csh_*" extensions (language packs)
4461 }
4465 // Divide file reference into extension key, directory (if any) and base name:
4466 list($file_extKey, $file_extPath) = explode('/', substr($fileRef, strlen($validatedPrefix)), 2);
4473 // If $fileRef is already prefix with "[language key]" then we should return it as this
4476 }
4478 // The filename is prefixed with "[language key]." because it prevents the llxmltranslate tool from detecting it.
4485 }
4486 }
4489 /**
4490 * Loads the $GLOBALS['TCA'] (Table Configuration Array) for the $table
4491 *
4492 * Requirements:
4493 * 1) must be configured table (the ctrl-section configured),
4494 * 2) columns must not be an array (which it is always if whole table loaded), and
4495 * 3) there is a value for dynamicConfigFile (filename in typo3conf)
4496 *
4497 * Note: For the frontend this loads only 'ctrl' and 'feInterface' parts.
4498 * For complete TCA use $GLOBALS['TSFE']->includeTCA() instead.
4499 *
4500 * @param string $table Table name for which to load the full TCA array part into $GLOBALS['TCA']
4501 * @return void
4502 */
4504 //needed for inclusion of the dynamic config files.
4517 }
4518 }
4519 }
4520 }
4521 }
4523 /**
4524 * 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).
4525 * If the sheet definition is in an external file that file is parsed and the data structure inside of that is returned.
4526 *
4527 * @param array $dataStructArray Input data structure, possibly with a sheet-definition and references to external data source files.
4528 * @param string $sheet The sheet to return, preferably.
4529 * @return array An array with two num. keys: key0: The data structure is returned in this key (array) UNLESS an error occurred in which case an error string is returned (string). key1: The used sheet key value!
4530 */
4534 }
4540 }
4543 // If not an array, but still set, then regard it as a relative reference to a file:
4548 }
4549 }
4557 }
4559 }
4561 /**
4562 * Resolves ALL sheet definitions in dataStructArray
4563 * If no sheet is found, then the default "sDEF" will be created with the dataStructure inside.
4564 *
4565 * @param array $dataStructArray Input data structure, possibly with a sheet-definition and references to external data source files.
4566 * @return array Output data structure with all sheets resolved as arrays.
4567 */
4575 }
4576 }
4580 }
4582 }
4584 /**
4585 * Calls a user-defined function/method in class
4586 * Such a function/method should look like this: "function proc(&$params, &$ref) {...}"
4587 *
4588 * @param string $funcName 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 ("singleton").
4589 * @param mixed $params Parameters to be pass along (typically an array) (REFERENCE!)
4590 * @param mixed $ref Reference to be passed along (typically "$this" - being a reference to the calling object) (REFERENCE!)
4591 * @param string $checkPrefix Alternative allowed prefix of class or function name
4592 * @param integer $errorMode Error mode (when class/function could not be found): 0 - call debug(), 1 - do nothing, 2 - raise an exception (allows to call a user function that may return FALSE)
4593 * @return mixed Content from method/function call or FALSE if the class/method/function was not found
4594 * @see getUserObj()
4595 */
4596 public static function callUserFunction($funcName, &$params, &$ref, $checkPrefix = 'user_', $errorMode = 0) {
4599 // Check persistent object and if found, call directly and exit.
4605 );
4606 }
4608 // Check file-reference prefix; if found, require_once() the file (should be library of code)
4614 }
4617 }
4619 // Check for persistent object token, "&"
4625 }
4627 // Check prefix is valid:
4634 }
4636 }
4638 // Call function or method:
4642 // Check if class/method exists:
4645 // Get/Create object of class:
4649 }
4653 }
4657 // If persistent object should be created, set reference:
4662 );
4663 }
4664 // Call method:
4668 );
4675 }
4676 }
4683 }
4684 }
4694 }
4695 }
4696 }
4698 }
4700 /**
4701 * Creates and returns reference to a user defined object.
4702 * 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.
4703 *
4704 * @param string $classRef 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!).
4705 * @param string $checkPrefix Required prefix of class name. By default "tx_" and "Tx_" are allowed.
4706 * @param boolean $silent If set, no debug() error message is shown if class/function is not present.
4707 * @return object The instance of the class asked for. Instance is created with t3lib_div::makeInstance
4708 * @see callUserFunction()
4709 */
4711 // Check persistent object and if found, call directly and exit.
4716 // Check file-reference prefix; if found, require_once() the file (should be library of code)
4722 }
4725 }
4727 // Check for persistent object token, "&"
4733 }
4735 // Check prefix is valid:
4738 debug("Class '" . $class . "' was not prepended with '" . $checkPrefix . "'", 't3lib_div::getUserObj');
4739 }
4741 }
4743 // Check if class exists:
4747 // If persistent object should be created, set reference:
4750 }
4756 }
4757 }
4758 }
4759 }
4761 /**
4762 * Checks if a class or function has a valid prefix: tx_, Tx_ or custom, e.g. user_
4763 *
4764 * @param string $classRef The class or function to check
4765 * @param array $additionalPrefixes Additional allowed prefixes, mostly this will be user_
4766 * @return bool TRUE if name is allowed
4767 */
4771 }
4774 }
4781 }
4786 }
4787 }
4790 }
4792 /**
4793 * Returns all valid class prefixes.
4794 *
4795 * @return array Array of valid prefixed of class names
4796 */
4802 ) {
4805 t3lib_div::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['SYS']['additionalAllowedClassPrefixes'])
4806 );
4807 }
4809 }
4811 /**
4812 * Creates an instance of a class taking into account the class-extensions
4813 * API of TYPO3. USE THIS method instead of the PHP "new" keyword.
4814 * Eg. "$obj = new myclass;" should be "$obj = t3lib_div::makeInstance("myclass")" instead!
4815 *
4816 * You can also pass arguments for a constructor:
4817 * t3lib_div::makeInstance('myClass', $arg1, $arg2, ..., $argN)
4818 *
4819 * @throws InvalidArgumentException if classname is an empty string
4820 * @param string $className
4821 * name of the class to instantiate, must not be empty
4822 * @return object the created instance
4823 */
4827 }
4829 // Determine final class name which must be instantiated, this takes XCLASS handling
4830 // into account. Cache in a local array to save some cycles for consecutive calls.
4833 }
4836 // Return singleton instance if it is already registered
4839 }
4841 // Return instance if it has been injected by addInstance()
4844 ) {
4846 }
4848 // Create new instance and call constructor with parameters
4857 }
4859 // Register new singleton instance
4862 }
4865 }
4867 /**
4868 * Returns the class name for a new instance, taking into account the
4869 * class-extension API.
4870 *
4871 * @param string $className Base class name to evaluate
4872 * @return string Final class name to instantiate with "new [classname]"
4873 */
4878 }
4879 }
4882 }
4884 /**
4885 * Sets the instance of a singleton class to be returned by makeInstance.
4886 *
4887 * If this function is called multiple times for the same $className,
4888 * makeInstance will return the last set instance.
4889 *
4890 * Warning: This is a helper method for unit tests. Do not call this directly in production code!
4891 *
4892 * @see makeInstance
4893 * @param string $className
4894 * the name of the class to set, must not be empty
4895 * @param t3lib_Singleton $instance
4896 * the instance to set, must be an instance of $className
4897 * @return void
4898 */
4902 }
4904 /**
4905 * Sets the instance of a non-singleton class to be returned by makeInstance.
4906 *
4907 * If this function is called multiple times for the same $className,
4908 * makeInstance will return the instances in the order in which they have
4909 * been added (FIFO).
4910 *
4911 * Warning: This is a helper method for unit tests. Do not call this directly in production code!
4912 *
4913 * @see makeInstance
4914 * @throws InvalidArgumentException if class extends t3lib_Singleton
4915 * @param string $className
4916 * the name of the class to set, must not be empty
4917 * @param object $instance
4918 * the instance to set, must be an instance of $className
4919 * @return void
4920 */
4928 1288969325
4929 );
4930 }
4934 }
4936 }
4938 /**
4939 * Checks that $className is non-empty and that $instance is an instance of
4940 * $className.
4941 *
4942 * @throws InvalidArgumentException if $className is empty or if $instance is no instance of $className
4943 * @param string $className a class name
4944 * @param object $instance an object
4945 * @return void
4946 */
4950 }
4953 '$instance must be an instance of ' . $className . ', but actually is an instance of ' . get_class($instance) . '.',
4954 1288967686
4955 );
4956 }
4957 }
4959 /**
4960 * Purge all instances returned by makeInstance.
4961 *
4962 * This function is most useful when called from tearDown in a test case
4963 * to drop any instances that have been created by the tests.
4964 *
4965 * Warning: This is a helper method for unit tests. Do not call this directly in production code!
4966 *
4967 * @see makeInstance
4968 * @return void
4969 */
4973 }
4975 /**
4976 * Find the best service and check if it works.
4977 * Returns object of the service class.
4978 *
4979 * @param string $serviceType Type of service (service key).
4980 * @param string $serviceSubType Sub type like file extensions or similar. Defined by the service.
4981 * @param mixed $excludeServiceKeys List of service keys which should be excluded in the search for a service. Array or comma list.
4982 * @return object The service object or an array with error info's.
4983 */
4984 public static function makeInstanceService($serviceType, $serviceSubType = '', $excludeServiceKeys = array()) {
4989 }
4995 );
4997 while ($info = t3lib_extMgm::findService($serviceType, $serviceSubType, $excludeServiceKeys)) {
4999 // provide information about requested service to service object
5002 // Check persistent object and if found, call directly and exit.
5005 // update request info in persistent object
5008 // reset service and return object
5012 // include file and create object
5020 // use silent logging??? I don't think so.
5022 }
5026 // create persistent object
5029 // needed to delete temp files
5033 }
5036 }
5037 }
5038 }
5039 // deactivate the service
5041 }
5043 }
5045 /**
5046 * Require a class for TYPO3
5047 * Useful to require classes from inside other classes (not global scope). A limited set of global variables are available (see function)
5048 *
5049 * @param string $requireFile: Path of the file to be included
5050 * @return void
5051 */
5053 // Needed for require_once
5057 }
5059 /**
5060 * Requires a class for TYPO3
5061 * Useful to require classes from inside other classes (not global scope).
5062 * A limited set of global variables are available (see function)
5063 *
5064 * @param string $requireFile: Path of the file to be included
5065 * @return void
5066 */
5068 // Needed for require
5071 }
5073 /**
5074 * Simple substitute for the PHP function mail() which allows you to specify encoding and character set
5075 * The fifth parameter ($encoding) will allow you to specify 'base64' encryption for the output (set $encoding=base64)
5076 * Further the output has the charset set to UTF-8 by default.
5077 *
5078 * @param string $email Email address to send to. (see PHP function mail())
5079 * @param string $subject Subject line, non-encoded. (see PHP function mail())
5080 * @param string $message Message content, non-encoded. (see PHP function mail())
5081 * @param string $headers Headers, separated by LF
5082 * @param string $encoding Encoding type: "base64", "quoted-printable", "8bit". Default value is "quoted-printable".
5083 * @param string $charset Charset used in encoding-headers (only if $encoding is set to a valid value which produces such a header)
5084 * @param boolean $dontEncodeHeader If set, the header content will not be encoded.
5085 * @return boolean TRUE if mail was accepted for delivery, FALSE otherwise
5086 */
5087 public static function plainMailEncoded($email, $subject, $message, $headers = '', $encoding = 'quoted-printable', $charset = '', $dontEncodeHeader = FALSE) {
5090 }
5094 // Mail headers must be ASCII, therefore we convert the whole header to either base64 or quoted_printable
5096 foreach (explode(LF, $headers) as $line) { // Split the header in lines and convert each line separately
5101 }
5105 $newHeaders[] = $line; // Should never happen - is such a mail header valid? Anyway, just add the unchanged line...
5106 }
5107 }
5111 $email = self::encodeHeader($email, $encoding, $charset); // Email address must not be encoded, but it could be appended by a name which should be so (e.g. "Kasper Skårhøj <kasperYYYY@typo3.com>")
5113 }
5122 $message = trim(chunk_split(base64_encode($message . LF))) . LF; // Adding LF because I think MS outlook 2002 wants it... may be removed later again.
5139 }
5141 // Headers must be separated by CRLF according to RFC 2822, not just LF.
5142 // But many servers (Gmail, for example) behave incorrectly and want only LF.
5143 // So we stick to LF in all cases.
5144 $headers = trim(implode(LF, self::trimExplode(LF, $headers, TRUE))); // Make sure no empty lines are there.
5147 }
5149 /**
5150 * Implementation of quoted-printable encode.
5151 * See RFC 1521, section 5.1 Quoted-Printable Content-Transfer-Encoding
5152 *
5153 * @param string $string Content to encode
5154 * @param integer $maxlen Length of the lines, default is 76
5155 * @return string The QP encoded string
5156 */
5158 // Make sure the string contains only Unix line breaks
5164 $linebreak = CRLF; // Line break for Windows. This is needed because PHP on Windows systems send mails via SMTP instead of using sendmail, and thus the line break needs to be \r\n.
5165 }
5179 }
5180 if (($ordVal >= 33 && $ordVal <= 60) || ($ordVal >= 62 && $ordVal <= 126) || $ordVal == 9 || $ordVal == 32) {
5186 }
5187 }
5188 $newVal = preg_replace('/' . chr(32) . '$/', '=20', $newVal); // Replaces a possible SPACE-character at the end of a line
5189 $newVal = preg_replace('/' . TAB . '$/', '=09', $newVal); // Replaces a possible TAB-character at the end of a line
5191 }
5193 }
5195 /**
5196 * Encode header lines
5197 * Email headers must be ASCII, therefore they will be encoded to quoted_printable (default) or base64.
5198 *
5199 * @param string $line Content to encode
5200 * @param string $enc Encoding type: "base64" or "quoted-printable". Default value is "quoted-printable".
5201 * @param string $charset Charset used for encoding
5202 * @return string The encoded string
5203 */
5205 // Avoid problems if "###" is found in $line (would conflict with the placeholder which is used below)
5208 }
5209 // Check if any non-ASCII characters are found - otherwise encoding is not needed
5212 }
5213 // Wrap email addresses in a special marker
5229 // Encoded words in the header should not contain non-encoded:
5230 // * spaces. "_" is a shortcut for "=20". See RFC 2047 for details.
5231 // * question mark. See RFC 1342 (http://tools.ietf.org/html/rfc1342)
5236 }
5238 }
5241 }
5243 }
5247 }
5249 /**
5250 * Takes a clear-text message body for a plain text email, finds all 'http://' links and if they are longer than 76 chars they are converted to a shorter URL with a hash parameter. The real parameter is stored in the database and the hash-parameter/URL will be redirected to the real parameter when the link is clicked.
5251 * This function is about preserving long links in messages.
5252 *
5253 * @param string $message Message content
5254 * @param string $urlmode URL mode; "76" or "all"
5255 * @param string $index_script_url URL of index script (see makeRedirectUrl())
5256 * @return string Processed message content
5257 * @see makeRedirectUrl()
5258 */
5259 public static function substUrlsInPlainText($message, $urlmode = '76', $index_script_url = '') {
5272 }
5275 // no processing
5281 $message
5282 );
5283 }
5286 }
5288 /**
5289 * Sub-function for substUrlsInPlainText() above.
5290 *
5291 * @param string $inUrl Input URL
5292 * @param integer $l URL string length limit
5293 * @param string $index_script_url URL of "index script" - the prefix of the "?RDCT=..." parameter. If not supplied it will default to t3lib_div::getIndpEnv('TYPO3_REQUEST_DIR').'index.php'
5294 * @return string Processed URL
5295 */
5303 );
5310 );
5313 }
5314 $inUrl = ($index_script_url ? $index_script_url : self::getIndpEnv('TYPO3_REQUEST_DIR') . 'index.php') .
5316 }
5319 }
5321 /**
5322 * Function to compensate for FreeType2 96 dpi
5323 *
5324 * @param integer $font_size Fontsize for freetype function call
5325 * @return integer Compensated fontsize based on $GLOBALS['TYPO3_CONF_VARS']['GFX']['TTFdpi']
5326 */
5331 }
5333 }
5335 /**
5336 * Initialize the system log.
5337 *
5338 * @return void
5339 * @see sysLog()
5340 */
5342 // for CLI logging name is <fqdn-hostname>:<TYPO3-path>
5343 // Note that TYPO3_REQUESTTYPE is not used here as it may not yet be defined
5345 $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] = self::getHostname($requestHost = FALSE) . ':' . PATH_site;
5346 }
5347 // for Web logging name is <protocol>://<request-hostame>/<site-path>
5349 $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] = self::getIndpEnv('TYPO3_SITE_URL');
5350 }
5352 // init custom logging
5353 if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'])) {
5356 foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'] as $hookMethod) {
5358 }
5359 }
5361 // init TYPO3 logging
5370 }
5371 openlog($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'], LOG_ODELAY, $facility);
5372 }
5373 }
5375 $GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLogLevel'] = t3lib_utility_Math::forceIntegerInRange($GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLogLevel'], 0, 4);
5376 $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogInit'] = TRUE;
5377 }
5379 /**
5380 * Logs message to the system log.
5381 * This should be implemented around the source code, including the Core and both frontend and backend, logging serious errors.
5382 * If you want to implement the sysLog in your applications, simply add lines like:
5383 * t3lib_div::sysLog('[write message in English here]', 'extension_key', 'severity');
5384 *
5385 * @param string $msg Message (in English).
5386 * @param string $extKey Extension key (from which extension you are calling the log) or "Core"
5387 * @param integer $severity Severity: 0 is info, 1 is notice, 2 is warning, 3 is error, 4 is fatal error
5388 * @return void
5389 */
5393 // is message worth logging?
5396 }
5398 // initialize logging
5399 if (!$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogInit']) {
5401 }
5403 // do custom logging
5404 if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog']) &&
5405 is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'])) {
5406 $params = array('msg' => $msg, 'extKey' => $extKey, 'backTrace' => debug_backtrace(), 'severity' => $severity);
5408 foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'] as $hookMethod) {
5410 }
5411 }
5413 // TYPO3 logging enabled?
5416 }
5421 // use all configured logging options
5425 // is message worth logging for this log type?
5428 }
5432 // write message to a file
5434 $lockObject = t3lib_div::makeInstance('t3lib_lock', $destination, $GLOBALS['TYPO3_CONF_VARS']['SYS']['lockingMode']);
5435 /** @var t3lib_lock $lockObject */
5443 }
5445 }
5446 // send message per mail
5451 }
5452 /** @var $mail t3lib_mail_Message */
5457 ->setBody('Host: ' . $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] . LF .
5461 );
5463 }
5464 // use the PHP error log
5466 error_log($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] . $msgLine, 0);
5467 }
5468 // use the system log
5472 }
5473 }
5474 }
5476 /**
5477 * Logs message to the development log.
5478 * This should be implemented around the source code, both frontend and backend, logging everything from the flow through an application, messages, results from comparisons to fatal errors.
5479 * The result is meant to make sense to developers during development or debugging of a site.
5480 * The idea is that this function is only a wrapper for external extensions which can set a hook which will be allowed to handle the logging of the information to any format they might wish and with any kind of filter they would like.
5481 * If you want to implement the devLog in your applications, simply add lines like:
5482 * if (TYPO3_DLOG) t3lib_div::devLog('[write message in english here]', 'extension key');
5483 *
5484 * @param string $msg Message (in english).
5485 * @param string $extKey Extension key (from which extension you are calling the log)
5486 * @param integer $severity Severity: 0 is info, 1 is notice, 2 is warning, 3 is fatal error, -1 is "OK" message
5487 * @param mixed $dataVar Additional data you want to pass to the logger.
5488 * @return void
5489 */
5491 if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['devLog'])) {
5492 $params = array('msg' => $msg, 'extKey' => $extKey, 'severity' => $severity, 'dataVar' => $dataVar);
5494 foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_div.php']['devLog'] as $hookMethod) {
5496 }
5497 }
5498 }
5500 /**
5501 * Writes a message to the deprecation log.
5502 *
5503 * @param string $msg Message (in English).
5504 * @return void
5505 */
5509 }
5512 $date = date($GLOBALS['TYPO3_CONF_VARS']['SYS']['ddmmyy'] . ' ' . $GLOBALS['TYPO3_CONF_VARS']['SYS']['hhmm'] . ': ');
5514 // legacy values (no strict comparison, $log can be boolean, string or int)
5517 }
5520 // In case lock is acquired before autoloader was defined:
5523 }
5524 // write a longer message to the deprecation log
5526 $lockObject = t3lib_div::makeInstance('t3lib_lock', $destination, $GLOBALS['TYPO3_CONF_VARS']['SYS']['lockingMode']);
5527 /** @var t3lib_lock $lockObject */
5535 }
5537 }
5540 // copy message also to the developer log
5542 }
5544 // do not use console in login screen
5547 }
5548 }
5550 /**
5551 * Gets the absolute path to the deprecation log file.
5552 *
5553 * @return string absolute path to the deprecation log file
5554 */
5560 ) .
5562 }
5564 /**
5565 * Logs a call to a deprecated function.
5566 * The log message will be taken from the annotation.
5567 * @return void
5568 */
5572 }
5574 // This require_once is needed for deprecation calls
5575 // thrown early during bootstrap, if the autoloader is
5576 // not instantiated yet. This can happen for example if
5577 // ext_localconf triggers a deprecation.
5586 }
5591 }
5593 // trigger PHP error with a short message: <function> is deprecated (called from <source>, defined in <source>)
5597 }
5598 $errorMsg .= ' is deprecated (called from ' . $trail[1]['file'] . '#' . $trail[1]['line'] . ', defined in ' . $function->getFileName() . '#' . $function->getStartLine() . ')';
5600 // write a longer message to the deprecation log: <function> <annotion> - <trace> (<source>)
5603 $logMsg .= ' (' . substr($function->getFileName(), strlen(PATH_site)) . '#' . $function->getStartLine() . ')';
5605 }
5607 /**
5608 * Converts a one dimensional array to a one line string which can be used for logging or debugging output
5609 * Example: "loginType: FE; refInfo: Array; HTTP_HOST: www.example.org; REMOTE_ADDR: 192.168.1.5; REMOTE_HOST:; security_level:; showHiddenRecords: 0;"
5610 *
5611 * @param array $arr Data array which should be outputted
5612 * @param mixed $valueList List of keys which should be listed in the output string. Pass a comma list or an array. An empty list outputs the whole array.
5613 * @param integer $valueLength Long string values are shortened to this length. Default: 20
5614 * @return string Output string with key names and their value as string
5615 */
5620 }
5624 $str .= (string) $key . trim(': ' . self::fixed_lgd_cs(str_replace(LF, '|', (string) $value), $valueLength)) . '; ';
5625 }
5626 }
5628 }
5630 /**
5631 * Compile the command for running ImageMagick/GraphicsMagick.
5632 *
5633 * @param string $command Command to be run: identify, convert or combine/composite
5634 * @param string $parameters The parameters string
5635 * @param string $path Override the default path (e.g. used by the install tool)
5636 * @return string Compiled command that deals with IM6 & GraphicsMagick
5637 */
5640 }
5642 /**
5643 * Explode a string (normally a list of filenames) with whitespaces by considering quotes in that string. This is mostly needed by the imageMagickCommand function above.
5644 *
5645 * @param string $parameters The whole parameters string
5646 * @param boolean $unQuote If set, the elements of the resulting array are unquoted.
5647 * @return array Exploded parameters
5648 */
5652 $quoteActive = -1; // Whenever a quote character (") is found, $quoteActive is set to the element number inside of $params. A value of -1 means that there are not open quotes at the current position.
5659 }
5665 }
5666 }
5673 }
5675 }
5676 // return reindexed array
5678 }
5681 /**
5682 * Quotes a string for usage as JS parameter.
5683 *
5684 * @param string $value the string to encode, may be empty
5685 *
5686 * @return string the encoded value already quoted (with single quotes),
5687 * will not be empty
5688 */
5692 }
5695 /**
5696 * Ends and cleans all output buffers
5697 *
5698 * @return void
5699 */
5702 ;
5703 }
5705 }
5708 /**
5709 * Ends and flushes all output buffers
5710 *
5711 * @return void
5712 */
5718 }
5720 // if previously a "Content-Encoding: whatever" has been set, we have to unset it
5724 // split it up at the :
5726 // check if we have a Content-Encoding other than 'None'
5730 }
5731 }
5732 }
5734 }
5735 }
5737 ?>