PageRenderTime 32ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 1ms

/administrator/components/com_zoo/framework/helpers/archive.php

https://bitbucket.org/organicdevelopment/joomla-2.5
PHP | 2219 lines | 1524 code | 216 blank | 479 comment | 362 complexity | 9744b13119f7b551d7f7069046e5c0e0 MD5 | raw file
Possible License(s): LGPL-3.0, GPL-2.0, MIT, BSD-3-Clause, LGPL-2.1 
    

  1. <?php

    2. 

  2. /**
    3. 

  3. * @package   com_zoo
    4. 

  4. * @author    YOOtheme http://www.yootheme.com
    5. 

  5. * @copyright Copyright (C) YOOtheme GmbH
    6. 

  6. * @license   http://www.gnu.org/licenses/gpl.html GNU/GPL
    7. 

  7. */
    8. 

  8. 

    9. 

  9. /**

    10. 

  10.  * Archive Helper class

    11. 

  11.  *

    12. 

  12.  * This class deals with the opening for archive files in tar and zip formats

    13. 

  13.  *

    14. 

  14.  * @package Framework.Helpers

    15. 

  15.  */

    16. 

  16. class ArchiveHelper extends AppHelper {

    17. 

  17. 

    18. 

  18. 	/**

    19. 

  19. 	 * Class Constructor

    20. 

  20. 	 *

    21. 

  21. 	 * @param App $app A reference to the global App object

    22. 

  22. 	 */

    23. 

  23. 	public function __construct($app) {

    24. 

  24. 		parent::__construct($app);

    25. 

  25. 

    26. 

  26. 		// increase memory limit

    27. 

  27. 		@ini_set('memory_limit', '256M');

    28. 

  28. 	}

    29. 

  29. 

    30. 

  30. 	/**

    31. 

  31. 	 * Open an archive file

    32. 

  32. 	 *

    33. 

  33. 	 * @param string $file The full file path to open

    34. 

  34. 	 * @param string $format The file format. If not specified, will be guessed by the file extension

    35. 

  35. 	 *

    36. 

  36. 	 * @return AppZipArchive|AppTarArchive The archive object (zip or tar)

    37. 

  37. 	 *

    38. 

  38. 	 * @since 1.0.0

    39. 

  39. 	 */

    40. 

  40. 	public function open($file, $format = null) {

    41. 

  41. 

    42. 

  42. 		// auto-detect format

    43. 

  43. 		if (!$format) {

    44. 

  44. 			$format = $this->format($file);

    45. 

  45. 		}

    46. 

  46. 

    47. 

  47. 		// create archive object

    48. 

  48. 		if ($format == 'zip') {

    49. 

  49. 			return new AppZipArchive($file);

    50. 

  50. 		} elseif ($format == 'tar') {

    51. 

  51. 			return new AppTarArchive($file);

    52. 

  52. 		}

    53. 

  53. 

    54. 

  54. 		return null;

    55. 

  55. 	}

    56. 

  56. 

    57. 

  57. 	/**

    58. 

  58. 	 * Get an archive format based on the file extension

    59. 

  59. 	 *

    60. 

  60. 	 * Any tar-related format (tgz, gz, etc) will be returned as tar

    61. 

  61. 	 *

    62. 

  62. 	 * @param string $file The filename or the full file path

    63. 

  63. 	 *

    64. 

  64. 	 * @return string The file format (zip or tar)

    65. 

  65. 	 *

    66. 

  66. 	 * @since 1.0.0

    67. 

  67. 	 */

    68. 

  68. 	public function format($file) {

    69. 

  69. 

    70. 

  70. 		// detect .zip format

    71. 

  71. 		if (preg_match('/\.zip$/i', $file)) {

    72. 

  72. 			return 'zip';

    73. 

  73. 		}

    74. 

  74. 

    75. 

  75. 		// detect .tar format

    76. 

  76. 		if (preg_match('/\.tar$|\.tar\.gz$|\.tgz$|\.tar\.bz2$|\.tbz2$/i', $file)) {

    77. 

  77. 			return 'tar';

    78. 

  78. 		}

    79. 

  79. 

    80. 

  80. 		return null;

    81. 

  81. 	}

    82. 

  82. 

    83. 

  83. }

    84. 

  84. 

    85. 

  85. /**

    86. 

  86.  * Class to manage zip archives

    87. 

  87.  *

    88. 

  88.  * @package Framework.Classes

    89. 

  89.  */

    90. 

  90. class AppZipArchive {

    91. 

  91. 

    92. 

  92. 	/**

    93. 

  93. 	 * The ZipArchive class that deals with the zip file

    94. 

  94. 	 *

    95. 

  95. 	 * @var ZipArchive

    96. 

  96. 	 * @since 1.0.0

    97. 

  97. 	 */

    98. 

  98. 	public $zip;

    99. 

  99. 

    100. 

  100. 	/**

    101. 

  101. 	 * Class Constructor

    102. 

  102. 	 *

    103. 

  103. 	 * @param string $file The file to open

    104. 

  104. 	 *

    105. 

  105. 	 * @since 1.0.0

    106. 

  106. 	 */

    107. 

  107. 	public function __construct($file) {

    108. 

  108. 		$this->zip = new ZipArchive();

    109. 

  109. 		$this->zip->open($file);

    110. 

  110. 	}

    111. 

  111. 

    112. 

  112. 	/**

    113. 

  113. 	 * Add a file to the archive

    114. 

  114. 	 *

    115. 

  115. 	 * @param string $file The file to add

    116. 

  116. 	 *

    117. 

  117. 	 * @since 1.0.0

    118. 

  118. 	 */

    119. 

  119. 	public function add($file) {

    120. 

  120. 		$this->zip->addFile($file);

    121. 

  121. 	}

    122. 

  122. 

    123. 

  123. 	/**

    124. 

  124. 	 * Extract the archive into a specific directory

    125. 

  125. 	 *

    126. 

  126. 	 * @param string $path The directory in which to extract the file

    127. 

  127. 	 * @param string|array $files The file(s) to extract from the archive. If empty, it will extract the entire archive content

    128. 

  128. 	 *

    129. 

  129. 	 * @return boolean If the operation was successful

    130. 

  130. 	 */

    131. 

  131. 	public function extract($path, $files = array()) {

    132. 

  132. 		return empty($files) ? $this->zip->extractTo($path) : $this->zip->extractTo($path, $files);

    133. 

  133. 	}

    134. 

  134. 

    135. 

  135. }

    136. 

  136. 

    137. 

  137. /**

    138. 

  138.  * Class to manage Tar-based archives

    139. 

  139.  *

    140. 

  140.  * @package Framework.Classes

    141. 

  141.  */

    142. 

  142. class AppTarArchive {

    143. 

  143. 

    144. 

  144. 	/**

    145. 

  145. 	 * The Archive_Tar object that will manage the archive

    146. 

  146. 	 *

    147. 

  147. 	 * @var Archive_Tar

    148. 

  148. 	 * @since 1.0.0

    149. 

  149. 	 */

    150. 

  150. 	public $tar;

    151. 

  151. 

    152. 

  152. 	/**

    153. 

  153. 	 * Class Constructor

    154. 

  154. 	 *

    155. 

  155. 	 * @param string $file The full file path of the archive

    156. 

  156. 	 *

    157. 

  157. 	 * @since 1.0.0

    158. 

  158. 	 */

    159. 

  159. 	public function __construct($file) {

    160. 

  160. 		$this->tar = new Archive_Tar($file);

    161. 

  161. 	}

    162. 

  162. 

    163. 

  163. 	/**

    164. 

  164. 	 * Add a file to the archive

    165. 

  165. 	 *

    166. 

  166. 	 * @param string $file The file to add

    167. 

  167. 	 *

    168. 

  168. 	 * @since 1.0.0

    169. 

  169. 	 */

    170. 

  170. 	public function add($file) {

    171. 

  171. 	    $this->tar->add($file);

    172. 

  172. 	}

    173. 

  173. 

    174. 

  174. 	/**

    175. 

  175. 	 * Extract the archive into a specific directory

    176. 

  176. 	 *

    177. 

  177. 	 * @param string $path The directory in which to extract the file

    178. 

  178. 	 * @param string|array $files The file(s) to extract from the archive. If empty, it will extract the entire archive content

    179. 

  179. 	 *

    180. 

  180. 	 * @return boolean If the operation was successful

    181. 

  181. 	 */

    182. 

  182. 	public function extract($path, $files = array()) {

    183. 

  183. 		return empty($files) ? $this->tar->extract($path) : $this->tar->extractList($files, $path);

    184. 

  184. 	}

    185. 

  185. 

    186. 

  186. }

    187. 

  187. 

    188. 

  188. /**

    189. 

  189.  * File::CSV

    190. 

  190.  *

    191. 

  191.  * PHP versions 4 and 5

    192. 

  192.  *

    193. 

  193.  * Copyright (c) 1997-2008,

    194. 

  194.  * Vincent Blavet <vincent@phpconcept.net>

    195. 

  195.  * All rights reserved.

    196. 

  196.  *

    197. 

  197.  * Redistribution and use in source and binary forms, with or without

    198. 

  198.  * modification, are permitted provided that the following conditions are met:

    199. 

  199.  *

    200. 

  200.  *     * Redistributions of source code must retain the above copyright notice,

    201. 

  201.  *       this list of conditions and the following disclaimer.

    202. 

  202.  *     * Redistributions in binary form must reproduce the above copyright

    203. 

  203.  *       notice, this list of conditions and the following disclaimer in the

    204. 

  204.  *       documentation and/or other materials provided with the distribution.

    205. 

  205.  *

    206. 

  206.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

    207. 

  207.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    208. 

  208.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    209. 

  209.  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE

    210. 

  210.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    211. 

  211.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

    212. 

  212.  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

    213. 

  213.  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

    214. 

  214.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    215. 

  215.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    216. 

  216.  *

    217. 

  217.  *

    218. 

  218.  * @package Framework.Classes

    219. 

  219.  * @author Vincent Blavet <vincent@phpconcept.net>

    220. 

  220.  * @copyright 1997-2008 The Authors

    221. 

  221.  * @license http://www.opensource.org/licenses/bsd-license.php New BSD License

    222. 

  222.  * @version CVS: $Id: system.tar.inc,v 1.5 2010/02/09 12:29:39 dries Exp $

    223. 

  223.  * @link http://pear.php.net/package/Archive_Tar

    224. 

  224.  */

    225. 

  225. 

    226. 

  226. define('ARCHIVE_TAR_ATT_SEPARATOR', 90001);

    227. 

  227. define('ARCHIVE_TAR_END_BLOCK', pack("a512", ''));

    228. 

  228. 

    229. 

  229. /**

    230. 

  230. * Creates a (compressed) Tar archive

    231. 

  231. *

    232. 

  232. * @author Vincent Blavet <vincent@phpconcept.net>

    233. 

  233. * @version $Revision: 1.5 $

    234. 

  234. * @license http://www.opensource.org/licenses/bsd-license.php New BSD License

    235. 

  235. * @package Framework.Classes

    236. 

  236. */

    237. 

  237. class Archive_Tar

    238. 

  238. {

    239. 

  239.     /**

    240. 

  240. 	 * Name of the Tar

    241. 

  241. 	 *

    242. 

  242.      * @var string

    243. 

  243.      */

    244. 

  244.     var $_tarname='';

    245. 

  245. 

    246. 

  246.     /**

    247. 

  247. 	 * if true, the Tar file will be gzipped

    248. 

  248. 	 *

    249. 

  249. 	 * @var boolean

    250. 

  250. 	 */

    251. 

  251.     var $_compress=false;

    252. 

  252. 

    253. 

  253.     /**

    254. 

  254. 	 * Type of compression : 'none', 'gz' or 'bz2'

    255. 

  255. 	 *

    256. 

  256. 	 * @var string

    257. 

  257. 	 */

    258. 

  258.     var $_compress_type='none';

    259. 

  259. 

    260. 

  260.     /**

    261. 

  261. 	 * Explode separator

    262. 

  262. 	 *

    263. 

  263. 	 * @var string

    264. 

  264. 	 */

    265. 

  265.     var $_separator=' ';

    266. 

  266. 

    267. 

  267.     /**

    268. 

  268.      * Descriptor

    269. 

  269. 	 *

    270. 

  270. 	 * @var file

    271. 

  271.      */

    272. 

  272.     var $_file=0;

    273. 

  273. 

    274. 

  274.     /**

    275. 

  275.      * Local Tar name of a remote Tar (http:// or ftp://)

    276. 

  276. 	 * @var string

    277. 

  277.      */

    278. 

  278.     var $_temp_tarname='';

    279. 

  279. 

    280. 

  280.     /**

    281. 

  281.     * Archive_Tar Class constructor. This flavour of the constructor only

    282. 

  282.     * declare a new Archive_Tar object, identifying it by the name of the

    283. 

  283.     * tar file.

    284. 

  284.     * If the compress argument is set the tar will be read or created as a

    285. 

  285.     * gzip or bz2 compressed TAR file.

    286. 

  286.     *

    287. 

  287.     * @param string $p_tarname The name of the tar archive to create

    288. 

  288.     * @param string $p_compress can be null, 'gz' or 'bz2'. This

    289. 

  289.     *                   parameter indicates if gzip or bz2 compression

    290. 

  290.     *                   is required.  For compatibility reason the

    291. 

  291.     *                   boolean value 'true' means 'gz'.

    292. 

  292.     * @access public

    293. 

  293.     */

    294. 

  294.     function __construct($p_tarname, $p_compress = null)

    295. 

  295.     {

    296. 

  296.         $this->_compress = false;

    297. 

  297.         $this->_compress_type = 'none';

    298. 

  298.         if (($p_compress === null) || ($p_compress == '')) {

    299. 

  299.             if (@file_exists($p_tarname)) {

    300. 

  300.                 if ($fp = @fopen($p_tarname, "rb")) {

    301. 

  301.                     // look for gzip magic cookie

    302. 

  302.                     $data = fread($fp, 2);

    303. 

  303.                     fclose($fp);

    304. 

  304.                     if ($data == "\37\213") {

    305. 

  305.                         $this->_compress = true;

    306. 

  306.                         $this->_compress_type = 'gz';

    307. 

  307.                     // No sure it's enought for a magic code ....

    308. 

  308.                     } elseif ($data == "BZ") {

    309. 

  309.                         $this->_compress = true;

    310. 

  310.                         $this->_compress_type = 'bz2';

    311. 

  311.                     }

    312. 

  312.                 }

    313. 

  313.             } else {

    314. 

  314.                 // probably a remote file or some file accessible

    315. 

  315.                 // through a stream interface

    316. 

  316.                 if (substr($p_tarname, -2) == 'gz') {

    317. 

  317.                     $this->_compress = true;

    318. 

  318.                     $this->_compress_type = 'gz';

    319. 

  319.                 } elseif ((substr($p_tarname, -3) == 'bz2') ||

    320. 

  320.                           (substr($p_tarname, -2) == 'bz')) {

    321. 

  321.                     $this->_compress = true;

    322. 

  322.                     $this->_compress_type = 'bz2';

    323. 

  323.                 }

    324. 

  324.             }

    325. 

  325.         } else {

    326. 

  326.             if (($p_compress === true) || ($p_compress == 'gz')) {

    327. 

  327.                 $this->_compress = true;

    328. 

  328.                 $this->_compress_type = 'gz';

    329. 

  329.             } else if ($p_compress == 'bz2') {

    330. 

  330.                 $this->_compress = true;

    331. 

  331.                 $this->_compress_type = 'bz2';

    332. 

  332.             } else {

    333. 

  333.                 die("Unsupported compression type '$p_compress'\n".

    334. 

  334.                     "Supported types are 'gz' and 'bz2'.\n");

    335. 

  335.                 return false;

    336. 

  336.             }

    337. 

  337.         }

    338. 

  338.         $this->_tarname = $p_tarname;

    339. 

  339.         if ($this->_compress) { // assert zlib or bz2 extension support

    340. 

  340.             if ($this->_compress_type == 'gz')

    341. 

  341.                 $extname = 'zlib';

    342. 

  342.             else if ($this->_compress_type == 'bz2')

    343. 

  343.                 $extname = 'bz2';

    344. 

  344. 

    345. 

  345.             if (!extension_loaded($extname)) {

    346. 

  346.                 $this->loadExtension($extname);

    347. 

  347.             }

    348. 

  348.             if (!extension_loaded($extname)) {

    349. 

  349.                 die("The extension '$extname' couldn't be found.\n".

    350. 

  350.                     "Make sure your version of PHP was built ".

    351. 

  351.                     "with '$extname' support.\n");

    352. 

  352.                 return false;

    353. 

  353.             }

    354. 

  354.         }

    355. 

  355.     }

    356. 

  356.     // }}}

    357. 

  357. 

    358. 

  358.     /**

    359. 

  359.     * OS independant PHP extension load. Remember to take care

    360. 

  360.     * on the correct extension name for case sensitive OSes.

    361. 

  361.     *

    362. 

  362.     * @param string $ext The extension name

    363. 

  363.     * @return bool Success or not on the dl() call

    364. 

  364.     */

    365. 

  365.     function loadExtension($ext)

    366. 

  366.     {

    367. 

  367.         if (!extension_loaded($ext)) {

    368. 

  368.             // if either returns true dl() will produce a FATAL error, stop that

    369. 

  369.             if ((ini_get('enable_dl') != 1) || (ini_get('safe_mode') == 1)) {

    370. 

  370.                 return false;

    371. 

  371.             }

    372. 

  372. 

    373. 

  373.             if (OS_WINDOWS) {

    374. 

  374.                 $suffix = '.dll';

    375. 

  375.             } elseif (PHP_OS == 'HP-UX') {

    376. 

  376.                 $suffix = '.sl';

    377. 

  377.             } elseif (PHP_OS == 'AIX') {

    378. 

  378.                 $suffix = '.a';

    379. 

  379.             } elseif (PHP_OS == 'OSX') {

    380. 

  380.                 $suffix = '.bundle';

    381. 

  381.             } else {

    382. 

  382.                 $suffix = '.so';

    383. 

  383.             }

    384. 

  384. 

    385. 

  385.             return @dl('php_'.$ext.$suffix) || @dl($ext.$suffix);

    386. 

  386.         }

    387. 

  387. 

    388. 

  388.         return true;

    389. 

  389.     }

    390. 

  390. 

    391. 

  391. 

    392. 

  392.     /**

    393. 

  393. 	 * Destructor

    394. 

  394. 	 */

    395. 

  395.     function __destruct()

    396. 

  396.     {

    397. 

  397.         $this->_close();

    398. 

  398.         // ----- Look for a local copy to delete

    399. 

  399.         if ($this->_temp_tarname != '')

    400. 

  400.             @unlink($this->_temp_tarname);

    401. 

  401.     }

    402. 

  402. 

    403. 

  403.     /**

    404. 

  404.     * This method creates the archive file and add the files / directories

    405. 

  405.     * that are listed in $p_filelist.

    406. 

  406.     * If a file with the same name exist and is writable, it is replaced

    407. 

  407.     * by the new tar.

    408. 

  408.     * The method return false and a PEAR error text.

    409. 

  409.     * The $p_filelist parameter can be an array of string, each string

    410. 

  410.     * representing a filename or a directory name with their path if

    411. 

  411.     * needed. It can also be a single string with names separated by a

    412. 

  412.     * single blank.

    413. 

  413.     * For each directory added in the archive, the files and

    414. 

  414.     * sub-directories are also added.

    415. 

  415.     * See also createModify() method for more details.

    416. 

  416.     *

    417. 

  417.     * @param array $p_filelist An array of filenames and directory names, or a

    418. 

  418. 	*                           single string with names separated by a single

    419. 

  419. 	*                           blank space.

    420. 

  420.     * @return true on success, false on error.

    421. 

  421.     * @see createModify()

    422. 

  422.     * @access public

    423. 

  423.     */

    424. 

  424.     function create($p_filelist)

    425. 

  425.     {

    426. 

  426.         return $this->createModify($p_filelist, '', '');

    427. 

  427.     }

    428. 

  428.     // }}}

    429. 

  429. 

    430. 

  430.     // {{{ add()

    431. 

  431.     /**

    432. 

  432.     * This method add the files / directories that are listed in $p_filelist in

    433. 

  433.     * the archive. If the archive does not exist it is created.

    434. 

  434.     * The method return false and a PEAR error text.

    435. 

  435.     * The files and directories listed are only added at the end of the archive,

    436. 

  436.     * even if a file with the same name is already archived.

    437. 

  437.     * See also createModify() method for more details.

    438. 

  438.     *

    439. 

  439.     * @param array $p_filelist An array of filenames and directory names, or a

    440. 

  440. 	*                           single string with names separated by a single

    441. 

  441. 	*                           blank space.

    442. 

  442.     * @return true on success, false on error.

    443. 

  443.     * @see createModify()

    444. 

  444.     * @access public

    445. 

  445.     */

    446. 

  446.     function add($p_filelist)

    447. 

  447.     {

    448. 

  448.         return $this->addModify($p_filelist, '', '');

    449. 

  449.     }

    450. 

  450.     // }}}

    451. 

  451. 

    452. 

  452.     /**

    453. 

  453. 	 * This method extract all the content of the archive in the directory

    454. 

  454. 	 *

    455. 

  455. 	 * @param string $p_path The path in which to extract the files

    456. 

  456. 	 *

    457. 

  457. 	 * @return boolean If the operation was successfull

    458. 

  458. 	 *

    459. 

  459. 	 * @see Archive_Tar::extractModify()

    460. 

  460. 	 */

    461. 

  461.     function extract($p_path='')

    462. 

  462.     {

    463. 

  463.         return $this->extractModify($p_path, '');

    464. 

  464.     }

    465. 

  465.     // }}}

    466. 

  466. 

    467. 

  467.     /**

    468. 

  468. 	 * Return the content of the archive

    469. 

  469. 	 *

    470. 

  470. 	 * @return array The content of the archive

    471. 

  471. 	 */

    472. 

  472.     function listContent()

    473. 

  473.     {

    474. 

  474.         $v_list_detail = array();

    475. 

  475. 

    476. 

  476.         if ($this->_openRead()) {

    477. 

  477.             if (!$this->_extractList('', $v_list_detail, "list", '', '')) {

    478. 

  478.                 unset($v_list_detail);

    479. 

  479.                 $v_list_detail = 0;

    480. 

  480.             }

    481. 

  481.             $this->_close();

    482. 

  482.         }

    483. 

  483. 

    484. 

  484.         return $v_list_detail;

    485. 

  485.     }

    486. 

  486.     // }}}

    487. 

  487. 

    488. 

  488.     // {{{ createModify()

    489. 

  489.     /**

    490. 

  490.     * This method creates the archive file and add the files / directories

    491. 

  491.     * that are listed in $p_filelist.

    492. 

  492.     * If the file already exists and is writable, it is replaced by the

    493. 

  493.     * new tar. It is a create and not an add. If the file exists and is

    494. 

  494.     * read-only or is a directory it is not replaced. The method return

    495. 

  495.     * false and a PEAR error text.

    496. 

  496.     * The $p_filelist parameter can be an array of string, each string

    497. 

  497.     * representing a filename or a directory name with their path if

    498. 

  498.     * needed. It can also be a single string with names separated by a

    499. 

  499.     * single blank.

    500. 

  500.     * The path indicated in $p_remove_dir will be removed from the

    501. 

  501.     * memorized path of each file / directory listed when this path

    502. 

  502.     * exists. By default nothing is removed (empty path '')

    503. 

  503.     * The path indicated in $p_add_dir will be added at the beginning of

    504. 

  504.     * the memorized path of each file / directory listed. However it can

    505. 

  505.     * be set to empty ''. The adding of a path is done after the removing

    506. 

  506.     * of path.

    507. 

  507.     * The path add/remove ability enables the user to prepare an archive

    508. 

  508.     * for extraction in a different path than the origin files are.

    509. 

  509.     * See also addModify() method for file adding properties.

    510. 

  510.     *

    511. 

  511.     * @param array $p_filelist An array of filenames and directory names,

    512. 

  512. 	*                               or a single string with names separated by

    513. 

  513. 	*                               a single blank space.

    514. 

  514.     * @param string $p_add_dir A string which contains a path to be added

    515. 

  515. 	*                               to the memorized path of each element in

    516. 

  516. 	*                               the list.

    517. 

  517.     * @param string $p_remove_dir A string which contains a path to be

    518. 

  518. 	*                               removed from the memorized path of each

    519. 

  519. 	*                               element in the list, when relevant.

    520. 

  520.     * @return boolean true on success, false on error.

    521. 

  521.     * @access public

    522. 

  522.     * @see addModify()

    523. 

  523.     */

    524. 

  524.     function createModify($p_filelist, $p_add_dir, $p_remove_dir='')

    525. 

  525.     {

    526. 

  526.         $v_result = true;

    527. 

  527. 

    528. 

  528.         if (!$this->_openWrite())

    529. 

  529.             return false;

    530. 

  530. 

    531. 

  531.         if ($p_filelist != '') {

    532. 

  532.             if (is_array($p_filelist))

    533. 

  533.                 $v_list = $p_filelist;

    534. 

  534.             elseif (is_string($p_filelist))

    535. 

  535.                 $v_list = explode($this->_separator, $p_filelist);

    536. 

  536.             else {

    537. 

  537.                 $this->_cleanFile();

    538. 

  538.                 $this->_error('Invalid file list');

    539. 

  539.                 return false;

    540. 

  540.             }

    541. 

  541. 

    542. 

  542.             $v_result = $this->_addList($v_list, $p_add_dir, $p_remove_dir);

    543. 

  543.         }

    544. 

  544. 

    545. 

  545.         if ($v_result) {

    546. 

  546.             $this->_writeFooter();

    547. 

  547.             $this->_close();

    548. 

  548.         } else

    549. 

  549.             $this->_cleanFile();

    550. 

  550. 

    551. 

  551.         return $v_result;

    552. 

  552.     }

    553. 

  553.     // }}}

    554. 

  554. 

    555. 

  555.     // {{{ addModify()

    556. 

  556.     /**

    557. 

  557.     * This method add the files / directories listed in $p_filelist at the

    558. 

  558.     * end of the existing archive. If the archive does not yet exists it

    559. 

  559.     * is created.

    560. 

  560.     * The $p_filelist parameter can be an array of string, each string

    561. 

  561.     * representing a filename or a directory name with their path if

    562. 

  562.     * needed. It can also be a single string with names separated by a

    563. 

  563.     * single blank.

    564. 

  564.     * The path indicated in $p_remove_dir will be removed from the

    565. 

  565.     * memorized path of each file / directory listed when this path

    566. 

  566.     * exists. By default nothing is removed (empty path '')

    567. 

  567.     * The path indicated in $p_add_dir will be added at the beginning of

    568. 

  568.     * the memorized path of each file / directory listed. However it can

    569. 

  569.     * be set to empty ''. The adding of a path is done after the removing

    570. 

  570.     * of path.

    571. 

  571.     * The path add/remove ability enables the user to prepare an archive

    572. 

  572.     * for extraction in a different path than the origin files are.

    573. 

  573.     * If a file/dir is already in the archive it will only be added at the

    574. 

  574.     * end of the archive. There is no update of the existing archived

    575. 

  575.     * file/dir. However while extracting the archive, the last file will

    576. 

  576.     * replace the first one. This results in a none optimization of the

    577. 

  577.     * archive size.

    578. 

  578.     * If a file/dir does not exist the file/dir is ignored. However an

    579. 

  579.     * error text is send to PEAR error.

    580. 

  580.     * If a file/dir is not readable the file/dir is ignored. However an

    581. 

  581.     * error text is send to PEAR error.

    582. 

  582.     *

    583. 

  583.     * @param array $p_filelist An array of filenames and directory

    584. 

  584. 	*                                   names, or a single string with names

    585. 

  585. 	*                                   separated by a single blank space.

    586. 

  586.     * @param string $p_add_dir A string which contains a path to be

    587. 

  587. 	*                                   added to the memorized path of each

    588. 

  588. 	*                                   element in the list.

    589. 

  589.     * @param string $p_remove_dir A string which contains a path to be

    590. 

  590. 	*                                   removed from the memorized path of

    591. 

  591. 	*                                   each element in the list, when

    592. 

  592.     *                                   relevant.

    593. 

  593.     * @return true on success, false on error.

    594. 

  594.     * @access public

    595. 

  595.     */

    596. 

  596.     function addModify($p_filelist, $p_add_dir, $p_remove_dir='')

    597. 

  597.     {

    598. 

  598.         $v_result = true;

    599. 

  599. 

    600. 

  600.         if (!$this->_isArchive())

    601. 

  601.             $v_result = $this->createModify($p_filelist, $p_add_dir,

    602. 

  602. 			                                $p_remove_dir);

    603. 

  603.         else {

    604. 

  604.             if (is_array($p_filelist))

    605. 

  605.                 $v_list = $p_filelist;

    606. 

  606.             elseif (is_string($p_filelist))

    607. 

  607.                 $v_list = explode($this->_separator, $p_filelist);

    608. 

  608.             else {

    609. 

  609.                 $this->_error('Invalid file list');

    610. 

  610.                 return false;

    611. 

  611.             }

    612. 

  612. 

    613. 

  613.             $v_result = $this->_append($v_list, $p_add_dir, $p_remove_dir);

    614. 

  614.         }

    615. 

  615. 

    616. 

  616.         return $v_result;

    617. 

  617.     }

    618. 

  618.     // }}}

    619. 

  619. 

    620. 

  620.     // {{{ addString()

    621. 

  621.     /**

    622. 

  622.     * This method add a single string as a file at the

    623. 

  623.     * end of the existing archive. If the archive does not yet exists it

    624. 

  624.     * is created.

    625. 

  625.     *

    626. 

  626.     * @param string $p_filename A string which contains the full

    627. 

  627. 	*                                   filename path that will be associated

    628. 

  628. 	*                                   with the string.

    629. 

  629.     * @param string $p_string The content of the file added in

    630. 

  630. 	*                                   the archive.

    631. 

  631.     * @return true on success, false on error.

    632. 

  632.     * @access public

    633. 

  633.     */

    634. 

  634.     function addString($p_filename, $p_string)

    635. 

  635.     {

    636. 

  636.         $v_result = true;

    637. 

  637. 

    638. 

  638.         if (!$this->_isArchive()) {

    639. 

  639.             if (!$this->_openWrite()) {

    640. 

  640.                 return false;

    641. 

  641.             }

    642. 

  642.             $this->_close();

    643. 

  643.         }

    644. 

  644. 

    645. 

  645.         if (!$this->_openAppend())

    646. 

  646.             return false;

    647. 

  647. 

    648. 

  648.         // Need to check the get back to the temporary file ? ....

    649. 

  649.         $v_result = $this->_addString($p_filename, $p_string);

    650. 

  650. 

    651. 

  651.         $this->_writeFooter();

    652. 

  652. 

    653. 

  653.         $this->_close();

    654. 

  654. 

    655. 

  655.         return $v_result;

    656. 

  656.     }

    657. 

  657.     // }}}

    658. 

  658. 

    659. 

  659.     // {{{ extractModify()

    660. 

  660.     /**

    661. 

  661.     * This method extract all the content of the archive in the directory

    662. 

  662.     * indicated by $p_path. When relevant the memorized path of the

    663. 

  663.     * files/dir can be modified by removing the $p_remove_path path at the

    664. 

  664.     * beginning of the file/dir path.

    665. 

  665.     * While extracting a file, if the directory path does not exists it is

    666. 

  666.     * created.

    667. 

  667.     * While extracting a file, if the file already exists it is replaced

    668. 

  668.     * without looking for last modification date.

    669. 

  669.     * While extracting a file, if the file already exists and is write

    670. 

  670.     * protected, the extraction is aborted.

    671. 

  671.     * While extracting a file, if a directory with the same name already

    672. 

  672.     * exists, the extraction is aborted.

    673. 

  673.     * While extracting a directory, if a file with the same name already

    674. 

  674.     * exists, the extraction is aborted.

    675. 

  675.     * While extracting a file/directory if the destination directory exist

    676. 

  676.     * and is write protected, or does not exist but can not be created,

    677. 

  677.     * the extraction is aborted.

    678. 

  678.     * If after extraction an extracted file does not show the correct

    679. 

  679.     * stored file size, the extraction is aborted.

    680. 

  680.     * When the extraction is aborted, a PEAR error text is set and false

    681. 

  681.     * is returned. However the result can be a partial extraction that may

    682. 

  682.     * need to be manually cleaned.

    683. 

  683.     *

    684. 

  684.     * @param string $p_path The path of the directory where the

    685. 

  685. 	*                               files/dir need to by extracted.

    686. 

  686.     * @param string $p_remove_path Part of the memorized path that can be

    687. 

  687. 	*                               removed if present at the beginning of

    688. 

  688. 	*                               the file/dir path.

    689. 

  689.     * @return boolean true on success, false on error.

    690. 

  690.     * @access public

    691. 

  691.     * @see extractList()

    692. 

  692.     */

    693. 

  693.     function extractModify($p_path, $p_remove_path)

    694. 

  694.     {

    695. 

  695.         $v_result = true;

    696. 

  696.         $v_list_detail = array();

    697. 

  697. 

    698. 

  698.         if ($v_result = $this->_openRead()) {

    699. 

  699.             $v_result = $this->_extractList($p_path, $v_list_detail,

    700. 

  700. 			                                "complete", 0, $p_remove_path);

    701. 

  701.             $this->_close();

    702. 

  702.         }

    703. 

  703. 

    704. 

  704.         return $v_result;

    705. 

  705.     }

    706. 

  706.     // }}}

    707. 

  707. 

    708. 

  708.     // {{{ extractInString()

    709. 

  709.     /**

    710. 

  710.     * This method extract from the archive one file identified by $p_filename.

    711. 

  711.     * The return value is a string with the file content, or NULL on error.

    712. 

  712.     * @param string $p_filename The path of the file to extract in a string.

    713. 

  713.     * @return a string with the file content or NULL.

    714. 

  714.     * @access public

    715. 

  715.     */

    716. 

  716.     function extractInString($p_filename)

    717. 

  717.     {

    718. 

  718.         if ($this->_openRead()) {

    719. 

  719.             $v_result = $this->_extractInString($p_filename);

    720. 

  720.             $this->_close();

    721. 

  721.         } else {

    722. 

  722.             $v_result = NULL;

    723. 

  723.         }

    724. 

  724. 

    725. 

  725.         return $v_result;

    726. 

  726.     }

    727. 

  727.     // }}}

    728. 

  728. 

    729. 

  729.     // {{{ extractList()

    730. 

  730.     /**

    731. 

  731.     * This method extract from the archive only the files indicated in the

    732. 

  732.     * $p_filelist. These files are extracted in the current directory or

    733. 

  733.     * in the directory indicated by the optional $p_path parameter.

    734. 

  734.     * If indicated the $p_remove_path can be used in the same way as it is

    735. 

  735.     * used in extractModify() method.

    736. 

  736.     * @param array $p_filelist An array of filenames and directory names,

    737. 

  737. 	*                               or a single string with names separated

    738. 

  738. 	*                               by a single blank space.

    739. 

  739.     * @param string $p_path The path of the directory where the

    740. 

  740. 	*                               files/dir need to by extracted.

    741. 

  741.     * @param string $p_remove_path Part of the memorized path that can be

    742. 

  742. 	*                               removed if present at the beginning of

    743. 

  743. 	*                               the file/dir path.

    744. 

  744.     * @return true on success, false on error.

    745. 

  745.     * @access public

    746. 

  746.     * @see extractModify()

    747. 

  747.     */

    748. 

  748.     function extractList($p_filelist, $p_path='', $p_remove_path='')

    749. 

  749.     {

    750. 

  750.         $v_result = true;

    751. 

  751.         $v_list_detail = array();

    752. 

  752. 

    753. 

  753.         if (is_array($p_filelist))

    754. 

  754.             $v_list = $p_filelist;

    755. 

  755.         elseif (is_string($p_filelist))

    756. 

  756.             $v_list = explode($this->_separator, $p_filelist);

    757. 

  757.         else {

    758. 

  758.             $this->_error('Invalid string list');

    759. 

  759.             return false;

    760. 

  760.         }

    761. 

  761. 

    762. 

  762.         if ($v_result = $this->_openRead()) {

    763. 

  763.             $v_result = $this->_extractList($p_path, $v_list_detail, "partial",

    764. 

  764. 			                                $v_list, $p_remove_path);

    765. 

  765.             $this->_close();

    766. 

  766.         }

    767. 

  767. 

    768. 

  768.         return $v_result;

    769. 

  769.     }

    770. 

  770.     // }}}

    771. 

  771. 

    772. 

  772.     // {{{ setAttribute()

    773. 

  773.     /**

    774. 

  774.     * This method set specific attributes of the archive. It uses a variable

    775. 

  775.     * list of parameters, in the format attribute code + attribute values :

    776. 

  776.     * $arch->setAttribute(ARCHIVE_TAR_ATT_SEPARATOR, ',');

    777. 

  777.     *

    778. 

  778.     * @return true on success, false on error.

    779. 

  779.     * @access public

    780. 

  780.     */

    781. 

  781.     function setAttribute()

    782. 

  782.     {

    783. 

  783.         $v_result = true;

    784. 

  784. 

    785. 

  785.         // ----- Get the number of variable list of arguments

    786. 

  786.         if (($v_size = func_num_args()) == 0) {

    787. 

  787.             return true;

    788. 

  788.         }

    789. 

  789. 

    790. 

  790.         // ----- Get the arguments

    791. 

  791.         $v_att_list = &func_get_args();

    792. 

  792. 

    793. 

  793.         // ----- Read the attributes

    794. 

  794.         $i=0;

    795. 

  795.         while ($i<$v_size) {

    796. 

  796. 

    797. 

  797.             // ----- Look for next option

    798. 

  798.             switch ($v_att_list[$i]) {

    799. 

  799.                 // ----- Look for options that request a string value

    800. 

  800.                 case ARCHIVE_TAR_ATT_SEPARATOR :

    801. 

  801.                     // ----- Check the number of parameters

    802. 

  802.                     if (($i+1) >= $v_size) {

    803. 

  803.                         $this->_error('Invalid number of parameters for '

    804. 

  804. 						              .'attribute ARCHIVE_TAR_ATT_SEPARATOR');

    805. 

  805.                         return false;

    806. 

  806.                     }

    807. 

  807. 

    808. 

  808.                     // ----- Get the value

    809. 

  809.                     $this->_separator = $v_att_list[$i+1];

    810. 

  810.                     $i++;

    811. 

  811.                 break;

    812. 

  812. 

    813. 

  813.                 default :

    814. 

  814.                     $this->_error('Unknow attribute code '.$v_att_list[$i].'');

    815. 

  815.                     return false;

    816. 

  816.             }

    817. 

  817. 

    818. 

  818.             // ----- Next attribute

    819. 

  819.             $i++;

    820. 

  820.         }

    821. 

  821. 

    822. 

  822.         return $v_result;

    823. 

  823.     }

    824. 

  824.     // }}}

    825. 

  825. 

    826. 

  826.     /**

    827. 

  827. 	 * Throw an exception

    828. 

  828. 	 *

    829. 

  829. 	 * @param string $p_message The error string

    830. 

  830. 	 *

    831. 

  831. 	 * @throws Exception

    832. 

  832. 	 */

    833. 

  833.     function _error($p_message)

    834. 

  834.     {

    835. 

  835.         // ----- To be completed

    836. 

  836.         throw new Exception($p_message);

    837. 

  837.     }

    838. 

  838.     // }}}

    839. 

  839. 

    840. 

  840.     /**

    841. 

  841. 	 * Throw an exception

    842. 

  842. 	 *

    843. 

  843. 	 * @param string $p_message The error string

    844. 

  844. 	 *

    845. 

  845. 	 * @throws Exception

    846. 

  846. 	 */

    847. 

  847.     function _warning($p_message)

    848. 

  848.     {

    849. 

  849.         // ----- To be completed

    850. 

  850.         throw new Exception($p_message);

    851. 

  851.     }

    852. 

  852.     // }}}

    853. 

  853. 

    854. 

  854.     /**

    855. 

  855. 	 * Check if the file is an archive

    856. 

  856. 	 *

    857. 

  857. 	 * @param string $p_filename The file to check

    858. 

  858. 	 *

    859. 

  859. 	 * @return boolean If the file is an archive

    860. 

  860. 	 */

    861. 

  861.     function _isArchive($p_filename=NULL)

    862. 

  862.     {

    863. 

  863.         if ($p_filename == NULL) {

    864. 

  864.             $p_filename = $this->_tarname;

    865. 

  865.         }

    866. 

  866.         clearstatcache();

    867. 

  867.         return @is_file($p_filename) && !@is_link($p_filename);

    868. 

  868.     }

    869. 

  869.     // }}}

    870. 

  870. 

    871. 

  871.     /**

    872. 

  872. 	 * Opens a file for writing

    873. 

  873. 	 *

    874. 

  874. 	 * @return boolean True on success

    875. 

  875. 	 */

    876. 

  876.     function _openWrite()

    877. 

  877.     {

    878. 

  878.         if ($this->_compress_type == 'gz')

    879. 

  879.             $this->_file = @gzopen($this->_tarname, "wb9");

    880. 

  880.         else if ($this->_compress_type == 'bz2')

    881. 

  881.             $this->_file = @bzopen($this->_tarname, "w");

    882. 

  882.         else if ($this->_compress_type == 'none')

    883. 

  883.             $this->_file = @fopen($this->_tarname, "wb");

    884. 

  884.         else

    885. 

  885.             $this->_error('Unknown or missing compression type ('

    886. 

  886. 			              .$this->_compress_type.')');

    887. 

  887. 

    888. 

  888.         if ($this->_file == 0) {

    889. 

  889.             $this->_error('Unable to open in write mode \''

    890. 

  890. 			              .$this->_tarname.'\'');

    891. 

  891.             return false;

    892. 

  892.         }

    893. 

  893. 

    894. 

  894.         return true;

    895. 

  895.     }

    896. 

  896.     // }}}

    897. 

  897. 

    898. 

  898.     /**

    899. 

  899. 	 * Open a file for reading

    900. 

  900. 	 *

    901. 

  901. 	 * @return boolean True on success

    902. 

  902. 	 */

    903. 

  903.     function _openRead()

    904. 

  904.     {

    905. 

  905.         if (strtolower(substr($this->_tarname, 0, 7)) == 'http://') {

    906. 

  906. 

    907. 

  907.           // ----- Look if a local copy need to be done

    908. 

  908.           if ($this->_temp_tarname == '') {

    909. 

  909.               $this->_temp_tarname = uniqid('tar').'.tmp';

    910. 

  910.               if (!$v_file_from = @fopen($this->_tarname, 'rb')) {

    911. 

  911.                 $this->_error('Unable to open in read mode \''

    912. 

  912. 				              .$this->_tarname.'\'');

    913. 

  913.                 $this->_temp_tarname = '';

    914. 

  914.                 return false;

    915. 

  915.               }

    916. 

  916.               if (!$v_file_to = @fopen($this->_temp_tarname, 'wb')) {

    917. 

  917.                 $this->_error('Unable to open in write mode \''

    918. 

  918. 				              .$this->_temp_tarname.'\'');

    919. 

  919.                 $this->_temp_tarname = '';

    920. 

  920.                 return false;

    921. 

  921.               }

    922. 

  922.               while ($v_data = @fread($v_file_from, 1024))

    923. 

  923.                   @fwrite($v_file_to, $v_data);

    924. 

  924.               @fclose($v_file_from);

    925. 

  925.               @fclose($v_file_to);

    926. 

  926.           }

    927. 

  927. 

    928. 

  928.           // ----- File to open if the local copy

    929. 

  929.           $v_filename = $this->_temp_tarname;

    930. 

  930. 

    931. 

  931.         } else

    932. 

  932.           // ----- File to open if the normal Tar file

    933. 

  933.           $v_filename = $this->_tarname;

    934. 

  934. 

    935. 

  935.         if ($this->_compress_type == 'gz')

    936. 

  936.             $this->_file = @gzopen($v_filename, "rb");

    937. 

  937.         else if ($this->_compress_type == 'bz2')

    938. 

  938.             $this->_file = @bzopen($v_filename, "r");

    939. 

  939.         else if ($this->_compress_type == 'none')

    940. 

  940.             $this->_file = @fopen($v_filename, "rb");

    941. 

  941.         else

    942. 

  942.             $this->_error('Unknown or missing compression type ('

    943. 

  943. 			              .$this->_compress_type.')');

    944. 

  944. 

    945. 

  945.         if ($this->_file == 0) {

    946. 

  946.             $this->_error('Unable to open in read mode \''.$v_filename.'\'');

    947. 

  947.             return false;

    948. 

  948.         }

    949. 

  949. 

    950. 

  950.         return true;

    951. 

  951.     }

    952. 

  952.     // }}}

    953. 

  953. 

    954. 

  954.    /**

    955. 

  955. 	 * Open a file for reading and writing

    956. 

  956. 	 *

    957. 

  957. 	 * @return boolean true on success

    958. 

  958. 	 */

    959. 

  959.     function _openReadWrite()

    960. 

  960.     {

    961. 

  961.         if ($this->_compress_type == 'gz')

    962. 

  962.             $this->_file = @gzopen($this->_tarname, "r+b");

    963. 

  963.         else if ($this->_compress_type == 'bz2') {

    964. 

  964.             $this->_error('Unable to open bz2 in read/write mode \''

    965. 

  965. 			              .$this->_tarname.'\' (limitation of bz2 extension)');

    966. 

  966.             return false;

    967. 

  967.         } else if ($this->_compress_type == 'none')

    968. 

  968.             $this->_file = @fopen($this->_tarname, "r+b");

    969. 

  969.         else

    970. 

  970.             $this->_error('Unknown or missing compression type ('

    971. 

  971. 			              .$this->_compress_type.')');

    972. 

  972. 

    973. 

  973.         if ($this->_file == 0) {

    974. 

  974.             $this->_error('Unable to open in read/write mode \''

    975. 

  975. 			              .$this->_tarname.'\'');

    976. 

  976.             return false;

    977. 

  977.         }

    978. 

  978. 

    979. 

  979.         return true;

    980. 

  980.     }

    981. 

  981.     // }}}

    982. 

  982. 

    983. 

  983.     /**

    984. 

  984. 	 * Close a file handler

    985. 

  985. 	 */

    986. 

  986.     function _close()

    987. 

  987.     {

    988. 

  988.         //if (isset($this->_file)) {

    989. 

  989.         if (is_resource($this->_file)) {

    990. 

  990.             if ($this->_compress_type == 'gz')

    991. 

  991.                 @gzclose($this->_file);

    992. 

  992.             else if ($this->_compress_type == 'bz2')

    993. 

  993.                 @bzclose($this->_file);

    994. 

  994.             else if ($this->_compress_type == 'none')

    995. 

  995.                 @fclose($this->_file);

    996. 

  996.             else

    997. 

  997.                 $this->_error('Unknown or missing compression type ('

    998. 

  998. 				              .$this->_compress_type.')');

    999. 

  999. 

    1000. 

  1000.             $this->_file = 0;

    1001. 

  1001.         }

    1002. 

  1002. 

    1003. 

  1003.         // ----- Look if a local copy need to be erase

    1004. 

  1004.         // Note that it might be interesting to keep the url for a time : ToDo

    1005. 

  1005.         if ($this->_temp_tarname != '') {

    1006. 

  1006.             @unlink($this->_temp_tarname);

    1007. 

  1007.             $this->_temp_tarname = '';

    1008. 

  1008.         }

    1009. 

  1009. 

    1010. 

  1010.         return true;

    1011. 

  1011.     }

    1012. 

  1012.     // }}}

    1013. 

  1013. 

    1014. 

  1014.     /**

    1015. 

  1015. 	 * Close the file handler and cleans the local vars

    1016. 

  1016. 	 *

    1017. 

  1017. 	 * @return boolean true on success

    1018. 

  1018. 	 */

    1019. 

  1019.     function _cleanFile()

    1020. 

  1020.     {

    1021. 

  1021.         $this->_close();

    1022. 

  1022. 

    1023. 

  1023.         // ----- Look for a local copy

    1024. 

  1024.         if ($this->_temp_tarname != '') {

    1025. 

  1025.             // ----- Remove the local copy but not the remote tarname

    1026. 

  1026.             @unlink($this->_temp_tarname);

    1027. 

  1027.             $this->_temp_tarname = '';

    1028. 

  1028.         } else {

    1029. 

  1029.             // ----- Remove the local tarname file

    1030. 

  1030.             @unlink($this->_tarname);

    1031. 

  1031.         }

    1032. 

  1032.         $this->_tarname = '';

    1033. 

  1033. 

    1034. 

  1034.         return true;

    1035. 

  1035.     }

    1036. 

  1036.     // }}}

    1037. 

  1037. 

    1038. 

  1038.     /**

    1039. 

  1039. 	 * Write a block of data

    1040. 

  1040. 	 *

    1041. 

  1041. 	 * @param mixed $p_binary_data The data to write

    1042. 

  1042. 	 * @param int $p_len The length of the data to write

    1043. 

  1043. 	 *

    1044. 

  1044. 	 * @return boolean true on success

    1045. 

  1045. 	 */

    1046. 

  1046.     function _writeBlock($p_binary_data, $p_len=null)

    1047. 

  1047.     {

    1048. 

  1048.       if (is_resource($this->_file)) {

    1049. 

  1049.           if ($p_len === null) {

    1050. 

  1050.               if ($this->_compress_type == 'gz')

    1051. 

  1051.                   @gzputs($this->_file, $p_binary_data);

    1052. 

  1052.               else if ($this->_compress_type == 'bz2')

    1053. 

  1053.                   @bzwrite($this->_file, $p_binary_data);

    1054. 

  1054.               else if ($this->_compress_type == 'none')

    1055. 

  1055.                   @fputs($this->_file, $p_binary_data);

    1056. 

  1056.               else

    1057. 

  1057.                   $this->_error('Unknown or missing compression type ('

    1058. 

  1058. 				                .$this->_compress_type.')');

    1059. 

  1059.           } else {

    1060. 

  1060.               if ($this->_compress_type == 'gz')

    1061. 

  1061.                   @gzputs($this->_file, $p_binary_data, $p_len);

    1062. 

  1062.               else if ($this->_compress_type == 'bz2')

    1063. 

  1063.                   @bzwrite($this->_file, $p_binary_data, $p_len);

    1064. 

  1064.               else if ($this->_compress_type == 'none')

    1065. 

  1065.                   @fputs($this->_file, $p_binary_data, $p_len);

    1066. 

  1066.               else

    1067. 

  1067.                   $this->_error('Unknown or missing compression type ('

    1068. 

  1068. 				                .$this->_compress_type.')');

    1069. 

  1069. 

    1070. 

  1070.           }

    1071. 

  1071.       }

    1072. 

  1072.       return true;

    1073. 

  1073.     }

    1074. 

  1074.     // }}}

    1075. 

  1075. 

    1076. 

  1076.     /**

    1077. 

  1077. 	 * Read a block of data

    1078. 

  1078. 	 *

    1079. 

  1079. 	 * @return mixed The data read

    1080. 

  1080. 	 */

    1081. 

  1081.     function _readBlock()

    1082. 

  1082.     {

    1083. 

  1083.       $v_block = null;

    1084. 

  1084.       if (is_resource($this->_file)) {

    1085. 

  1085.           if ($this->_compress_type == 'gz')

    1086. 

  1086.               $v_block = @gzread($this->_file, 512);

    1087. 

  1087.           else if ($this->_compress_type == 'bz2')

    1088. 

  1088.               $v_block = @bzread($this->_file, 512);

    1089. 

  1089.           else if ($this->_compress_type == 'none')

    1090. 

  1090.               $v_block = @fread($this->_file, 512);

    1091. 

  1091.           else

    1092. 

  1092.               $this->_error('Unknown or missing compression type ('

    1093. 

  1093. 			                .$this->_compress_type.')');

    1094. 

  1094.       }

    1095. 

  1095.       return $v_block;

    1096. 

  1096.     }

    1097. 

  1097.     // }}}

    1098. 

  1098. 

    1099. 

  1099.     /**

    1100. 

  1100. 	 * Jump to a block of data

    1101. 

  1101. 	 *

    1102. 

  1102. 	 * @param int $p_len The position to jump to

    1103. 

  1103. 	 *

    1104. 

  1104. 	 * @return boolean True on success

    1105. 

  1105. 	 */

    1106. 

  1106.     function _jumpBlock($p_len=null)

    1107. 

  1107.     {

    1108. 

  1108.       if (is_resource($this->_file)) {

    1109. 

  1109.           if ($p_len === null)

    1110. 

  1110.               $p_len = 1;

    1111. 

  1111. 

    1112. 

  1112.           if ($this->_compress_type == 'gz') {

    1113. 

  1113.               @gzseek($this->_file, gztell($this->_file)+($p_len*512));

    1114. 

  1114.           }

    1115. 

  1115.           else if ($this->_compress_type == 'bz2') {

    1116. 

  1116.               // ----- Replace missing bztell() and bzseek()

    1117. 

  1117.               for ($i=0; $i<$p_len; $i++)

    1118. 

  1118.                   $this->_readBlock();

    1119. 

  1119.           } else if ($this->_compress_type == 'none')

    1120. 

  1120.               @fseek($this->_file, ftell($this->_file)+($p_len*512));

    1121. 

  1121.           else

    1122. 

  1122.               $this->_error('Unknown or missing compression type ('

    1123. 

  1123. 			                .$this->_compress_type.')');

    1124. 

  1124. 

    1125. 

  1125.       }

    1126. 

  1126.       return true;

    1127. 

  1127.     }

    1128. 

  1128.     // }}}

    1129. 

  1129. 

    1130. 

  1130.     /**

    1131. 

  1131. 	 * Write the end of the file

    1132. 

  1132. 	 *

    1133. 

  1133. 	 * @return boolean true on success

    1134. 

  1134. 	 */

    1135. 

  1135.     function _writeFooter()

    1136. 

  1136.     {

    1137. 

  1137.       if (is_resource($this->_file)) {

    1138. 

  1138.           // ----- Write the last 0 filled block for end of archive

    1139. 

  1139.           $v_binary_data = pack('a1024', '');

    1140. 

  1140.           $this->_writeBlock($v_binary_data);

    1141. 

  1141.       }

    1142. 

  1142.       return true;

    1143. 

  1143.     }

    1144. 

  1144.     // }}}

    1145. 

  1145. 

    1146. 

  1146.     /**

    1147. 

  1147. 	 * Add a list of resources

    1148. 

  1148. 	 *

    1149. 

  1149. 	 * @param array $p_list The list of files to add

    1150. 

  1150. 	 * @param string $p_add_dir The directory to add the files to

    1151. 

  1151. 	 * @param string $p_remove_dir A directory to remove from the file path

    1152. 

  1152. 	 *

    1153. 

  1153. 	 * @return boolean True on success

    1154. 

  1154. 	 */

    1155. 

  1155.     function _addList($p_list, $p_add_dir, $p_remove_dir)

    1156. 

  1156.     {

    1157. 

  1157.       $v_result=true;

    1158. 

  1158.       $v_header = array();

    1159. 

  1159. 

    1160. 

  1160.       // ----- Remove potential windows directory separator

    1161. 

  1161.       $p_add_dir = $this->_translateWinPath($p_add_dir);

    1162. 

  1162.       $p_remove_dir = $this->_translateWinPath($p_remove_dir, false);

    1163. 

  1163. 

    1164. 

  1164.       if (!$this->_file) {

    1165. 

  1165.           $this->_error('Invalid file descriptor');

    1166. 

  1166.           return false;

    1167. 

  1167.       }

    1168. 

  1168. 

    1169. 

  1169.       if (sizeof($p_list) == 0)

    1170. 

  1170.           return true;

    1171. 

  1171. 

    1172. 

  1172.       foreach ($p_list as $v_filename) {

    1173. 

  1173.           if (!$v_result) {

    1174. 

  1174.               break;

    1175. 

  1175.           }

    1176. 

  1176. 

    1177. 

  1177.         // ----- Skip the current tar name

    1178. 

  1178.         if ($v_filename == $this->_tarname)

    1179. 

  1179.             continue;

    1180. 

  1180. 

    1181. 

  1181.         if ($v_filename == '')

    1182. 

  1182.             continue;

    1183. 

  1183. 

    1184. 

  1184.         if (!file_exists($v_filename)) {

    1185. 

  1185.             $this->_warning("File '$v_filename' does not exist");

    1186. 

  1186.             continue;

    1187. 

  1187.         }

    1188. 

  1188. 

    1189. 

  1189.         // ----- Add the file or directory header

    1190. 

  1190.         if (!$this->_addFile($v_filename, $v_header, $p_add_dir, $p_remove_dir))

    1191. 

  1191.             return false;

    1192. 

  1192. 

    1193. 

  1193.         if (@is_dir($v_filename) && !@is_link($v_filename)) {

    1194. 

  1194.             if (!($p_hdir = opendir($v_filename))) {

    1195. 

  1195.                 $this->_warning("Directory '$v_filename' can not be read");

    1196. 

  1196.                 continue;

    1197. 

  1197.             }

    1198. 

  1198.             while (false !== ($p_hitem = readdir($p_hdir))) {

    1199. 

  1199.                 if (($p_hitem != '.') && ($p_hitem != '..')) {

    1200. 

  1200.                     if ($v_filename != ".")

    1201. 

  1201.                         $p_temp_list[0] = $v_filename.'/'.$p_hitem;

    1202. 

  1202.                     else

    1203. 

  1203.                         $p_temp_list[0] = $p_hitem;

    1204. 

  1204. 

    1205. 

  1205.                     $v_result = $this->_addList($p_temp_list,

    1206. 

  1206. 					                            $p_add_dir,

    1207. 

  1207. 												$p_remove_dir);

    1208. 

  1208.                 }

    1209. 

  1209.             }

    1210. 

  1210. 

    1211. 

  1211.             unset($p_temp_list);

    1212. 

  1212.             unset($p_hdir);

    1213. 

  1213.             unset($p_hitem);

    1214. 

  1214.         }

    1215. 

  1215.       }

    1216. 

  1216. 

    1217. 

  1217.       return $v_result;

    1218. 

  1218.     }

    1219. 

  1219.     // }}}

    1220. 

  1220. 

    1221. 

  1221.     /**

    1222. 

  1222. 	 * Add a file

    1223. 

  1223. 	 *

    1224. 

  1224. 	 * @param string $p_filename The file to add

    1225. 

  1225. 	 * @param string $p_header Header

    1226. 

  1226. 	 * @param string $p_add_dir The directory to add the files to

    1227. 

  1227. 	 * @param string $p_remove_dir A directory to remove from the file path

    1228. 

  1228. 	 *

    1229. 

  1229. 	 * @return boolean True on success

    1230. 

  1230. 	 */

    1231. 

  1231.     function _addFile($p_filename, &$p_header, $p_add_dir, $p_remove_dir)

    1232. 

  1232.     {

    1233. 

  1233.       if (!$this->_file) {

    1234. 

  1234.           $this->_error('Invalid file descriptor');

    1235. 

  1235.           return false;

    1236. 

  1236.       }

    1237. 

  1237. 

    1238. 

  1238.       if ($p_filename == '') {

    1239. 

  1239.           $this->_error('Invalid file name');

    1240. 

  1240.           return false;

    1241. 

  1241.       }

    1242. 

  1242. 

    1243. 

  1243.       // ----- Calculate the stored filename

    1244. 

  1244.       $p_filename = $this->_translateWinPath($p_filename, false);

    1245. 

  1245.       $v_stored_filename = $p_filename;

    1246. 

  1246.       if (strcmp($p_filename, $p_remove_dir) == 0) {

    1247. 

  1247.           return true;

    1248. 

  1248.       }

    1249. 

  1249.       if ($p_remove_dir != '') {

    1250. 

  1250.           if (substr($p_remove_dir, -1) != '/')

    1251. 

  1251.               $p_remove_dir .= '/';

    1252. 

  1252. 

    1253. 

  1253.           if (substr($p_filename, 0, strlen($p_remove_dir)) == $p_remove_dir)

    1254. 

  1254.               $v_stored_filename = substr($p_filename, strlen($p_remove_dir));

    1255. 

  1255.       }

    1256. 

  1256.       $v_stored_filename = $this->_translateWinPath($v_stored_filename);

    1257. 

  1257.       if ($p_add_dir != '') {

    1258. 

  1258.           if (substr($p_add_dir, -1) == '/')

    1259. 

  1259.               $v_stored_filename = $p_add_dir.$v_stored_filename;

    1260. 

  1260.           else

    1261. 

  1261.               $v_stored_filename = $p_add_dir.'/'.$v_stored_filename;

    1262. 

  1262.       }

    1263. 

  1263. 

    1264. 

  1264.       $v_stored_filename = $this->_pathReduction($v_stored_filename);

    1265. 

  1265. 

    1266. 

  1266.       if ($this->_isArchive($p_filename)) {

    1267. 

  1267.           if (($v_file = @fopen($p_filename, "rb")) == 0) {

    1268. 

  1268.               $this->_warning("Unable to open file '".$p_filename

    1269. 

  1269. 			                  ."' in binary read mode");

    1270. 

  1270.               return true;

    1271. 

  1271.           }

    1272. 

  1272. 

    1273. 

  1273.           if (!$this->_writeHeader($p_filename, $v_stored_filename))

    1274. 

  1274.               return false;

    1275. 

  1275. 

    1276. 

  1276.           while (($v_buffer = fread($v_file, 512)) != '') {

    1277. 

  1277.               $v_binary_data = pack("a512", "$v_buffer");

    1278. 

  1278.               $this->_writeBlock($v_binary_data);

    1279. 

  1279.           }

    1280. 

  1280. 

    1281. 

  1281.           fclose($v_file);

    1282. 

  1282. 

    1283. 

  1283.       } else {

    1284. 

  1284.           // ----- Only header for dir

    1285. 

  1285.           if (!$this->_writeHeader($p_filename, $v_stored_filename))

    1286. 

  1286.               return false;

    1287. 

  1287.       }

    1288. 

  1288. 

    1289. 

  1289.       return true;

    1290. 

  1290.     }

    1291. 

  1291.     // }}}

    1292. 

  1292. 

    1293. 

  1293.     /**

    1294. 

  1294. 	 * Add a string to a file

    1295. 

  1295. 	 *

    1296. 

  1296. 	 * @param string $p_filename The file

    1297. 

  1297. 	 * @param string $p_string The string

    1298. 

  1298. 	 *

    1299. 

  1299. 	 * @return boolean true on success

    1300. 

  1300. 	 */

    1301. 

  1301.     function _addString($p_filename, $p_string)

    1302. 

  1302.     {

    1303. 

  1303.       if (!$this->_file) {

    1304. 

  1304.           $this->_error('Invalid file descriptor');

    1305. 

  1305.           return false;

    1306. 

  1306.       }

    1307. 

  1307. 

    1308. 

  1308.       if ($p_filename == '') {

    1309. 

  1309.           $this->_error('Invalid file name');

    1310. 

  1310.           return false;

    1311. 

  1311.       }

    1312. 

  1312. 

    1313. 

  1313.       // ----- Calculate the stored filename

    1314. 

  1314.       $p_filename = $this->_translateWinPath($p_filename, false);

    1315. 

  1315. 

    1316. 

  1316.       if (!$this->_writeHeaderBlock($p_filename, strlen($p_string),

    1317. 

  1317. 	                                  time(), 384, "", 0, 0))

    1318. 

  1318.           return false;

    1319. 

  1319. 

    1320. 

  1320.       $i=0;

    1321. 

  1321.       while (($v_buffer = substr($p_string, (($i++)*512), 512)) != '') {

    1322. 

  1322.           $v_binary_data = pack("a512", $v_buffer);

    1323. 

  1323.           $this->_writeBlock($v_binary_data);

    1324. 

  1324.       }

    1325. 

  1325. 

    1326. 

  1326.       return true;

    1327. 

  1327.     }

    1328. 

  1328.     // }}}

    1329. 

  1329. 

    1330. 

  1330.     /**

    1331. 

  1331. 	 * Write an header to a file

    1332. 

  1332. 	 *

    1333. 

  1333. 	 * @param string $p_filename The file

    1334. 

  1334. 	 * @param string $p_stored_filename The stored file

    1335. 

  1335. 	 */

    1336. 

  1336.     function _writeHeader($p_filename, $p_stored_filename)

    1337. 

  1337.     {

    1338. 

  1338.         if ($p_stored_filename == '')

    1339. 

  1339.             $p_stored_filename = $p_filename;

    1340. 

  1340.         $v_reduce_filename = $this->_pathReduction($p_stored_filename);

    1341. 

  1341. 

    1342. 

  1342.         if (strlen($v_reduce_filename) > 99) {

    1343. 

  1343.           if (!$this->_writeLongHeader($v_reduce_filename))

    1344. 

  1344.             return false;

    1345. 

  1345.         }

    1346. 

  1346. 

    1347. 

  1347.         $v_info = lstat($p_filename);

    1348. 

  1348.         $v_uid = sprintf("%6s ", DecOct($v_info[4]));

    1349. 

  1349.         $v_gid = sprintf("%6s ", DecOct($v_info[5]));

    1350. 

  1350.         $v_perms = sprintf("%6s ", DecOct($v_info['mode']));

    1351. 

  1351. 

    1352. 

  1352.         $v_mtime = sprintf("%11s", DecOct($v_info['mode']));

    1353. 

  1353. 

    1354. 

  1354.         $v_linkname = '';

    1355. 

  1355. 

    1356. 

  1356.         if (@is_link($p_filename)) {

    1357. 

  1357.           $v_typeflag = '2';

    1358. 

  1358.           $v_linkname = readlink($p_filename);

    1359. 

  1359.           $v_size = sprintf("%11s ", DecOct(0));

    1360. 

  1360.         } elseif (@is_dir($p_filename)) {

    1361. 

  1361.           $v_typeflag = "5";

    1362. 

  1362.           $v_size = sprintf("%11s ", DecOct(0));

    1363. 

  1363.         } else {

    1364. 

  1364.           $v_typeflag = '';

    1365. 

  1365.           clearstatcache();

    1366. 

  1366.           $v_size = sprintf("%11s ", DecOct($v_info['size']));

    1367. 

  1367.         }

    1368. 

  1368. 

    1369. 

  1369.         $v_magic = '';

    1370. 

  1370. 

    1371. 

  1371.         $v_version = '';

    1372. 

  1372. 

    1373. 

  1373.         $v_uname = '';

    1374. 

  1374. 

    1375. 

  1375.         $v_gname = '';

    1376. 

  1376. 

    1377. 

  1377.         $v_devmajor = '';

    1378. 

  1378. 

    1379. 

  1379.         $v_devminor = '';

    1380. 

  1380. 

    1381. 

  1381.         $v_prefix = '';

    1382. 

  1382. 

    1383. 

  1383.         $v_binary_data_first = pack("a100a8a8a8a12A12",

    1384. 

  1384. 		                            $v_reduce_filename, $v_perms, $v_uid,

    1385. 

  1385. 									$v_gid, $v_size, $v_mtime);

    1386. 

  1386.         $v_binary_data_last = pack("a1a100a6a2a32a32a8a8a155a12",

    1387. 

  1387. 		                           $v_typeflag, $v_linkname, $v_magic,

    1388. 

  1388. 								   $v_version, $v_uname, $v_gname,

    1389. 

  1389. 								   $v_devmajor, $v_devminor, $v_prefix, '');

    1390. 

  1390. 

    1391. 

  1391.         // ----- Calculate the checksum

    1392. 

  1392.         $v_checksum = 0;

    1393. 

  1393.         // ..... First part of the header

    1394. 

  1394.         for ($i=0; $i<148; $i++)

    1395. 

  1395.             $v_checksum += ord(substr($v_binary_data_first,$i,1));

    1396. 

  1396.         // ..... Ignore the checksum value and replace it by ' ' (space)

    1397. 

  1397.         for ($i=148; $i<156; $i++)

    1398. 

  1398.             $v_checksum += ord(' ');

    1399. 

  1399.         // ..... Last part of the header

    1400. 

  1400.         for ($i=156, $j=0; $i<512; $i++, $j++)

    1401. 

  1401.             $v_checksum += ord(substr($v_binary_data_last,$j,1));

    1402. 

  1402. 

    1403. 

  1403.         // ----- Write the first 148 bytes of the header in the archive

    1404. 

  1404.         $this->_writeBlock($v_binary_data_first, 148);

    1405. 

  1405. 

    1406. 

  1406.         // ----- Write the calculated checksum

    1407. 

  1407.         $v_checksum = sprintf("%6s ", DecOct($v_checksum));

    1408. 

  1408.         $v_binary_data = pack("a8", $v_checksum);

    1409. 

  1409.         $this->_writeBlock($v_binary_data, 8);

    1410. 

  1410. 

    1411. 

  1411.         // ----- Write the last 356 bytes of the header in the archive

    1412. 

  1412.         $this->_writeBlock($v_binary_data_last, 356);

    1413. 

  1413. 

    1414. 

  1414.         return true;

    1415. 

  1415.     }

    1416. 

  1416.     // }}}

    1417. 

  1417. 

    1418. 

  1418.     /**

    1419. 

  1419. 	 * Write an header block

    1420. 

  1420. 	 *

    1421. 

  1421. 	 * @param string $p_filename The file

    1422. 

  1422. 	 * @param int $p_size The size

    1423. 

  1423. 	 * @param int $p_mtime The mtime

    1424. 

  1424. 	 * @param string $p_perms The permissions

    1425. 

  1425. 	 * @param string $p_type The type of the file

    1426. 

  1426. 	 * @param int $p_uid The uid

    1427. 

  1427. 	 * @param int $p_gid the gid

    1428. 

  1428. 	 *

    1429. 

  1429. 	 * @return boolean Ture on succcess

    1430. 

  1430. 	 */

    1431. 

  1431.     function _writeHeaderBlock($p_filename, $p_size, $p_mtime=0, $p_perms=0,

    1432. 

  1432. 	                           $p_type='', $p_uid=0, $p_gid=0)

    1433. 

  1433.     {

    1434. 

  1434.         $p_filename = $this->_pathReduction($p_filename);

    1435. 

  1435. 

    1436. 

  1436.         if (strlen($p_filename) > 99) {

    1437. 

  1437.           if (!$this->_writeLongHeader($p_filename))

    1438. 

  1438.             return false;

    1439. 

  1439.         }

    1440. 

  1440. 

    1441. 

  1441.         if ($p_type == "5") {

    1442. 

  1442.           $v_size = sprintf("%11s ", DecOct(0));

    1443. 

  1443.         } else {

    1444. 

  1444.           $v_size = sprintf("%11s ", DecOct($p_size));

    1445. 

  1445.         }

    1446. 

  1446. 

    1447. 

  1447.         $v_uid = sprintf("%6s ", DecOct($p_uid));

    1448. 

  1448.         $v_gid = sprintf("%6s ", DecOct($p_gid));

    1449. 

  1449.         $v_perms = sprintf("%6s ", DecOct($p_perms));

    1450. 

  1450. 

    1451. 

  1451.         $v_mtime = sprintf("%11s", DecOct($p_mtime));

    1452. 

  1452. 

    1453. 

  1453.         $v_linkname = '';

    1454. 

  1454. 

    1455. 

  1455.         $v_magic = '';

    1456. 

  1456. 

    1457. 

  1457.         $v_version = '';

    1458. 

  1458. 

    1459. 

  1459.         $v_uname = '';

    1460. 

  1460. 

    1461. 

  1461.         $v_gname = '';

    1462. 

  1462. 

    1463. 

  1463.         $v_devmajor = '';

    1464. 

  1464. 

    1465. 

  1465.         $v_devminor = '';

    1466. 

  1466. 

    1467. 

  1467.         $v_prefix = '';

    1468. 

  1468. 

    1469. 

  1469.         $v_binary_data_first = pack("a100a8a8a8a12A12",

    1470. 

  1470. 		                            $p_filename, $v_perms, $v_uid, $v_gid,

    1471. 

  1471. 									$v_size, $v_mtime);

    1472. 

  1472.         $v_binary_data_last = pack("a1a100a6a2a32a32a8a8a155a12",

    1473. 

  1473. 		                           $p_type, $v_linkname, $v_magic,

    1474. 

  1474. 								   $v_version, $v_uname, $v_gname,

    1475. 

  1475. 								   $v_devmajor, $v_devminor, $v_prefix, '');

    1476. 

  1476. 

    1477. 

  1477.         // ----- Calculate the checksum

    1478. 

  1478.         $v_checksum = 0;

    1479. 

  1479.         // ..... First part of the header

    1480. 

  1480.         for ($i=0; $i<148; $i++)

    1481. 

  1481.             $v_checksum += ord(substr($v_binary_data_first,$i,1));

    1482. 

  1482.         // ..... Ignore the checksum value and replace it by ' ' (space)

    1483. 

  1483.         for ($i=148; $i<156; $i++)

    1484. 

  1484.             $v_checksum += ord(' ');

    1485. 

  1485.         // ..... Last part of the header

    1486. 

  1486.         for ($i=156, $j=0; $i<512; $i++, $j++)

    1487. 

  1487.             $v_checksum += ord(substr($v_binary_data_last,$j,1));

    1488. 

  1488. 

    1489. 

  1489.         // ----- Write the first 148 bytes of the header in the archive

    1490. 

  1490.         $this->_writeBlock($v_binary_data_first, 148);

    1491. 

  1491. 

    1492. 

  1492.         // ----- Write the calculated checksum

    1493. 

  1493.         $v_checksum = sprintf("%6s ", DecOct($v_checksum));

    1494. 

  1494.         $v_binary_data = pack("a8", $v_checksum);

    1495. 

  1495.         $this->_writeBlock($v_binary_data, 8);

    1496. 

  1496. 

    1497. 

  1497.         // ----- Write the last 356 bytes of the header in the archive

    1498. 

  1498.         $this->_writeBlock($v_binary_data_last, 356);

    1499. 

  1499. 

    1500. 

  1500.         return true;

    1501. 

  1501.     }

    1502. 

  1502.     // }}}

    1503. 

  1503. 

    1504. 

  1504.     /**

    1505. 

  1505. 	 * Write a long header

    1506. 

  1506. 	 *

    1507. 

  1507. 	 * @param string $p_filename The file

    1508. 

  1508. 	 */

    1509. 

  1509.     function _writeLongHeader($p_filename)

    1510. 

  1510.     {

    1511. 

  1511.         $v_size = sprintf("%11s ", DecOct(strlen($p_filename)));

    1512. 

  1512. 

    1513. 

  1513.         $v_typeflag = 'L';

    1514. 

  1514. 

    1515. 

  1515.         $v_linkname = '';

    1516. 

  1516. 

    1517. 

  1517.         $v_magic = '';

    1518. 

  1518. 

    1519. 

  1519.         $v_version = '';

    1520. 

  1520. 

    1521. 

  1521.         $v_uname = '';

    1522. 

  1522. 

    1523. 

  1523.         $v_gname = '';

    1524. 

  1524. 

    1525. 

  1525.         $v_devmajor = '';

    1526. 

  1526. 

    1527. 

  1527.         $v_devminor = '';

    1528. 

  1528. 

    1529. 

  1529.         $v_prefix = '';

    1530. 

  1530. 

    1531. 

  1531.         $v_binary_data_first = pack("a100a8a8a8a12A12",

    1532. 

  1532. 		                            '././@LongLink', 0, 0, 0, $v_size, 0);

    1533. 

  1533.         $v_binary_data_last = pack("a1a100a6a2a32a32a8a8a155a12",

    1534. 

  1534. 		                           $v_typeflag, $v_linkname, $v_magic,

    1535. 

  1535. 								   $v_version, $v_uname, $v_gname,

    1536. 

  1536. 								   $v_devmajor, $v_devminor, $v_prefix, '');

    1537. 

  1537. 

    1538. 

  1538.         // ----- Calculate the checksum

    1539. 

  1539.         $v_checksum = 0;

    1540. 

  1540.         // ..... First part of the header

    1541. 

  1541.         for ($i=0; $i<148; $i++)

    1542. 

  1542.             $v_checksum += ord(substr($v_binary_data_first,$i,1));

    1543. 

  1543.         // ..... Ignore the checksum value and replace it by ' ' (space)

    1544. 

  1544.         for ($i=148; $i<156; $i++)

    1545. 

  1545.             $v_checksum += ord(' ');

    1546. 

  1546.         // ..... Last part of the header

    1547. 

  1547.         for ($i=156, $j=0; $i<512; $i++, $j++)

    1548. 

  1548.             $v_checksum += ord(substr($v_binary_data_last,$j,1));

    1549. 

  1549. 

    1550. 

  1550.         // ----- Write the first 148 bytes of the header in the archive

    1551. 

  1551.         $this->_writeBlock($v_binary_data_first, 148);

    1552. 

  1552. 

    1553. 

  1553.         // ----- Write the calculated checksum

    1554. 

  1554.         $v_checksum = sprintf("%6s ", DecOct($v_checksum));

    1555. 

  1555.         $v_binary_data = pack("a8", $v_checksum);

    1556. 

  1556.         $this->_writeBlock($v_binary_data, 8);

    1557. 

  1557. 

    1558. 

  1558.         // ----- Write the last 356 bytes of the header in the archive

    1559. 

  1559.         $this->_writeBlock($v_binary_data_last, 356);

    1560. 

  1560. 

    1561. 

  1561.         // ----- Write the filename as content of the block

    1562. 

  1562.         $i=0;

    1563. 

  1563.         while (($v_buffer = substr($p_filename, (($i++)*512), 512)) != '') {

    1564. 

  1564.             $v_binary_data = pack("a512", "$v_buffer");

    1565. 

  1565.             $this->_writeBlock($v_binary_data);

    1566. 

  1566.         }

    1567. 

  1567. 

    1568. 

  1568.         return true;

    1569. 

  1569.     }

    1570. 

  1570.     // }}}

    1571. 

  1571. 

    1572. 

  1572.     /**

    1573. 

  1573. 	 * Read an header

    1574. 

  1574. 	 *

    1575. 

  1575. 	 * @param mixed $v_binary_data The data

    1576. 

  1576. 	 * @param mixed $v_header the header

    1577. 

  1577. 	 *

    1578. 

  1578. 	 * @return boolean True on success

    1579. 

  1579. 	 */

    1580. 

  1580.     function _readHeader($v_binary_data, &$v_header)

    1581. 

  1581.     {

    1582. 

  1582.         if (strlen($v_binary_data)==0) {

    1583. 

  1583.             $v_header['filename'] = '';

    1584. 

  1584.             return true;

    1585. 

  1585.         }

    1586. 

  1586. 

    1587. 

  1587.         if (strlen($v_binary_data) != 512) {

    1588. 

  1588.             $v_header['filename'] = '';

    1589. 

  1589.             $this->_error('Invalid block size : '.strlen($v_binary_data));

    1590. 

  1590.             return false;

    1591. 

  1591.         }

    1592. 

  1592. 

    1593. 

  1593.         if (!is_array($v_header)) {

    1594. 

  1594.             $v_header = array();

    1595. 

  1595.         }

    1596. 

  1596.         // ----- Calculate the checksum

    1597. 

  1597.         $v_checksum = 0;

    1598. 

  1598.         // ..... First part of the header

    1599. 

  1599.         for ($i=0; $i<148; $i++)

    1600. 

  1600.             $v_checksum+=ord(substr($v_binary_data,$i,1));

    1601. 

  1601.         // ..... Ignore the checksum value and replace it by ' ' (space)

    1602. 

  1602.         for ($i=148; $i<156; $i++)

    1603. 

  1603.             $v_checksum += ord(' ');

    1604. 

  1604.         // ..... Last part of the header

    1605. 

  1605.         for ($i=156; $i<512; $i++)

    1606. 

  1606.            $v_checksum+=ord(substr($v_binary_data,$i,1));

    1607. 

  1607. 

    1608. 

  1608.         $v_data = unpack("a100filename/a8mode/a8uid/a8gid/a12size/a12mtime/"

    1609. 

  1609. 		                 ."a8checksum/a1typeflag/a100link/a6magic/a2version/"

    1610. 

  1610. 						 ."a32uname/a32gname/a8devmajor/a8devminor",

    1611. 

  1611. 						 $v_binary_data);

    1612. 

  1612. 

    1613. 

  1613.         // ----- Extract the checksum

    1614. 

  1614.         $v_header['checksum'] = OctDec(trim($v_data['checksum']));

    1615. 

  1615.         if ($v_header['checksum'] != $v_checksum) {

    1616. 

  1616.             $v_header['filename'] = '';

    1617. 

  1617. 

    1618. 

  1618.             // ----- Look for last block (empty block)

    1619. 

  1619.             if (($v_checksum == 256) && ($v_header['checksum'] == 0))

    1620. 

  1620.                 return true;

    1621. 

  1621. 

    1622. 

  1622.             $this->_error('Invalid checksum for file "'.$v_data['filename']

    1623. 

  1623. 			              .'" : '.$v_checksum.' calculated, '

    1624. 

  1624. 						  .$v_header['checksum'].' expected');

    1625. 

  1625.             return false;

    1626. 

  1626.         }

    1627. 

  1627. 

    1628. 

  1628.         // ----- Extract the properties

    1629. 

  1629.         $v_header['filename'] = trim($v_data['filename']);

    1630. 

  1630.         if ($this->_maliciousFilename($v_header['filename'])) {

    1631. 

  1631.             $this->_error('Malicious .tar detected, file "' . $v_header['filename'] .

    1632. 

  1632.                 '" will not install in desired directory tree');

    1633. 

  1633.             return false;

    1634. 

  1634.         }

    1635. 

  1635.         $v_header['mode'] = OctDec(trim($v_data['mode']));

    1636. 

  1636.         $v_header['uid'] = OctDec(trim($v_data['uid']));

    1637. 

  1637.         $v_header['gid'] = OctDec(trim($v_data['gid']));

    1638. 

  1638.         $v_header['size'] = OctDec(trim($v_data['size']));

    1639. 

  1639.         $v_header['mtime'] = OctDec(trim($v_data['mtime']));

    1640. 

  1640.         if (($v_header['typeflag'] = $v_data['typeflag']) == "5") {

    1641. 

  1641.           $v_header['size'] = 0;

    1642. 

  1642.         }

    1643. 

  1643.         $v_header['link'] = trim($v_data['link']);

    1644. 

  1644.         /* ----- All these fields are removed form the header because

    1645. 

  1645. 		they do not carry interesting info

    1646. 

  1646.         $v_header[magic] = trim($v_data[magic]);

    1647. 

  1647.         $v_header[version] = trim($v_data[version]);

    1648. 

  1648.         $v_header[uname] = trim($v_data[uname]);

    1649. 

  1649.         $v_header[gname] = trim($v_data[gname]);

    1650. 

  1650.         $v_header[devmajor] = trim($v_data[devmajor]);

    1651. 

  1651.         $v_header[devminor] = trim($v_data[devminor]);

    1652. 

  1652.         */

    1653. 

  1653. 

    1654. 

  1654.         return true;

    1655. 

  1655.     }

    1656. 

  1656.     // }}}

    1657. 

  1657. 

    1658. 

  1658.     // {{{ _maliciousFilename()

    1659. 

  1659.     /**

    1660. 

  1660.      * Detect and report a malicious file name

    1661. 

  1661.      *

    1662. 

  1662.      * @param string $file

    1663. 

  1663.      * @return boolean

    1664. 

  1664.      */

    1665. 

  1665.     function _maliciousFilename($file)

    1666. 

  1666.     {

    1667. 

  1667.         if (strpos($file, '/../') !== false) {

    1668. 

  1668.             return true;

    1669. 

  1669.         }

    1670. 

  1670.         if (strpos($file, '../') === 0) {

    1671. 

  1671.             return true;

    1672. 

  1672.         }

    1673. 

  1673.         return false;

    1674. 

  1674.     }

    1675. 

  1675.     // }}}

    1676. 

  1676. 

    1677. 

  1677.     /**

    1678. 

  1678. 	 * Read a long header

    1679. 

  1679. 	 *

    1680. 

  1680. 	 * @param mixed $v_header The header to read

    1681. 

  1681. 	 *

    1682. 

  1682. 	 * @return boolean true on success

    1683. 

  1683. 	 */

    1684. 

  1684.     function _readLongHeader(&$v_header)

    1685. 

  1685.     {

    1686. 

  1686.       $v_filename = '';

    1687. 

  1687.       $n = floor($v_header['size']/512);

    1688. 

  1688.       for ($i=0; $i<$n; $i++) {

    1689. 

  1689.         $v_content = $this->_readBlock();

    1690. 

  1690.         $v_filename .= $v_content;

    1691. 

  1691.       }

    1692. 

  1692.       if (($v_header['size'] % 512) != 0) {

    1693. 

  1693.         $v_content = $this->_readBlock();

    1694. 

  1694.         $v_filename .= $v_content;

    1695. 

  1695.       }

    1696. 

  1696. 

    1697. 

  1697.       // ----- Read the next header

    1698. 

  1698.       $v_binary_data = $this->_readBlock();

    1699. 

  1699. 

    1700. 

  1700.       if (!$this->_readHeader($v_binary_data, $v_header))

    1701. 

  1701.         return false;

    1702. 

  1702. 

    1703. 

  1703.       $v_filename = trim($v_filename);

    1704. 

  1704.       $v_header['filename'] = $v_filename;

    1705. 

  1705.         if ($this->_maliciousFilename($v_filename)) {

    1706. 

  1706.             $this->_error('Malicious .tar detected, file "' . $v_filename .

    1707. 

  1707.                 '" will not install in desired directory tree');

    1708. 

  1708.             return false;

    1709. 

  1709.       }

    1710. 

  1710. 

    1711. 

  1711.       return true;

    1712. 

  1712.     }

    1713. 

  1713.     // }}}

    1714. 

  1714. 

    1715. 

  1715.     // {{{ _extractInString()

    1716. 

  1716.     /**

    1717. 

  1717.     * This method extract from the archive one file identified by $p_filename.

    1718. 

  1718.     * The return value is a string with the file content, or NULL on error.

    1719. 

  1719.     *

    1720. 

  1720. 	* @param string $p_filename The path of the file to extract in a string.

    1721. 

  1721.     * @return string a string with the file content or NULL.

    1722. 

  1722.     */

    1723. 

  1723.     function _extractInString($p_filename)

    1724. 

  1724.     {

    1725. 

  1725.         $v_result_str = "";

    1726. 

  1726. 

    1727. 

  1727.         While (strlen($v_binary_data = $this->_readBlock()) != 0)

    1728. 

  1728.         {

    1729. 

  1729.           if (!$this->_readHeader($v_binary_data, $v_header))

    1730. 

  1730.             return NULL;

    1731. 

  1731. 

    1732. 

  1732.           if ($v_header['filename'] == '')

    1733. 

  1733.             continue;

    1734. 

  1734. 

    1735. 

  1735.           // ----- Look for long filename

    1736. 

  1736.           if ($v_header['typeflag'] == 'L') {

    1737. 

  1737.             if (!$this->_readLongHeader($v_header))

    1738. 

  1738.               return NULL;

    1739. 

  1739.           }

    1740. 

  1740. 

    1741. 

  1741.           if ($v_header['filename'] == $p_filename) {

    1742. 

  1742.               if ($v_header['typeflag'] == "5") {

    1743. 

  1743.                   $this->_error('Unable to extract in string a directory '

    1744. 

  1744. 				                .'entry {'.$v_header['filename'].'}');

    1745. 

  1745.                   return NULL;

    1746. 

  1746.               } else {

    1747. 

  1747.                   $n = floor($v_header['size']/512);

    1748. 

  1748.                   for ($i=0; $i<$n; $i++) {

    1749. 

  1749.                       $v_result_str .= $this->_readBlock();

    1750. 

  1750.                   }

    1751. 

  1751.                   if (($v_header['size'] % 512) != 0) {

    1752. 

  1752.                       $v_content = $this->_readBlock();

    1753. 

  1753.                       $v_result_str .= substr($v_content, 0,

    1754. 

  1754. 					                          ($v_header['size'] % 512));

    1755. 

  1755.                   }

    1756. 

  1756.                   return $v_result_str;

    1757. 

  1757.               }

    1758. 

  1758.           } else {

    1759. 

  1759.               $this->_jumpBlock(ceil(($v_header['size']/512)));

    1760. 

  1760.           }

    1761. 

  1761.         }

    1762. 

  1762. 

    1763. 

  1763.         return NULL;

    1764. 

  1764.     }

    1765. 

  1765.     // }}}

    1766. 

  1766. 

    1767. 

  1767.     /**

    1768. 

  1768. 	 * Extract a list of files

    1769. 

  1769. 	 *

    1770. 

  1770. 	 * @param string $p_path The path

    1771. 

  1771. 	 * @param array $p_list_detail The list detail

    1772. 

  1772. 	 * @param string $p_mode The mode

    1773. 

  1773. 	 * @param array $p_file_list The list of files

    1774. 

  1774. 	 * @param string $p_remove_path The path to remove

    1775. 

  1775. 	 *

    1776. 

  1776. 	 * @return boolean true on success

    1777. 

  1777. 	 *

    1778. 

  1778. 	 */

    1779. 

  1779.     function _extractList($p_path, &$p_list_detail, $p_mode,

    1780. 

  1780. 	                      $p_file_list, $p_remove_path)

    1781. 

  1781.     {

    1782. 

  1782.     $v_result=true;

    1783. 

  1783.     $v_nb = 0;

    1784. 

  1784.     $v_extract_all = true;

    1785. 

  1785.     $v_listing = false;

    1786. 

  1786. 

    1787. 

  1787.     $p_path = $this->_translateWinPath($p_path, false);

    1788. 

  1788.     if ($p_path == '' || (substr($p_path, 0, 1) != '/'

    1789. 

  1789. 	    && substr($p_path, 0, 3) != "../" && !strpos($p_path, ':'))) {

    1790. 

  1790.       $p_path = "./".$p_path;

    1791. 

  1791.     }

    1792. 

  1792.     $p_remove_path = $this->_translateWinPath($p_remove_path);

    1793. 

  1793. 

    1794. 

  1794.     // ----- Look for path to remove format (should end by /)

    1795. 

  1795.     if (($p_remove_path != '') && (substr($p_remove_path, -1) != '/'))

    1796. 

  1796.       $p_remove_path .= '/';

    1797. 

  1797.     $p_remove_path_size = strlen($p_remove_path);

    1798. 

  1798. 

    1799. 

  1799.     switch ($p_mode) {

    1800. 

  1800.       case "complete" :

    1801. 

  1801.         $v_extract_all = TRUE;

    1802. 

  1802.         $v_listing = FALSE;

    1803. 

  1803.       break;

    1804. 

  1804.       case "partial" :

    1805. 

  1805.           $v_extract_all = FALSE;

    1806. 

  1806.           $v_listing = FALSE;

    1807. 

  1807.       break;

    1808. 

  1808.       case "list" :

    1809. 

  1809.           $v_extract_all = FALSE;

    1810. 

  1810.           $v_listing = TRUE;

    1811. 

  1811.       break;

    1812. 

  1812.       default :

    1813. 

  1813.         $this->_error('Invalid extract mode ('.$p_mode.')');

    1814. 

  1814.         return false;

    1815. 

  1815.     }

    1816. 

  1816. 

    1817. 

  1817.     clearstatcache();

    1818. 

  1818. 

    1819. 

  1819.     while (strlen($v_binary_data = $this->_readBlock()) != 0)

    1820. 

  1820.     {

    1821. 

  1821.       $v_extract_file = FALSE;

    1822. 

  1822.       $v_extraction_stopped = 0;

    1823. 

  1823. 

    1824. 

  1824.       if (!$this->_readHeader($v_binary_data, $v_header))

    1825. 

  1825.         return false;

    1826. 

  1826. 

    1827. 

  1827.       if ($v_header['filename'] == '') {

    1828. 

  1828.         continue;

    1829. 

  1829.       }

    1830. 

  1830. 

    1831. 

  1831.       // ----- Look for long filename

    1832. 

  1832.       if ($v_header['typeflag'] == 'L') {

    1833. 

  1833.         if (!$this->_readLongHeader($v_header))

    1834. 

  1834.           return false;

    1835. 

  1835.       }

    1836. 

  1836. 

    1837. 

  1837.       if ((!$v_extract_all) && (is_array($p_file_list))) {

    1838. 

  1838.         // ----- By default no unzip if the file is not found

    1839. 

  1839.         $v_extract_file = false;

    1840. 

  1840. 

    1841. 

  1841.         for ($i=0; $i<sizeof($p_file_list); $i++) {

    1842. 

  1842.           // ----- Look if it is a directory

    1843. 

  1843.           if (substr($p_file_list[$i], -1) == '/') {

    1844. 

  1844.             // ----- Look if the directory is in the filename path

    1845. 

  1845.             if ((strlen($v_header['filename']) > strlen($p_file_list[$i]))

    1846. 

  1846. 			    && (substr($v_header['filename'], 0, strlen($p_file_list[$i]))

    1847. 

  1847. 				    == $p_file_list[$i])) {

    1848. 

  1848.               $v_extract_file = TRUE;

    1849. 

  1849.               break;

    1850. 

  1850.             }

    1851. 

  1851.           }

    1852. 

  1852. 

    1853. 

  1853.           // ----- It is a file, so compare the file names

    1854. 

  1854.           elseif ($p_file_list[$i] == $v_header['filename']) {

    1855. 

  1855.             $v_extract_file = TRUE;

    1856. 

  1856.             break;

    1857. 

  1857.           }

    1858. 

  1858.         }

    1859. 

  1859.       } else {

    1860. 

  1860.         $v_extract_file = TRUE;

    1861. 

  1861.       }

    1862. 

  1862. 

    1863. 

  1863.       // ----- Look if this file need to be extracted

    1864. 

  1864.       if (($v_extract_file) && (!$v_listing))

    1865. 

  1865.       {

    1866. 

  1866.         if (($p_remove_path != '')

    1867. 

  1867.             && (substr($v_header['filename'], 0, $p_remove_path_size)

    1868. 

  1868. 			    == $p_remove_path))

    1869. 

  1869.           $v_header['filename'] = substr($v_header['filename'],

    1870. 

  1870. 		                                 $p_remove_path_size);

    1871. 

  1871.         if (($p_path != './') && ($p_path != '/')) {

    1872. 

  1872.           while (substr($p_path, -1) == '/')

    1873. 

  1873.             $p_path = substr($p_path, 0, strlen($p_path)-1);

    1874. 

  1874. 

    1875. 

  1875.           if (substr($v_header['filename'], 0, 1) == '/')

    1876. 

  1876.               $v_header['filename'] = $p_path.$v_header['filename'];

    1877. 

  1877.           else

    1878. 

  1878.             $v_header['filename'] = $p_path.'/'.$v_header['filename'];

    1879. 

  1879.         }

    1880. 

  1880.         if (file_exists($v_header['filename'])) {

    1881. 

  1881.           if (   (@is_dir($v_header['filename']))

    1882. 

  1882. 		      && ($v_header['typeflag'] == '')) {

    1883. 

  1883.             $this->_error('File '.$v_header['filename']

    1884. 

  1884. 			              .' already exists as a directory');

    1885. 

  1885.             return false;

    1886. 

  1886.           }

    1887. 

  1887.           if (   ($this->_isArchive($v_header['filename']))

    1888. 

  1888. 		      && ($v_header['typeflag'] == "5")) {

    1889. 

  1889.             $this->_error('Directory '.$v_header['filename']

    1890. 

  1890. 			              .' already exists as a file');

    1891. 

  1891.             return false;

    1892. 

  1892.           }

    1893. 

  1893.           if (!is_writeable($v_header['filename'])) {

    1894. 

  1894.             $this->_error('File '.$v_header['filename']

    1895. 

  1895. 			              .' already exists and is write protected');

    1896. 

  1896.             return false;

    1897. 

  1897.           }

    1898. 

  1898.           if (filemtime($v_header['filename']) > $v_header['mtime']) {

    1899. 

  1899.             // To be completed : An error or silent no replace ?

    1900. 

  1900.           }

    1901. 

  1901.         }

    1902. 

  1902. 

    1903. 

  1903.         // ----- Check the directory availability and create it if necessary

    1904. 

  1904.         elseif (($v_result

    1905. 

  1905. 		         = $this->_dirCheck(($v_header['typeflag'] == "5"

    1906. 

  1906. 				                    ?$v_header['filename']

    1907. 

  1907. 									:dirname($v_header['filename'])))) != 1) {

    1908. 

  1908.             $this->_error('Unable to create path for '.$v_header['filename']);

    1909. 

  1909.             return false;

    1910. 

  1910.         }

    1911. 

  1911. 

    1912. 

  1912.         if ($v_extract_file) {

    1913. 

  1913.           if ($v_header['typeflag'] == "5") {

    1914. 

  1914.             if (!@file_exists($v_header['filename'])) {

    1915. 

  1915.                 if (!@mkdir($v_header['filename'], 0777)) {

    1916. 

  1916.                     $this->_error('Unable to create directory {'

    1917. 

  1917. 					              .$v_header['filename'].'}');

    1918. 

  1918.                     return false;

    1919. 

  1919.                 }

    1920. 

  1920.             }

    1921. 

  1921.           } elseif ($v_header['typeflag'] == "2") {

    1922. 

  1922.               if (@file_exists($v_header['filename'])) {

    1923. 

  1923.                   @unlink($v_header['filename']);

    1924. 

  1924.               }

    1925. 

  1925.               if (!@symlink($v_header['link'], $v_header['filename'])) {

    1926. 

  1926.                   $this->_error('Unable to extract symbolic link {'

    1927. 

  1927.                                 .$v_header['filename'].'}');

    1928. 

  1928.                   return false;

    1929. 

  1929.               }

    1930. 

  1930.           } else {

    1931. 

  1931.               if (($v_dest_file = @fopen($v_header['filename'], "wb")) == 0) {

    1932. 

  1932.                   $this->_error('Error while opening {'.$v_header['filename']

    1933. 

  1933. 				                .'} in write binary mode');

    1934. 

  1934.                   return false;

    1935. 

  1935.               } else {

    1936. 

  1936.                   $n = floor($v_header['size']/512);

    1937. 

  1937.                   for ($i=0; $i<$n; $i++) {

    1938. 

  1938.                       $v_content = $this->_readBlock();

    1939. 

  1939.                       fwrite($v_dest_file, $v_content, 512);

    1940. 

  1940.                   }

    1941. 

  1941.             if (($v_header['size'] % 512) != 0) {

    1942. 

  1942.               $v_content = $this->_readBlock();

    1943. 

  1943.               fwrite($v_dest_file, $v_content, ($v_header['size'] % 512));

    1944. 

  1944.             }

    1945. 

  1945. 

    1946. 

  1946.             @fclose($v_dest_file);

    1947. 

  1947. 

    1948. 

  1948.             // ----- Change the file mode, mtime

    1949. 

  1949.             @touch($v_header['filename'], $v_header['mtime']);

    1950. 

  1950.             if ($v_header['mode'] & 0111) {

    1951. 

  1951.                 // make file executable, obey umask

    1952. 

  1952.                 $mode = fileperms($v_header['filename']) | (~umask() & 0111);

    1953. 

  1953.                 @chmod($v_header['filename'], $mode);

    1954. 

  1954.             }

    1955. 

  1955.           }

    1956. 

  1956. 

    1957. 

  1957.           // ----- Check the file size

    1958. 

  1958.           clearstatcache();

    1959. 

  1959.           if (filesize($v_header['filename']) != $v_header['size']) {

    1960. 

  1960.               $this->_error('Extracted file '.$v_header['filename']

    1961. 

  1961. 			                .' does not have the correct file size \''

    1962. 

  1962. 							.filesize($v_header['filename'])

    1963. 

  1963. 							.'\' ('.$v_header['size']

    1964. 

  1964. 							.' expected). Archive may be corrupted.');

    1965. 

  1965.               return false;

    1966. 

  1966.           }

    1967. 

  1967.           }

    1968. 

  1968.         } else {

    1969. 

  1969.           $this->_jumpBlock(ceil(($v_header['size']/512)));

    1970. 

  1970.         }

    1971. 

  1971.       } else {

    1972. 

  1972.           $this->_jumpBlock(ceil(($v_header['size']/512)));

    1973. 

  1973.       }

    1974. 

  1974. 

    1975. 

  1975.       /* TBC : Seems to be unused ...

    1976. 

  1976.       if ($this->_compress)

    1977. 

  1977.         $v_end_of_file = @gzeof($this->_file);

    1978. 

  1978.       else

    1979. 

  1979.         $v_end_of_file = @feof($this->_file);

    1980. 

  1980.         */

    1981. 

  1981. 

    1982. 

  1982.       if ($v_listing || $v_extract_file || $v_extraction_stopped) {

    1983. 

  1983.         // ----- Log extracted files

    1984. 

  1984.         if (($v_file_dir = dirname($v_header['filename']))

    1985. 

  1985. 		    == $v_header['filename'])

    1986. 

  1986.           $v_file_dir = '';

    1987. 

  1987.         if ((substr($v_header['filename'], 0, 1) == '/') && ($v_file_dir == ''))

    1988. 

  1988.           $v_file_dir = '/';

    1989. 

  1989. 

    1990. 

  1990.         $p_list_detail[$v_nb++] = $v_header;

    1991. 

  1991.         if (is_array($p_file_list) && (count($p_list_detail) == count($p_file_list))) {

    1992. 

  1992.             return true;

    1993. 

  1993.         }

    1994. 

  1994.       }

    1995. 

  1995.     }

    1996. 

  1996. 

    1997. 

  1997.         return true;

    1998. 

  1998.     }

    1999. 

  1999.     // }}}

    2000. 

  2000. 

    2001. 

  2001.     /**

    2002. 

  2002. 	 * Open a file in appen mode

    2003. 

  2003. 	 *

    2004. 

  2004. 	 * @return boolean true on success

    2005. 

  2005. 	 */

    2006. 

  2006.     function _openAppend()

    2007. 

  2007.     {

    2008. 

  2008.         if (filesize($this->_tarname) == 0)

    2009. 

  2009.           return $this->_openWrite();

    2010. 

  2010. 

    2011. 

  2011.         if ($this->_compress) {

    2012. 

  2012.             $this->_close();

    2013. 

  2013. 

    2014. 

  2014.             if (!@rename($this->_tarname, $this->_tarname.".tmp")) {

    2015. 

  2015.                 $this->_error('Error while renaming \''.$this->_tarname

    2016. 

  2016. 				              .'\' to temporary file \''.$this->_tarname

    2017. 

  2017. 							  .'.tmp\'');

    2018. 

  2018.                 return false;

    2019. 

  2019.             }

    2020. 

  2020. 

    2021. 

  2021.             if ($this->_compress_type == 'gz')

    2022. 

  2022.                 $v_temp_tar = @gzopen($this->_tarname.".tmp", "rb");

    2023. 

  2023.             elseif ($this->_compress_type == 'bz2')

    2024. 

  2024.                 $v_temp_tar = @bzopen($this->_tarname.".tmp", "r");

    2025. 

  2025. 

    2026. 

  2026.             if ($v_temp_tar == 0) {

    2027. 

  2027.                 $this->_error('Unable to open file \''.$this->_tarname

    2028. 

  2028. 				              .'.tmp\' in binary read mode');

    2029. 

  2029.                 @rename($this->_tarname.".tmp", $this->_tarname);

    2030. 

  2030.                 return false;

    2031. 

  2031.             }

    2032. 

  2032. 

    2033. 

  2033.             if (!$this->_openWrite()) {

    2034. 

  2034.                 @rename($this->_tarname.".tmp", $this->_tarname);

    2035. 

  2035.                 return false;

    2036. 

  2036.             }

    2037. 

  2037. 

    2038. 

  2038.             if ($this->_compress_type == 'gz') {

    2039. 

  2039.                 while (!@gzeof($v_temp_tar)) {

    2040. 

  2040.                     $v_buffer = @gzread($v_temp_tar, 512);

    2041. 

  2041.                     if ($v_buffer == ARCHIVE_TAR_END_BLOCK) {

    2042. 

  2042.                         // do not copy end blocks, we will re-make them

    2043. 

  2043.                         // after appending

    2044. 

  2044.                         continue;

    2045. 

  2045.                     }

    2046. 

  2046.                     $v_binary_data = pack("a512", $v_buffer);

    2047. 

  2047.                     $this->_writeBlock($v_binary_data);

    2048. 

  2048.                 }

    2049. 

  2049. 

    2050. 

  2050.                 @gzclose($v_temp_tar);

    2051. 

  2051.             }

    2052. 

  2052.             elseif ($this->_compress_type == 'bz2') {

    2053. 

  2053.                 while (strlen($v_buffer = @bzread($v_temp_tar, 512)) > 0) {

    2054. 

  2054.                     if ($v_buffer == ARCHIVE_TAR_END_BLOCK) {

    2055. 

  2055.                         continue;

    2056. 

  2056.                     }

    2057. 

  2057.                     $v_binary_data = pack("a512", $v_buffer);

    2058. 

  2058.                     $this->_writeBlock($v_binary_data);

    2059. 

  2059.                 }

    2060. 

  2060. 

    2061. 

  2061.                 @bzclose($v_temp_tar);

    2062. 

  2062.             }

    2063. 

  2063. 

    2064. 

  2064.             if (!@unlink($this->_tarname.".tmp")) {

    2065. 

  2065.                 $this->_error('Error while deleting temporary file \''

    2066. 

  2066. 				              .$this->_tarname.'.tmp\'');

    2067. 

  2067.             }

    2068. 

  2068. 

    2069. 

  2069.         } else {

    2070. 

  2070.             // ----- For not compressed tar, just add files before the last

    2071. 

  2071. 			//       one or two 512 bytes block

    2072. 

  2072.             if (!$this->_openReadWrite())

    2073. 

  2073.                return false;

    2074. 

  2074. 

    2075. 

  2075.             clearstatcache();

    2076. 

  2076.             $v_size = filesize($this->_tarname);

    2077. 

  2077. 

    2078. 

  2078.             // We might have zero, one or two end blocks.

    2079. 

  2079.             // The standard is two, but we should try to handle

    2080. 

  2080.             // other cases.

    2081. 

  2081.             fseek($this->_file, $v_size - 1024);

    2082. 

  2082.             if (fread($this->_file, 512) == ARCHIVE_TAR_END_BLOCK) {

    2083. 

  2083.                 fseek($this->_file, $v_size - 1024);

    2084. 

  2084.             }

    2085. 

  2085.             elseif (fread($this->_file, 512) == ARCHIVE_TAR_END_BLOCK) {

    2086. 

  2086.                 fseek($this->_file, $v_size - 512);

    2087. 

  2087.             }

    2088. 

  2088.         }

    2089. 

  2089. 

    2090. 

  2090.         return true;

    2091. 

  2091.     }

    2092. 

  2092.     // }}}

    2093. 

  2093. 

    2094. 

  2094.     /**

    2095. 

  2095. 	 * Append data to a file

    2096. 

  2096. 	 *

    2097. 

  2097. 	 * @param array $p_filelist The list of files

    2098. 

  2098. 	 * @param string $p_add_dir The dir to add the files to

    2099. 

  2099. 	 * @param string $p_remove_dir THe remove dir

    2100. 

  2100. 	 */

    2101. 

  2101.     function _append($p_filelist, $p_add_dir='', $p_remove_dir='')

    2102. 

  2102.     {

    2103. 

  2103.         if (!$this->_openAppend())

    2104. 

  2104.             return false;

    2105. 

  2105. 

    2106. 

  2106.         if ($this->_addList($p_filelist, $p_add_dir, $p_remove_dir))

    2107. 

  2107.            $this->_writeFooter();

    2108. 

  2108. 

    2109. 

  2109.         $this->_close();

    2110. 

  2110. 

    2111. 

  2111.         return true;

    2112. 

  2112.     }

    2113. 

  2113.     // }}}

    2114. 

  2114. 

    2115. 

  2115.     // {{{ _dirCheck()

    2116. 

  2116. 

    2117. 

  2117.     /**

    2118. 

  2118.      * Check if a directory exists and create it (including parent

    2119. 

  2119.      * dirs) if not.

    2120. 

  2120.      *

    2121. 

  2121.      * @param string $p_dir directory to check

    2122. 

  2122.      *

    2123. 

  2123.      * @return boolean TRUE if the directory exists or was created

    2124. 

  2124.      */

    2125. 

  2125.     function _dirCheck($p_dir)

    2126. 

  2126.     {

    2127. 

  2127.         clearstatcache();

    2128. 

  2128.         if ((@is_dir($p_dir)) || ($p_dir == ''))

    2129. 

  2129.             return true;

    2130. 

  2130. 

    2131. 

  2131.         $p_parent_dir = dirname($p_dir);

    2132. 

  2132. 

    2133. 

  2133.         if (($p_parent_dir != $p_dir) &&

    2134. 

  2134.             ($p_parent_dir != '') &&

    2135. 

  2135.             (!$this->_dirCheck($p_parent_dir)))

    2136. 

  2136.              return false;

    2137. 

  2137. 

    2138. 

  2138.         if (!@mkdir($p_dir, 0777)) {

    2139. 

  2139.             $this->_error("Unable to create directory '$p_dir'");

    2140. 

  2140.             return false;

    2141. 

  2141.         }

    2142. 

  2142. 

    2143. 

  2143.         return true;

    2144. 

  2144.     }

    2145. 

  2145. 

    2146. 

  2146.     // }}}

    2147. 

  2147. 

    2148. 

  2148.     // {{{ _pathReduction()

    2149. 

  2149. 

    2150. 

  2150.     /**

    2151. 

  2151.      * Compress path by changing for example "/dir/foo/../bar" to "/dir/bar",

    2152. 

  2152.      * rand emove double slashes.

    2153. 

  2153.      *

    2154. 

  2154.      * @param string $p_dir path to reduce

    2155. 

  2155.      *

    2156. 

  2156.      * @return string reduced path

    2157. 

  2157.      *

    2158. 

  2158.      */

    2159. 

  2159.     function _pathReduction($p_dir)

    2160. 

  2160.     {

    2161. 

  2161.         $v_result = '';

    2162. 

  2162. 

    2163. 

  2163.         // ----- Look for not empty path

    2164. 

  2164.         if ($p_dir != '') {

    2165. 

  2165.             // ----- Explode path by directory names

    2166. 

  2166.             $v_list = explode('/', $p_dir);

    2167. 

  2167. 

    2168. 

  2168.             // ----- Study directories from last to first

    2169. 

  2169.             for ($i=sizeof($v_list)-1; $i>=0; $i--) {

    2170. 

  2170.                 // ----- Look for current path

    2171. 

  2171.                 if ($v_list[$i] == ".") {

    2172. 

  2172.                     // ----- Ignore this directory

    2173. 

  2173.                     // Should be the first $i=0, but no check is done

    2174. 

  2174.                 }

    2175. 

  2175.                 else if ($v_list[$i] == "..") {

    2176. 

  2176.                     // ----- Ignore it and ignore the $i-1

    2177. 

  2177.                     $i--;

    2178. 

  2178.                 }

    2179. 

  2179.                 else if (   ($v_list[$i] == '')

    2180. 

  2180. 				         && ($i!=(sizeof($v_list)-1))

    2181. 

  2181. 						 && ($i!=0)) {

    2182. 

  2182.                     // ----- Ignore only the double '//' in path,

    2183. 

  2183.                     // but not the first and last /

    2184. 

  2184.                 } else {

    2185. 

  2185.                     $v_result = $v_list[$i].($i!=(sizeof($v_list)-1)?'/'

    2186. 

  2186. 					            .$v_result:'');

    2187. 

  2187.                 }

    2188. 

  2188.             }

    2189. 

  2189.         }

    2190. 

  2190.         $v_result = strtr($v_result, '\\', '/');

    2191. 

  2191.         return $v_result;

    2192. 

  2192.     }

    2193. 

  2193. 

    2194. 

  2194.     // }}}

    2195. 

  2195. 

    2196. 

  2196.     /**

    2197. 

  2197. 	 * translate a windows style path

    2198. 

  2198. 	 *

    2199. 

  2199. 	 * @param string $p_path The path

    2200. 

  2200. 	 * @param boolean $p_remove_disk_letter If we have to remove the disk letter

    2201. 

  2201. 	 */

    2202. 

  2202.     function _translateWinPath($p_path, $p_remove_disk_letter=true)

    2203. 

  2203.     {

    2204. 

  2204.       if (defined('OS_WINDOWS') && OS_WINDOWS) {

    2205. 

  2205.           // ----- Look for potential disk letter

    2206. 

  2206.           if (   ($p_remove_disk_letter)

    2207. 

  2207. 		      && (($v_position = strpos($p_path, ':')) != false)) {

    2208. 

  2208.               $p_path = substr($p_path, $v_position+1);

    2209. 

  2209.           }

    2210. 

  2210.           // ----- Change potential windows directory separator

    2211. 

  2211.           if ((strpos($p_path, '\\') > 0) || (substr($p_path, 0,1) == '\\')) {

    2212. 

  2212.               $p_path = strtr($p_path, '\\', '/');

    2213. 

  2213.           }

    2214. 

  2214.       }

    2215. 

  2215.       return $p_path;

    2216. 

  2216.     }

    2217. 

  2217.     // }}}

    2218. 

  2218. 

    2219. 

  2219. }

    2220. 

  2220.