PageRenderTime 62ms CodeModel.GetById 13ms RepoModel.GetById 0ms app.codeStats 1ms

/wp-content/plugins/wordpress-flash-uploader/tfu/tfu_helper.php

https://bitbucket.org/sidi09/aryans
PHP | 2663 lines | 2286 code | 163 blank | 214 comment | 633 complexity | 7771ab0174e4ff16a1de50286d71e374 MD5 | raw file
Possible License(s): AGPL-1.0, LGPL-2.1, GPL-3.0, GPL-2.0 
    

  1. <?php

    2. 

  2. /**

    3. 

  3.  * TWG Flash uploader 2.14.x

    4. 

  4.  *

    5. 

  5.  * Copyright (c) 2004-2011 TinyWebGallery

    6. 

  6.  * written by Michael Dempfle

    7. 

  7.  *

    8. 

  8.  *

    9. 

  9.  *        This file has all the helper functions.

    10. 

  10.  *        Normally you don't have to modify anything here.

    11. 

  11.  *        Only the timezone can be interesting for you: $timezone

    12. 

  12.  */

    13. 

  13. /**

    14. 

  14.  * * ensure this file is being included by a parent file

    15. 

  15.  */

    16. 

  16. defined('_VALID_TWG') or die('Direct Access to this location is not allowed.');

    17. 

  17. $tfu_help_version = '2.14';

    18. 

  18. // some globals you can change

    19. 

  19. $check_safemode = true;              // New 2.12.x - By default TFU checks if you have a safe mode problem. On some server this test does not work. There you can try to turn it off and test if you can e.g. create directories, upload files to new created directories.

    20. 

  20. $session_double_fix = false; // this is only needed if you get errors because of corrupt sessions. If you turn this on a backup is made and checked if the first one is corrupt

    21. 

  21. $timezone = ''; // Please set your timezone here if you have problems with timezones - if you need exact times - enter your timezone - see http://www.dynamicwebpages.de/php/timezones.php

    22. 

  22. if (function_exists('date_default_timezone_set')) { // php 5.1.x

    23. 

  23.         if ($timezone != '') {

    24. 

  24.           @date_default_timezone_set($timezone);

    25. 

  25.         } else if (function_exists('date_default_timezone_get')) {

    26. 

  26.           set_error_handler('on_error_no_output');

    27. 

  27.           @date_default_timezone_set(@date_default_timezone_get());

    28. 

  28.           set_error_handler('on_error');

    29. 

  29.         } else {

    30. 

  30.           @date_default_timezone_set('Europe/Berlin');

    31. 

  31.         }

    32. 

  32. }

    33. 

  33. // default settings you should normally not change.

    34. 

  34. $bg_color_preview_R = 255;

    35. 

  35. $bg_color_preview_G = 255;

    36. 

  36. $bg_color_preview_B = 255;

    37. 

  37. $input_invalid = false;

    38. 

  38. $old_error_handler = false;

    39. 

  39. $master_profile = false;

    40. 

  40. $debug_file = dirname(__FILE__) . "/tfu.log"; // can be overwritten in the config!

    41. 

  41. 

    42. 

  42. tfu_setHeader();

    43. 

  43. 

    44. 

  44. @ob_start();

    45. 

  45. 

    46. 

  46. include dirname(__FILE__) . '/tfu_zip.class.php';

    47. 

  47. 

    48. 

  48. // check if all included files have the same version to avoid problems during update!

    49. 

  49. if ($tfu_zip_version != '2.14') {

    50. 

  50.   tfu_debug('Not all files belong to this version. Please update all files.');

    51. 

  51. }

    52. 

  52. 

    53. 

  53. /**

    54. 

  54.  * * Needed for Https and IE!

    55. 

  55.  */

    56. 

  56. function tfu_setHeader()

    57. 

  57. {

    58. 

  58.     // header("Pragma: public");

    59. 

  59.     // header("Expires: 0");

    60. 

  60.     // header("Cache-Control: must-revalidate, post-check=0, pre-check=0");

    61. 

  61.     // header('Pragma: I-hate-internet-explorer');

    62. 

  62.     // header('Cache-Control:no-store');

    63. 

  63.      if (strstr($_SERVER['HTTP_USER_AGENT'], "MSIE"))

    64. 

  64.     {

    65. 

  65.       header('Pragma: private');

    66. 

  66.       header('Cache-Control: private');

    67. 

  67.     }

    68. 

  68.     else

    69. 

  69.     {

    70. 

  70.       header('Pragma: public');

    71. 

  71.       header('Cache-Control: no-store, no-cache, must-revalidate' );

    72. 

  72.       header('Cache-Control: post-check=0, pre-check=0', false );

    73. 

  73.     }

    74. 

  74. 

    75. 

  75.     header('Expires: Sat, 26 Jul 1997 05:00:00 GMT' );

    76. 

  76.     header('Last-Modified: ' . gmdate( 'D, d M Y H:i:s' ) . ' GMT' );

    77. 

  77.     header('Vary: User-Agent');

    78. 

  78. 

    79. 

  79. }

    80. 

  80. /**

    81. 

  81.  * function:tfu_debug()

    82. 

  82.  */

    83. 

  83. function tfu_debug($data)

    84. 

  84. {

    85. 

  85.     global $debug_file; // set in the tfu_config.php or is overwritten by the twg config

    86. 

  86.     global $enable_enhanced_debug;

    87. 

  87.     	$data = replaceInput($data); // we check output data too - you never know!

    88. 

  88. 	    $input_invalid = false;

    89. 

  89. 

    90. 

  90.       if(stristr($data, 'called statically') === false && stristr($data, 'deprecated') === false) { // This error can happen in Joomla and can be ignored

    91. 

  91.         $debug_string = date('m.d.Y G:i:s') . ' - ' . $data . "\n";

    92. 

  92. 	      if ($enable_enhanced_debug) {

    93. 

  93.           $debug_string .= '    Request: ' . $_SERVER['PHP_SELF'] . '?' . $_SERVER['QUERY_STRING'] . "\n";

    94. 

  94.           foreach (debug_backtrace() as $element) {

    95. 

  95.             $debug_string .= '      Stack: ' . basename($element['file']) . ":" . $element['line'] . ":" . $element['function'];

    96. 

  96.             foreach ($element['args'] as $par) {

    97. 

  97.               if (is_array($par)) {

    98. 

  98.                 $par = str_replace("\n", "", print_r($par, true));

    99. 

  99.               }

    100. 

  100.               $debug_string .= ":" . substr($par, 0, 100); // max 100 chars

    101. 

  101.             }

    102. 

  102.             $debug_string .= "\n";

    103. 

  103.           }

    104. 

  104.         }

    105. 

  105.         if ($debug_file == '') {

    106. 

  106. 		      @ob_start();

    107. 

  107.               @error_log($debug_string, 0);

    108. 

  108. 		      @ob_end_clean();

    109. 

  109. 		      return;

    110. 

  110. 	      }

    111. 

  111. 

    112. 

  112.         if (file_exists($debug_file)) {

    113. 

  113.             if (filesize($debug_file) > 2000000) { // debug file max = 2MB !

    114. 

  114.                 // we move the old one and start a new one - but only once!

    115. 

  115.                 rename (dirname(__FILE__) . '/tfu.log', dirname(__FILE__) . '/tfu.log.bak');

    116. 

  116.                 $debug_file_local = fopen($debug_file, 'w');

    117. 

  117.             } else {

    118. 

  118.                 $debug_file_local = fopen($debug_file, 'a');

    119. 

  119.             }

    120. 

  120.             fputs($debug_file_local, $debug_string);

    121. 

  121.             fclose($debug_file_local);

    122. 

  122.         } else {

    123. 

  123.             if (is_writeable(dirname(__FILE__))) {

    124. 

  124.                 if (!isset($debug_file)) { // if helper is included somewhere else!

    125. 

  125.                   $debug_file = dirname(__FILE__) . "/tfu.log";

    126. 

  126.                 }

    127. 

  127.                 $debug_file_local = @fopen($debug_file, 'a');

    128. 

  128.                 @fputs($debug_file_local, $debug_string);

    129. 

  129.                 @fclose($debug_file_local);

    130. 

  130.                 clearstatcache();

    131. 

  131.             } else {

    132. 

  132.                 @ob_start();

    133. 

  133.                 @error_log($debug_string, 0);

    134. 

  134. 		        @ob_end_clean();

    135. 

  135.             }

    136. 

  136.         }

    137. 

  137.     }

    138. 

  138. }

    139. 

  139. 

    140. 

  140. function on_error($num, $str, $file, $line)

    141. 

  141. {

    142. 

  142.     if ((strpos ($file, 'email.inc.php') === false) && (strpos ($str, 'fopen') === false) && (strpos ($str, 'Deprecated') === false)) {

    143. 

  143.         tfu_debug("ERROR $num in " . substr($file, -40) . ", line $line: $str");

    144. 

  144.     }

    145. 

  145. }

    146. 

  146. 

    147. 

  147. function on_error_no_output($num, $str, $file, $line)

    148. 

  148. {

    149. 

  149. }

    150. 

  150. 

    151. 

  151. if (!isset($skip_error_handling)) {

    152. 

  152.   @ini_set('display_errors','On');

    153. 

  153.   $old_error_handler = set_error_handler("on_error");

    154. 

  154. }

    155. 

  155. 

    156. 

  156. 

    157. 

  157. /**

    158. 

  158.  * Resizes a jpg/png/gif file if needed and stores it back to the original location

    159. 

  159.  * Needs gdlib > 2.0!

    160. 

  160.  * All other files are untouched

    161. 

  161.  * 1 = ok

    162. 

  162.  * 0 = failed

    163. 

  163.  * 2 = unknown - we retry after the save later.

    164. 

  164.  *

    165. 

  165.  */

    166. 

  166. function resize_file($image, $size, $compression, $image_name, $dest_image = false)

    167. 

  167. {

    168. 

  168.     global $use_image_magic, $image_magic_path, $enable_upload_debug, $store;

    169. 

  169. 

    170. 

  170.     if (!isset($store)) {

    171. 

  171.       $store = 0;

    172. 

  172.     }

    173. 

  173.     set_error_handler('on_error_no_output');

    174. 

  174.     ini_set('gd.jpeg_ignore_warning', 1); // since php 5.1.3 this leads that corrupt jpgs are read much better!

    175. 

  175.     set_error_handler('on_error');

    176. 

  176.     // we can do some caching here! - nice for 2.6 ;).

    177. 

  177.     if ($size == 'undefined') {

    178. 

  178.       tfu_debug('Resize: ERROR - No size is sent from the flash. Make sure that you have at least one value entered in the config. The image is NOT resized.');

    179. 

  179.       return 1;

    180. 

  180.     }

    181. 

  181. 

    182. 

  182. 

    183. 

  183.     $srcx = 0;

    184. 

  184.     $srcy = 0;

    185. 

  185.     if ($enable_upload_debug) { tfu_debug('Resize: Preparing to resize "' . $image . ' with size: '.$size.'"'); }

    186. 

  186.     if (file_exists($image)) {

    187. 

  187.         $oldsize = getimagesize($image);

    188. 

  188.         if ($oldsize[0] == 0) {

    189. 

  189.             // for broken images we try to read the exif data!

    190. 

  190.             $oldsize = get_exif_size($image, $image_name);

    191. 

  191.         }

    192. 

  192.         $oldsizex = $oldsize[0];

    193. 

  193.         $oldsizey = $oldsize[1];

    194. 

  194. 

    195. 

  195.         if (strpos($size, "x") !== false) {

    196. 

  196.            $s = explode("x", $size);

    197. 

  197.            $width =  $s[0];

    198. 

  198.            $height = $s[1] ;

    199. 

  199.         } else {

    200. 

  200.              if (($oldsizex < $size) && ($oldsizey < $size)) {

    201. 

  201.                  if ($enable_upload_debug) { tfu_debug('Resize: Image ('. $oldsizex .'x' .$oldsizey. ') is not resized with setting "' . $size . '"'); }

    202. 

  202.                  return 1;

    203. 

  203.              }

    204. 

  204.              if ($oldsizex > $oldsizey) { // querformat - this keeps the dimension between horzonal and vertical

    205. 

  205.                  $width = $size;

    206. 

  206.                  $height = ($width / $oldsizex) * $oldsizey;

    207. 

  207.              } else { // hochformat - this keeps the dimension between horzonal an vertical

    208. 

  208.                  $height = $size;

    209. 

  209.                  $width = ($height / $oldsizey) * $oldsizex;

    210. 

  210.              }

    211. 

  211.              $width =  round($width);

    212. 

  212.              $height = round($height);

    213. 

  213.         }

    214. 

  214.         if ($use_image_magic) {

    215. 

  215.             if ($enable_upload_debug) {

    216. 

  216.               tfu_debug("Resize: Image magick is used");

    217. 

  217.             }

    218. 

  218.             $ima = $loc_ima = realpath($image);

    219. 

  219.             $resize = $width . 'x' . $height;

    220. 

  220.             if ($dest_image) {

    221. 

  221.               $store = 1;

    222. 

  222.               $loc_ima = $dest_image;

    223. 

  223.             } else {

    224. 

  224.               if ($store == 2) { // 1st attempt was not o.k. - we try it with a backup name.

    225. 

  225.                 $loc_ima = $ima . '.bak';

    226. 

  226.               }

    227. 

  227.             }

    228. 

  228.             $command = $image_magic_path . ' "' . $ima . '" -quality ' . $compression . ' -resize ' . $resize . ' "' . $loc_ima . '"';

    229. 

  229.             if ($enable_upload_debug) {

    230. 

  230.               tfu_debug("Resize: Image magick command: " . $command);

    231. 

  231.             }

    232. 

  232.             execute_command ($command);

    233. 

  233.              // we check if the resize was o.k.

    234. 

  234.               if ($store == 0) { // we do the resize to the same image again

    235. 

  235.                  // we check if the resize was o.k.

    236. 

  236.                 $newsize = getimagesize($ima);

    237. 

  237.                 if ($width != $newsize[0]) { // resize failed for unknown reasons.

    238. 

  238.                    if ($enable_upload_debug) { tfu_debug("Resize: Image could not be resized."); }

    239. 

  239.                    return 2; // we try to resize again later!

    240. 

  240.                 } else {

    241. 

  241.                    return 1;

    242. 

  242.                 }

    243. 

  243.               } else { // we resize to a temp file

    244. 

  244.                 if (file_exists($ima . '.bak')) {

    245. 

  245.                 $newsize = getimagesize($ima . '.bak');

    246. 

  246.                  if ($width != $newsize[0]) { // resize failed for unknown reasons.

    247. 

  247.                    if ($enable_upload_debug) { tfu_debug("Resize: Image could not be resized - wrong size"); }

    248. 

  248.                    unlink($ima . '.bak');

    249. 

  249.                    return 2; // we try to resize again later!

    250. 

  250.                  } else { // resize is o.k.

    251. 

  251.                    unlink($ima);

    252. 

  252.                    rename($ima . '.bak',$ima);

    253. 

  253.                    return 1;

    254. 

  254.                 }

    255. 

  255.                 } else {

    256. 

  256.                   if ($enable_upload_debug) { tfu_debug("Resize: Image could not be resized in temp upload dir. Retry after move to final destination."); }

    257. 

  257.                   return 2;

    258. 

  258.                 }

    259. 

  259.               }

    260. 

  260.         } else {

    261. 

  261.             if ($enable_upload_debug) { tfu_debug("Resize: gd-lib is used."); }

    262. 

  262.             if (!isMemoryOk($oldsize, $size, $image_name, true)) {

    263. 

  263.                 return 0;

    264. 

  264.             }

    265. 

  265.             if ($enable_upload_debug) { tfu_debug("Resize: memory seems o.k."); }

    266. 

  266. 

    267. 

  267.             $src = get_image_src($image, $oldsize[2]);

    268. 

  268.             if (!$src) {

    269. 

  269.                 tfu_debug('File ' . $image_name . ' cannot be resized!');

    270. 

  270.                 return false;

    271. 

  271.             }

    272. 

  272.             $dst = ImageCreateTrueColor($width, $height);

    273. 

  273.             imagecopyresampled($dst, $src, 0, 0, $srcx, $srcy , $width, $height, $oldsizex, $oldsizey);

    274. 

  274.             @imagedestroy($src);

    275. 

  275. 

    276. 

  276.             if ($dest_image) {

    277. 

  277.                 $image = $dest_image;

    278. 

  278.             }

    279. 

  279.             if ($enable_upload_debug) { tfu_debug("Resize: image was resampled."); }

    280. 

  280. 

    281. 

  281.             if ($oldsize[2] == 1) { // gif

    282. 

  282.                 $res = imagegif($dst, $image);

    283. 

  283.             } else if ($oldsize[2] == 2) { // jpg

    284. 

  284.                 $res = imagejpeg($dst, $image, $compression);

    285. 

  285.             } else if ($oldsize[2] == 3) { // png

    286. 

  286.                 $res = imagepng($dst, $image);

    287. 

  287.             } else {

    288. 

  288.                 $res = imagejpeg($dst, $image, $compression);

    289. 

  289.             }

    290. 

  290.             if ($res) {

    291. 

  291.                 // we check if the resize was o.k.

    292. 

  292.                 $newsize = getimagesize($image);

    293. 

  293.                 if ($width != $newsize[0]) { // resize failed for unknown reasons.

    294. 

  294.                      if ($enable_upload_debug) { tfu_debug("Resize: Image could not be resized."); }

    295. 

  295.                      return 2;

    296. 

  296.                 }

    297. 

  297.                 if ($enable_upload_debug) { tfu_debug("Resize: Image was saved and resized."); }

    298. 

  298.                 @imagedestroy($dst);

    299. 

  299.                 return 1;

    300. 

  300.             } else {

    301. 

  301.                 tfu_debug('cannot save: ' . $image);

    302. 

  302.                 return 0;

    303. 

  303.             }

    304. 

  304.         }

    305. 

  305.     } else

    306. 

  306.         return 2;

    307. 

  307. }

    308. 

  308. 

    309. 

  309. /**

    310. 

  310.  * resizes a file and writes it back to the user! - can do jpg, png and gif if the support is there !

    311. 

  311.  * renamed png's (that that are actually jpg's are handled as well!)

    312. 

  312.  * Needs gdlib > 2.0!

    313. 

  313.  */

    314. 

  314. function send_thumb($image, $compression, $sizex, $sizey, $generateOnly = false)

    315. 

  315. {

    316. 

  316.     global $bg_color_preview_R, $bg_color_preview_G, $bg_color_preview_B;

    317. 

  317.     global $info_text, $info_textcolor_R, $info_textcolor_G, $info_textcolor_B, $info_font, $info_fontsize;

    318. 

  318. 

    319. 

  319.     set_error_handler('on_error_no_output');

    320. 

  320.     ini_set('gd.jpeg_ignore_warning', 1); // since php 5.1.3 this leads that corrupt jpgs are read much better!

    321. 

  321.     set_error_handler('on_error');

    322. 

  322.     $srcx = 0;

    323. 

  323.     $srcy = 0;

    324. 

  324.     $dimx = $sizex;

    325. 

  325.     $dimy = $sizey;

    326. 

  326.     $usethumbs = false;

    327. 

  327. 

    328. 

  328.     if (file_exists(dirname(__FILE__) . '/thumbs') && is_writable(dirname(__FILE__) . '/thumbs')) { // is a caching dir available and writeable?

    329. 

  329.         $cachename = dirname(__FILE__) . '/thumbs/' . sha1($image . $sizex) . '.jpg';

    330. 

  330.         $usethumbs = true;

    331. 

  331.     }

    332. 

  332. 

    333. 

  333.     if ($usethumbs && file_exists($cachename)) {

    334. 

  334.         // we return the jpg!

    335. 

  335.         header('Content-type: image/jpg');

    336. 

  336.         header('Content-Length: ' . filesize($cachename));

    337. 

  337.         $fp = fopen($cachename, 'rb');

    338. 

  338.         while ($content = fread($fp, 8192)) {

    339. 

  339.             print $content;

    340. 

  340.         }

    341. 

  341.         fclose($fp);

    342. 

  342.         return true;

    343. 

  343.     } else if (file_exists($image)) {

    344. 

  344.         if (filesize($image) == 0) {

    345. 

  345.           return false;

    346. 

  346.         }

    347. 

  347.         $oldsize = getimagesize($image);

    348. 

  348.         // for broken images we try to read the exif data!

    349. 

  349.         if ($oldsize[0] == 0) {

    350. 

  350.             $oldsize = get_exif_size($image, $image);

    351. 

  351.         }

    352. 

  352.         $oldsizex = $oldsize[0];

    353. 

  353.         $oldsizey = $oldsize[1];

    354. 

  354. 

    355. 

  355.         if ($oldsizex < $sizex && $oldsizey < $sizey) {

    356. 

  356.             $sizex = $oldsizex;

    357. 

  357.             $sizey = $oldsizey;

    358. 

  358.         }

    359. 

  359.         $height = $sizey;

    360. 

  360.         $width = ($height / $oldsizey) * $oldsizex;

    361. 

  361. 

    362. 

  362.         if ($width > $sizex) {

    363. 

  363.             $width = $sizex;

    364. 

  364.             $height = ($width / $oldsizex) * $oldsizey;

    365. 

  365.         }

    366. 

  366. 

    367. 

  367.         if (isMemoryOk($oldsize, $sizex, '')) {

    368. 

  368.             $src = get_image_src($image, $oldsize[2]);

    369. 

  369.             if (!$src) { // error in image!

    370. 

  370.                 if ($sizex < 100) {

    371. 

  371.                     // we return an empty white one ;).

    372. 

  372.                     $src = ImageCreateTrueColor($oldsizex, $oldsizey);

    373. 

  373.                     $back = imagecolorallocate($src, 255, 255, 255);

    374. 

  374.                     imagefilledrectangle($src, 0, 0, $oldsizex, $oldsizex, $back);

    375. 

  375.                 }

    376. 

  376.                 tfu_debug($image . ' is not a valid image - please check the file.');

    377. 

  377.                 return false;

    378. 

  378.             }

    379. 

  379.             // $dst = ImageCreateTrueColor($width, $height);

    380. 

  380.             $dst = ImageCreateTrueColor($dimx, $dimy);

    381. 

  381.             if ($dimx < 100) { // white bg for small preview

    382. 

  382.                 $back = imagecolorallocate($dst, $bg_color_preview_R, $bg_color_preview_G, $bg_color_preview_B);

    383. 

  383.             } else { // gray bg for big preview

    384. 

  384.                 $back = imagecolorallocate($dst, 245, 245, 245);

    385. 

  385.             }

    386. 

  386.             imagefilledrectangle($dst, 0, 0, $dimx, $dimy, $back);

    387. 

  387.             if ($dimx > 100) { // border

    388. 

  388.                 imagerectangle ($dst, 0, 0, $dimx-1, $dimy-1, imagecolorallocate($dst, 160, 160, 160));

    389. 

  389.             }

    390. 

  390. 

    391. 

  391.             $offsetx = 0;

    392. 

  392.             $offsetx_b = 0;

    393. 

  393.             if ($dimx > $width) { // we have to center!

    394. 

  394.                 $offsetx = floor(($dimx - $width) / 2);

    395. 

  395.             } else if ($dimx > 100) {

    396. 

  396.                 $offsetx = 4;

    397. 

  397.                 $offsetx_b = 8;

    398. 

  398.             }

    399. 

  399. 

    400. 

  400.             $offsety = 0;

    401. 

  401.             $offsety_b = 0;

    402. 

  402.             if ($dimy > $height) { // we have to center!

    403. 

  403.                 $offsety = floor(($dimy - $height) / 2);

    404. 

  404.             } else if ($dimx > 100) {

    405. 

  405.                 $offsety = 4;

    406. 

  406.                 $offsety_b = 8;

    407. 

  407.             }

    408. 

  408. 

    409. 

  409.             $trans = imagecolortransparent ($src);

    410. 

  410.             imagecolorset ($src, $trans, 255, 255, 255);

    411. 

  411.             imagecolortransparent($src, imagecolorallocate($src, 0, 0, 0));

    412. 

  412.             imagecopyresampled($dst, $src, $offsetx, $offsety, $srcx, $srcy, $width - $offsetx_b, $height - $offsety_b, $oldsizex, $oldsizey);

    413. 

  413. 

    414. 

  414.             if (function_exists("imagettftext") && $dimx > 100 && $info_text != '' ) {

    415. 

  415.                // some extra info at the bottom of the image. Available parameters: {date} {size} {dimension}

    416. 

  416.                   $text = str_replace('{dimension}', $oldsizex."x".$oldsizey, $info_text);

    417. 

  417.                   $text = str_replace('{size}', formatSize(filesize($image)), $text);

    418. 

  418.                   $text = str_replace('{date}', date("d.m.Y",filemtime($image)), $text);

    419. 

  419. 			   $color = imagecolorclosest ($dst, $info_textcolor_R, $info_textcolor_G, $info_textcolor_B);

    420. 

  420. 			   imagettftext($dst, $info_fontsize, 0, 8, $dimy-8, $color, $info_font, $text);

    421. 

  421.             }

    422. 

  422. 

    423. 

  423.             header('Content-type: image/jpg');

    424. 

  424.             if ($usethumbs) { // we save the thumb

    425. 

  425.                 imagejpeg($dst, $cachename, $compression);

    426. 

  426.             }

    427. 

  427.             if (!$generateOnly) {

    428. 

  428.                 ob_start();

    429. 

  429.                 if (imagejpeg($dst, '', $compression)) {

    430. 

  430.                     $buffer = ob_get_contents();

    431. 

  431.                     header('Content-Length: ' . strlen($buffer));

    432. 

  432.                     ob_end_clean();

    433. 

  433.                     echo $buffer;

    434. 

  434.                     @imagedestroy($dst);

    435. 

  435.                     return true;

    436. 

  436.                 } else {

    437. 

  437.                     ob_end_flush();

    438. 

  438.                     tfu_debug('cannot save: ' . $image);

    439. 

  439.                     @imagedestroy($src);

    440. 

  440.                 }

    441. 

  441.             }

    442. 

  442.         }

    443. 

  443.     }

    444. 

  444.     return false;

    445. 

  445. }

    446. 

  446. // we check if we can get a memory problem!

    447. 

  447. function isMemoryOk($oldsize, $newsize, $image_name, $debug = true)

    448. 

  448. {

    449. 

  449.     $memory_read = (($oldsize[0] * $oldsize[1] * 6) + 2048576) * 1.1; // mem and we add 2 MB + 10% for safty

    450. 

  450.     $memory_orig = ($newsize * $newsize * 6) * 1.1; // 10% overhead.

    451. 

  451.     $memory = $memory_read + $memory_orig;

    452. 

  452. 

    453. 

  453.     // I try to increase the memory if more is needed and if it is possible.

    454. 

  454.     if (function_exists("memory_get_usage")) {

    455. 

  455.       $InUse=memory_get_usage();

    456. 

  456.       if ($memory > return_kbytes(ini_get('memory_limit')*1024) - $InUse)

    457. 

  457.       {

    458. 

  458.         @ini_set('memory_limit',$memory + $InUse + 5000000); // 5 MB for processing extra!

    459. 

  459.       }

    460. 

  460.     }

    461. 

  461.     $memory_limit = return_kbytes(ini_get('memory_limit')) * 1024;

    462. 

  462.     if ($memory > $memory_limit && $memory_limit > 0) { // we store the number of images that have a size problem in the session and output this in the readDir file

    463. 

  463.         $mem_errors = 0;

    464. 

  464.         if (isset($_SESSION['upload_memory_limit'])) {

    465. 

  465.             $mem_errors = $_SESSION['upload_memory_limit'];

    466. 

  466.         }

    467. 

  467.         $_SESSION['upload_memory_limit'] = ($mem_errors + 1);

    468. 

  468.         if ($debug) {

    469. 

  469.             tfu_debug('File ' . $image_name . ' cannot be processed because not enough memory is available! Needed: ~' . $memory . '. Available: ' . $memory_limit);

    470. 

  470.         }

    471. 

  471.         return false;

    472. 

  472.     } else {

    473. 

  473.         return true;

    474. 

  474.     }

    475. 

  475. }

    476. 

  476. $sn = get_server_name();

    477. 

  477. 

    478. 

  478. function get_image_src($image, $type)

    479. 

  479. {

    480. 

  480.     set_error_handler('on_error_no_output'); // No error shown because we handle this error!

    481. 

  481.     if ($type == 1) { // gif

    482. 

  482.         $src = imagecreatefromgif($image);

    483. 

  483.     } else if ($type == 2) { // jpg

    484. 

  484.         $src = imagecreatefromjpeg($image);

    485. 

  485.     } else if ($type == 3) { // png

    486. 

  486.         $src = @imagecreatefrompng($image);

    487. 

  487.     } else {

    488. 

  488.         $src = imagecreatefromjpeg($image); // if error we try read an jpg!

    489. 

  489.     }

    490. 

  490.     set_error_handler('on_error');

    491. 

  491.     return $src;

    492. 

  492. }

    493. 

  493. /**

    494. 

  494.  * A small helper function !

    495. 

  495.  */

    496. 

  496. function return_kbytes($val)

    497. 

  497. {

    498. 

  498.     $val = trim($val);

    499. 

  499.     if (strlen($val) == 0) {

    500. 

  500.         return 0;

    501. 

  501.     }

    502. 

  502.     $last = strtolower($val{strlen($val)-1});

    503. 

  503.     switch ($last) {

    504. 

  504.         // The 'G' modifier is available since PHP 5.1.0

    505. 

  505.         case 'g':

    506. 

  506.             $val *= 1024;

    507. 

  507.         case 'm':

    508. 

  508.             $val *= 1024;

    509. 

  509.         case 'k':

    510. 

  510.             $val *= 1;

    511. 

  511.     }

    512. 

  512.     return $val;

    513. 

  513. }

    514. 

  514. $m = is_renameable();

    515. 

  515. 

    516. 

  516. /**

    517. 

  517.  * get maximum upload size

    518. 

  518.  */

    519. 

  519. function getMaximumUploadSize()

    520. 

  520. {

    521. 

  521.     $upload_max = return_kbytes(ini_get('upload_max_filesize'));

    522. 

  522.     $post_max = return_kbytes(ini_get('post_max_size'));

    523. 

  523.     return $upload_max < $post_max ? $upload_max : $post_max;

    524. 

  524. }

    525. 

  525. 

    526. 

  526. /**

    527. 

  527.  * compares caseinsensitive - normally this could be done with natcasesort -

    528. 

  528.  * but this seems to be buggy on my test system!

    529. 

  529.  */

    530. 

  530. function mycmp ($a, $b)

    531. 

  531. {

    532. 

  532.     return strnatcasecmp ($a, $b);

    533. 

  533. }

    534. 

  534. 

    535. 

  535. /**

    536. 

  536.  * compares caseinsensitive - ascending for date

    537. 

  537.  */

    538. 

  538. function mycmp_date ($a, $b)

    539. 

  539. {

    540. 

  540.     return strnatcasecmp ($b, $a);

    541. 

  541. }

    542. 

  542. 

    543. 

  543. function cmp_dec ($a, $b)

    544. 

  544. {

    545. 

  545.     return mycmp(urldecode($a), urldecode($b));

    546. 

  546. }

    547. 

  547. 

    548. 

  548. function cmp_dir_dec ($a, $b)

    549. 

  549. {

    550. 

  550.     $a = substr($a, 0);

    551. 

  551.     $b = substr($b, 0);

    552. 

  552.     return mycmp(urldecode($a), urldecode($b));

    553. 

  553. }

    554. 

  554. 

    555. 

  555. function cmp_date_dec ($a, $b)

    556. 

  556. {

    557. 

  557.     return mycmp_date(urldecode($a), urldecode($b));

    558. 

  558. }

    559. 

  559. 

    560. 

  560. /**

    561. 

  561.  * deletes everything from the starting dir on! tfu deletes only one level by default - but this

    562. 

  562.  * is triggered by the endableing/disabling of the delete Folder status! not by this function!

    563. 

  563.  */

    564. 

  564. function remove($item) // remove file / dir

    565. 

  565. {

    566. 

  566.     $item = realpath($item);

    567. 

  567.     $ok = true;

    568. 

  568.     if (is_link($item) || is_file($item))

    569. 

  569.         $ok = @unlink($item);

    570. 

  570.     elseif (is_dir($item)) {

    571. 

  571.         if (($handle = opendir($item)) === false)

    572. 

  572.             return false;

    573. 

  573. 

    574. 

  574.         while (($file = readdir($handle)) !== false) {

    575. 

  575.             if (($file == '..' || $file == '.')) continue;

    576. 

  576. 

    577. 

  577.             $new_item = $item . '/' . $file;

    578. 

  578.             if (!file_exists($new_item))

    579. 

  579.                 return false;

    580. 

  580.             if (is_dir($new_item)) {

    581. 

  581.                 $ok = remove($new_item);

    582. 

  582.             } else {

    583. 

  583.                 $ok = @unlink($new_item);

    584. 

  584.             }

    585. 

  585.         }

    586. 

  586.         closedir($handle);

    587. 

  587.         $ok = @rmdir($item);

    588. 

  588.     }

    589. 

  589.     return $ok;

    590. 

  590. }

    591. 

  591. 

    592. 

  592. function is_tfu_deletable($file)

    593. 

  593. {

    594. 

  594.     $isWindows = substr(PHP_OS, 0, 3) == 'WIN';

    595. 

  595. 

    596. 

  596.     set_error_handler('on_error_no_output');

    597. 

  597.     $owner = @fileowner($file);

    598. 

  598.     set_error_handler('on_error');

    599. 

  599.     // if we cannot read the owner we assume that the safemode is on and we cannot access this file!

    600. 

  600.     if ($owner === false) {

    601. 

  601.         return false;

    602. 

  602.     }

    603. 

  603.     // if dir owner not same as effective uid of this process, then perms must be full 777.

    604. 

  604.     // No other perms combo seems reliable across system implementations

    605. 

  605.     if (function_exists('posix_getpwuid')) {

    606. 

  606.         if (!$isWindows && posix_geteuid() !== $owner) {

    607. 

  607.             return (substr(decoct(@fileperms($file)), -3) == '777' || @is_writable(dirname($file)));

    608. 

  608.         }

    609. 

  609.     }

    610. 

  610.     if ($isWindows && getmyuid() != $owner) {

    611. 

  611.         return (substr(decoct(fileperms($file)), -3) == '777');

    612. 

  612.     }

    613. 

  613.     // otherwise if this process owns the directory, we can chmod it ourselves to delete it

    614. 

  614.     return is_writable(dirname($file));

    615. 

  615. }

    616. 

  616. 

    617. 

  617. function replaceInput($input)

    618. 

  618. {

    619. 

  619.     global $input_invalid;

    620. 

  620. 

    621. 

  621.     $output = str_replace('<', '_', $input);

    622. 

  622.     $output = str_replace('>', '_', $output);

    623. 

  623.     $output = str_replace('?', '_Q_', $input);

    624. 

  624.     // we check some other settings too :)

    625. 

  625.     if (strpos($output, 'cookie(') || strpos($output, 'popup(') || strpos($output, 'open(') || strpos($output, 'alert(') || strpos($output, 'reload(') || strpos($output, 'refresh(')) {

    626. 

  626.         $output = 'XSS';

    627. 

  627.     }

    628. 

  628.     // we check for security if a .. is in the path we remove this!	and .// like in http:// is invalid too!

    629. 

  629.     $output = str_replace("..", "__", $output);

    630. 

  630.     $output = str_replace("//", "__", $output);

    631. 

  631.     return $output;

    632. 

  632. }

    633. 

  633. 

    634. 

  634. function getCurrentDir()

    635. 

  635. {

    636. 

  636.     // we read the dir - first session, then parameter, then default!

    637. 

  637.     if (isset($_SESSION['TFU_DIR'])) {

    638. 

  638.         $dir = $_SESSION['TFU_DIR'];

    639. 

  639.     } else {

    640. 

  640.         $dir = 'upload';

    641. 

  641.     }

    642. 

  642.     return $dir;

    643. 

  643. }

    644. 

  644. 

    645. 

  645. function getFileName($dir)

    646. 

  646. {

    647. 

  647.     global $fix_utf8, $exclude_directories, $sort_files_by_date, $hide_hidden_files, $enable_enhanced_debug;

    648. 

  648. 

    649. 

  649.     if (!isset($_GET['index']) || $_GET['index'] == '') {

    650. 

  650.         return '';

    651. 

  651.     }

    652. 

  652.     $index = parseInputParameter($_GET['index']);

    653. 

  653.     // All files are sorted in the array myFiles

    654. 

  654.     $dirhandle = opendir($dir);

    655. 

  655.     $myFiles = array();

    656. 

  656.     while (($file = readdir($dirhandle)) !== false) {

    657. 

  657.         if ($file != '.' && $file != '..' && !in_array($file, $exclude_directories)&& (!($hide_hidden_files && (strpos($file, '.') === 0)))) {

    658. 

  658.             if (!is_dir($dir . '/' . $file) && check_view_extension($file)) {

    659. 

  659.                 if ($sort_files_by_date) {

    660. 

  660.                     $file = filemtime(($dir . '/' . $file)) . $file;

    661. 

  661.                 }

    662. 

  662.                 array_push($myFiles, fix_encoding($file, $fix_utf8));

    663. 

  663.             }

    664. 

  664.         }

    665. 

  665.     }

    666. 

  666.     closedir ($dirhandle);

    667. 

  667.     if ($sort_files_by_date) {

    668. 

  668.         usort ($myFiles, 'mycmp_date');

    669. 

  669.     } else {

    670. 

  670.         usort ($myFiles, 'mycmp');

    671. 

  671.     }

    672. 

  672.     // now we have the same order as in the listing and check if we have one or multiple indexes !

    673. 

  673.     if (strpos($index, ',') === false) { // only 1 selection

    674. 

  674.         if (isset($myFiles[$index])) {

    675. 

  675.           return get_decoded_string($dir, $myFiles[$index]);

    676. 

  676.         } else {

    677. 

  677.           if ($enable_enhanced_debug) {

    678. 

  678.             tfu_debug("File index not found.");

    679. 

  679.           }

    680. 

  680.           return "_FILE_NOT_FOUND";

    681. 

  681.         }

    682. 

  682.     } else { // we return an array !

    683. 

  683.         // we need the offset

    684. 

  684.         $offset = parseInputParameter($_GET['offset']);

    685. 

  685.         $filenames = array();

    686. 

  686.         $index = trim($index, ',');

    687. 

  687.         $indices = explode(',', $index);

    688. 

  688.         foreach ($indices as $ind) {

    689. 

  689.             $filenames[] = get_decoded_string($dir, $myFiles[$ind - $offset]);

    690. 

  690.         }

    691. 

  691.         return $filenames;

    692. 

  692.     }

    693. 

  693. }

    694. 

  694. 

    695. 

  695. function get_decoded_string($dir, $string)

    696. 

  696. {

    697. 

  697.     global $fix_utf8;

    698. 

  698.     if ($fix_utf8 == 'none') {

    699. 

  699.         return $dir . '/' . $string;

    700. 

  700.     } else if ($fix_utf8 == '') {

    701. 

  701.         return $dir . '/' . utf8_decode(remove_sort_prefix($string));

    702. 

  702.     } else {

    703. 

  703.         return $dir . '/' . iconv('UTF-8', $fix_utf8, remove_sort_prefix($string));

    704. 

  704.     }

    705. 

  705. }

    706. 

  706. 

    707. 

  707. function remove_sort_prefix($string) {

    708. 

  708.     global $sort_files_by_date;

    709. 

  709.     if ($sort_files_by_date) {

    710. 

  710.         return substr($string, 10);

    711. 

  711.     } else {

    712. 

  712.         return $string;

    713. 

  713.     }

    714. 

  714. }

    715. 

  715. 

    716. 

  716. function getRootUrl() {

    717. 

  717.     if (isset($_SERVER)) {

    718. 

  718.         $GLOBALS['__SERVER'] = &$_SERVER;

    719. 

  719.     } elseif (isset($HTTP_SERVER_VARS)) {

    720. 

  720.         $GLOBALS['__SERVER'] = &$HTTP_SERVER_VARS;

    721. 

  721.     }

    722. 

  722.     $dirn = dirname ($GLOBALS['__SERVER']['PHP_SELF']);

    723. 

  723.     if ($dirn == '\\' || $dirn == '/') $dirn = '';

    724. 

  724.     return 'http' . (isset($GLOBALS['__SERVER']['HTTPS']) ? 's' : '') . '://' . $GLOBALS['__SERVER']['HTTP_HOST'] . $dirn . '/';

    725. 

  725. }

    726. 

  726. 

    727. 

  727. function tfu_checkSession()

    728. 

  728. {

    729. 

  729. }

    730. 

  730. if (isset($_SESSION['TF' . 'U_RN'])) {

    731. 

  731.     $s = $_SESSION['TF' . 'U_RN'];

    732. 

  732.     $t = substr($s, 0, 3) . substr($s, 21, 3) . substr($s, 10, 4);

    733. 

  733.     if (time() > ($t + (6 * 12 * 2 * 1000))) $_SESSION['TF' . 'U_RN'] = '0';

    734. 

  734. }

    735. 

  735. 

    736. 

  736. /**

    737. 

  737.  * * removes ../ in a pathname!

    738. 

  738.  */

    739. 

  739. function fixUrl($url)

    740. 

  740. {

    741. 

  741.     $pos = strpos ($url, '../');

    742. 

  742.    	while ($pos !== false && $pos != 0) {

    743. 

  743.         $before = substr($url, 0, $pos-1);

    744. 

  744.         $after = substr($url, $pos + 3);

    745. 

  745.         $before = substr($before, 0, strrpos($before, '/') + 1);

    746. 

  746.         $url = $before . $after;

    747. 

  747.         $pos = strpos ($url, '../');

    748. 

  748.     }

    749. 

  749.     return $url;

    750. 

  750. }

    751. 

  751. 

    752. 

  752. function runsNotAsCgi()

    753. 

  753. {

    754. 

  754.     $no_cgi = true;

    755. 

  755.     if (isset($_SERVER['SERVER_SOFTWARE'])) {

    756. 

  756.         $mystring = $_SERVER['SERVER_SOFTWARE'];

    757. 

  757.         $pos = strpos ($mystring, 'CGI');

    758. 

  758.         if ($pos === false) {

    759. 

  759.             // nicht gefunden...

    760. 

  760.         } else {

    761. 

  761.             $no_cgi = false;

    762. 

  762.         }

    763. 

  763.         $mystring = $_SERVER['SERVER_SOFTWARE'];

    764. 

  764.         $pos = strpos ($mystring, 'cgi');

    765. 

  765.         if ($pos === false) {

    766. 

  766.             // nicht gefunden...

    767. 

  767.         } else {

    768. 

  768.             $no_cgi = false;

    769. 

  769.         }

    770. 

  770.     }

    771. 

  771.     return $no_cgi;

    772. 

  772. }

    773. 

  773. 

    774. 

  774. function has_safemode_problem_global()

    775. 

  775. {

    776. 

  776.     $isWindows = substr(PHP_OS, 0, 3) == 'WIN';

    777. 

  777.     $no_cgi = runsNotAsCgi();

    778. 

  778. 

    779. 

  779.     if (function_exists('posix_getpwuid') && function_exists('posix_getpwuid')) {

    780. 

  780.         if (!isset($_SESSION['tfu_posix_geteuid_works'])) {

    781. 

  781.           $_SESSION['tfu_posix_geteuid_works'] = 'check';

    782. 

  782.           $userid = @posix_geteuid();

    783. 

  783.           $userinfo = @posix_getpwuid($userid);

    784. 

  784.           $def_user = array ('apache', 'nobody', 'www');

    785. 

  785.           if (in_array ($userinfo['name'], $def_user)) {

    786. 

  786.             $no_cgi = true;

    787. 

  787.           }

    788. 

  788.           unset($_SESSION['tfu_posix_geteuid_works']);

    789. 

  789.         }

    790. 

  790.     }

    791. 

  791.     if (ini_get('safe_mode') == 1 && $no_cgi && !$isWindows) {

    792. 

  792.         return true;

    793. 

  793.     }

    794. 

  794.     return false;

    795. 

  795. }

    796. 

  796. // set a umask that makes the files deletable again!

    797. 

  797. if ($check_safemode && (has_safemode_problem_global() || runsNotAsCgi())) {

    798. 

  798.     umask(0000); // otherwise you cannot delete files anymore with ftp if you are no the owner!

    799. 

  799. } else {

    800. 

  800.     umask(0022); // Added to make created files/dirs group writable

    801. 

  801. }

    802. 

  802. 

    803. 

  803. function gd_version()

    804. 

  804. {

    805. 

  805.     static $gd_version_number = null;

    806. 

  806.     if ($gd_version_number === null) {

    807. 

  807.         if (function_exists('gd_info')) {

    808. 

  808.             $info = gd_info();

    809. 

  809.             $module_info = $info['GD Version'];

    810. 

  810.             if (preg_match("/[^\d\n\r]*?([\d\.]+)/i",

    811. 

  811.                     $module_info, $matches)) {

    812. 

  812.                 $gd_version_number = $matches[1];

    813. 

  813.             } else {

    814. 

  814.                 $gd_version_number = 0;

    815. 

  815.             }

    816. 

  816.         } else { // needed before 4.3 !

    817. 

  817.             ob_start();

    818. 

  818.             phpinfo(8);

    819. 

  819.             $module_info = ob_get_contents();

    820. 

  820.             @ob_end_clean();

    821. 

  821.             if (preg_match("/\bgd\s+version\b[^\d\n\r]+?([\d\.]+)/i",

    822. 

  822.                     $module_info, $matches)) {

    823. 

  823.                 $gd_version_number = $matches[1];

    824. 

  824.             } else {

    825. 

  825.                 $gd_version_number = 0;

    826. 

  826.             }

    827. 

  827.         }

    828. 

  828.     }

    829. 

  829.     return $gd_version_number;

    830. 

  830. }

    831. 

  831. 

    832. 

  832. function is_gd_version_min_20()

    833. 

  833. {

    834. 

  834.     if (gd_version() >= 2) {

    835. 

  835.         return 'true';

    836. 

  836.     } else {

    837. 

  837.         return 'false';

    838. 

  838.     }

    839. 

  839. }

    840. 

  840. 

    841. 

  841. function restore_split_files($items)

    842. 

  842. {

    843. 

  843.     $split_array = array();

    844. 

  844.     // first we check if files are split and group he splited files

    845. 

  845.     foreach ($items as $filename) {

    846. 

  846.         if (is_part($filename)) {

    847. 

  847.             $split_array[removeExtension($filename)][] = $filename;

    848. 

  848.         }

    849. 

  849.     }

    850. 

  850. 

    851. 

  851.     foreach ($split_array as $restore => $parts) {

    852. 

  852.         $totsize = 0;

    853. 

  853.         // sorting of parts is important!

    854. 

  854.         usort($parts, 'mycmp');

    855. 

  855.         // we open the destination

    856. 

  856.         $dest_file = fopen($restore, 'wb');

    857. 

  857.         foreach ($parts as $parts_name) {

    858. 

  858.             $totsize += filesize($parts_name);

    859. 

  859.             $fp = fopen($parts_name, 'rb');

    860. 

  860.             while ($content = fread($fp, 8192)) {

    861. 

  861.                 fputs($dest_file, $content);

    862. 

  862.                 flush();

    863. 

  863.                 ob_flush();

    864. 

  864.             }

    865. 

  865.             fclose($fp);

    866. 

  866.         }

    867. 

  867.         fclose($dest_file);

    868. 

  868.         // if o.k. we delete the .part files! - check the filesize maybe?

    869. 

  869.         if (filesize($restore) == $totsize) {

    870. 

  870.             array_map('unlink', $parts);

    871. 

  871.         }

    872. 

  872.     }

    873. 

  873. }

    874. 

  874. 

    875. 

  875. function resize_merged_files($items, $size)

    876. 

  876. {

    877. 

  877.     global $compression;

    878. 

  878.     $split_array = array();

    879. 

  879.     // first we check if files are split and group the splited files

    880. 

  880.     foreach ($items as $filename) {

    881. 

  881.         if (is_part($filename)) {

    882. 

  882.             $split_array[removeExtension($filename)][] = $filename;

    883. 

  883.         }

    884. 

  884.     }

    885. 

  885.     foreach ($split_array as $restore => $parts) {

    886. 

  886.         if (is_supported_tfu_image(my_basename($restore), $restore) && $size < 100000) {

    887. 

  887.           resize_file($restore, $size, $compression, my_basename($restore));

    888. 

  888.         }

    889. 

  889.     }

    890. 

  890. }

    891. 

  891. 

    892. 

  892. function is_part($str)

    893. 

  893. {

    894. 

  894.     global $split_extension;

    895. 

  895.     $ex = substr (strrchr ($str, '.'), 1);

    896. 

  896.     $pos = strpos ($ex, $split_extension);

    897. 

  897.     if ($pos === false) {

    898. 

  898.         return false;

    899. 

  899.     } else if ($pos == 0) {

    900. 

  900.         return true;

    901. 

  901.     } else {

    902. 

  902.         return false;

    903. 

  903.     }

    904. 

  904. }

    905. 

  905. 

    906. 

  906. function is_supported_tfu_image($image,$current)

    907. 

  907. {

    908. 

  908.     global $scan_images;

    909. 

  909.     $image = strtolower ($image);

    910. 

  910.     $isimage = preg_match('/.*\.(jp)(e){0,1}(g)$/', $image) ||

    911. 

  911.     preg_match('/.*\.(gif)$/', $image) ||

    912. 

  912.     preg_match('/.*\.(png)$/', $image) ;

    913. 

  913.     if ($isimage) {

    914. 

  914.       // we check if this is really an image - if we cannot read the size we assume it could be a php fake

    915. 

  915.       set_error_handler('on_error_no_output');

    916. 

  916.       if (file_exists($current)) {

    917. 

  917.         $size = @getimagesize ($current);

    918. 

  918.         if ($size === false || $scan_images) {

    919. 

  919.           // seems not to be an image - now we we replace the <?php with <_php

    920. 

  920.           $data = file_get_contents($current);

    921. 

  921.           $data2 = str_replace("<?php","<_php",$data);

    922. 

  922.           if ($data2 != $data) {

    923. 

  923.             file_put_contents($current, $data2);

    924. 

  924.             tfu_debug("SECURITY WARNING: Please check the file ".$image.". It was uploaded with an image extensions but included php code. The php start of this file was changed because of security issues!" );

    925. 

  925.           }

    926. 

  926.         }

    927. 

  927.       }

    928. 

  928.       set_error_handler('on_error');

    929. 

  929.     }

    930. 

  930.     return $isimage;

    931. 

  931. }

    932. 

  932. 

    933. 

  933. if (!isset($skip_error_handling)) {

    934. 

  934.   set_error_handler("on_error_no_output"); // 4.x gives depreciated errors here but if I change it it does only work with 5.x - therefore I don't show any errors here !

    935. 

  935. }

    936. 

  936. if (file_exists('tfu_exifReader.php')) {

    937. 

  937.   include 'tfu_exifReader.php';

    938. 

  938. }

    939. 

  939. if (!isset($skip_error_handling)) {

    940. 

  940.   set_error_handler("on_error");

    941. 

  941. }

    942. 

  942. 

    943. 

  943. 

    944. 

  944. 

    945. 

  945. function get_exif_size($filename, $image_name)

    946. 

  946. {

    947. 

  947.     set_error_handler('on_error_no_output'); // is needed because error are most likly but we don't care about fields we don't even know

    948. 

  948.     $er = new phpExifReader($filename);

    949. 

  949.     $er->processFile();

    950. 

  950.     $exif_info = $er->getImageInfo();

    951. 

  951.     set_error_handler('on_error');

    952. 

  952. 

    953. 

  953.     $size_array = array();

    954. 

  954.     $size_array[2] = 2;

    955. 

  955.     if (isset($er->ImageInfo[TAG_EXIF_IMAGEWIDTH])) {

    956. 

  956.         $size_array[0] = $er->ImageInfo[TAG_EXIF_IMAGEWIDTH];

    957. 

  957.     } else {

    958. 

  958.         $size_array[0] = 1024;

    959. 

  959.         tfu_debug('Size of image ' . $image_name . ' cannot be detected using 1024x768.');

    960. 

  960.     }

    961. 

  961. 

    962. 

  962.     if (isset($er->ImageInfo[TAG_EXIF_IMAGELENGTH])) {

    963. 

  963.         $size_array[1] = $er->ImageInfo[TAG_EXIF_IMAGELENGTH];

    964. 

  964.     } else {

    965. 

  965.         $size_array[1] = 768;

    966. 

  966.     }

    967. 

  967.     return $size_array;

    968. 

  968. }

    969. 

  969. 

    970. 

  970. function removeCacheThumb($filename)

    971. 

  971. {

    972. 

  972.     $thumbsdir = dirname(__FILE__) . '/thumbs';

    973. 

  973.     if (file_exists($thumbsdir) && is_writable($thumbsdir)) { // is a caching dir available and writeable?

    974. 

  974.         $cachename = $thumbsdir . '/' . sha1($filename . '160') . '.jpg'; // small

    975. 

  975.         if (file_exists($cachename)) {

    976. 

  976.             @unlink($cachename);

    977. 

  977.         }

    978. 

  978.         $cachename = $thumbsdir . '/' . sha1($filename . '400') . '.jpg'; // big

    979. 

  979.         if (file_exists($cachename)) {

    980. 

  980.             @unlink($cachename);

    981. 

  981.         }

    982. 

  982.     }

    983. 

  983.     cleanup_thumbs_cache();

    984. 

  984. }

    985. 

  985. 

    986. 

  986. function cleanup_thumbs_cache()

    987. 

  987. {

    988. 

  988.     if (isset($_SESSION['checkcache'])) { // we only check once per session!

    989. 

  989.         return;

    990. 

  990.     }

    991. 

  991.     $_SESSION['checkcache'] = 'TRUE';

    992. 

  992. 

    993. 

  993.     $cache_time = 10; // in days !!

    994. 

  994.     $thumbsdir = dirname(__FILE__) . '/thumbs';

    995. 

  995. 

    996. 

  996.     $cache_time = $cache_time * 86400;

    997. 

  997.     $del_time = time() - $cache_time;

    998. 

  998.     if (file_exists($thumbsdir) && is_writable($thumbsdir)) {

    999. 

  999.         $d = opendir($thumbsdir);

    1000. 

  1000.         $i = 0;

    1001. 

  1001.         while (false !== ($entry = readdir($d))) {

    1002. 

  1002.             if ($entry != '.' && $entry != '..') {

    1003. 

  1003.                 $atime = fileatime($thumbsdir . '/' . $entry);

    1004. 

  1004.                 if ($atime < $del_time) {

    1005. 

  1005.                     @unlink($thumbsdir . '/' . $entry);

    1006. 

  1006.                 }

    1007. 

  1007.             }

    1008. 

  1008.         }

    1009. 

  1009.         closedir($d);

    1010. 

  1010.     }

    1011. 

  1011. }

    1012. 

  1012. 

    1013. 

  1013. function removeExtension($name)

    1014. 

  1014. {

    1015. 

  1015.     return substr($name, 0, strrpos ($name, '.'));

    1016. 

  1016. }

    1017. 

  1017. 

    1018. 

  1018. /**

    1019. 

  1019.  * * create a unique directory - 1 st is year, 2 and 3 rd is month - rest is unique up to length

    1020. 

  1020.  */

    1021. 

  1021. function createUniqueDir($basedir, $length = 10)

    1022. 

  1022. {

    1023. 

  1023.     $dir = '';

    1024. 

  1024.     $prefix = substr(date('Ym'), 3);

    1025. 

  1025.     while ($dir == '') {

    1026. 

  1026.         $start = pow (10, $length-3);

    1027. 

  1027.         $stop = pow (10, $length-2)-1;

    1028. 

  1028.         $value = rand($start, $stop);

    1029. 

  1029. 

    1030. 

  1030.         $tempdir = $basedir . $prefix . $value;

    1031. 

  1031.         if (!file_exists($tempdir)) {

    1032. 

  1032.             mkdir($tempdir);

    1033. 

  1033.             $dir = $tempdir;

    1034. 

  1034.             break;

    1035. 

  1035.         }

    1036. 

  1036.     }

    1037. 

  1037.     return $dir;

    1038. 

  1038. }

    1039. 

  1039. 

    1040. 

  1040. /**

    1041. 

  1041.  * Finds the destination folder depending on the id - the id has the format 1,2,0

    1042. 

  1042.  * means folder 2 in level 1, 3 rd folder in level 2, 1st folder in level 3.....

    1043. 

  1043.  * empty means root!

    1044. 

  1044.  */

    1045. 

  1045. function getDestinationFolder($id_list)

    1046. 

  1046. {

    1047. 

  1047.     global $exclude_directories, $hide_hidden_files;

    1048. 

  1048.     $base_dir = $_SESSION['TFU_ROOT_DIR'];

    1049. 

  1049.     if ($id_list == '') return $base_dir;

    1050. 

  1050.     $ids = explode(',', $id_list);

    1051. 

  1051.     $dir = $base_dir;

    1052. 

  1052.     foreach ($ids as $id) {

    1053. 

  1053.         // read the dir - get the directory and set the base to the new level.

    1054. 

  1054.         $dirhandle = opendir($dir);

    1055. 

  1055.         $myDirs = array();

    1056. 

  1056.         while (false !== ($filed = readdir($dirhandle))) {

    1057. 

  1057.             if ($filed != '.' && $filed != '..' && !in_array($filed, $exclude_directories) && (!($hide_hidden_files && (strpos($filed, '.') === 0)))) {

    1058. 

  1058.                 if (is_dir($dir . '/' . $filed)) {

    1059. 

  1059.                     array_push($myDirs, $filed);

    1060. 

  1060.                 }

    1061. 

  1061.             }

    1062. 

  1062.         }

    1063. 

  1063.         usort ($myDirs, 'mycmp');

    1064. 

  1064.         $dir = $dir . '/' . $myDirs[$id];

    1065. 

  1065.     }

    1066. 

  1066.     return $dir;

    1067. 

  1067. }

    1068. 

  1068. 

    1069. 

  1069. function get_tree_xml()

    1070. 

  1070. {

    1071. 

  1071.     if (isset($_SESSION["TREE_" . $_SESSION['TFU_ROOT_DIR']])) {

    1072. 

  1072.       return $_SESSION["TREE_" . $_SESSION['TFU_ROOT_DIR']];

    1073. 

  1073.     } else {

    1074. 

  1074.       $tree = '<node><node label="/"  id="">' . show_dir_xml($_SESSION['TFU_ROOT_DIR']) . '</node></node>';

    1075. 

  1075.       $_SESSION["TREE_" . $_SESSION['TFU_ROOT_DIR']] = $tree;

    1076. 

  1076.       return $tree;

    1077. 

  1077.     }

    1078. 

  1078. }

    1079. 

  1079. 

    1080. 

  1080. function show_dir_xml($myDir = '.', $indent = 0, $levelStr = '')

    1081. 

  1081. {

    1082. 

  1082.     global $exclude_directories, $hide_hidden_files;

    1083. 

  1083.     $dir = opendir($myDir);

    1084. 

  1084.     $einrueckung = str_repeat(' ', $indent * 4);

    1085. 

  1085.     if ($levelStr != '') {

    1086. 

  1086.         $levelStr .= ',';

    1087. 

  1087.     }

    1088. 

  1088.     $foo = '';

    1089. 

  1089.     $counter = 0;

    1090. 

  1090.     $dirlist = array();

    1091. 

  1091. 

    1092. 

  1092.     while ($file = readdir($dir)) {

    1093. 

  1093.         $dirlist[] = $file;

    1094. 

  1094.     }

    1095. 

  1095.     usort ($dirlist, 'mycmp');

    1096. 

  1096.     foreach ($dirlist as $file) {

    1097. 

  1097.         $newDir = $myDir . '/' . $file;

    1098. 

  1098. 

    1099. 

  1099.         if ($file == '.' || $file == '..' || in_array($file, $exclude_directories)&& (!($hide_hidden_files && (strpos($file, '.') === 0))))

    1100. 

  1100.             continue;

    1101. 

  1101. 

    1102. 

  1102.         if (is_dir($newDir)) {

    1103. 

  1103.             $curLevelStr = $levelStr . '' . $counter++;

    1104. 

  1104.             $foo .= '<node id="' . $curLevelStr . '" label="' . $file . '">' . "\n" . show_dir_xml($newDir . '/', 1, $curLevelStr) . "</node>\n";

    1105. 

  1105.         }

    1106. 

  1106.     }

    1107. 

  1107.     return $foo;

    1108. 

  1108. }

    1109. 

  1109. 

    1110. 

  1110. function get_unique_filename($dir, $image)

    1111. 

  1111. {

    1112. 

  1112.     $i = 1;

    1113. 

  1113.     $probeer = $image;

    1114. 

  1114.     while (file_exists($dir . $probeer)) {

    1115. 

  1115.         $punt = strrpos($image, '.');

    1116. 

  1116.         if (substr($image, ($punt-3), 1) !== ('(') && substr($image, ($punt-1), 1) !== (')')) {

    1117. 

  1117.             $probeer = substr($image, 0, $punt) . '(' . $i . ')' .

    1118. 

  1118.             substr($image, ($punt), strlen($image) - $punt);

    1119. 

  1119.         } else {

    1120. 

  1120.             $probeer = substr($image, 0, ($punt-3)) . '(' . $i . ')' .

    1121. 

  1121.             substr($image, ($punt), strlen($image) - $punt);

    1122. 

  1122.         }

    1123. 

  1123.         $i++;

    1124. 

  1124.     }

    1125. 

  1125.     return $probeer;

    1126. 

  1126. }

    1127. 

  1127. 

    1128. 

  1128. /**

    1129. 

  1129.  * Needed for loading saving text files

    1130. 

  1130.  */

    1131. 

  1131. $cp1252_map = array(

    1132. 

  1132. 		      '\xc2\x80' => '\xe2\x82\xac', /* EURO SIGN */

    1133. 

  1133. 		      '\xc2\x82' => '\xe2\x80\x9a', /* SINGLE LOW-9 QUOTATION MARK */

    1134. 

  1134. 		      '\xc2\x83' => '\xc6\x92',     /* LATIN SMALL LETTER F WITH HOOK */

    1135. 

  1135. 		      '\xc2\x84' => '\xe2\x80\x9e', /* DOUBLE LOW-9 QUOTATION MARK */

    1136. 

  1136. 		      '\xc2\x85' => '\xe2\x80\xa6', /* HORIZONTAL ELLIPSIS */

    1137. 

  1137. 		      '\xc2\x86' => '\xe2\x80\xa0', /* DAGGER */

    1138. 

  1138. 		      '\xc2\x87' => '\xe2\x80\xa1', /* DOUBLE DAGGER */

    1139. 

  1139. 		      '\xc2\x88' => '\xcb\x86',     /* MODIFIER LETTER CIRCUMFLEX ACCENT */

    1140. 

  1140. 		      '\xc2\x89' => '\xe2\x80\xb0', /* PER MILLE SIGN */

    1141. 

  1141. 		      '\xc2\x8a' => '\xc5\xa0',     /* LATIN CAPITAL LETTER S WITH CARON */

    1142. 

  1142. 		      '\xc2\x8b' => '\xe2\x80\xb9', /* SINGLE LEFT-POINTING ANGLE QUOTATION */

    1143. 

  1143. 		      '\xc2\x8c' => '\xc5\x92',     /* LATIN CAPITAL LIGATURE OE */

    1144. 

  1144. 		      '\xc2\x8e' => '\xc5\xbd',     /* LATIN CAPITAL LETTER Z WITH CARON */

    1145. 

  1145. 		      '\xc2\x91' => '\xe2\x80\x98', /* LEFT SINGLE QUOTATION MARK */

    1146. 

  1146. 		      '\xc2\x92' => '\xe2\x80\x99', /* RIGHT SINGLE QUOTATION MARK */

    1147. 

  1147. 		      '\xc2\x93' => '\xe2\x80\x9c', /* LEFT DOUBLE QUOTATION MARK */

    1148. 

  1148. 		      '\xc2\x94' => '\xe2\x80\x9d', /* RIGHT DOUBLE QUOTATION MARK */

    1149. 

  1149. 		      '\xc2\x95' => '\xe2\x80\xa2', /* BULLET */

    1150. 

  1150. 		      '\xc2\x96' => '\xe2\x80\x93', /* EN DASH */

    1151. 

  1151. 		      '\xc2\x97' => '\xe2\x80\x94', /* EM DASH */

    1152. 

  1152. 

    1153. 

  1153. 		      '\xc2\x98' => '\xcb\x9c',     /* SMALL TILDE */

    1154. 

  1154. 		      '\xc2\x99' => '\xe2\x84\xa2', /* TRADE MARK SIGN */

    1155. 

  1155. 		      '\xc2\x9a' => '\xc5\xa1',     /* LATIN SMALL LETTER S WITH CARON */

    1156. 

  1156. 		      '\xc2\x9b' => '\xe2\x80\xba', /* SINGLE RIGHT-POINTING ANGLE QUOTATION*/

    1157. 

  1157. 		      '\xc2\x9c' => '\xc5\x93',     /* LATIN SMALL LIGATURE OE */

    1158. 

  1158. 		      '\xc2\x9e' => '\xc5\xbe',     /* LATIN SMALL LETTER Z WITH CARON */

    1159. 

  1159. 		      '\xc2\x9f' => '\xc5\xb8'      /* LATIN CAPITAL LETTER Y WITH DIAERESIS*/

    1160. 

  1160.     );

    1161. 

  1161. 

    1162. 

  1162. function tfu_seems_utf8($Str)

    1163. 

  1163. {

    1164. 

  1164.     for ($i = 0; $i < strlen($Str); $i++) {

    1165. 

  1165.         if (ord($Str[$i]) < 0x80) $n = 0; # 0bbbbbbb

    1166. 

  1166.         elseif ((ord($Str[$i]) &0xE0) == 0xC0) $n = 1; # 110bbbbb

    1167. 

  1167.         elseif ((ord($Str[$i]) &0xF0) == 0xE0) $n = 2; # 1110bbbb

    1168. 

  1168.         elseif ((ord($Str[$i]) &0xF0) == 0xF0) $n = 3; # 1111bbbb

    1169. 

  1169.         else return false; # Does not match any model

    1170. 

  1170.         for ($j = 0; $j < $n; $j++) { // n octets that match 10bbbbbb follow ?

    1171. 

  1171.             if ((++$i == strlen($Str)) || ((ord($Str[$i]) &0xC0) != 0x80)) return false;

    1172. 

  1172.         }

    1173. 

  1173.     }

    1174. 

  1174.     return true;

    1175. 

  1175. }

    1176. 

  1176. 

    1177. 

  1177. function cp1252_to_utf8($str)

    1178. 

  1178. {

    1179. 

  1179.     global $cp1252_map;

    1180. 

  1180.     return strtr(utf8_encode($str), $cp1252_map);

    1181. 

  1181. }

    1182. 

  1182. 

    1183. 

  1183. function utf8_to_cp1252($str)

    1184. 

  1184. {

    1185. 

  1185.     global $cp1252_map;

    1186. 

  1186.     return utf8_decode(strtr($str, array_flip($cp1252_map)));

    1187. 

  1187. }

    1188. 

  1188. 

    1189. 

  1189. function getExtension($name)

    1190. 

  1190. {

    1191. 

  1191.     $name = rtrim($name, ".,; \t\n\r\0\x0B");

    1192. 

  1192.     return substr (strrchr ($name, '.'), 1);

    1193. 

  1193. }

    1194. 

  1194. 

    1195. 

  1195. 

    1196. 

  1196. function space_enc($string) {

    1197. 

  1197.   global $description_mode;

    1198. 

  1198. 

    1199. 

  1199.   if ($description_mode == 'true') { // - description is added at the end - we don't encode ' : ' and the rest.

    1200. 

  1200.     $teile = explode(" : ", $string,2);

    1201. 

  1201.     $teile[0] =  str_replace(" ", "%20",  $teile[0]);

    1202. 

  1202.     $string = implode(" : ", $teile);

    1203. 

  1203.   } else {

    1204. 

  1204.     $string =  str_replace(" ", "%20", $string);

    1205. 

  1205.   }

    1206. 

  1206.   return $string;

    1207. 

  1207. 

    1208. 

  1208. }

    1209. 

  1209. /**

    1210. 

  1210.  * This does a nice character exchange with a random crypt key!

    1211. 

  1211.  * If you need a 100% secure connection please use https!

    1212. 

  1212.  */

    1213. 

  1213. function tfu_enc($str, $id, $length = false)

    1214. 

  1214. {

    1215. 

  1215.     if ($length) {

    1216. 

  1216.         $str = substr($str, 0, $length);

    1217. 

  1217.     }

    1218. 

  1218.     for ($i = 0; $i < strlen($id); $i++) {

    1219. 

  1219.         if (ord($id{$i}) > 127) {

    1220. 

  1220.             tfu_debug('The crypt key at position ' . $i . ' is not valid - please change the implementation.');

    1221. 

  1221.             return $str;

    1222. 

  1222.         }

    1223. 

  1223.     }

    1224. 

  1224.     $code = '';

    1225. 

  1225.     $keylen = strlen($id);

    1226. 

  1226.     for ($i = 0; $i < strlen($str); $i++) {

    1227. 

  1227.         $code .= chr(ord($str{$i}) + ord($id{$i%$keylen}));

    1228. 

  1228.     }

    1229. 

  1229.     return utf8_encode($code);

    1230. 

  1230. }

    1231. 

  1231. 

    1232. 

  1232. function setSessionVariables()

    1233. 

  1233. {

    1234. 

  1234.     global $folder, $user, $login;

    1235. 

  1235.     // this settings are needed in the other php files too!

    1236. 

  1236.     if ($login == 'true') {

    1237. 

  1237.         $_SESSION['TFU_LOGIN'] = 'true';

    1238. 

  1238.         if (!isset($_SESSION['TFU_USER'])) { // can be set by the Joomla wrapper and we don't overwrite it with a dummy value!

    1239. 

  1239.           $_SESSION['TFU_USER'] = ($user != '' && $user != '__empty__') ? $user : $_SERVER['REMOTE_ADDR'];

    1240. 

  1240.         }

    1241. 

  1241.     } else {

    1242. 

  1242.        unset($_SESSION['TFU_USER']);

    1243. 

  1243.     }

    1244. 

  1244.     $_SESSION['TFU_RN'] = parseInputParameter($_POST['twg_rn']);

    1245. 

  1245.     $_SESSION['TFU_ROOT_DIR'] = $_SESSION['TFU_DIR'] = $folder;

    1246. 

  1246.     store_temp_session();

    1247. 

  1247. }

    1248. 

  1248. 

    1249. 

  1249. /**

    1250. 

  1250.  * All parameters a sent to the flash

    1251. 

  1251.  * First I wanted to introduce a Config class but this is the only place where they

    1252. 

  1252.  * have to be passed globaly - therefore no class is used now.

    1253. 

  1253.  */

    1254. 

  1254. function sendConfigData()

    1255. 

  1255. {

    1256. 

  1256.     global $login, $rn, $maxfilesize, $resize_show, $resize_data, $resize_label, $resize_default, $allowed_file_extensions;

    1257. 

  1257.     global $forbidden_file_extensions, $show_delete, $enable_folder_browsing, $enable_folder_creation;

    1258. 

  1258.     global $enable_folder_deletion, $enable_file_download, $keep_file_extension, $show_preview, $show_big_preview;

    1259. 

  1259.     global $enable_file_rename, $enable_folder_rename, $enable_folder_move, $enable_file_copymove, $language_dropdown;

    1260. 

  1260.     global $preview_textfile_extensions, $edit_textfile_extensions;

    1261. 

  1261.     //, $maxfilesize_split;

    1262. 

  1262.     // optional settings

    1263. 

  1263.     global $reg_infos, $login_text, $relogin_text, $upload_file, $base_dir, $titel;

    1264. 

  1264.     global $warning_setting, $hide_remote_view, $directory_file_limit, $remote_label;

    1265. 

  1265.     global $preview_label, $show_full_url_for_selected_file, $upload_finished_js_url;

    1266. 

  1266.     global $preview_select_js_url, $delete_js_url, $js_change_folder, $js_create_folder;

    1267. 

  1267.     global $js_rename_folder, $js_delete_folder, $js_copymove, $queue_file_limit, $show_size;

    1268. 

  1268.     global $queue_file_limit_size, $split_extension, $hide_help_button, $direct_download;

    1269. 

  1269.     global $description_mode_show_default, $description_mode, $download_multiple_files_as_zip;

    1270. 

  1270.     global $overwrite_files, $description_mode_mandatory, $post_upload_panel, $form_fields;

    1271. 

  1271.     global $big_progressbar,$img_progressbar,$img_progressbar_back,$img_progressbar_anim, $big_server_view;

    1272. 

  1272.     global $zip_file_pattern, $is_jfu_plugin, $has_post_processing, $directory_file_limit_size;

    1273. 

  1273.     global $show_server_date_instead_size, $enable_file_creation, $enable_file_creation_extensions;

    1274. 

  1274. 

    1275. 

  1275.     // the sessionid is mandatory because upload in flash and Firefox would create a new session otherwise - sessionhandled login would fail then!

    1276. 

  1276.     $output = '&login=' . $login .  '&maxfilesize=' . '' . $maxfilesize;

    1277. 

  1277.     // $output .= '&maxfilesize_split=' . tfu_enc('' . $maxfilesize_split, $rn);

    1278. 

  1278.     // $output .= '&maxfilesize_php=' . getMaximumUploadSize();

    1279. 

  1279.     $output .= '&resize_show=' . $resize_show . '&resize_data=' . $resize_data;

    1280. 

  1280.     $output .= '&resize_label=' . urlencode($resize_label) . '&resize_default=' . $resize_default;

    1281. 

  1281.     $output .= '&allowed_file_extensions=' . $allowed_file_extensions . '&forbidden_file_extensions=' . $forbidden_file_extensions;

    1282. 

  1282.     $output .= '&show_delete=' . $show_delete . '&enable_folder_browsing=' . $enable_folder_browsing;

    1283. 

  1283.     $output .= '&enable_folder_creation=' . $enable_folder_creation . '&enable_folder_deletion=' . $enable_folder_deletion ;

    1284. 

  1284.     $output .= '&enable_file_download=' . $enable_file_download . '&keep_file_extension=' . $keep_file_extension;

    1285. 

  1285.     $output .= '&show_preview=' . $show_preview . '&show_big_preview=' . $show_big_preview ;

    1286. 

  1286.     $output .= '&enable_file_rename=' . $enable_file_rename . '&enable_folder_rename=' . $enable_folder_rename;

    1287. 

  1287.     $output .= '&enable_folder_copy=' . $enable_folder_move . '&enable_file_copy=' . $enable_file_copymove;

    1288. 

  1288.     $output .= '&language_dropdown=' . $language_dropdown;

    1289. 

  1289.     $output .= '&preview_textfile_extensions=' . $preview_textfile_extensions . '&edit_textfile_extensions=' . $edit_textfile_extensions;

    1290. 

  1290.     // optional settings

    1291. 

  1291.     $output .= $reg_infos . '&login_text=' . $login_text;

    1292. 

  1292.     $output .= '&relogin_text=' . $relogin_text . '&upload_file=' . $upload_file;

    1293. 

  1293.     $output .= '&base_dir=' . $base_dir . '&titel=' . urlencode($titel);

    1294. 

  1294.     $output .= '&warning_setting=' . $warning_setting . '&hide_remote_view=' . $hide_remote_view;

    1295. 

  1295.     $output .= '&directory_file_limit=' . $directory_file_limit;

    1296. 

  1296.     $output .= '&remote_label=' . urlencode($remote_label) . '&preview_label=' . $preview_label;

    1297. 

  1297.     $output .= '&show_full_url_for_selected_file=' . $show_full_url_for_selected_file;

    1298. 

  1298.     $output .= '&upload_finished_js_url=' . urlencode($upload_finished_js_url) . '&preview_select_js_url=' . urlencode($preview_select_js_url);

    1299. 

  1299.     $output .= '&delete_js_url=' . urlencode($delete_js_url) . '&js_change_folder=' . urlencode($js_change_folder);

    1300. 

  1300.     $output .= '&js_create_folder=' . urlencode($js_create_folder) . '&js_rename_folder=' . urlencode($js_rename_folder);

    1301. 

  1301.     $output .= '&js_delete_folder=' . urlencode($js_delete_folder) . '&js_copymove=' . urlencode($js_copymove);

    1302. 

  1302.     $output .= '&queue_file_limit=' . $queue_file_limit . '&queue_file_limit_size=' . $queue_file_limit_size;

    1303. 

  1303.     $output .= '&split_extension=' . $split_extension . '&hide_help_button=' . $hide_help_button;

    1304. 

  1304.     $output .= '&direct_download=' . $direct_download . '&show_size=' . $show_size;

    1305. 

  1305.     $output .= '&description_mode=' . $description_mode . '&description_mode_show_default=' . $description_mode_show_default;

    1306. 

  1306.     $output .= '&multiple_zip_download=' . $download_multiple_files_as_zip;

    1307. 

  1307.     $output .= '&overwrite_files=' . $overwrite_files . '&description_mode_mandatory=' . $description_mode_mandatory;

    1308. 

  1308.     $output .= '&post_upload_panel=' . $post_upload_panel . '&form_fields=' .$form_fields;

    1309. 

  1309.     $output .= '&big_progressbar=' . $big_progressbar . '&img_progressbar=' .$img_progressbar;

    1310. 

  1310.     $output .= '&img_progressbar_back=' . $img_progressbar_back . '&img_progressbar_anim=' .$img_progressbar_anim;

    1311. 

  1311.     $output .= '&big_server_view=' . $big_server_view . '&zip_file_pattern=' . $zip_file_pattern;

    1312. 

  1312.     $output .= '&is_jfu_plugin=' . $is_jfu_plugin . '&has_post_processing=' . $has_post_processing;

    1313. 

  1313.     $output .= '&directory_file_limit_size=' . $directory_file_limit_size . '&show_server_date_instead_size=' . $show_server_date_instead_size;

    1314. 

  1314.     $output .= '&enable_file_creation=' . $enable_file_creation . '&enable_file_creation_extensions=' . $enable_file_creation_extensions;

    1315. 

  1315.     

    1316. 

  1316. 

    1317. 

  1317.     // all parameters are sent encrypted to the client.

    1318. 

  1318.     $parameters = "&parameters=" . urlencode(tfu_enc($output, $rn));

    1319. 

  1319. 

    1320. 

  1320.     // we generate a nonce for this request

    1321. 

  1321.     // last=true is added for such websites who add their own code to each page!

    1322. 

  1322.     echo '&tfu_nonce=' . create_tfu_nonce() . $parameters . "&last=true";

    1323. 

  1323. }

    1324. 

  1324. 

    1325. 

  1325. /**

    1326. 

  1326.  * This stores all data in a session in a temporary folder as well if it does exist.

    1327. 

  1327.  * This is a workaround if a session is lost and empty in the tfu_upload.php and restored there!

    1328. 

  1328.  */

    1329. 

  1329. function store_temp_session()

    1330. 

  1330. {

    1331. 

  1331.     global $session_double_fix;

    1332. 

  1332.     clearstatcache();

    1333. 

  1333.     if (file_exists(dirname(__FILE__) . '/session_cache') && session_id() != "") { // we do your own small session handling

    1334. 

  1334.         $cachename = dirname(__FILE__) . '/session_cache/' . session_id();

    1335. 

  1335.         $ser_file = fopen($cachename, 'w');

    1336. 

  1336.         fwrite($ser_file, serialize($_SESSION));

    1337. 

  1337.         fclose($ser_file);

    1338. 

  1338.         if ($session_double_fix) {

    1339. 

  1339.             $ser_file = fopen($cachename . '2', 'w');

    1340. 

  1340.             fwrite($ser_file, serialize($_SESSION));

    1341. 

  1341.             fclose($ser_file);

    1342. 

  1342.         }

    1343. 

  1343.     }

    1344. 

  1344. }

    1345. 

  1345. 

    1346. 

  1346. function checkSessionTempDir($type = 0)

    1347. 

  1347. {

    1348. 

  1348.     global $keep_internal_session_handling;

    1349. 

  1349.     if (isset($_FILES) && (count ($_FILES) > 0)) {

    1350. 

  1350.         $filen = array_shift($_FILES);

    1351. 

  1351.         $filename = $filen['name'];

    1352. 

  1352.         tfu_debug('It can be possible that someone tried to upload something without permissions! If you think this is the case the IP of this user is logged: ' . $_SERVER['REMOTE_ADDR'] . '. He tried to upload the following file: ' . $filename);

    1353. 

  1353.     }

    1354. 

  1354.     if (!file_exists(dirname(__FILE__) . '/session_cache')) {

    1355. 

  1355.         tfu_debug('Or it is possible that the session handling of the server is not o.k. Therefore TFU simulates a basic session handling and uses the session_cache folder for that.');

    1356. 

  1356.         if (!mkdir(dirname(__FILE__) . '/session_cache')) {

    1357. 

  1357.             tfu_debug('Directory session_cache could not be created! Please create the sub directoy session_cache and set the permissions of it to 777.');

    1358. 

  1358.         } else {

    1359. 

  1359.             tfu_debug('Directory session_cache could be created! TFU does now an internal session handling. Delete the directory session_cache to turn the internal handling off.');

    1360. 

  1360.             @chmod(dirname(__FILE__) . '/session_cache', 0777);

    1361. 

  1361.             // we create an index.htm to prevent listings!

    1362. 

  1362.             $datei = fopen(dirname(__FILE__) . '/session_cache/index.htm', 'w');

    1363. 

  1363.             fclose($datei);

    1364. 

  1364.         }

    1365. 

  1365. 

    1366. 

  1366.     } else if ($type == 5) { // the upload check has to fail because the whole session data is gone.

    1367. 

  1367.       echo 'int_session_handling=true';

    1368. 

  1368.     } else {

    1369. 

  1369.         tfu_debug('It seems that the session handling of the server is not o.k. TFU already tried a workaround that does not seem to work. TFU deleted the session_cache folder. Maybe it was created because of a wrong request! Please go to http://www.tinywebgallery.com/de/tfu/tfu_faq_12.php. If this does not help please report this in the forum to find a solution!');

    1370. 

  1370.         if (!$keep_internal_session_handling) {

    1371. 

  1371.             remove(dirname(__FILE__) . '/session_cache');

    1372. 

  1372.         }

    1373. 

  1373.       echo 'int_session_handling=false';

    1374. 

  1374.     }

    1375. 

  1375. }

    1376. 

  1376. 

    1377. 

  1377. $check_server_file_extensions = $m;

    1378. 

  1378. 

    1379. 

  1379. function restore_temp_session($checkrn = false)

    1380. 

  1380. {

    1381. 

  1381.     global $session_double_fix;

    1382. 

  1382.     clearstatcache();

    1383. 

  1383.     if (file_exists(dirname(__FILE__) . '/session_cache')) { // we do your own small session handling

    1384. 

  1384.         $cachename = dirname(__FILE__) . '/session_cache/' . session_id();

    1385. 

  1385.         if (file_exists($cachename)) {

    1386. 

  1386.             $data = file_get_contents($cachename);

    1387. 

  1387.             set_error_handler('on_error_no_output'); // is needed because error are most likly but we don't care about fields we don't even know

    1388. 

  1388.             $sdata = unserialize($data);

    1389. 

  1389.             set_error_handler('on_error');

    1390. 

  1390.             if (isset($sdata) && (isset($sdata['TFU_RN']) || $checkrn)) {

    1391. 

  1391.                 $_SESSION = $sdata;

    1392. 

  1392.             } else { // we try again

    1393. 

  1393.                 sleep(1);

    1394. 

  1394.                 if ($session_double_fix) {

    1395. 

  1395.                     $cachename .= '2';

    1396. 

  1396.                 }

    1397. 

  1397.                 $data = file_get_contents ($cachename);

    1398. 

  1398.                 set_error_handler('on_error_no_output'); // is needed because error are most likly but we don't care about fields we don't even know

    1399. 

  1399.                 $sdata = unserialize($data);

    1400. 

  1400.                 set_error_handler('on_error');

    1401. 

  1401.                 if (isset($sdata) && (isset($sdata['TFU_RN'])|| $checkrn)) {

    1402. 

  1402.                     $_SESSION = $sdata;

    1403. 

  1403.                 } else {

    1404. 

  1404.                     tfu_debug('Session data could no be restored :' . $data);

    1405. 

  1405.                 }

    1406. 

  1406.             }

    1407. 

  1407.         }

    1408. 

  1408.         // now we have to clean old temp sessions! - we do this once a day only!

    1409. 

  1409.         // first we check if we have done this already!

    1410. 

  1410.         $today = dirname(__FILE__) . '/session_cache/_cache_day_' . date('Y_m_d') . '.tmp';

    1411. 

  1411.         if (file_exists($today)) {

    1412. 

  1412.             return;

    1413. 

  1413.         }

    1414. 

  1414.         // not done - we delete all files on this folder older than 1 day + the _cache_day_*.tmp files

    1415. 

  1415.         $d = opendir(dirname(__FILE__) . '/session_cache');

    1416. 

  1416.         $i = 0;

    1417. 

  1417.         $del_time = time() - 86000; // we delete file older then 24 hours

    1418. 

  1418.         while (false !== ($entry = readdir($d))) {

    1419. 

  1419.             if ($entry != '.' && $entry != '..') {

    1420. 

  1420.                 $atime = fileatime(dirname(__FILE__) . '/session_cache/' . $entry);

    1421. 

  1421.                 if ($atime < $del_time) {

    1422. 

  1422.                     @unlink(dirname(__FILE__) . '/session_cache/' . $entry);

    1423. 

  1423.                 }

    1424. 

  1424.             }

    1425. 

  1425.         }

    1426. 

  1426.         $tmp_files = glob(dirname(__FILE__) . '/session_cache/*.tmp');

    1427. 

  1427.         if ($tmp_files) {

    1428. 

  1428.             foreach($tmp_files as $fn) {

    1429. 

  1429.                 if ($fn != '/session_cache/.' && $fn != '/session_cache/..') {

    1430. 

  1430.                   @unlink($fn);

    1431. 

  1431.                 }

    1432. 

  1432.             }

    1433. 

  1433.         }

    1434. 

  1434.         // now we write the flag

    1435. 

  1435.         $fh = fopen($today, 'w');

    1436. 

  1436.         fclose($fh);

    1437. 

  1437.     }

    1438. 

  1438. 

    1439. 

  1439.     // Joomla session update!

    1440. 

  1440.     if (isset($_SESSION['__default']['session.counter'])) {

    1441. 

  1441.       $_SESSION['__default']['session.counter'] = $_SESSION['__default']['session.counter'] + 1;

    1442. 

  1442.       $_SESSION['__default']['session.timer.now'] = time();

    1443. 

  1443.       $_SESSION['__default']['session.timer.last'] = $_SESSION['__default']['session.timer.now'];

    1444. 

  1444.     }

    1445. 

  1445. }

    1446. 

  1446. 

    1447. 

  1447. // creates a nonce see http://en.wikipedia.org/wiki/Cryptographic_nonce

    1448. 

  1448. // just some random parts and then a hash of it.

    1449. 

  1449. function create_tfu_nonce() {

    1450. 

  1450.     return nhash(date("is") . session_id() . rand());

    1451. 

  1451. }

    1452. 

  1452. 

    1453. 

  1453. // checks if the extension is allowed to be viewed!

    1454. 

  1454. function check_view_extension($name)

    1455. 

  1455. {

    1456. 

  1456.     global $check_server_file_extensions, $allowed_view_file_extensions, $forbidden_view_file_extensions, $forbidden_view_file_filter;

    1457. 

  1457.     $allowed_view_file_extensions = str_replace(' ', '', strtolower($allowed_view_file_extensions));

    1458. 

  1458.     $forbidden_view_file_extensions = str_replace(' ', '', strtolower($forbidden_view_file_extensions));

    1459. 

  1459.     $forbidden_view_file_filter = str_replace(' ', '', strtolower($forbidden_view_file_filter));

    1460. 

  1460. 

    1461. 

  1461.     $isAllowed = true;

    1462. 

  1462. 

    1463. 

  1463.     if ($check_server_file_extensions == 'v') {

    1464. 

  1464.          if ($allowed_view_file_extensions != 'all' || $forbidden_view_file_extensions != '') {

    1465. 

  1465.              if ($allowed_view_file_extensions != 'all' && strpos($name, '.') === false) {

    1466. 

  1466.                  $isAllowed = false;

    1467. 

  1467.              } else {

    1468. 

  1468.                  $ext = strtolower(getExtension($name));

    1469. 

  1469.                  if ($allowed_view_file_extensions == 'all') { // we check the not allowed extensions

    1470. 

  1470.                      $isAllowed = !in_array($ext, explode(',', $forbidden_view_file_extensions));

    1471. 

  1471.                  } else { // we only allow the allowed extension

    1472. 

  1472.                      $isAllowed = in_array($ext, explode(',', $allowed_view_file_extensions));

    1473. 

  1473.                  }

    1474. 

  1474.              }

    1475. 

  1475.          } else {

    1476. 

  1476.              $isAllowed = true;

    1477. 

  1477.          }

    1478. 

  1478.          // now we check the filter on non windows systems!

    1479. 

  1479.          if (function_exists('fnmatch')) {

    1480. 

  1480.               if ($forbidden_view_file_filter != '') {

    1481. 

  1481.                    $filters =explode(',', $forbidden_view_file_filter);

    1482. 

  1482.                    foreach ($filters as $filter) {

    1483. 

  1483.                      if (fnmatch ($filter, $name)) {

    1484. 

  1484.                        $isAllowed = false;

    1485. 

  1485.                        break;

    1486. 

  1486.                      }

    1487. 

  1487.                    }

    1488. 

  1488.               }

    1489. 

  1489.          }

    1490. 

  1490.     }

    1491. 

  1491. 

    1492. 

  1492.     return $isAllowed;

    1493. 

  1493. 

    1494. 

  1494. }

    1495. 

  1495. 

    1496. 

  1496. function t($l, $s)

    1497. 

  1497. {

    1498. 

  1498.     $n = '';

    1499. 

  1499.     $m = explode(';', $l);

    1500. 

  1500.     foreach($m as $v) {

    1501. 

  1501.       $nrp = substr_count($v, '.');

    1502. 

  1502.       if ($nrp == 1 && (strpos($v,'*')=== false)) { $nrp++; $v.="*."; }

    1503. 

  1503.         $el = explode('.', $s);

    1504. 

  1504.         if ($el !== false) {

    1505. 

  1505.           $r = array_slice($el, 0, -$nrp);

    1506. 

  1506.           $n .= ';' . str_replace('*', 'ww'.'w'. ((count($r) >0) ? ('.'.array_pop($r)) : ''), $v);

    1507. 

  1507.         }

    1508. 

  1508.       }

    1509. 

  1509.     return $n;

    1510. 

  1510. }

    1511. 

  1511. // Checks if the uploaded extension is o.k. on the server side!

    1512. 

  1512. // Trailing . are removed because of security issues.

    1513. 

  1513. function check_valid_extension($name, $die_if_invalid = true)

    1514. 

  1514. {

    1515. 

  1515.     global $forbidden_file_extensions, $allowed_file_extensions;

    1516. 

  1516. 

    1517. 

  1517.     $afe = str_replace(' ', '', strtolower($allowed_file_extensions));

    1518. 

  1518.     $name = rtrim($name, ".,; \t\n\r\0\x0B");

    1519. 

  1519.     $path_info = pathinfo($name);

    1520. 

  1520.     if (isset($path_info['extension'])) {

    1521. 

  1521.       $file_extension = strtolower($path_info['extension']);

    1522. 

  1522.     } else {

    1523. 

  1523.       $file_extension = '';

    1524. 

  1524.     }

    1525. 

  1525.     

    1526. 

  1526.     if ($afe == '') { // this can be useful if you don't allow to upload - only to download!

    1527. 

  1527.         return false;

    1528. 

  1528.     }

    1529. 

  1529.     if ($afe != 'all') {

    1530. 

  1530.         $extension_whitelist = explode(',', $afe); // Allowed file extensions

    1531. 

  1531.         // $valid_chars_regex = '.A-Z0-9_ !@#$%^&()+={}\[\]\',~`-';				// Characters allowed in the file name (in a Regular Expression format)

    1532. 

  1532.         $is_valid_extension = false;

    1533. 

  1533.         foreach ($extension_whitelist as $extension) {

    1534. 

  1534.             if ($file_extension == $extension) {

    1535. 

  1535.                 $is_valid_extension = true;

    1536. 

  1536.                 break;

    1537. 

  1537.             }

    1538. 

  1538.         }

    1539. 

  1539.     } else { // not allowed extensions

    1540. 

  1540.         $nafe = str_replace(' ', '', strtolower($forbidden_file_extensions));

    1541. 

  1541.         $is_valid_extension = true;

    1542. 

  1542.         if ($nafe != '') {

    1543. 

  1543.             $extension_blacklist = explode(',', $nafe);

    1544. 

  1544.             foreach ($extension_blacklist as $extension) {

    1545. 

  1545.                 if (strpos($file_extension, $extension) !== false) {

    1546. 

  1546.                     $is_valid_extension = false;

    1547. 

  1547.                     break;

    1548. 

  1548.                 }

    1549. 

  1549.             }

    1550. 

  1550.         }

    1551. 

  1551.     }

    1552. 

  1552.     if (!$is_valid_extension && $die_if_invalid) {

    1553. 

  1553.         header('HTTP/1.1 500 Internal Server Error');

    1554. 

  1554.         echo 'No valid extension - upload not permitted.';

    1555. 

  1555.         exit(0);

    1556. 

  1556.     }

    1557. 

  1557.     return $is_valid_extension;

    1558. 

  1558. }

    1559. 

  1559. // Validate the file size (Warning the largest files supported by this code is 2GB)

    1560. 

  1560. function check_valid_filesize($name)

    1561. 

  1561. {

    1562. 

  1562.     global $maxfilesize;

    1563. 

  1563.     $file_size = sprintf("%u", @filesize($name));

    1564. 

  1564.     if (!$file_size || $file_size > ($maxfilesize * 1024)) {

    1565. 

  1565.         @unlink($name);

    1566. 

  1566.         header('HTTP/1.1 500 Internal Server Error');

    1567. 

  1567.         echo 'File size too big - upload not permitted.';

    1568. 

  1568.         exit(0);

    1569. 

  1569.     }

    1570. 

  1570. }

    1571. 

  1571. 

    1572. 

  1572. /**

    1573. 

  1573.  * Right now the parameters are only checked very basic because they are not

    1574. 

  1574.  * returned back to a frontend or passed somewhere else.

    1575. 

  1575.  * Therefore only a basic regular expression is used!

    1576. 

  1576.  * You can pass a different regex if you want to restrict something more (e.g a file name)

    1577. 

  1577.  * The are 2 functions

    1578. 

  1578.  * - parseInputParameter check for valid caracters because there I know the proper values

    1579. 

  1579.  * - parseInputParameterFile is an exclude - there I only check for chars that are not allowed in file names!

    1580. 

  1580.  */

    1581. 

  1581. function parseInputParameter($value, $def = '', $valid_chars_regex = '.\w_,-')

    1582. 

  1582. {

    1583. 

  1583.     return (isset($value)) ? preg_replace('/[^' . $valid_chars_regex . ']|\.+$/i', '_', $value) : $def;

    1584. 

  1584. }

    1585. 

  1585. 

    1586. 

  1586. function parseInputParameterFile($value, $def = '')

    1587. 

  1587. {

    1588. 

  1588.     if (isset($value)) {

    1589. 

  1589.         $reserved = preg_quote("\/:*?'<>", "/");

    1590. 

  1590.         return preg_replace("/([\\x00-\\x1f{$reserved}])/", '_', $value);

    1591. 

  1591.     } else {

    1592. 

  1592.         return $def;

    1593. 

  1593.     }

    1594. 

  1594. }

    1595. 

  1595. 

    1596. 

  1596. function printServerInfo()

    1597. 

  1597. {

    1598. 

  1598.    global $check_image_magic;                                                                                                                                                                                   global $m;

    1599. 

  1599.     echo '

    1600. 

  1600.   <style type="text/css">

    1601. 

  1601.   body { 	font-family : Arial, Helvetica, sans-serif; font-size: 12px; background-color:#ffffff; }

    1602. 

  1602.   td { vertical-align: top; font-size: 12px; }

    1603. 

  1603.   .install {  margin-left: auto;  margin-right: auto;  margin-top: 3em;  margin-bottom: 3em; padding: 10px; border: 1px solid #cccccc;  width: 650px; background: #F1F1F1; }

    1604. 

  1604.   </style>

    1605. 

  1605. ';

    1606. 

  1606.     $limit = return_kbytes(ini_get('memory_limit'));

    1607. 

  1607. 

    1608. 

  1608.     echo '<br><p><center>Some info\'s about your server. This limits are not TFU limits. You have to change this in the php.ini.</center></p>';

    1609. 

  1609.     echo '<div class="install">';

    1610. 

  1610.     echo '<table><tr><td>';

    1611. 

  1611.     echo '<tr><td width="400">TFU version:</td><td width="250">2.14&nbsp;';

    1612. 

  1612.     // simply output the license type by checking the strings in the license. No real check like in the flash is done here.

    1613. 

  1613.     if ($m != "" && $m != "s" && $m !="w" ) {

    1614. 

  1614.         ob_start();

    1615. 

  1615.         $ff = dirname(__FILE__) . "/twg.lic.php";

    1616. 

  1616.         if (!file_exists($ff)) { // we are in TWG

    1617. 

  1617.           $ff = dirname(__FILE__) . "/../../twg.lic.php";

    1618. 

  1618.         }

    1619. 

  1619.         include  $ff;

    1620. 

  1620.         ob_end_clean();

    1621. 

  1621.         if ($l == $d) {

    1622. 

  1622.           echo " (Enterprise Edition License)";

    1623. 

  1623.         } else if (strpos($d, "TWG_PROFESSIONAL") !== false) {

    1624. 

  1624.           echo " (Professional Edition License)";

    1625. 

  1625.         } else if (strpos($d, "TWG_SOURCE") !== false) {

    1626. 

  1626.           echo " (Source code Edition License)";

    1627. 

  1627.         } else {

    1628. 

  1628.           echo " (Standart Edition License)";

    1629. 

  1629.         }

    1630. 

  1630.     } else {

    1631. 

  1631.       echo " (Freeware Edition)";

    1632. 

  1632.     }

    1633. 

  1633.     echo  '</td></tr>';

    1634. 

  1634. 

    1635. 

  1635.     echo '<tr><td width="400">Server name:</td><td width="250">' . get_server_name() . '</td></tr>';

    1636. 

  1636.     echo '<tr><td>PHP upload limit (in KB): </td><td>' . getMaximumUploadSize() . '</td></tr>';

    1637. 

  1637.     echo '<tr><td>PHP memory limit (in KB):&nbsp;&nbsp;&nbsp;</td><td>' . $limit . '</td></tr>';

    1638. 

  1638.     echo '<tr><td>Safe mode:</td><td>';

    1639. 

  1639.     echo (ini_get('safe_mode') == 1) ? 'ON<br>You maybe have some limitations creating folders or uploading<br>if the permissions are not set properly.<br>Please check the TWG FAQ 30 if you want to know more about<br>safe mode and the problems that comes with this setting.' : 'OFF';

    1640. 

  1640.     echo '</td></tr><tr><td>GD lib:</td><td>';

    1641. 

  1641.     echo (!function_exists('imagecreatetruecolor')) ? '<font color="red">GDlib is not installed properly.<br>TFU Preview does not work!</font>' : 'Available';

    1642. 

  1642.     echo '</td></tr>';

    1643. 

  1643.     echo '<tr><td>Max resize resolution (GDlib):</td><td>';

    1644. 

  1644.     if (!$limit) {

    1645. 

  1645.         echo '<font color="green">No limit</font>';

    1646. 

  1646.     } else {

    1647. 

  1647.         $xy = $limit * 1024 / 6.6;  // 10 % overhead. 

    1648. 

  1648.         $x = floor(sqrt ($xy / 0.75));

    1649. 

  1649.         $y = floor(sqrt($xy / 1.33));

    1650. 

  1650.         if ($x > 4000) {

    1651. 

  1651.             echo '<font color="green">~ ' . $x . ' x ' . $y . '</font>';

    1652. 

  1652.         } else if ($x > 2000) {

    1653. 

  1653.             echo '<font color="orange">~ ' . $x . ' x ' . $y . '</font>';

    1654. 

  1654.         } else {

    1655. 

  1655.             echo '<font color="red">~ ' . $x . ' x ' . $y . '</font>';

    1656. 

  1656.         }

    1657. 

  1657.     }

    1658. 

  1658.     echo '</td></tr>';

    1659. 

  1659.     $test = check_image_magic("",$check_image_magic);

    1660. 

  1660.     echo '<tr><td>Image magick support:&nbsp;&nbsp;&nbsp;</td><td>' . (($test == '1') ? '<font color="green">Available</font>' : (($test == '0') ? '<b><font color="red">Not available</b><br>(or test could not be performed!)</font>': '<font color="red">Test disabled</font>')) . '</td></tr>';

    1661. 

  1661.     echo '<tr><td>The times below have to be longer than the maximum<br>upload duration! Otherwise the upload will fail.</td><td>&nbsp;</td></tr>';

    1662. 

  1662.     echo '<tr><td>PHP maximum execution time: </td><td>' . ini_get('max_execution_time') . ' s</td></tr>';

    1663. 

  1663.     echo '<tr><td>PHP maximum input time: </td><td>' . ini_get('max_input_time') . ' s</td></tr>';

    1664. 

  1664.     echo '<tr><td>PHP default socket timeout: </td><td>' . ini_get('default_socket_timeout') . ' s</td></tr>';

    1665. 

  1665.     echo '</table>';

    1666. 

  1666.     echo '</div>';

    1667. 

  1667. }

    1668. 

  1668. 

    1669. 

  1669. /*

    1670. 

  1670.   We check if we can create a image with image magick

    1671. 

  1671.   The check is only done once per session because in JFU this function is called every time we access

    1672. 

  1672.   a profile page. If this function has a problem because of the execute you would never get to the config page.

    1673. 

  1673. */

    1674. 

  1674. function check_image_magic($path = "", $check_image_magic = true) {

    1675. 

  1675.    global $folder, $image_magic_path;

    1676. 

  1676. 

    1677. 

  1677.    if ($check_image_magic) {

    1678. 

  1678.      if (isset($_SESSION['IM_CHECK'])) {

    1679. 

  1679.         return ($_SESSION['IM_CHECK']);

    1680. 

  1680.      }

    1681. 

  1681.      $inputimage = dirname(__FILE__) . "/lang/de.gif";

    1682. 

  1682.      set_error_handler('on_error_no_output'); // is needed because the cache folder could be not reachable because of base_dir restrictions

    1683. 

  1683.      if (!file_exists($folder)) {

    1684. 

  1684.        $folder =  dirname(__FILE__) . "/../../../../cache"; // if the tfu folder is in the administration

    1685. 

  1685.           if (!file_exists($folder) && (!is_writeable($folder))) {

    1686. 

  1686.             $folder =  dirname(__FILE__) . "/../../../cache"; // if the tfu folder is in the frontend

    1687. 

  1687.             if (!file_exists($folder) && (!is_writeable($folder))) {

    1688. 

  1688.             // now we check if we can do the test in the local directoy

    1689. 

  1689.             $folder = dirname(__FILE__);

    1690. 

  1690.             if (!is_writeable($folder)) {

    1691. 

  1691.               set_error_handler('on_error');

    1692. 

  1692.               return '0';

    1693. 

  1693.             }

    1694. 

  1694.           }

    1695. 

  1695.        }

    1696. 

  1696.      }

    1697. 

  1697.      set_error_handler('on_error');

    1698. 

  1698. 

    1699. 

  1699.      if ($path != "") {

    1700. 

  1700.        $image_magic_path = $path;

    1701. 

  1701.      }

    1702. 

  1702.      $outputcachetest = $folder . "/_image_magick_test.jpg";

    1703. 

  1703.      $fh=fopen($outputcachetest,'w'); // fix for a but in some php - versions - thanks to Anders

    1704. 

  1704.      fclose($fh);

    1705. 

  1705.      $command = $image_magic_path. " \"" .  realpath($inputimage) . "\" -quality 80 -resize 120x81  \"" . realpath($outputcachetest) . "\"";

    1706. 

  1706.      @unlink($outputcachetest);

    1707. 

  1707.      $_SESSION['IM_CHECK'] = '0';

    1708. 

  1708.      execute_command($command);

    1709. 

  1709.      if (file_exists($outputcachetest)) {

    1710. 

  1710.         $ok = '1';

    1711. 

  1711.         @unlink($outputcachetest);

    1712. 

  1712.         $_SESSION['IM_CHECK'] = '1';

    1713. 

  1713.      } else {

    1714. 

  1714.        $ok = '0';

    1715. 

  1715.      }

    1716. 

  1716.      return $ok;

    1717. 

  1717.    } else {

    1718. 

  1718.     return '-1';

    1719. 

  1719.    }

    1720. 

  1720. }

    1721. 

  1721. 

    1722. 

  1722. /**

    1723. 

  1723.  *  Normalizes the file names - fix_encoding has to be called before this function is used.

    1724. 

  1724.  *  This isn't done here because normalize filenames is an optional step while fix_encoding

    1725. 

  1725.  *  is always done.

    1726. 

  1726.  **/

    1727. 

  1727. function normalizeFileNames($imageName){

    1728. 

  1728.    global $normalizeSpaces;

    1729. 

  1729. 

    1730. 

  1730.   // it's needed to decode first because str_replace does not handle str_replace in utf-8

    1731. 

  1731.   $imageName = utf8_decode($imageName);

    1732. 

  1732.   // we make the file name lowercase ÄÖÜ as well.

    1733. 

  1733.   $imageName = mb_strtolower($imageName);

    1734. 

  1734.   

    1735. 

  1735.   if ($normalizeSpaces == 'true') {

    1736. 

  1736.     $imageName=str_replace(' ','_',$imageName);

    1737. 

  1737.   }

    1738. 

  1738.   // Some characters I know how to fix ;).

    1739. 

  1739.   $imageName=str_replace(array('ä','ö','ü','ß'),array('ae','oe','ue','ss'),$imageName);

    1740. 

  1740.   // and some others might need

    1741. 

  1741.   $imageName=str_replace(array('á','ŕ','ă','â','ç','˘','é','ę','č','ë','í','î','ď','ě','ń','ô','ó','ő','ň','š','ú','ů','ű','ü','ý','˙','ž'),

    1742. 

  1742.                          array('a','a','a','a','c','c','e','e','e','e','i','i','i','i','n','o','o','o','o','s','u','u','u','u','y','y','z'),$imageName);

    1743. 

  1743.  

    1744. 

  1744.   // we remove the rest of unwanted chars

    1745. 

  1745.   $patterns[] = '/[\x7b-\xff]/';  // remove all characters above the letter z.  This will eliminate some non-English language letters

    1746. 

  1746.   $patterns[] = '/[\x21-\x2c]/'; // remove range of shifted characters on keyboard - !"#$%&'()*+

    1747. 

  1747.   $patterns[] = '/[\x5b-\x60]/'; // remove range including brackets - []\^_`

    1748. 

  1748.   // we remove all kind of special characters for utf8 encoding as well

    1749. 

  1749.   $patterns[] = '/[\x7b-\xff]/u';  // remove all characters above the letter z.  This will eliminate some non-English language letters

    1750. 

  1750.   $patterns[] = '/[\x21-\x2c]/u'; // remove range of shifted characters on keyboard - !"#$%&'()*+

    1751. 

  1751.   $patterns[] = '/[\x5b-\x60]/u'; // remove range including brackets - []\^_`

    1752. 

  1752.   $replacement ="_";

    1753. 

  1753.   return utf8_encode(preg_replace($patterns, $replacement, $imageName));

    1754. 

  1754. }

    1755. 

  1755. 

    1756. 

  1756. function execute_command ($command) {

    1757. 

  1757.   $use_shell_exec = true;;

    1758. 

  1758.   ob_start();

    1759. 

  1759.   set_error_handler('on_error_no_output');

    1760. 

  1760.   if (substr(@php_uname(), 0, 7) == "Windows"){

    1761. 

  1761.   	   // Make a new instance of the COM object

    1762. 

  1762.   		$WshShell = new COM("WScript.Shell");

    1763. 

  1763.   		 // Make the command window but dont show it.

    1764. 

  1764.   	   $oExec = $WshShell->Run("cmd /C " . $command, 0, true);

    1765. 

  1765.   } else {

    1766. 

  1766.       if ($use_shell_exec) {

    1767. 

  1767.          shell_exec($command);

    1768. 

  1768.        } else {

    1769. 

  1769.   	      exec($command . " > /dev/null");

    1770. 

  1770.        }

    1771. 

  1771.   }

    1772. 

  1772.   set_error_handler('on_error');

    1773. 

  1773.   ob_end_clean();

    1774. 

  1774. }

    1775. 

  1775. 

    1776. 

  1776. /*

    1777. 

  1777.           Functions used for file handling

    1778. 

  1778. */

    1779. 

  1779. function tfu_rename_file($dir, $file, $enable_file_rename, $keep_file_extension, $fix_utf8) {

    1780. 

  1780.     global $normalise_file_names;

    1781. 

  1781.     if ($enable_file_rename != 'true') {

    1782. 

  1782.         echo 'This action is not enabled!';

    1783. 

  1783.         exit(0);

    1784. 

  1784.     }

    1785. 

  1785.     $newName = parseInputParameterFile(trim(my_basename(' ' . $_GET['newfilename']))); // fixes that file can be renamed to an upper dir.

    1786. 

  1786.     if ($normalise_file_names) {

    1787. 

  1787.        $newName = normalizeFileNames($newName);

    1788. 

  1788.     }

    1789. 

  1789.     $newName = fix_decoding($newName, $fix_utf8);

    1790. 

  1790.     if ($keep_file_extension == 'true') {

    1791. 

  1791.         $newNameEx = getExtension($newName);

    1792. 

  1792.         $fileEx = getExtension($file);

    1793. 

  1793.         if (strtolower($newNameEx) != strtolower($fileEx)) {

    1794. 

  1794.             echo 'This action is not allowed. Changing file extensions is disabled because of security issues!';

    1795. 

  1795.             exit(0);

    1796. 

  1796.         }

    1797. 

  1797.     }

    1798. 

  1798. 

    1799. 

  1799.     $newName = $dir . '/' . $newName;

    1800. 

  1800.     if (!file_exists($newName) || ($file != $newName && strtolower($file) == strtolower($newName) )) {  // file_exists does not check case sensitive on windows

    1801. 

  1801.         if (is_writeable($file)) {

    1802. 

  1802.             $result = @rename($file, $newName);

    1803. 

  1803.             if ($result) {

    1804. 

  1804.                 echo '&result=true';

    1805. 

  1805.             } else {

    1806. 

  1806.                 echo '&result=false';

    1807. 

  1807.             }

    1808. 

  1808.         } else {

    1809. 

  1809.             echo '&result=perm';

    1810. 

  1810.         }

    1811. 

  1811.     } else {

    1812. 

  1812.         echo '&result=exists';

    1813. 

  1813.     }

    1814. 

  1814. }

    1815. 

  1815. 

    1816. 

  1816. function tfu_delete_file($file, $show_delete) {

    1817. 

  1817.     // first we check if delete is enabled!

    1818. 

  1818.     if ($show_delete != 'true') {

    1819. 

  1819.         echo 'This action is not enabled!';

    1820. 

  1820.         exit(0);

    1821. 

  1821.     }

    1822. 

  1822.     if (is_tfu_deletable($file)) {

    1823. 

  1823.         set_error_handler('on_error_no_output');

    1824. 

  1824.         @chmod($file , 0777);

    1825. 

  1825.         set_error_handler('on_error');

    1826. 

  1826.         $result = @unlink($file);

    1827. 

  1827.         if ($result) {

    1828. 

  1828.             echo '&result=true';

    1829. 

  1829.         } else {

    1830. 

  1830.             echo '&result=false';

    1831. 

  1831.         }

    1832. 

  1832.     } else {

    1833. 

  1833.         echo '&result=perm';

    1834. 

  1834.     }

    1835. 

  1835. }

    1836. 

  1836. 

    1837. 

  1837. function tfu_delete_files($file, $show_delete) {

    1838. 

  1838.     // first we check if delete is enabled!

    1839. 

  1839.     if ($show_delete != 'true') {

    1840. 

  1840.         echo 'This action is not enabled!';

    1841. 

  1841.         exit(0);

    1842. 

  1842.     }

    1843. 

  1843.     $deleted = 0;

    1844. 

  1844.     $perm = 0;

    1845. 

  1845.     $notdel = 0;

    1846. 

  1846.     foreach ($file as $ff) {

    1847. 

  1847.         if (is_tfu_deletable($ff)) {

    1848. 

  1848.             set_error_handler('on_error_no_output');

    1849. 

  1849.             @chmod($ff , 0777);

    1850. 

  1850.             set_error_handler('on_error');

    1851. 

  1851.             $result = @unlink($ff);

    1852. 

  1852.             if ($result) {

    1853. 

  1853.                 $deleted++;

    1854. 

  1854.             } else {

    1855. 

  1855.                 $notdel++;

    1856. 

  1856.             }

    1857. 

  1857.         } else {

    1858. 

  1858.             $perm++;

    1859. 

  1859.         }

    1860. 

  1860.     }

    1861. 

  1861. 

    1862. 

  1862.     echo '&result=multiple&nr_del=' . $deleted . '&nr_perm=' . $perm . '&nr_not_del=' . $notdel;

    1863. 

  1863. }

    1864. 

  1864. 

    1865. 

  1865. function tfu_copy_move($dir, $file, $enable_file_copymove, $enable_folder_copymove ) {

    1866. 

  1866.     // first we check if delete is enabled!

    1867. 

  1867.     if ($enable_file_copymove != 'true' && $enable_folder_copymove != 'true') {

    1868. 

  1868.         echo 'This action is not enabled!';

    1869. 

  1869.         exit(0);

    1870. 

  1870.     }

    1871. 

  1871.     $done = 0;

    1872. 

  1872.     $total = 0;

    1873. 

  1873.     $error = 0;

    1874. 

  1874.     $exists = 0;

    1875. 

  1875.     resetSessionTree();

    1876. 

  1876.     $overwrite = parseInputParameter($_GET['overwrite']);

    1877. 

  1877.     $folder = getDestinationFolder(parseInputParameter($_GET['target']));

    1878. 

  1878.     $dest_folder = $folder . '/' . my_basename($dir);

    1879. 

  1879.     if ($_GET['copyfolder'] == 'true') {

    1880. 

  1880.         if ($folder == $dir) {

    1881. 

  1881.             $error = 1;

    1882. 

  1882.         } else if (strpos ($folder, $dir) !== false) {

    1883. 

  1883.             $error = 2;

    1884. 

  1884.         } else if ($overwrite == 'false' && file_exists($dest_folder)) {

    1885. 

  1885.             $error = 3;

    1886. 

  1886.         } else {

    1887. 

  1887.             if (@rename($dir, $dest_folder)) {

    1888. 

  1888.                 $done = 1;

    1889. 

  1889.                 $upperdir = substr($dir, 0, strrpos ($dir, "/"));

    1890. 

  1890.                 $_SESSION['TFU_DIR'] = $upperdir;

    1891. 

  1891.             } else {

    1892. 

  1892.                 $error = 4;

    1893. 

  1893.             }

    1894. 

  1894.         }

    1895. 

  1895.     } else {

    1896. 

  1896.         foreach ($file as $ff) {

    1897. 

  1897.             $total++;

    1898. 

  1898.             $dest = $folder . '/' . my_basename($ff);

    1899. 

  1899.             if ($_GET['type'] == 'c') {

    1900. 

  1900.                 if ($folder == $dir) {

    1901. 

  1901.                     $u_file = get_unique_filename($folder, my_basename($ff));

    1902. 

  1902.                     $dest = $folder . "/" . $u_file;

    1903. 

  1903.                 }

    1904. 

  1904.                 if (file_exists($dest) && $overwrite == 'false') { // if file exists and not overwrite = error

    1905. 

  1905.                     $exists++;

    1906. 

  1906.                 } else {

    1907. 

  1907.                     if ($ff == $dest) {

    1908. 

  1908.                         $nr = 2;

    1909. 

  1909.                         $dest = $folder . '/Copy of ' . my_basename($ff);

    1910. 

  1910.                         while (file_exists($dest)) {

    1911. 

  1911.                             $dest = $folder . '/Copy (' . $nr++ . ') of ' . my_basename($ff);

    1912. 

  1912.                         }

    1913. 

  1913.                     }

    1914. 

  1914.                     if (@copy($ff, $dest)) {

    1915. 

  1915.                         $done++;

    1916. 

  1916.                     } else {

    1917. 

  1917.                         $error++;

    1918. 

  1918.                     }

    1919. 

  1919.                 }

    1920. 

  1920.             } else {

    1921. 

  1921.                 if ($ff != $dest) {

    1922. 

  1922.                     if (file_exists($dest) && $overwrite) {

    1923. 

  1923.                         @unlink($dest);

    1924. 

  1924.                     }

    1925. 

  1925.                     if (!file_exists($dest)) {

    1926. 

  1926.                         if (@rename($ff, $dest)) {

    1927. 

  1927.                             $done++;

    1928. 

  1928.                         } else {

    1929. 

  1929.                             $error++;

    1930. 

  1930.                         }

    1931. 

  1931.                     }

    1932. 

  1932.                 }

    1933. 

  1933.             }

    1934. 

  1934.         }

    1935. 

  1935.     }

    1936. 

  1936.     echo '&total=' . $total . '&ok=' . $done . '&error=' . $error . '&exists=' . $exists ;

    1937. 

  1937. }

    1938. 

  1938. 

    1939. 

  1939. function tfu_preview($file) {

    1940. 

  1940.     global $use_image_magic, $image_magic_path, $pdf_thumb_format;

    1941. 

  1941.     $pdf_preview = false;

    1942. 

  1942.     if (file_exists(dirname(__FILE__) . '/thumbs') && is_writable(dirname(__FILE__) . '/thumbs')) { // is a caching dir available and writeable?

    1943. 

  1943.         $pdf_preview = true;

    1944. 

  1944.     }

    1945. 

  1945. 

    1946. 

  1946.     // we store the url of the last preview image in the session - use it if you need it ;).

    1947. 

  1947.     // we generate thumbs for jpge,png and gif!

    1948. 

  1948.     if (preg_match("/.*\.(j|J)(p|P)(e|E){0,1}(g|G)$/", $file) ||

    1949. 

  1949.             preg_match("/.*\.(p|P)(n|N)(g|G)$/", $file) ||

    1950. 

  1950.             preg_match("/.*\.(g|G)(i|I)(f|F)$/", $file)) {

    1951. 

  1951.         if (isset($_GET['big'])) {

    1952. 

  1952.             send_thumb($file, 90, 440, 280); // big preview 4x bigger!

    1953. 

  1953.         } else {

    1954. 

  1954.             send_thumb($file, 90, 80, 55); // small preview

    1955. 

  1955.         }

    1956. 

  1956.     } else if (preg_match("/.*\.(p|P)(d|D)(f|F)$/", $file) && $use_image_magic && $pdf_preview) {

    1957. 

  1957.             $cachename = dirname(__FILE__) . '/thumbs/' . sha1($file) . '.' . $pdf_thumb_format;

    1958. 

  1958.             if (!file_exists($cachename)) {

    1959. 

  1959.               $ima = realpath($file);

    1960. 

  1960.               $resize = '1000x1000';

    1961. 

  1961.               $command = $image_magic_path . ' -colorspace rgb "' . $ima . '[0]" -border 1x1 -quality 80 -thumbnail ' . $resize . ' "' . $cachename . '"';

    1962. 

  1962.               execute_command ($command);

    1963. 

  1963.             }

    1964. 

  1964.             if (isset($_GET['big'])) {

    1965. 

  1965.               send_thumb($cachename, 90, 440, 280); // big preview 4x bigger!

    1966. 

  1966.             } else {

    1967. 

  1967.               send_thumb($cachename, 90, 80, 55); // small preview

    1968. 

  1968.             }

    1969. 

  1969.             // the cleanup is done in the thumbs folder which is cleaned up regularly

    1970. 

  1970.             // @unlink($cachename);

    1971. 

  1971.             return;

    1972. 

  1972.     } else {

    1973. 

  1973.         return; // we return nothing if no image.

    1974. 

  1974.     }

    1975. 

  1975. }

    1976. 

  1976. 

    1977. 

  1977. function tfu_createThumb($file) {

    1978. 

  1978.       global $compression, $use_image_magic, $image_magic_path, $pdf_thumb_format;

    1979. 

  1979.       if (!(preg_match("/.*\.(p|P)(d|D)(f|F)$/", $file) && $use_image_magic)) {

    1980. 

  1980.         $name = removeExtension($file) . "-" . $_GET['tfu_width'] . 'x' . $_GET['tfu_height'] . "." . getExtension($file);

    1981. 

  1981.         resize_file($file, $_GET['tfu_width'] . 'x' . $_GET['tfu_height'], $compression, basename($file), $name); 

    1982. 

  1982.       } else {

    1983. 

  1983.         $name = dirname(__FILE__) . '/' . removeExtension($file) . "-" . $_GET['tfu_width'] . '.' . $pdf_thumb_format;

    1984. 

  1984.         // create a pdf thumbnail

    1985. 

  1985.           $ima = realpath($file);

    1986. 

  1986.           if (!file_exists($name)) {

    1987. 

  1987.             $ima = realpath($file);

    1988. 

  1988.             $resize = $_GET['tfu_width'] . 'x' . $_GET['tfu_height'];

    1989. 

  1989.             $command = $image_magic_path . ' -colorspace rgb "' . $ima . '[0]" -border 1x1 -quality 80 -thumbnail ' . $resize . ' "' . $name . '"';

    1990. 

  1990.             execute_command ($command);

    1991. 

  1991.           }

    1992. 

  1992.       }     

    1993. 

  1993. }

    1994. 

  1994. 

    1995. 

  1995. function tfu_info($file) {

    1996. 

  1996.     global $use_image_magic;

    1997. 

  1997.     unset($_SESSION['TFU_LAST_UPLOADS']);

    1998. 

  1998.     $_SESSION['TFU_LAST_PREVIEW'] = fixUrl(getRootUrl() . $file);

    1999. 

  1999.     echo '&size=' . sprintf("%u", @filesize($file));

    2000. 

  2000.     // we check if the image can be resized

    2001. 

  2001.     if (is_supported_tfu_image($file,$file)) {

    2002. 

  2002.         set_error_handler('on_error_no_output'); // is needed because error are most likly but we don't care about fields we don't even know

    2003. 

  2003.         $oldsize = @getimagesize($file);

    2004. 

  2004.         set_error_handler('on_error');

    2005. 

  2005.         if ($oldsize) {

    2006. 

  2006.             if (isMemoryOk($oldsize, 400, "")) {

    2007. 

  2007.                 echo '&hasPreview=true&tfu_x=' . $oldsize[0] . '&tfu_y=' . $oldsize[1] ; // has preview!

    2008. 

  2008.             } else {

    2009. 

  2009.                 echo '&hasPreview=error&tfu_x=0&tfu_y=0'; // too big! - same error massage as hasPreview=false

    2010. 

  2010.             }

    2011. 

  2011.             return;

    2012. 

  2012.         }

    2013. 

  2013.         echo '&hasPreview=false'; // no image!

    2014. 

  2014.     }

    2015. 

  2015.     if (preg_match("/.*\.(p|P)(d|D)(f|F)$/", $file) && $use_image_magic &&

    2016. 

  2016.         file_exists(dirname(__FILE__) . '/thumbs') && is_writable(dirname(__FILE__) . '/thumbs')) {  // check if pdf

    2017. 

  2017.        echo '&hasPreview=true&tfu_x=1000&tfu_y=1000'; // has preview! - pdfs are max 1000x1000';

    2018. 

  2018.        return;

    2019. 

  2019.     }

    2020. 

  2020.     echo '&hasPreview=false&tfu_x=0&tfu_y=0';

    2021. 

  2021. }

    2022. 

  2022. 

    2023. 

  2023. function  tfu_text($file) {

    2024. 

  2024.     if (is_writable($file)) {

    2025. 

  2025.         echo '&writeable=true';

    2026. 

  2026.     } else {

    2027. 

  2027.         echo '&writeable=false';

    2028. 

  2028.     }

    2029. 

  2029.     echo '&data=';

    2030. 

  2030.     $enc = 'UTF-8';

    2031. 

  2031.     $format = 'UNIX';

    2032. 

  2032.     $fp = fopen($file, 'rb');

    2033. 

  2033.     $content = '';

    2034. 

  2034.     if (filesize ($file) > 0) {

    2035. 

  2035.       $content = fread ($fp, filesize ($file));

    2036. 

  2036.     }

    2037. 

  2037.     // we replace \r with nothing

    2038. 

  2038.     $content_new = str_replace("\r", "", $content);

    2039. 

  2039.     if ($content_new != $content) {

    2040. 

  2040.         $format = 'DOS';

    2041. 

  2041.     }

    2042. 

  2042.     if (!tfu_seems_utf8($content_new)) {

    2043. 

  2043.         $content_new = cp1252_to_utf8($content_new);

    2044. 

  2044.         $enc = 'ANSI';

    2045. 

  2045.     }

    2046. 

  2046.     echo urlencode($content_new);

    2047. 

  2047.     echo '&encoding=' . $enc;

    2048. 

  2048.     echo '&format=' . $format;

    2049. 

  2049.     fclose($fp);

    2050. 

  2050. }

    2051. 

  2051. 

    2052. 

  2052. function tfu_savetext($file, $overwrite=true) {

    2053. 

  2053.     if (file_exists($file) && !$overwrite) {

    2054. 

  2054.       echo "&create_file=exists";

    2055. 

  2055.     } else {

    2056. 

  2056.       $content = urldecode($_POST['data']);

    2057. 

  2057.       if ($_POST['encoding'] == 'ANSI') {

    2058. 

  2058.           $content = utf8_to_cp1252($content);

    2059. 

  2059.       }

    2060. 

  2060.       if ($_POST['format'] == 'DOS') {

    2061. 

  2061.           $content = preg_replace("/\r\n|\r|\n/", chr(13) . chr(10), $content);

    2062. 

  2062.       } else {

    2063. 

  2063.           $content = preg_replace("/\r\n|\r|\n/", chr(10), $content);

    2064. 

  2064.       }

    2065. 

  2065.       // now we write the file again

    2066. 

  2066.       $file_local = fopen($file, 'w');

    2067. 

  2067.       if (getExtension($file) == 'php') { // we remove leading and trailing spaces returns if it is a php file!

    2068. 

  2068.           $content = trim($content);

    2069. 

  2069.       }

    2070. 

  2070.       fputs($file_local, $content);

    2071. 

  2071.       fclose($file_local);

    2072. 

  2072.       

    2073. 

  2073.       if (file_exists($file)) {

    2074. 

  2074.         echo "&create_file=true";

    2075. 

  2075.       } else {

    2076. 

  2076.         echo "&create_file=false";

    2077. 

  2077.       }

    2078. 

  2078.     }  

    2079. 

  2079. }

    2080. 

  2080. 

    2081. 

  2081. function tfu_download($file, $enable_file_download) {

    2082. 

  2082.     if ($enable_file_download == 'false' && !isset($_GET['fullscreen'])) {

    2083. 

  2083.         echo 'This action is not enabled!';

    2084. 

  2084.         exit(0);

    2085. 

  2085.     }

    2086. 

  2086. 

    2087. 

  2087.     if (isset($_GET['fullscreen'])) { // we check if we have an image in the cache folder!

    2088. 

  2088.        $cachename = dirname(__FILE__) . '/thumbs/' . sha1($file) . '.jpg';

    2089. 

  2089.        if (file_exists($cachename)) {

    2090. 

  2090.          $file = $cachename;

    2091. 

  2091.        }

    2092. 

  2092.     }

    2093. 

  2093.     ini_set('zlib.output_compression','Off');

    2094. 

  2094.     header("Content-Transfer-Encoding: binary");

    2095. 

  2095.     header('Content-type: application/octet-stream');

    2096. 

  2096.     header('Content-Length: ' . filesize($file));

    2097. 

  2097. 

    2098. 

  2098.     // small chunk size is used for IE! 1024 would be better but has only half the dl speed - 2048 seems to be the best trade off.

    2099. 

  2099.     $fp = fopen($file, 'rb');

    2100. 

  2100.     while ($content = fread($fp, 2048)) {

    2101. 

  2101.         echo $content;

    2102. 

  2102.         set_error_handler('on_error_no_output');

    2103. 

  2103.         @set_time_limit(20);

    2104. 

  2104.         @flush();

    2105. 

  2105.         @ob_flush(); // some server need this althou on some server this throws a warning

    2106. 

  2106.         set_error_handler('on_error');

    2107. 

  2107.     }

    2108. 

  2108.     fclose($fp);

    2109. 

  2109. }

    2110. 

  2110. 

    2111. 

  2111. function tfu_zip_download($files, $enable_file_download) {

    2112. 

  2112.     global $zip_folder, $zip_file_pattern; // The folder is used to create the temp download files!

    2113. 

  2113.     if ($enable_file_download == 'false' && !isset($_GET['fullscreen'])) {

    2114. 

  2114.         echo 'This action is not enabled!';

    2115. 

  2115.         exit(0);

    2116. 

  2116.     }

    2117. 

  2117. 

    2118. 

  2118.     /*

    2119. 

  2119.     $createZip = new createZip;

    2120. 

  2120.     $nrfiles = count($files);

    2121. 

  2121.     for ($i = 0; $i < $nrfiles; $i++) {

    2122. 

  2122.       $createZip -> addFile(file_get_contents($files[$i]), my_basename($files[$i]));

    2123. 

  2123.     }

    2124. 

  2124.     $fileName = $zip_folder . '/' . $_GET['zipname'];

    2125. 

  2125.     $fd = fopen ($fileName, "wb");

    2126. 

  2126.     $out = fwrite ($fd, $createZip -> getZippedfile());

    2127. 

  2127.     fclose ($fd);

    2128. 

  2128.     */

    2129. 

  2129.     $nrfiles = count($files);

    2130. 

  2130. 

    2131. 

  2131.     if ($zip_file_pattern == '') {

    2132. 

  2132.       $zipName = parseInputParameterFile(trim(my_basename(' ' . $_GET['zipname']))); // fixes that file can be renamed to an upper dir.

    2133. 

  2133.       $fileName = $zip_folder . '/' . $zipName;

    2134. 

  2134.     } else {

    2135. 

  2135.       // zip file pattern can have the following patterns {folder}, {number}, {date} e.g. "download-{number}-files_{date}.zip"

    2136. 

  2136.       // but here I only use {number} and {date} because this is enough to be unique. The filename itself is build in the flash.

    2137. 

  2137.       $newName = str_replace('{number}', $nrfiles, $zip_file_pattern);

    2138. 

  2138.       $newName = str_replace('{date}', date("Y-m-d"), $newName);

    2139. 

  2139.       $fileName = $zip_folder . '/' . $newName;

    2140. 

  2140.     }

    2141. 

  2141.     

    2142. 

  2142.     if (!is_writeable($zip_folder)) {

    2143. 

  2143.       tfu_debug("ERROR: The folder '" . $zip_folder . "' is not writeable. Please set the permissions properly to enable the download of multiple files.");

    2144. 

  2144.     }

    2145. 

  2145.     

    2146. 

  2146.     $fd = @fopen ($fileName, "wb");

    2147. 

  2147.     if ($fd) {

    2148. 

  2148.       $createZip = new TFUZipFile($fd);

    2149. 

  2149.       for ($i = 0; $i < $nrfiles; $i++) {

    2150. 

  2150.         $createZip -> addFile($files[$i], my_basename($files[$i]));

    2151. 

  2151.       }

    2152. 

  2152.       $createZip -> close();

    2153. 

  2153.   

    2154. 

  2154.       tfu_download($fileName, $enable_file_download);

    2155. 

  2155.       @unlink($fileName);

    2156. 

  2156.     } else {

    2157. 

  2157.       tfu_debug("ERROR: The file '" . $fileName . "' could not be created. Please set the permissions properly to enable the download of multiple files.");

    2158. 

  2158.     }

    2159. 

  2159. }

    2160. 

  2160. 

    2161. 

  2161. /*

    2162. 

  2162.           Functions used for directory handling

    2163. 

  2163. */

    2164. 

  2164. function create_dir($dir, $enable_folder_creation, $fix_utf8) {

    2165. 

  2165.     global $normalise_directory_names, $dir_chmod;

    2166. 

  2166.     global $ftp_enable, $ftp_host, $ftp_port, $ftp_user, $ftp_pass, $ftp_root, $master_profile;

    2167. 

  2167.     if ($enable_folder_creation != 'true') {

    2168. 

  2168.             echo 'This action is not enabled!';

    2169. 

  2169.             exit(0);

    2170. 

  2170.         }

    2171. 

  2171.         resetSessionTree();

    2172. 

  2172.         $newdir = parseInputParameterFile(trim(my_basename(' ' . $_GET['newdir'])));

    2173. 

  2173.         if ($normalise_directory_names) {

    2174. 

  2174.            $newdir = normalizeFileNames($newdir);

    2175. 

  2175.         }

    2176. 

  2176.         $newdir = fix_decoding($newdir, $fix_utf8);

    2177. 

  2177.         $createdir = $dir . "/" . $newdir;

    2178. 

  2178.         if (file_exists($createdir)) {

    2179. 

  2179.             $status = '&create_dir=exists';

    2180. 

  2180.         } else {

    2181. 

  2181.             if (isset($ftp_enable) && $ftp_enable) {

    2182. 

  2182.                if ($master_profile) {

    2183. 

  2183.                  // we have to remove one level from the TFU_ROOT_DIR that was added automatically by the jfu wrapper

    2184. 

  2184.                  $parent_root = dirname($_SESSION['TFU_ROOT_DIR']);

    2185. 

  2185.                  $ftp_createdir = substr($createdir,strlen($parent_root)+1);

    2186. 

  2186.               } else {

    2187. 

  2187.                $ftp_createdir = substr($createdir,strlen($_SESSION['TFU_ROOT_DIR'])+1);

    2188. 

  2188.               }

    2189. 

  2189.               $conn_id = ftp_connect($ftp_host, $ftp_port);

    2190. 

  2190.               $login_result = ftp_login($conn_id, $ftp_user, $ftp_pass);

    2191. 

  2191.               ftp_chdir($conn_id, $ftp_root);

    2192. 

  2192.               $result = ftp_mkdir ($conn_id , $ftp_createdir);

    2193. 

  2193.               if ($result && $dir_chmod != 0) {

    2194. 

  2194.                 @ftp_chmod($conn_id, $dir_chmod, $ftp_createdir);

    2195. 

  2195.               }

    2196. 

  2196.               ftp_close($conn_id);

    2197. 

  2197.             } else {

    2198. 

  2198.               $result = mkdir ($createdir);

    2199. 

  2199.               if ($result && $dir_chmod != 0) {

    2200. 

  2200.                 @chmod($createdir, $dir_chmod);

    2201. 

  2201.               }

    2202. 

  2202.             }

    2203. 

  2203.             $status = ($result) ? '&create_dir=true':'&create_dir=false';

    2204. 

  2204.         }

    2205. 

  2205.     return $status;

    2206. 

  2206. }

    2207. 

  2207. 

    2208. 

  2208. function rename_dir( &$dir, $enable_folder_rename, $fix_utf8) {

    2209. 

  2209.     global $normalise_directory_names;

    2210. 

  2210. 

    2211. 

  2211.     if ($enable_folder_rename != 'true') {

    2212. 

  2212.             echo 'This action is not enabled!';

    2213. 

  2213.             exit(0);

    2214. 

  2214.         }

    2215. 

  2215.         resetSessionTree();

    2216. 

  2216.         $upperdir = substr($dir, 0, strrpos ($dir, "/"));

    2217. 

  2217.         $newdir = parseInputParameterFile(trim(my_basename(' ' . $_GET['newdir'])));

    2218. 

  2218.         if ($normalise_directory_names) {

    2219. 

  2219.            $newdir = normalizeFileNames($newdir);

    2220. 

  2220.         }

    2221. 

  2221.         $newdir = fix_decoding($newdir, $fix_utf8);

    2222. 

  2222.         if ($dir == $_SESSION["TFU_ROOT_DIR"]) {

    2223. 

  2223.             $status = "&rename_dir=main";

    2224. 

  2224.         } else {

    2225. 

  2225.             $createdir = $upperdir . "/" . $newdir;

    2226. 

  2226.             if (file_exists($createdir)) {

    2227. 

  2227.                 $status = "&rename_dir=exists";

    2228. 

  2228.             } else {

    2229. 

  2229.                 $result = rename ($dir, $upperdir . "/" . $newdir);

    2230. 

  2230.                 if ($result) {

    2231. 

  2231.                     $dir = $createdir;

    2232. 

  2232.                     $_SESSION["TFU_DIR"] = $dir;

    2233. 

  2233.                     $status = "&rename_dir=true";

    2234. 

  2234.                 } else {

    2235. 

  2235.                     $status = "&rename_dir=false";

    2236. 

  2236.                 }

    2237. 

  2237.             }

    2238. 

  2238.         }

    2239. 

  2239.     return $status;

    2240. 

  2240. }

    2241. 

  2241. 

    2242. 

  2242. function delete_folder(&$dir, $enable_folder_deletion, $fix_utf8) {

    2243. 

  2243.    global $folder; // the root folder!

    2244. 

  2244.    if ($enable_folder_deletion != 'true') {

    2245. 

  2245.             echo 'This action is not enabled!';

    2246. 

  2246.             exit(0);

    2247. 

  2247.     }

    2248. 

  2248.     // we check if this is the root dir. We don't allow this even when the request was faked!

    2249. 

  2249.     if ($dir == $folder) {

    2250. 

  2250.        echo 'Deleting the root folder is not allowed!';

    2251. 

  2251.        exit(0);

    2252. 

  2252.     }

    2253. 

  2253.     resetSessionTree();

    2254. 

  2254.     $upperdir = substr($dir, 0, strrpos ($dir, "/"));

    2255. 

  2255.     $result = remove($dir);

    2256. 

  2256.     if ($result) {

    2257. 

  2257.         $status = "&delete_dir=true";

    2258. 

  2258.         $dir = $upperdir;

    2259. 

  2259.         $_SESSION["TFU_DIR"] = $dir;

    2260. 

  2260.     } else {

    2261. 

  2261.         $status = "&delete_dir=false";

    2262. 

  2262.     }

    2263. 

  2263.    return $status;

    2264. 

  2264. }

    2265. 

  2265. 

    2266. 

  2266. function change_folder($dir, $show_root, $enable_folder_browsing, $exclude_directories, $sort_directores_by_date) {

    2267. 

  2267.     global $hide_hidden_files;

    2268. 

  2268. 

    2269. 

  2269.     if ($enable_folder_browsing != 'true') {

    2270. 

  2270.         echo 'This action is not enabled!';

    2271. 

  2271.         exit(0);

    2272. 

  2272.     }

    2273. 

  2273.     $index = parseInputParameter($_GET['index']);

    2274. 

  2274.     if ($index == 0 && $show_root) { // we go up!

    2275. 

  2275.         $dir = substr($_SESSION["TFU_DIR"], 0, strrpos ($_SESSION["TFU_DIR"], "/"));

    2276. 

  2276.     } else { // we go deeper

    2277. 

  2277.         if ($show_root) {

    2278. 

  2278.             $index--;

    2279. 

  2279.         }

    2280. 

  2280.         $dirhandle = opendir($dir);

    2281. 

  2281.         $myDirs = array();

    2282. 

  2282.         while (false !== ($filed = readdir($dirhandle))) {

    2283. 

  2283.             if ($filed != "." && $filed != ".." && !in_array($filed, $exclude_directories) && (!($hide_hidden_files && (strpos($filed, '.') === 0)))) {

    2284. 

  2284.                 if (is_dir($dir . '/' . $filed)) {

    2285. 

  2285.                    if ($sort_directores_by_date) {

    2286. 

  2286.                      $fdate = filemtime($dir . '/' . $filed);

    2287. 

  2287.                      $filed = $fdate . $filed;

    2288. 

  2288.                    }    

    2289. 

  2289.                     array_push($myDirs, $filed);

    2290. 

  2290.                 }

    2291. 

  2291.             }

    2292. 

  2292.         }

    2293. 

  2293.         if ($sort_directores_by_date) {

    2294. 

  2294.             usort ($myDirs, "cmp_date_dec");

    2295. 

  2295.             $i = 0;

    2296. 

  2296.             foreach ($myDirs as $fieldName) {

    2297. 

  2297.                 $myDirs[$i++] = substr($fieldName, 10);

    2298. 

  2298.             }

    2299. 

  2299.         } else {

    2300. 

  2300.             usort ($myDirs, "cmp_dir_dec");

    2301. 

  2301.         }

    2302. 

  2302.         $dir = $dir . "/" . $myDirs[$index];

    2303. 

  2303.     }

    2304. 

  2304.     $_SESSION["TFU_DIR"] = $dir;

    2305. 

  2305.     return $dir;

    2306. 

  2306. }

    2307. 

  2307. 

    2308. 

  2308. function create_directory_title($dir, $hide_directory_in_title, $truncate_dir_in_title, $fix_utf8) {

    2309. 

  2309.     if ($hide_directory_in_title == 'true') {

    2310. 

  2310.         $dirsub = " ";

    2311. 

  2311.     } else if ($truncate_dir_in_title == 'true') {

    2312. 

  2312.       $root = isset($_SESSION["TFU_ROOT_DIR"]) ? $_SESSION["TFU_ROOT_DIR"] : '';

    2313. 

  2313.       $folder =  substr($dir, strlen($root) + 1);

    2314. 

  2314.       $dirsub = " - Upload Folder: " . $folder;

    2315. 

  2315.     } else {

    2316. 

  2316.         // we only show the path - relative path is not shown! Therefore I replace some things.

    2317. 

  2317.         $dirsub = ($fix_utf8 == "") ? utf8_encode(str_replace("../", "", $dir)) : str_replace("../", "", $dir);

    2318. 

  2318.         $dirsub = str_replace("..", "", str_replace("//", "/", $dirsub)); // display fixes

    2319. 

  2319.         $dirsub = " - Upload Folder: " . $dirsub;

    2320. 

  2320.     }

    2321. 

  2321.     return $dirsub;

    2322. 

  2322. }

    2323. 

  2323. 

    2324. 

  2324. function read_dir($dir, &$myFiles, &$myDirs, $fix_utf8, $exclude_directories, $sort_files_by_date, $sort_directores_by_date) {

    2325. 

  2325.     global $hide_hidden_files, $show_server_date_instead_size;

    2326. 

  2326.     $size = 0;

    2327. 

  2327.     if (!file_exists($dir)) {

    2328. 

  2328.       return;

    2329. 

  2329.     }

    2330. 

  2330.     $dirhandle = opendir($dir);

    2331. 

  2331.     while (false !== ($file = readdir($dirhandle))) {

    2332. 

  2332.         if ($file != "." && $file != ".." && !in_array($file, $exclude_directories) && (!($hide_hidden_files && (strpos($file, '.') === 0)))) {

    2333. 

  2333.             $filepath = $dir . '/' . $file;

    2334. 

  2334.             if (is_dir($filepath)) {

    2335. 

  2335.                 $dirname = fix_encoding($file, $fix_utf8);

    2336. 

  2336.                 if ($sort_directores_by_date) {

    2337. 

  2337.                   $dirname = filemtime($filepath) . $dirname;

    2338. 

  2338.                 }

    2339. 

  2339.                 array_push($myDirs, urlencode($dirname));

    2340. 

  2340.             } else if (check_view_extension($file)) {

    2341. 

  2341.                 set_error_handler("on_error_no_output");

    2342. 

  2342.                 $current_size = sprintf("%u", @filesize($dir . '/' . $file));

    2343. 

  2343.                 $size += $current_size;

    2344. 

  2344.                 if ($show_server_date_instead_size=='true' || $sort_files_by_date) {

    2345. 

  2345.                    $fdate = filemtime($filepath);

    2346. 

  2346.                 }

    2347. 

  2347.                 if ($show_server_date_instead_size=='true') {

    2348. 

  2348.                    $current_size = $fdate;

    2349. 

  2349.                 }

    2350. 

  2350.                 // size or date is added.

    2351. 

  2351.                 $file = $file . "**" . $current_size;

    2352. 

  2352.                 if ($sort_files_by_date) {

    2353. 

  2353.                     $file = $fdate . $file;

    2354. 

  2354.                 }

    2355. 

  2355.                 set_error_handler("on_error");

    2356. 

  2356.                 array_push($myFiles, urlencode(fix_encoding($file, $fix_utf8)));

    2357. 

  2357.             }

    2358. 

  2358.         }

    2359. 

  2359.     }

    2360. 

  2360.     closedir ($dirhandle);

    2361. 

  2361.     return $size;

    2362. 

  2362. }

    2363. 

  2363. 

    2364. 

  2364. function sort_data (&$myFiles, &$myDirs, $sort_files_by_date, $sort_directores_by_date) {

    2365. 

  2365.     if ($sort_files_by_date) {

    2366. 

  2366.         usort ($myFiles, "cmp_date_dec");

    2367. 

  2367.         $i = 0;

    2368. 

  2368.         foreach ($myFiles as $fieldName) {

    2369. 

  2369.             $myFiles[$i] = substr($myFiles[$i], 10);

    2370. 

  2370.             $i++;

    2371. 

  2371.         }

    2372. 

  2372.     } else {

    2373. 

  2373.         usort ($myFiles, "cmp_dec");

    2374. 

  2374.     }

    2375. 

  2375.     reset($myFiles);

    2376. 

  2376. 

    2377. 

  2377.     if ($sort_directores_by_date) {

    2378. 

  2378.         usort ($myDirs, "cmp_date_dec");

    2379. 

  2379.         $i = 0;

    2380. 

  2380.         foreach ($myDirs as $fieldName) {

    2381. 

  2381.             $myDirs[$i] = substr($myDirs[$i], 10);

    2382. 

  2382.             $i++;

    2383. 

  2383.         }

    2384. 

  2384.     } else {

    2385. 

  2385.         usort ($myDirs, "cmp_dir_dec");

    2386. 

  2386.     }

    2387. 

  2387.     reset($myDirs);

    2388. 

  2388. }

    2389. 

  2389. 

    2390. 

  2390. function check_restrictions($dir, $show_root, &$myFiles, $fix_utf8, $status) {

    2391. 

  2391.     global $enable_dir_create_detection, $check_safemode;

    2392. 

  2392.     // this is a check if the dir exists - this is a configuration error!

    2393. 

  2393.     if (file_exists($dir)) {

    2394. 

  2394.       $status .=  "&dir_exists=true";

    2395. 

  2395.     } else {

    2396. 

  2396.       $status .=  "&dir_exists=false";

    2397. 

  2397.       // no other checks are made because the directory is not available!

    2398. 

  2398.       return $status;

    2399. 

  2399.     }

    2400. 

  2400.     // now we check if we can delete the current folder - root folder cannot be deleted!

    2401. 

  2401.     $status .= (is_tfu_deletable($dir) && $show_root) ? "&dir_delete=true" : "&dir_delete=false";

    2402. 

  2402.     // new we check if we can create folders - we have to check safemode too!

    2403. 

  2403.     set_error_handler("on_error_no_output");

    2404. 

  2404.     $sm_prob = $check_safemode && has_safemode_problem_global() && runsNotAsCgi();

    2405. 

  2405. 

    2406. 

  2406.     if (is_writeable($dir)) {

    2407. 

  2407.         if ($enable_dir_create_detection) { // the detection of the safemode does not work on all systems - therefore it can be disabled.

    2408. 

  2408.           $status .= ($sm_prob) ? "&dir_create=subdir" : "&dir_create=true";

    2409. 

  2409.         } else {

    2410. 

  2410.           $status .= "&dir_create=true";

    2411. 

  2411.         }

    2412. 

  2412.     } else {

    2413. 

  2413.         $status .= ($sm_prob) ? "&dir_create=safemode" : "&dir_create=false";

    2414. 

  2414.     }

    2415. 

  2415.     set_error_handler("on_error");

    2416. 

  2416. 

    2417. 

  2417.     $nrFiles = count($myFiles);

    2418. 

  2418.     // now we check if can delete files - we only check the 1st file!

    2419. 

  2419.     if ($nrFiles > 0) { 

    2420. 

  2420.         $delfile = fix_decoding(urldecode($myFiles[0]), $fix_utf8);

    2421. 

  2421.         // we have to remove the ** before checking

    2422. 

  2422.         $delfile = substr($delfile, 0, strpos($delfile, "**"));

    2423. 

  2423.         $status .= (is_tfu_deletable($dir . "/" . $delfile)) ? "&file_delete=true" : "&file_delete=false";

    2424. 

  2424.     }

    2425. 

  2425.    return $status;

    2426. 

  2426. }

    2427. 

  2427. 

    2428. 

  2428. function get_server_name() {

    2429. 

  2429.   if(isset($_SERVER['HTTP_HOST'])) {

    2430. 

  2430.     $domain = $_SERVER['HTTP_HOST'];

    2431. 

  2431.   } else if(isset($_SERVER['SERVER_NAME'])) {

    2432. 

  2432.    $domain = $_SERVER['SERVER_NAME'];

    2433. 

  2433.   } else {

    2434. 

  2434.     $domain = '';

    2435. 

  2435.   }

    2436. 

  2436.   $port = strpos($domain, ':');

    2437. 

  2437.   if ( $port !== false ) $domain = substr($domain, 0, $port);

    2438. 

  2438.   return $domain;

    2439. 

  2439. }

    2440. 

  2440. 

    2441. 

  2441. 

    2442. 

  2442. /*

    2443. 

  2443. encodes only the part without the /

    2444. 

  2444. */

    2445. 

  2445. function tfu_urlencode($data)

    2446. 

  2446. {

    2447. 

  2447. 	$data = str_replace("/", "__TWG__", $data);

    2448. 

  2448. 	$data = str_replace(":", "__QT__", $data);

    2449. 

  2449. 	$parts = explode (" - ", $data); // descripton should not be encoded

    2450. 

  2450. 	if (count($parts) > 1) {

    2451. 

  2451.       	$parts[0] = rawurlencode ($parts[0]);

    2452. 

  2452.       	$data = implode(" - ", $parts);

    2453. 

  2453.     } else {

    2454. 

  2454.       	$data = rawurlencode ($data);

    2455. 

  2455.     }

    2456. 

  2456. 	$data = str_replace("__QT__", ":", $data);

    2457. 

  2457. 	return str_replace("__TWG__", "/", $data);

    2458. 

  2458. }

    2459. 

  2459. 

    2460. 

  2460. // only executes basename if a / or \ is in the filename.

    2461. 

  2461. // Fixes the problem that basename e.g. destroys chinese filename encoded in utf-8

    2462. 

  2462. function my_basename($name) {

    2463. 

  2463.   if ((strpos($name, '\\') === false) && (strpos($name, '/') === false)) {

    2464. 

  2464.     return $name;

    2465. 

  2465.   } else {

    2466. 

  2466.     $sep = ((strpos($name, '/') === false)) ?  '\\' : '/';

    2467. 

  2467.     return ltrim(substr($name, strrpos($name, $sep) ), $sep);

    2468. 

  2468.   }

    2469. 

  2469. }

    2470. 

  2470. 

    2471. 

  2471. /**

    2472. 

  2472.  * Fixes the encoding of the file names we get from the flash. They come utf-8 encoded

    2473. 

  2473.  * from the flash and writing this directly to the filesystem produces depending on the

    2474. 

  2474.  * system unreadable file names. Especially if special characters like öäü or even

    2475. 

  2475.  * chinese Characters are used.

    2476. 

  2476. */

    2477. 

  2477. function fix_decoding($encoded_filename, $fix_utf8) {

    2478. 

  2478.   if ($fix_utf8 == 'none') {

    2479. 

  2479.     return $encoded_filename;

    2480. 

  2480.   } else {

    2481. 

  2481.     $temp = str_replace("\\'", "'", $encoded_filename ); // we change escaped ' to normal '

    2482. 

  2482.     return ($fix_utf8 == '') ? utf8_decode($temp ) :  iconv('UTF-8', $fix_utf8, $temp);

    2483. 

  2483.   }

    2484. 

  2484. }

    2485. 

  2485. 

    2486. 

  2486. function fix_encoding($decoded_filename, $fix_utf8) {

    2487. 

  2487.   if ($fix_utf8 == 'none') {

    2488. 

  2488.     return $decoded_filename;

    2489. 

  2489.   } else {

    2490. 

  2490.     return ($fix_utf8 == '') ? utf8_encode($decoded_filename) : iconv($fix_utf8, 'UTF-8', $decoded_filename);

    2491. 

  2491.   }

    2492. 

  2492. }

    2493. 

  2493. 

    2494. 

  2494. // Specifiy the file_put_contents() function for PHP version 4

    2495. 

  2495. if (function_exists('file_put_contents') == false) {

    2496. 

  2496.   function file_put_contents($file, $string) {

    2497. 

  2497.   $f=fopen($file, 'w');

    2498. 

  2498.   fwrite($f, $string);

    2499. 

  2499.   fclose($f);

    2500. 

  2500.   }

    2501. 

  2501. }

    2502. 

  2502. 

    2503. 

  2503. function formatSize($size) {

    2504. 

  2504. 		if ($size>=1048576*1000) {

    2505. 

  2505. 			//  > 1000 MB - no komma - display e.g. 1421 MB

    2506. 

  2506. 			$strSize = floor($size/1048576)." MB";

    2507. 

  2507. 		} else if ($size>1048576*100) {

    2508. 

  2508. 		  // > 100 MB - 1 digit - e.g.  71.5 MB

    2509. 

  2509. 		  $num = floor($size/1048576.0);

    2510. 

  2510. 			$strSize = $num . "." . floor(($size-($num*1048576))/104857.6) . " MB";

    2511. 

  2511. 		} else if ($size>1048576) {

    2512. 

  2512. 			// > 1 MB - 2 digit - e.g.  2.53 MB

    2513. 

  2513. 			$num = floor($size/1048576.0);

    2514. 

  2514. 			$komma = floor(($size-($num*1048576.0))/1048.576);

    2515. 

  2515. 			$pad = "";

    2516. 

  2516. 			if ($komma<100) {	$pad = "0";	}

    2517. 

  2517. 			if ($komma<10) {	$pad = "00"; }

    2518. 

  2518. 			$strSize = $num . "." . $pad. $komma ." KB";

    2519. 

  2519. 		} else if ($size == 0) {

    2520. 

  2520. 			$strSize = "0 KB";

    2521. 

  2521. 		} else {

    2522. 

  2522. 			$strSize = ceil($size/1024)." KB";

    2523. 

  2523. 		}

    2524. 

  2524. 		return $strSize;

    2525. 

  2525. }

    2526. 

  2526. 

    2527. 

  2527. function resetSessionTree() {

    2528. 

  2528.   unset($_SESSION["TREE_" . $_SESSION['TFU_ROOT_DIR']]);

    2529. 

  2529. }

    2530. 

  2530. 

    2531. 

  2531. function check_multiple_extensions($image, $remove_multiple_php_extension) {

    2532. 

  2532.   if ($remove_multiple_php_extension) {

    2533. 

  2533.     $ext = getExtension($image);

    2534. 

  2534.     if (substr($ext,0,2) != "php") {

    2535. 

  2535.       $image2 = str_replace(".php", "", $image);

    2536. 

  2536.       if ($image != $image2) {

    2537. 

  2537.           tfu_debug("SECURITY WARNING: Please check the file ".$image2.". It was uploaded with an image extensions and also a nested php extension. On some server this is a security problem (multiple extensions) and therefore the .php part of the file name was removed!" );

    2538. 

  2538.           $image = $image2;

    2539. 

  2539.       }

    2540. 

  2540.     }

    2541. 

  2541.   }

    2542. 

  2542.   return $image;

    2543. 

  2543. }

    2544. 

  2544. 

    2545. 

  2545. 

    2546. 

  2546. function getFolderSizeCached($path) {

    2547. 

  2547.      $md = md5($path);

    2548. 

  2548. 

    2549. 

  2549.      if (isset($_SESSION['TFU_TMP']) && isset($_SESSION['TFU_TMP']['FS' . $md] )) {

    2550. 

  2550.         echo "c";

    2551. 

  2551.         return $_SESSION['TFU_TMP']['FS' . $md];

    2552. 

  2552.      } else {

    2553. 

  2553.        echo "b";

    2554. 

  2554.        if (!isset($_SESSION['TFU_TMP'])) {

    2555. 

  2555.           $_SESSION['TFU_TMP'] = array();

    2556. 

  2556.        }

    2557. 

  2557.        $size = getFoldersize($path);

    2558. 

  2558.        $_SESSION['TFU_TMP']['FS' . $md] = $size;

    2559. 

  2559.        return $size;

    2560. 

  2560.      }

    2561. 

  2561. }

    2562. 

  2562. 

    2563. 

  2563. /**

    2564. 

  2564.  *   Optimized way to read the the size of a directoy.

    2565. 

  2565.  *

    2566. 

  2566.  *    First the windows or Unix way is tried. If this fails

    2567. 

  2567.  *    the php internal stuff is used.

    2568. 

  2568.  *

    2569. 

  2569.  *    if you select legacy = false only the pure php

    2570. 

  2570.  *    version is used.

    2571. 

  2571.  */

    2572. 

  2572. function getFoldersize($path, $legacy = true) {

    2573. 

  2573.   $size = -1;

    2574. 

  2574.   ob_start();

    2575. 

  2575.   set_error_handler('on_error_no_output');

    2576. 

  2576.   if ($legacy) {

    2577. 

  2577.        if (substr(@php_uname(), 0, 7) == "Windows"){

    2578. 

  2578.           // we have to make the path absolute !

    2579. 

  2579.           $path_ab = realpath($path);

    2580. 

  2580.           $obj = new COM ( 'scripting.filesystemobject' );

    2581. 

  2581.           if ( is_object ( $obj ) ) {

    2582. 

  2582.          	  $ref = $obj->getfolder ( $path_ab );

    2583. 

  2583.          	  $size = $ref->size;

    2584. 

  2584.          	  $obj = null;

    2585. 

  2585.          }

    2586. 

  2586.        } else { // hopefully unix -  du has to be in the path. If it is not you have to adjust the path.

    2587. 

  2587.          $io = popen ( 'du -sb ' . $path, 'r' );

    2588. 

  2588.          $usize = trim(fgets ( $io, 4096));

    2589. 

  2589.          $split = preg_split('/\s+/', $usize);

    2590. 

  2590.          $usize = $split[0];

    2591. 

  2591.          pclose ( $io );

    2592. 

  2592.          if (is_numeric($usize)) {

    2593. 

  2593.            $size = $usize;

    2594. 

  2594.          }

    2595. 

  2595.        }

    2596. 

  2596.   }

    2597. 

  2597.   set_error_handler('on_error');

    2598. 

  2598.   @ob_end_clean();

    2599. 

  2599.   // backup if both ways fail. It is ~ 18 times slower (tested on windows) than one of the solutions above.

    2600. 

  2600.   if ($size == -1) {

    2601. 

  2601.     $size = foldersize($path);

    2602. 

  2602.   }

    2603. 

  2603.   return $size;

    2604. 

  2604. }

    2605. 

  2605. 

    2606. 

  2606. /**

    2607. 

  2607.  *  The basic php way to go through all directories and adding the file sizes.

    2608. 

  2608.  *  It does also check the parameters $exclude_directories and $hide_hidden_files

    2609. 

  2609.  */

    2610. 

  2610. function foldersize($p) {

    2611. 

  2611.     global $exclude_directories, $hide_hidden_files;

    2612. 

  2612.     $size = 0;

    2613. 

  2613.     $fs = scandir($p);

    2614. 

  2614.     foreach($fs as $f) {

    2615. 

  2615.         if (is_dir(rtrim($p, '/') . '/' . $f)) {

    2616. 

  2616.             if ($f!='.' && $f!='..') {

    2617. 

  2617.                 $size += foldersize(rtrim($p, '/') . '/' . $f);

    2618. 

  2618.             }

    2619. 

  2619.         } else {

    2620. 

  2620.             if ($f != '.' && $f != '..' && !in_array($f, $exclude_directories)&&

    2621. 

  2621.                 (!($hide_hidden_files && (strpos($f, '.') === 0)))) {

    2622. 

  2622.               $size += filesize(rtrim($p, '/') . '/' . $f);

    2623. 

  2623.             }

    2624. 

  2624.         }

    2625. 

  2625.     }

    2626. 

  2626.     return $size;

    2627. 

  2627. }

    2628. 

  2628. 

    2629. 

  2629. function check_syntax($file)

    2630. 

  2630. {

    2631. 

  2631. // load file

    2632. 

  2632. $code = file_get_contents($file);

    2633. 

  2633. // remove non php blocks

    2634. 

  2634. $code = preg_replace('/(^|\?>).*?(<\?php|$)/i', '', $code);

    2635. 

  2635. // create lambda function

    2636. 

  2636. $f = @create_function('', $code);

    2637. 

  2637. // return function error status

    2638. 

  2638. return !empty($f);

    2639. 

  2639. }

    2640. 

  2640. 

    2641. 

  2641. function file_upload_error_message($error_code) {

    2642. 

  2642.     switch ($error_code) {

    2643. 

  2643.         case UPLOAD_ERR_INI_SIZE:

    2644. 

  2644.             return 'The uploaded file exceeds the upload_max_filesize directive in php.ini';

    2645. 

  2645.         case UPLOAD_ERR_FORM_SIZE:

    2646. 

  2646.             return 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form';

    2647. 

  2647.         case UPLOAD_ERR_PARTIAL:

    2648. 

  2648.             return 'The uploaded file was only partially uploaded. Please check your timeouts.';

    2649. 

  2649.         case UPLOAD_ERR_NO_FILE:

    2650. 

  2650.             return 'No file was uploaded';

    2651. 

  2651.         case UPLOAD_ERR_NO_TMP_DIR:

    2652. 

  2652.             return 'Missing a temporary folder';

    2653. 

  2653.         case UPLOAD_ERR_CANT_WRITE:

    2654. 

  2654.             return 'Failed to write file to disk';

    2655. 

  2655.         case UPLOAD_ERR_EXTENSION:

    2656. 

  2656.             return 'File upload stopped by extension';

    2657. 

  2657.         default:

    2658. 

  2658.             return 'Unknown upload error';

    2659. 

  2659.     }

    2660. 

  2660. }

    2661. 

  2661. 

    2662. 

  2662. @ob_end_clean();

    2663. 

  2663. ?>
    2664.