PageRenderTime 72ms CodeModel.GetById 25ms 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

Large files files are truncated, but you can click here to view the full file

    

  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=' . $overwrit…
    1308.

Large files files are truncated, but you can click here to view the full file