PageRenderTime 68ms CodeModel.GetById 25ms RepoModel.GetById 0ms app.codeStats 0ms

/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

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

    

  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.         w…
    1564.

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