Peter M. Groen / knowledgetree

Commit 7d6b4102adb81a99d735c27c4cf3a53acc08c287

Authored by Paul Barrett 2009-11-25 16:25:12 +0200

CRLF replaced by LF in thirdparty/peclzip/pclzip.lib.php.

Committed by: Paul Barrett

Inline Side-by-side

Showing 1 changed file with 5694 additions and 5694 deletions

thirdparty/peclzip/pclzip.lib.php

View file @7d6b410

1	-<?php
2	-// --------------------------------------------------------------------------------
3	-// PhpConcept Library - Zip Module 2.8.2
4	-// --------------------------------------------------------------------------------
5	-// License GNU/LGPL - Vincent Blavet - August 2009
6	-// http://www.phpconcept.net
7	-// --------------------------------------------------------------------------------
8	-//
9	-// Presentation :
10	-// PclZip is a PHP library that manage ZIP archives.
11	-// So far tests show that archives generated by PclZip are readable by
12	-// WinZip application and other tools.
13	-//
14	-// Description :
15	-// See readme.txt and http://www.phpconcept.net
16	-//
17	-// Warning :
18	-// This library and the associated files are non commercial, non professional
19	-// work.
20	-// It should not have unexpected results. However if any damage is caused by
21	-// this software the author can not be responsible.
22	-// The use of this software is at the risk of the user.
23	-//
24	-// --------------------------------------------------------------------------------
25	-// $Id: pclzip.lib.php,v 1.60 2009/09/30 21:01:04 vblavet Exp $
26	-// --------------------------------------------------------------------------------
27	-
28	- // ----- Constants
29	- if (!defined('PCLZIP_READ_BLOCK_SIZE')) {
30	- define( 'PCLZIP_READ_BLOCK_SIZE', 2048 );
31	- }
32	-
33	- // ----- File list separator
34	- // In version 1.x of PclZip, the separator for file list is a space
35	- // (which is not a very smart choice, specifically for windows paths !).
36	- // A better separator should be a comma (,). This constant gives you the
37	- // abilty to change that.
38	- // However notice that changing this value, may have impact on existing
39	- // scripts, using space separated filenames.
40	- // Recommanded values for compatibility with older versions :
41	- //define( 'PCLZIP_SEPARATOR', ' ' );
42	- // Recommanded values for smart separation of filenames.
43	- if (!defined('PCLZIP_SEPARATOR')) {
44	- define( 'PCLZIP_SEPARATOR', ',' );
45	- }
46	-
47	- // ----- Error configuration
48	- // 0 : PclZip Class integrated error handling
49	- // 1 : PclError external library error handling. By enabling this
50	- // you must ensure that you have included PclError library.
51	- // [2,...] : reserved for futur use
52	- if (!defined('PCLZIP_ERROR_EXTERNAL')) {
53	- define( 'PCLZIP_ERROR_EXTERNAL', 0 );
54	- }
55	-
56	- // ----- Optional static temporary directory
57	- // By default temporary files are generated in the script current
58	- // path.
59	- // If defined :
60	- // - MUST BE terminated by a '/'.
61	- // - MUST be a valid, already created directory
62	- // Samples :
63	- // define( 'PCLZIP_TEMPORARY_DIR', '/temp/' );
64	- // define( 'PCLZIP_TEMPORARY_DIR', 'C:/Temp/' );
65	- if (!defined('PCLZIP_TEMPORARY_DIR')) {
66	- define( 'PCLZIP_TEMPORARY_DIR', '' );
67	- }
68	-
69	- // ----- Optional threshold ratio for use of temporary files
70	- // Pclzip sense the size of the file to add/extract and decide to
71	- // use or not temporary file. The algorythm is looking for
72	- // memory_limit of PHP and apply a ratio.
73	- // threshold = memory_limit * ratio.
74	- // Recommended values are under 0.5. Default 0.47.
75	- // Samples :
76	- // define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.5 );
77	- if (!defined('PCLZIP_TEMPORARY_FILE_RATIO')) {
78	- define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.47 );
79	- }
80	-
81	-// --------------------------------------------------------------------------------
82	-// *** UNDER THIS LINE NOTHING NEEDS TO BE MODIFIED ***
83	-// --------------------------------------------------------------------------------
84	-
85	- // ----- Global variables
86	- $g_pclzip_version = "2.8.2";
87	-
88	- // ----- Error codes
89	- // -1 : Unable to open file in binary write mode
90	- // -2 : Unable to open file in binary read mode
91	- // -3 : Invalid parameters
92	- // -4 : File does not exist
93	- // -5 : Filename is too long (max. 255)
94	- // -6 : Not a valid zip file
95	- // -7 : Invalid extracted file size
96	- // -8 : Unable to create directory
97	- // -9 : Invalid archive extension
98	- // -10 : Invalid archive format
99	- // -11 : Unable to delete file (unlink)
100	- // -12 : Unable to rename file (rename)
101	- // -13 : Invalid header checksum
102	- // -14 : Invalid archive size
103	- define( 'PCLZIP_ERR_USER_ABORTED', 2 );
104	- define( 'PCLZIP_ERR_NO_ERROR', 0 );
105	- define( 'PCLZIP_ERR_WRITE_OPEN_FAIL', -1 );
106	- define( 'PCLZIP_ERR_READ_OPEN_FAIL', -2 );
107	- define( 'PCLZIP_ERR_INVALID_PARAMETER', -3 );
108	- define( 'PCLZIP_ERR_MISSING_FILE', -4 );
109	- define( 'PCLZIP_ERR_FILENAME_TOO_LONG', -5 );
110	- define( 'PCLZIP_ERR_INVALID_ZIP', -6 );
111	- define( 'PCLZIP_ERR_BAD_EXTRACTED_FILE', -7 );
112	- define( 'PCLZIP_ERR_DIR_CREATE_FAIL', -8 );
113	- define( 'PCLZIP_ERR_BAD_EXTENSION', -9 );
114	- define( 'PCLZIP_ERR_BAD_FORMAT', -10 );
115	- define( 'PCLZIP_ERR_DELETE_FILE_FAIL', -11 );
116	- define( 'PCLZIP_ERR_RENAME_FILE_FAIL', -12 );
117	- define( 'PCLZIP_ERR_BAD_CHECKSUM', -13 );
118	- define( 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP', -14 );
119	- define( 'PCLZIP_ERR_MISSING_OPTION_VALUE', -15 );
120	- define( 'PCLZIP_ERR_INVALID_OPTION_VALUE', -16 );
121	- define( 'PCLZIP_ERR_ALREADY_A_DIRECTORY', -17 );
122	- define( 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION', -18 );
123	- define( 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION', -19 );
124	- define( 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE', -20 );
125	- define( 'PCLZIP_ERR_DIRECTORY_RESTRICTION', -21 );
126	-
127	- // ----- Options values
128	- define( 'PCLZIP_OPT_PATH', 77001 );
129	- define( 'PCLZIP_OPT_ADD_PATH', 77002 );
130	- define( 'PCLZIP_OPT_REMOVE_PATH', 77003 );
131	- define( 'PCLZIP_OPT_REMOVE_ALL_PATH', 77004 );
132	- define( 'PCLZIP_OPT_SET_CHMOD', 77005 );
133	- define( 'PCLZIP_OPT_EXTRACT_AS_STRING', 77006 );
134	- define( 'PCLZIP_OPT_NO_COMPRESSION', 77007 );
135	- define( 'PCLZIP_OPT_BY_NAME', 77008 );
136	- define( 'PCLZIP_OPT_BY_INDEX', 77009 );
137	- define( 'PCLZIP_OPT_BY_EREG', 77010 );
138	- define( 'PCLZIP_OPT_BY_PREG', 77011 );
139	- define( 'PCLZIP_OPT_COMMENT', 77012 );
140	- define( 'PCLZIP_OPT_ADD_COMMENT', 77013 );
141	- define( 'PCLZIP_OPT_PREPEND_COMMENT', 77014 );
142	- define( 'PCLZIP_OPT_EXTRACT_IN_OUTPUT', 77015 );
143	- define( 'PCLZIP_OPT_REPLACE_NEWER', 77016 );
144	- define( 'PCLZIP_OPT_STOP_ON_ERROR', 77017 );
145	- // Having big trouble with crypt. Need to multiply 2 long int
146	- // which is not correctly supported by PHP ...
147	- //define( 'PCLZIP_OPT_CRYPT', 77018 );
148	- define( 'PCLZIP_OPT_EXTRACT_DIR_RESTRICTION', 77019 );
149	- define( 'PCLZIP_OPT_TEMP_FILE_THRESHOLD', 77020 );
150	- define( 'PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD', 77020 ); // alias
151	- define( 'PCLZIP_OPT_TEMP_FILE_ON', 77021 );
152	- define( 'PCLZIP_OPT_ADD_TEMP_FILE_ON', 77021 ); // alias
153	- define( 'PCLZIP_OPT_TEMP_FILE_OFF', 77022 );
154	- define( 'PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022 ); // alias
155	-
156	- // ----- File description attributes
157	- define( 'PCLZIP_ATT_FILE_NAME', 79001 );
158	- define( 'PCLZIP_ATT_FILE_NEW_SHORT_NAME', 79002 );
159	- define( 'PCLZIP_ATT_FILE_NEW_FULL_NAME', 79003 );
160	- define( 'PCLZIP_ATT_FILE_MTIME', 79004 );
161	- define( 'PCLZIP_ATT_FILE_CONTENT', 79005 );
162	- define( 'PCLZIP_ATT_FILE_COMMENT', 79006 );
163	-
164	- // ----- Call backs values
165	- define( 'PCLZIP_CB_PRE_EXTRACT', 78001 );
166	- define( 'PCLZIP_CB_POST_EXTRACT', 78002 );
167	- define( 'PCLZIP_CB_PRE_ADD', 78003 );
168	- define( 'PCLZIP_CB_POST_ADD', 78004 );
169	- /* For futur use
170	- define( 'PCLZIP_CB_PRE_LIST', 78005 );
171	- define( 'PCLZIP_CB_POST_LIST', 78006 );
172	- define( 'PCLZIP_CB_PRE_DELETE', 78007 );
173	- define( 'PCLZIP_CB_POST_DELETE', 78008 );
174	- */
175	-
176	- // --------------------------------------------------------------------------------
177	- // Class : PclZip
178	- // Description :
179	- // PclZip is the class that represent a Zip archive.
180	- // The public methods allow the manipulation of the archive.
181	- // Attributes :
182	- // Attributes must not be accessed directly.
183	- // Methods :
184	- // PclZip() : Object creator
185	- // create() : Creates the Zip archive
186	- // listContent() : List the content of the Zip archive
187	- // extract() : Extract the content of the archive
188	- // properties() : List the properties of the archive
189	- // --------------------------------------------------------------------------------
190	- class PclZip
191	- {
192	- // ----- Filename of the zip file
193	- var $zipname = '';
194	-
195	- // ----- File descriptor of the zip file
196	- var $zip_fd = 0;
197	-
198	- // ----- Internal error handling
199	- var $error_code = 1;
200	- var $error_string = '';
201	-
202	- // ----- Current status of the magic_quotes_runtime
203	- // This value store the php configuration for magic_quotes
204	- // The class can then disable the magic_quotes and reset it after
205	- var $magic_quotes_status;
206	-
207	- // --------------------------------------------------------------------------------
208	- // Function : PclZip()
209	- // Description :
210	- // Creates a PclZip object and set the name of the associated Zip archive
211	- // filename.
212	- // Note that no real action is taken, if the archive does not exist it is not
213	- // created. Use create() for that.
214	- // --------------------------------------------------------------------------------
215	- function PclZip($p_zipname)
216	- {
217	-
218	- // ----- Tests the zlib
219	- if (!function_exists('gzopen'))
220	- {
221	- die('Abort '.basename(__FILE__).' : Missing zlib extensions');
222	- }
223	-
224	- // ----- Set the attributes
225	- $this->zipname = $p_zipname;
226	- $this->zip_fd = 0;
227	- $this->magic_quotes_status = -1;
228	-
229	- // ----- Return
230	- return;
231	- }
232	- // --------------------------------------------------------------------------------
233	-
234	- // --------------------------------------------------------------------------------
235	- // Function :
236	- // create($p_filelist, $p_add_dir="", $p_remove_dir="")
237	- // create($p_filelist, $p_option, $p_option_value, ...)
238	- // Description :
239	- // This method supports two different synopsis. The first one is historical.
240	- // This method creates a Zip Archive. The Zip file is created in the
241	- // filesystem. The files and directories indicated in $p_filelist
242	- // are added in the archive. See the parameters description for the
243	- // supported format of $p_filelist.
244	- // When a directory is in the list, the directory and its content is added
245	- // in the archive.
246	- // In this synopsis, the function takes an optional variable list of
247	- // options. See bellow the supported options.
248	- // Parameters :
249	- // $p_filelist : An array containing file or directory names, or
250	- // a string containing one filename or one directory name, or
251	- // a string containing a list of filenames and/or directory
252	- // names separated by spaces.
253	- // $p_add_dir : A path to add before the real path of the archived file,
254	- // in order to have it memorized in the archive.
255	- // $p_remove_dir : A path to remove from the real path of the file to archive,
256	- // in order to have a shorter path memorized in the archive.
257	- // When $p_add_dir and $p_remove_dir are set, $p_remove_dir
258	- // is removed first, before $p_add_dir is added.
259	- // Options :
260	- // PCLZIP_OPT_ADD_PATH :
261	- // PCLZIP_OPT_REMOVE_PATH :
262	- // PCLZIP_OPT_REMOVE_ALL_PATH :
263	- // PCLZIP_OPT_COMMENT :
264	- // PCLZIP_CB_PRE_ADD :
265	- // PCLZIP_CB_POST_ADD :
266	- // Return Values :
267	- // 0 on failure,
268	- // The list of the added files, with a status of the add action.
269	- // (see PclZip::listContent() for list entry format)
270	- // --------------------------------------------------------------------------------
271	- function create($p_filelist)
272	- {
273	- $v_result=1;
274	-
275	- // ----- Reset the error handler
276	- $this->privErrorReset();
277	-
278	- // ----- Set default values
279	- $v_options = array();
280	- $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
281	-
282	- // ----- Look for variable options arguments
283	- $v_size = func_num_args();
284	-
285	- // ----- Look for arguments
286	- if ($v_size > 1) {
287	- // ----- Get the arguments
288	- $v_arg_list = func_get_args();
289	-
290	- // ----- Remove from the options list the first argument
291	- array_shift($v_arg_list);
292	- $v_size--;
293	-
294	- // ----- Look for first arg
295	- if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
296	-
297	- // ----- Parse the options
298	- $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
299	- array (PCLZIP_OPT_REMOVE_PATH => 'optional',
300	- PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
301	- PCLZIP_OPT_ADD_PATH => 'optional',
302	- PCLZIP_CB_PRE_ADD => 'optional',
303	- PCLZIP_CB_POST_ADD => 'optional',
304	- PCLZIP_OPT_NO_COMPRESSION => 'optional',
305	- PCLZIP_OPT_COMMENT => 'optional',
306	- PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
307	- PCLZIP_OPT_TEMP_FILE_ON => 'optional',
308	- PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
309	- //, PCLZIP_OPT_CRYPT => 'optional'
310	- ));
311	- if ($v_result != 1) {
312	- return 0;
313	- }
314	- }
315	-
316	- // ----- Look for 2 args
317	- // Here we need to support the first historic synopsis of the
318	- // method.
319	- else {
320	-
321	- // ----- Get the first argument
322	- $v_options[PCLZIP_OPT_ADD_PATH] = $v_arg_list[0];
323	-
324	- // ----- Look for the optional second argument
325	- if ($v_size == 2) {
326	- $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
327	- }
328	- else if ($v_size > 2) {
329	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
330	- "Invalid number / type of arguments");
331	- return 0;
332	- }
333	- }
334	- }
335	-
336	- // ----- Look for default option values
337	- $this->privOptionDefaultThreshold($v_options);
338	-
339	- // ----- Init
340	- $v_string_list = array();
341	- $v_att_list = array();
342	- $v_filedescr_list = array();
343	- $p_result_list = array();
344	-
345	- // ----- Look if the $p_filelist is really an array
346	- if (is_array($p_filelist)) {
347	-
348	- // ----- Look if the first element is also an array
349	- // This will mean that this is a file description entry
350	- if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
351	- $v_att_list = $p_filelist;
352	- }
353	-
354	- // ----- The list is a list of string names
355	- else {
356	- $v_string_list = $p_filelist;
357	- }
358	- }
359	-
360	- // ----- Look if the $p_filelist is a string
361	- else if (is_string($p_filelist)) {
362	- // ----- Create a list from the string
363	- $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
364	- }
365	-
366	- // ----- Invalid variable type for $p_filelist
367	- else {
368	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_filelist");
369	- return 0;
370	- }
371	-
372	- // ----- Reformat the string list
373	- if (sizeof($v_string_list) != 0) {
374	- foreach ($v_string_list as $v_string) {
375	- if ($v_string != '') {
376	- $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;
377	- }
378	- else {
379	- }
380	- }
381	- }
382	-
383	- // ----- For each file in the list check the attributes
384	- $v_supported_attributes
385	- = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
386	- ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
387	- ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
388	- ,PCLZIP_ATT_FILE_MTIME => 'optional'
389	- ,PCLZIP_ATT_FILE_CONTENT => 'optional'
390	- ,PCLZIP_ATT_FILE_COMMENT => 'optional'
391	- );
392	- foreach ($v_att_list as $v_entry) {
393	- $v_result = $this->privFileDescrParseAtt($v_entry,
394	- $v_filedescr_list[],
395	- $v_options,
396	- $v_supported_attributes);
397	- if ($v_result != 1) {
398	- return 0;
399	- }
400	- }
401	-
402	- // ----- Expand the filelist (expand directories)
403	- $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
404	- if ($v_result != 1) {
405	- return 0;
406	- }
407	-
408	- // ----- Call the create fct
409	- $v_result = $this->privCreate($v_filedescr_list, $p_result_list, $v_options);
410	- if ($v_result != 1) {
411	- return 0;
412	- }
413	-
414	- // ----- Return
415	- return $p_result_list;
416	- }
417	- // --------------------------------------------------------------------------------
418	-
419	- // --------------------------------------------------------------------------------
420	- // Function :
421	- // add($p_filelist, $p_add_dir="", $p_remove_dir="")
422	- // add($p_filelist, $p_option, $p_option_value, ...)
423	- // Description :
424	- // This method supports two synopsis. The first one is historical.
425	- // This methods add the list of files in an existing archive.
426	- // If a file with the same name already exists, it is added at the end of the
427	- // archive, the first one is still present.
428	- // If the archive does not exist, it is created.
429	- // Parameters :
430	- // $p_filelist : An array containing file or directory names, or
431	- // a string containing one filename or one directory name, or
432	- // a string containing a list of filenames and/or directory
433	- // names separated by spaces.
434	- // $p_add_dir : A path to add before the real path of the archived file,
435	- // in order to have it memorized in the archive.
436	- // $p_remove_dir : A path to remove from the real path of the file to archive,
437	- // in order to have a shorter path memorized in the archive.
438	- // When $p_add_dir and $p_remove_dir are set, $p_remove_dir
439	- // is removed first, before $p_add_dir is added.
440	- // Options :
441	- // PCLZIP_OPT_ADD_PATH :
442	- // PCLZIP_OPT_REMOVE_PATH :
443	- // PCLZIP_OPT_REMOVE_ALL_PATH :
444	- // PCLZIP_OPT_COMMENT :
445	- // PCLZIP_OPT_ADD_COMMENT :
446	- // PCLZIP_OPT_PREPEND_COMMENT :
447	- // PCLZIP_CB_PRE_ADD :
448	- // PCLZIP_CB_POST_ADD :
449	- // Return Values :
450	- // 0 on failure,
451	- // The list of the added files, with a status of the add action.
452	- // (see PclZip::listContent() for list entry format)
453	- // --------------------------------------------------------------------------------
454	- function add($p_filelist)
455	- {
456	- $v_result=1;
457	-
458	- // ----- Reset the error handler
459	- $this->privErrorReset();
460	-
461	- // ----- Set default values
462	- $v_options = array();
463	- $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
464	-
465	- // ----- Look for variable options arguments
466	- $v_size = func_num_args();
467	-
468	- // ----- Look for arguments
469	- if ($v_size > 1) {
470	- // ----- Get the arguments
471	- $v_arg_list = func_get_args();
472	-
473	- // ----- Remove form the options list the first argument
474	- array_shift($v_arg_list);
475	- $v_size--;
476	-
477	- // ----- Look for first arg
478	- if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
479	-
480	- // ----- Parse the options
481	- $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
482	- array (PCLZIP_OPT_REMOVE_PATH => 'optional',
483	- PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
484	- PCLZIP_OPT_ADD_PATH => 'optional',
485	- PCLZIP_CB_PRE_ADD => 'optional',
486	- PCLZIP_CB_POST_ADD => 'optional',
487	- PCLZIP_OPT_NO_COMPRESSION => 'optional',
488	- PCLZIP_OPT_COMMENT => 'optional',
489	- PCLZIP_OPT_ADD_COMMENT => 'optional',
490	- PCLZIP_OPT_PREPEND_COMMENT => 'optional',
491	- PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
492	- PCLZIP_OPT_TEMP_FILE_ON => 'optional',
493	- PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
494	- //, PCLZIP_OPT_CRYPT => 'optional'
495	- ));
496	- if ($v_result != 1) {
497	- return 0;
498	- }
499	- }
500	-
501	- // ----- Look for 2 args
502	- // Here we need to support the first historic synopsis of the
503	- // method.
504	- else {
505	-
506	- // ----- Get the first argument
507	- $v_options[PCLZIP_OPT_ADD_PATH] = $v_add_path = $v_arg_list[0];
508	-
509	- // ----- Look for the optional second argument
510	- if ($v_size == 2) {
511	- $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
512	- }
513	- else if ($v_size > 2) {
514	- // ----- Error log
515	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
516	-
517	- // ----- Return
518	- return 0;
519	- }
520	- }
521	- }
522	-
523	- // ----- Look for default option values
524	- $this->privOptionDefaultThreshold($v_options);
525	-
526	- // ----- Init
527	- $v_string_list = array();
528	- $v_att_list = array();
529	- $v_filedescr_list = array();
530	- $p_result_list = array();
531	-
532	- // ----- Look if the $p_filelist is really an array
533	- if (is_array($p_filelist)) {
534	-
535	- // ----- Look if the first element is also an array
536	- // This will mean that this is a file description entry
537	- if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
538	- $v_att_list = $p_filelist;
539	- }
540	-
541	- // ----- The list is a list of string names
542	- else {
543	- $v_string_list = $p_filelist;
544	- }
545	- }
546	-
547	- // ----- Look if the $p_filelist is a string
548	- else if (is_string($p_filelist)) {
549	- // ----- Create a list from the string
550	- $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
551	- }
552	-
553	- // ----- Invalid variable type for $p_filelist
554	- else {
555	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type '".gettype($p_filelist)."' for p_filelist");
556	- return 0;
557	- }
558	-
559	- // ----- Reformat the string list
560	- if (sizeof($v_string_list) != 0) {
561	- foreach ($v_string_list as $v_string) {
562	- $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;
563	- }
564	- }
565	-
566	- // ----- For each file in the list check the attributes
567	- $v_supported_attributes
568	- = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
569	- ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
570	- ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
571	- ,PCLZIP_ATT_FILE_MTIME => 'optional'
572	- ,PCLZIP_ATT_FILE_CONTENT => 'optional'
573	- ,PCLZIP_ATT_FILE_COMMENT => 'optional'
574	- );
575	- foreach ($v_att_list as $v_entry) {
576	- $v_result = $this->privFileDescrParseAtt($v_entry,
577	- $v_filedescr_list[],
578	- $v_options,
579	- $v_supported_attributes);
580	- if ($v_result != 1) {
581	- return 0;
582	- }
583	- }
584	-
585	- // ----- Expand the filelist (expand directories)
586	- $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
587	- if ($v_result != 1) {
588	- return 0;
589	- }
590	-
591	- // ----- Call the create fct
592	- $v_result = $this->privAdd($v_filedescr_list, $p_result_list, $v_options);
593	- if ($v_result != 1) {
594	- return 0;
595	- }
596	-
597	- // ----- Return
598	- return $p_result_list;
599	- }
600	- // --------------------------------------------------------------------------------
601	-
602	- // --------------------------------------------------------------------------------
603	- // Function : listContent()
604	- // Description :
605	- // This public method, gives the list of the files and directories, with their
606	- // properties.
607	- // The properties of each entries in the list are (used also in other functions) :
608	- // filename : Name of the file. For a create or add action it is the filename
609	- // given by the user. For an extract function it is the filename
610	- // of the extracted file.
611	- // stored_filename : Name of the file / directory stored in the archive.
612	- // size : Size of the stored file.
613	- // compressed_size : Size of the file's data compressed in the archive
614	- // (without the headers overhead)
615	- // mtime : Last known modification date of the file (UNIX timestamp)
616	- // comment : Comment associated with the file
617	- // folder : true \| false
618	- // index : index of the file in the archive
619	- // status : status of the action (depending of the action) :
620	- // Values are :
621	- // ok : OK !
622	- // filtered : the file / dir is not extracted (filtered by user)
623	- // already_a_directory : the file can not be extracted because a
624	- // directory with the same name already exists
625	- // write_protected : the file can not be extracted because a file
626	- // with the same name already exists and is
627	- // write protected
628	- // newer_exist : the file was not extracted because a newer file exists
629	- // path_creation_fail : the file is not extracted because the folder
630	- // does not exist and can not be created
631	- // write_error : the file was not extracted because there was a
632	- // error while writing the file
633	- // read_error : the file was not extracted because there was a error
634	- // while reading the file
635	- // invalid_header : the file was not extracted because of an archive
636	- // format error (bad file header)
637	- // Note that each time a method can continue operating when there
638	- // is an action error on a file, the error is only logged in the file status.
639	- // Return Values :
640	- // 0 on an unrecoverable failure,
641	- // The list of the files in the archive.
642	- // --------------------------------------------------------------------------------
643	- function listContent()
644	- {
645	- $v_result=1;
646	-
647	- // ----- Reset the error handler
648	- $this->privErrorReset();
649	-
650	- // ----- Check archive
651	- if (!$this->privCheckFormat()) {
652	- return(0);
653	- }
654	-
655	- // ----- Call the extracting fct
656	- $p_list = array();
657	- if (($v_result = $this->privList($p_list)) != 1)
658	- {
659	- unset($p_list);
660	- return(0);
661	- }
662	-
663	- // ----- Return
664	- return $p_list;
665	- }
666	- // --------------------------------------------------------------------------------
667	-
668	- // --------------------------------------------------------------------------------
669	- // Function :
670	- // extract($p_path="./", $p_remove_path="")
671	- // extract([$p_option, $p_option_value, ...])
672	- // Description :
673	- // This method supports two synopsis. The first one is historical.
674	- // This method extract all the files / directories from the archive to the
675	- // folder indicated in $p_path.
676	- // If you want to ignore the 'root' part of path of the memorized files
677	- // you can indicate this in the optional $p_remove_path parameter.
678	- // By default, if a newer file with the same name already exists, the
679	- // file is not extracted.
680	- //
681	- // If both PCLZIP_OPT_PATH and PCLZIP_OPT_ADD_PATH aoptions
682	- // are used, the path indicated in PCLZIP_OPT_ADD_PATH is append
683	- // at the end of the path value of PCLZIP_OPT_PATH.
684	- // Parameters :
685	- // $p_path : Path where the files and directories are to be extracted
686	- // $p_remove_path : First part ('root' part) of the memorized path
687	- // (if any similar) to remove while extracting.
688	- // Options :
689	- // PCLZIP_OPT_PATH :
690	- // PCLZIP_OPT_ADD_PATH :
691	- // PCLZIP_OPT_REMOVE_PATH :
692	- // PCLZIP_OPT_REMOVE_ALL_PATH :
693	- // PCLZIP_CB_PRE_EXTRACT :
694	- // PCLZIP_CB_POST_EXTRACT :
695	- // Return Values :
696	- // 0 or a negative value on failure,
697	- // The list of the extracted files, with a status of the action.
698	- // (see PclZip::listContent() for list entry format)
699	- // --------------------------------------------------------------------------------
700	- function extract()
701	- {
702	- $v_result=1;
703	-
704	- // ----- Reset the error handler
705	- $this->privErrorReset();
706	-
707	- // ----- Check archive
708	- if (!$this->privCheckFormat()) {
709	- return(0);
710	- }
711	-
712	- // ----- Set default values
713	- $v_options = array();
714	-// $v_path = "./";
715	- $v_path = '';
716	- $v_remove_path = "";
717	- $v_remove_all_path = false;
718	-
719	- // ----- Look for variable options arguments
720	- $v_size = func_num_args();
721	-
722	- // ----- Default values for option
723	- $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
724	-
725	- // ----- Look for arguments
726	- if ($v_size > 0) {
727	- // ----- Get the arguments
728	- $v_arg_list = func_get_args();
729	-
730	- // ----- Look for first arg
731	- if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
732	-
733	- // ----- Parse the options
734	- $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
735	- array (PCLZIP_OPT_PATH => 'optional',
736	- PCLZIP_OPT_REMOVE_PATH => 'optional',
737	- PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
738	- PCLZIP_OPT_ADD_PATH => 'optional',
739	- PCLZIP_CB_PRE_EXTRACT => 'optional',
740	- PCLZIP_CB_POST_EXTRACT => 'optional',
741	- PCLZIP_OPT_SET_CHMOD => 'optional',
742	- PCLZIP_OPT_BY_NAME => 'optional',
743	- PCLZIP_OPT_BY_EREG => 'optional',
744	- PCLZIP_OPT_BY_PREG => 'optional',
745	- PCLZIP_OPT_BY_INDEX => 'optional',
746	- PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
747	- PCLZIP_OPT_EXTRACT_IN_OUTPUT => 'optional',
748	- PCLZIP_OPT_REPLACE_NEWER => 'optional'
749	- ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
750	- ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
751	- PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
752	- PCLZIP_OPT_TEMP_FILE_ON => 'optional',
753	- PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
754	- ));
755	- if ($v_result != 1) {
756	- return 0;
757	- }
758	-
759	- // ----- Set the arguments
760	- if (isset($v_options[PCLZIP_OPT_PATH])) {
761	- $v_path = $v_options[PCLZIP_OPT_PATH];
762	- }
763	- if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {
764	- $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];
765	- }
766	- if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
767	- $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];
768	- }
769	- if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {
770	- // ----- Check for '/' in last path char
771	- if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {
772	- $v_path .= '/';
773	- }
774	- $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];
775	- }
776	- }
777	-
778	- // ----- Look for 2 args
779	- // Here we need to support the first historic synopsis of the
780	- // method.
781	- else {
782	-
783	- // ----- Get the first argument
784	- $v_path = $v_arg_list[0];
785	-
786	- // ----- Look for the optional second argument
787	- if ($v_size == 2) {
788	- $v_remove_path = $v_arg_list[1];
789	- }
790	- else if ($v_size > 2) {
791	- // ----- Error log
792	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
793	-
794	- // ----- Return
795	- return 0;
796	- }
797	- }
798	- }
799	-
800	- // ----- Look for default option values
801	- $this->privOptionDefaultThreshold($v_options);
802	-
803	- // ----- Trace
804	-
805	- // ----- Call the extracting fct
806	- $p_list = array();
807	- $v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path,
808	- $v_remove_all_path, $v_options);
809	- if ($v_result < 1) {
810	- unset($p_list);
811	- return(0);
812	- }
813	-
814	- // ----- Return
815	- return $p_list;
816	- }
817	- // --------------------------------------------------------------------------------
818	-
819	-
820	- // --------------------------------------------------------------------------------
821	- // Function :
822	- // extractByIndex($p_index, $p_path="./", $p_remove_path="")
823	- // extractByIndex($p_index, [$p_option, $p_option_value, ...])
824	- // Description :
825	- // This method supports two synopsis. The first one is historical.
826	- // This method is doing a partial extract of the archive.
827	- // The extracted files or folders are identified by their index in the
828	- // archive (from 0 to n).
829	- // Note that if the index identify a folder, only the folder entry is
830	- // extracted, not all the files included in the archive.
831	- // Parameters :
832	- // $p_index : A single index (integer) or a string of indexes of files to
833	- // extract. The form of the string is "0,4-6,8-12" with only numbers
834	- // and '-' for range or ',' to separate ranges. No spaces or ';'
835	- // are allowed.
836	- // $p_path : Path where the files and directories are to be extracted
837	- // $p_remove_path : First part ('root' part) of the memorized path
838	- // (if any similar) to remove while extracting.
839	- // Options :
840	- // PCLZIP_OPT_PATH :
841	- // PCLZIP_OPT_ADD_PATH :
842	- // PCLZIP_OPT_REMOVE_PATH :
843	- // PCLZIP_OPT_REMOVE_ALL_PATH :
844	- // PCLZIP_OPT_EXTRACT_AS_STRING : The files are extracted as strings and
845	- // not as files.
846	- // The resulting content is in a new field 'content' in the file
847	- // structure.
848	- // This option must be used alone (any other options are ignored).
849	- // PCLZIP_CB_PRE_EXTRACT :
850	- // PCLZIP_CB_POST_EXTRACT :
851	- // Return Values :
852	- // 0 on failure,
853	- // The list of the extracted files, with a status of the action.
854	- // (see PclZip::listContent() for list entry format)
855	- // --------------------------------------------------------------------------------
856	- //function extractByIndex($p_index, options...)
857	- function extractByIndex($p_index)
858	- {
859	- $v_result=1;
860	-
861	- // ----- Reset the error handler
862	- $this->privErrorReset();
863	-
864	- // ----- Check archive
865	- if (!$this->privCheckFormat()) {
866	- return(0);
867	- }
868	-
869	- // ----- Set default values
870	- $v_options = array();
871	-// $v_path = "./";
872	- $v_path = '';
873	- $v_remove_path = "";
874	- $v_remove_all_path = false;
875	-
876	- // ----- Look for variable options arguments
877	- $v_size = func_num_args();
878	-
879	- // ----- Default values for option
880	- $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
881	-
882	- // ----- Look for arguments
883	- if ($v_size > 1) {
884	- // ----- Get the arguments
885	- $v_arg_list = func_get_args();
886	-
887	- // ----- Remove form the options list the first argument
888	- array_shift($v_arg_list);
889	- $v_size--;
890	-
891	- // ----- Look for first arg
892	- if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
893	-
894	- // ----- Parse the options
895	- $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
896	- array (PCLZIP_OPT_PATH => 'optional',
897	- PCLZIP_OPT_REMOVE_PATH => 'optional',
898	- PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
899	- PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
900	- PCLZIP_OPT_ADD_PATH => 'optional',
901	- PCLZIP_CB_PRE_EXTRACT => 'optional',
902	- PCLZIP_CB_POST_EXTRACT => 'optional',
903	- PCLZIP_OPT_SET_CHMOD => 'optional',
904	- PCLZIP_OPT_REPLACE_NEWER => 'optional'
905	- ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
906	- ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
907	- PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
908	- PCLZIP_OPT_TEMP_FILE_ON => 'optional',
909	- PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
910	- ));
911	- if ($v_result != 1) {
912	- return 0;
913	- }
914	-
915	- // ----- Set the arguments
916	- if (isset($v_options[PCLZIP_OPT_PATH])) {
917	- $v_path = $v_options[PCLZIP_OPT_PATH];
918	- }
919	- if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {
920	- $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];
921	- }
922	- if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
923	- $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];
924	- }
925	- if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {
926	- // ----- Check for '/' in last path char
927	- if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {
928	- $v_path .= '/';
929	- }
930	- $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];
931	- }
932	- if (!isset($v_options[PCLZIP_OPT_EXTRACT_AS_STRING])) {
933	- $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
934	- }
935	- else {
936	- }
937	- }
938	-
939	- // ----- Look for 2 args
940	- // Here we need to support the first historic synopsis of the
941	- // method.
942	- else {
943	-
944	- // ----- Get the first argument
945	- $v_path = $v_arg_list[0];
946	-
947	- // ----- Look for the optional second argument
948	- if ($v_size == 2) {
949	- $v_remove_path = $v_arg_list[1];
950	- }
951	- else if ($v_size > 2) {
952	- // ----- Error log
953	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
954	-
955	- // ----- Return
956	- return 0;
957	- }
958	- }
959	- }
960	-
961	- // ----- Trace
962	-
963	- // ----- Trick
964	- // Here I want to reuse extractByRule(), so I need to parse the $p_index
965	- // with privParseOptions()
966	- $v_arg_trick = array (PCLZIP_OPT_BY_INDEX, $p_index);
967	- $v_options_trick = array();
968	- $v_result = $this->privParseOptions($v_arg_trick, sizeof($v_arg_trick), $v_options_trick,
969	- array (PCLZIP_OPT_BY_INDEX => 'optional' ));
970	- if ($v_result != 1) {
971	- return 0;
972	- }
973	- $v_options[PCLZIP_OPT_BY_INDEX] = $v_options_trick[PCLZIP_OPT_BY_INDEX];
974	-
975	- // ----- Look for default option values
976	- $this->privOptionDefaultThreshold($v_options);
977	-
978	- // ----- Call the extracting fct
979	- if (($v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path, $v_remove_all_path, $v_options)) < 1) {
980	- return(0);
981	- }
982	-
983	- // ----- Return
984	- return $p_list;
985	- }
986	- // --------------------------------------------------------------------------------
987	-
988	- // --------------------------------------------------------------------------------
989	- // Function :
990	- // delete([$p_option, $p_option_value, ...])
991	- // Description :
992	- // This method removes files from the archive.
993	- // If no parameters are given, then all the archive is emptied.
994	- // Parameters :
995	- // None or optional arguments.
996	- // Options :
997	- // PCLZIP_OPT_BY_INDEX :
998	- // PCLZIP_OPT_BY_NAME :
999	- // PCLZIP_OPT_BY_EREG :
1000	- // PCLZIP_OPT_BY_PREG :
1001	- // Return Values :
1002	- // 0 on failure,
1003	- // The list of the files which are still present in the archive.
1004	- // (see PclZip::listContent() for list entry format)
1005	- // --------------------------------------------------------------------------------
1006	- function delete()
1007	- {
1008	- $v_result=1;
1009	-
1010	- // ----- Reset the error handler
1011	- $this->privErrorReset();
1012	-
1013	- // ----- Check archive
1014	- if (!$this->privCheckFormat()) {
1015	- return(0);
1016	- }
1017	-
1018	- // ----- Set default values
1019	- $v_options = array();
1020	-
1021	- // ----- Look for variable options arguments
1022	- $v_size = func_num_args();
1023	-
1024	- // ----- Look for arguments
1025	- if ($v_size > 0) {
1026	- // ----- Get the arguments
1027	- $v_arg_list = func_get_args();
1028	-
1029	- // ----- Parse the options
1030	- $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
1031	- array (PCLZIP_OPT_BY_NAME => 'optional',
1032	- PCLZIP_OPT_BY_EREG => 'optional',
1033	- PCLZIP_OPT_BY_PREG => 'optional',
1034	- PCLZIP_OPT_BY_INDEX => 'optional' ));
1035	- if ($v_result != 1) {
1036	- return 0;
1037	- }
1038	- }
1039	-
1040	- // ----- Magic quotes trick
1041	- $this->privDisableMagicQuotes();
1042	-
1043	- // ----- Call the delete fct
1044	- $v_list = array();
1045	- if (($v_result = $this->privDeleteByRule($v_list, $v_options)) != 1) {
1046	- $this->privSwapBackMagicQuotes();
1047	- unset($v_list);
1048	- return(0);
1049	- }
1050	-
1051	- // ----- Magic quotes trick
1052	- $this->privSwapBackMagicQuotes();
1053	-
1054	- // ----- Return
1055	- return $v_list;
1056	- }
1057	- // --------------------------------------------------------------------------------
1058	-
1059	- // --------------------------------------------------------------------------------
1060	- // Function : deleteByIndex()
1061	- // Description :
1062	- // *** Deprecated ***
1063	- // delete(PCLZIP_OPT_BY_INDEX, $p_index) should be prefered.
1064	- // --------------------------------------------------------------------------------
1065	- function deleteByIndex($p_index)
1066	- {
1067	-
1068	- $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index);
1069	-
1070	- // ----- Return
1071	- return $p_list;
1072	- }
1073	- // --------------------------------------------------------------------------------
1074	-
1075	- // --------------------------------------------------------------------------------
1076	- // Function : properties()
1077	- // Description :
1078	- // This method gives the properties of the archive.
1079	- // The properties are :
1080	- // nb : Number of files in the archive
1081	- // comment : Comment associated with the archive file
1082	- // status : not_exist, ok
1083	- // Parameters :
1084	- // None
1085	- // Return Values :
1086	- // 0 on failure,
1087	- // An array with the archive properties.
1088	- // --------------------------------------------------------------------------------
1089	- function properties()
1090	- {
1091	-
1092	- // ----- Reset the error handler
1093	- $this->privErrorReset();
1094	-
1095	- // ----- Magic quotes trick
1096	- $this->privDisableMagicQuotes();
1097	-
1098	- // ----- Check archive
1099	- if (!$this->privCheckFormat()) {
1100	- $this->privSwapBackMagicQuotes();
1101	- return(0);
1102	- }
1103	-
1104	- // ----- Default properties
1105	- $v_prop = array();
1106	- $v_prop['comment'] = '';
1107	- $v_prop['nb'] = 0;
1108	- $v_prop['status'] = 'not_exist';
1109	-
1110	- // ----- Look if file exists
1111	- if (@is_file($this->zipname))
1112	- {
1113	- // ----- Open the zip file
1114	- if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
1115	- {
1116	- $this->privSwapBackMagicQuotes();
1117	-
1118	- // ----- Error log
1119	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
1120	-
1121	- // ----- Return
1122	- return 0;
1123	- }
1124	-
1125	- // ----- Read the central directory informations
1126	- $v_central_dir = array();
1127	- if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
1128	- {
1129	- $this->privSwapBackMagicQuotes();
1130	- return 0;
1131	- }
1132	-
1133	- // ----- Close the zip file
1134	- $this->privCloseFd();
1135	-
1136	- // ----- Set the user attributes
1137	- $v_prop['comment'] = $v_central_dir['comment'];
1138	- $v_prop['nb'] = $v_central_dir['entries'];
1139	- $v_prop['status'] = 'ok';
1140	- }
1141	-
1142	- // ----- Magic quotes trick
1143	- $this->privSwapBackMagicQuotes();
1144	-
1145	- // ----- Return
1146	- return $v_prop;
1147	- }
1148	- // --------------------------------------------------------------------------------
1149	-
1150	- // --------------------------------------------------------------------------------
1151	- // Function : duplicate()
1152	- // Description :
1153	- // This method creates an archive by copying the content of an other one. If
1154	- // the archive already exist, it is replaced by the new one without any warning.
1155	- // Parameters :
1156	- // $p_archive : The filename of a valid archive, or
1157	- // a valid PclZip object.
1158	- // Return Values :
1159	- // 1 on success.
1160	- // 0 or a negative value on error (error code).
1161	- // --------------------------------------------------------------------------------
1162	- function duplicate($p_archive)
1163	- {
1164	- $v_result = 1;
1165	-
1166	- // ----- Reset the error handler
1167	- $this->privErrorReset();
1168	-
1169	- // ----- Look if the $p_archive is a PclZip object
1170	- if ((is_object($p_archive)) && (get_class($p_archive) == 'pclzip'))
1171	- {
1172	-
1173	- // ----- Duplicate the archive
1174	- $v_result = $this->privDuplicate($p_archive->zipname);
1175	- }
1176	-
1177	- // ----- Look if the $p_archive is a string (so a filename)
1178	- else if (is_string($p_archive))
1179	- {
1180	-
1181	- // ----- Check that $p_archive is a valid zip file
1182	- // TBC : Should also check the archive format
1183	- if (!is_file($p_archive)) {
1184	- // ----- Error log
1185	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "No file with filename '".$p_archive."'");
1186	- $v_result = PCLZIP_ERR_MISSING_FILE;
1187	- }
1188	- else {
1189	- // ----- Duplicate the archive
1190	- $v_result = $this->privDuplicate($p_archive);
1191	- }
1192	- }
1193	-
1194	- // ----- Invalid variable
1195	- else
1196	- {
1197	- // ----- Error log
1198	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
1199	- $v_result = PCLZIP_ERR_INVALID_PARAMETER;
1200	- }
1201	-
1202	- // ----- Return
1203	- return $v_result;
1204	- }
1205	- // --------------------------------------------------------------------------------
1206	-
1207	- // --------------------------------------------------------------------------------
1208	- // Function : merge()
1209	- // Description :
1210	- // This method merge the $p_archive_to_add archive at the end of the current
1211	- // one ($this).
1212	- // If the archive ($this) does not exist, the merge becomes a duplicate.
1213	- // If the $p_archive_to_add archive does not exist, the merge is a success.
1214	- // Parameters :
1215	- // $p_archive_to_add : It can be directly the filename of a valid zip archive,
1216	- // or a PclZip object archive.
1217	- // Return Values :
1218	- // 1 on success,
1219	- // 0 or negative values on error (see below).
1220	- // --------------------------------------------------------------------------------
1221	- function merge($p_archive_to_add)
1222	- {
1223	- $v_result = 1;
1224	-
1225	- // ----- Reset the error handler
1226	- $this->privErrorReset();
1227	-
1228	- // ----- Check archive
1229	- if (!$this->privCheckFormat()) {
1230	- return(0);
1231	- }
1232	-
1233	- // ----- Look if the $p_archive_to_add is a PclZip object
1234	- if ((is_object($p_archive_to_add)) && (get_class($p_archive_to_add) == 'pclzip'))
1235	- {
1236	-
1237	- // ----- Merge the archive
1238	- $v_result = $this->privMerge($p_archive_to_add);
1239	- }
1240	-
1241	- // ----- Look if the $p_archive_to_add is a string (so a filename)
1242	- else if (is_string($p_archive_to_add))
1243	- {
1244	-
1245	- // ----- Create a temporary archive
1246	- $v_object_archive = new PclZip($p_archive_to_add);
1247	-
1248	- // ----- Merge the archive
1249	- $v_result = $this->privMerge($v_object_archive);
1250	- }
1251	-
1252	- // ----- Invalid variable
1253	- else
1254	- {
1255	- // ----- Error log
1256	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
1257	- $v_result = PCLZIP_ERR_INVALID_PARAMETER;
1258	- }
1259	-
1260	- // ----- Return
1261	- return $v_result;
1262	- }
1263	- // --------------------------------------------------------------------------------
1264	-
1265	-
1266	-
1267	- // --------------------------------------------------------------------------------
1268	- // Function : errorCode()
1269	- // Description :
1270	- // Parameters :
1271	- // --------------------------------------------------------------------------------
1272	- function errorCode()
1273	- {
1274	- if (PCLZIP_ERROR_EXTERNAL == 1) {
1275	- return(PclErrorCode());
1276	- }
1277	- else {
1278	- return($this->error_code);
1279	- }
1280	- }
1281	- // --------------------------------------------------------------------------------
1282	-
1283	- // --------------------------------------------------------------------------------
1284	- // Function : errorName()
1285	- // Description :
1286	- // Parameters :
1287	- // --------------------------------------------------------------------------------
1288	- function errorName($p_with_code=false)
1289	- {
1290	- $v_name = array ( PCLZIP_ERR_NO_ERROR => 'PCLZIP_ERR_NO_ERROR',
1291	- PCLZIP_ERR_WRITE_OPEN_FAIL => 'PCLZIP_ERR_WRITE_OPEN_FAIL',
1292	- PCLZIP_ERR_READ_OPEN_FAIL => 'PCLZIP_ERR_READ_OPEN_FAIL',
1293	- PCLZIP_ERR_INVALID_PARAMETER => 'PCLZIP_ERR_INVALID_PARAMETER',
1294	- PCLZIP_ERR_MISSING_FILE => 'PCLZIP_ERR_MISSING_FILE',
1295	- PCLZIP_ERR_FILENAME_TOO_LONG => 'PCLZIP_ERR_FILENAME_TOO_LONG',
1296	- PCLZIP_ERR_INVALID_ZIP => 'PCLZIP_ERR_INVALID_ZIP',
1297	- PCLZIP_ERR_BAD_EXTRACTED_FILE => 'PCLZIP_ERR_BAD_EXTRACTED_FILE',
1298	- PCLZIP_ERR_DIR_CREATE_FAIL => 'PCLZIP_ERR_DIR_CREATE_FAIL',
1299	- PCLZIP_ERR_BAD_EXTENSION => 'PCLZIP_ERR_BAD_EXTENSION',
1300	- PCLZIP_ERR_BAD_FORMAT => 'PCLZIP_ERR_BAD_FORMAT',
1301	- PCLZIP_ERR_DELETE_FILE_FAIL => 'PCLZIP_ERR_DELETE_FILE_FAIL',
1302	- PCLZIP_ERR_RENAME_FILE_FAIL => 'PCLZIP_ERR_RENAME_FILE_FAIL',
1303	- PCLZIP_ERR_BAD_CHECKSUM => 'PCLZIP_ERR_BAD_CHECKSUM',
1304	- PCLZIP_ERR_INVALID_ARCHIVE_ZIP => 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP',
1305	- PCLZIP_ERR_MISSING_OPTION_VALUE => 'PCLZIP_ERR_MISSING_OPTION_VALUE',
1306	- PCLZIP_ERR_INVALID_OPTION_VALUE => 'PCLZIP_ERR_INVALID_OPTION_VALUE',
1307	- PCLZIP_ERR_UNSUPPORTED_COMPRESSION => 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION',
1308	- PCLZIP_ERR_UNSUPPORTED_ENCRYPTION => 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION'
1309	- ,PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE => 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE'
1310	- ,PCLZIP_ERR_DIRECTORY_RESTRICTION => 'PCLZIP_ERR_DIRECTORY_RESTRICTION'
1311	- );
1312	-
1313	- if (isset($v_name[$this->error_code])) {
1314	- $v_value = $v_name[$this->error_code];
1315	- }
1316	- else {
1317	- $v_value = 'NoName';
1318	- }
1319	-
1320	- if ($p_with_code) {
1321	- return($v_value.' ('.$this->error_code.')');
1322	- }
1323	- else {
1324	- return($v_value);
1325	- }
1326	- }
1327	- // --------------------------------------------------------------------------------
1328	-
1329	- // --------------------------------------------------------------------------------
1330	- // Function : errorInfo()
1331	- // Description :
1332	- // Parameters :
1333	- // --------------------------------------------------------------------------------
1334	- function errorInfo($p_full=false)
1335	- {
1336	- if (PCLZIP_ERROR_EXTERNAL == 1) {
1337	- return(PclErrorString());
1338	- }
1339	- else {
1340	- if ($p_full) {
1341	- return($this->errorName(true)." : ".$this->error_string);
1342	- }
1343	- else {
1344	- return($this->error_string." [code ".$this->error_code."]");
1345	- }
1346	- }
1347	- }
1348	- // --------------------------------------------------------------------------------
1349	-
1350	-
1351	-// --------------------------------------------------------------------------------
1352	-// *** UNDER THIS LINE ARE DEFINED PRIVATE INTERNAL FUNCTIONS ***
1353	-// *** ***
1354	-// *** THESES FUNCTIONS MUST NOT BE USED DIRECTLY ***
1355	-// --------------------------------------------------------------------------------
1356	-
1357	-
1358	-
1359	- // --------------------------------------------------------------------------------
1360	- // Function : privCheckFormat()
1361	- // Description :
1362	- // This method check that the archive exists and is a valid zip archive.
1363	- // Several level of check exists. (futur)
1364	- // Parameters :
1365	- // $p_level : Level of check. Default 0.
1366	- // 0 : Check the first bytes (magic codes) (default value))
1367	- // 1 : 0 + Check the central directory (futur)
1368	- // 2 : 1 + Check each file header (futur)
1369	- // Return Values :
1370	- // true on success,
1371	- // false on error, the error code is set.
1372	- // --------------------------------------------------------------------------------
1373	- function privCheckFormat($p_level=0)
1374	- {
1375	- $v_result = true;
1376	-
1377	- // ----- Reset the file system cache
1378	- clearstatcache();
1379	-
1380	- // ----- Reset the error handler
1381	- $this->privErrorReset();
1382	-
1383	- // ----- Look if the file exits
1384	- if (!is_file($this->zipname)) {
1385	- // ----- Error log
1386	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "Missing archive file '".$this->zipname."'");
1387	- return(false);
1388	- }
1389	-
1390	- // ----- Check that the file is readeable
1391	- if (!is_readable($this->zipname)) {
1392	- // ----- Error log
1393	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to read archive '".$this->zipname."'");
1394	- return(false);
1395	- }
1396	-
1397	- // ----- Check the magic code
1398	- // TBC
1399	-
1400	- // ----- Check the central header
1401	- // TBC
1402	-
1403	- // ----- Check each file header
1404	- // TBC
1405	-
1406	- // ----- Return
1407	- return $v_result;
1408	- }
1409	- // --------------------------------------------------------------------------------
1410	-
1411	- // --------------------------------------------------------------------------------
1412	- // Function : privParseOptions()
1413	- // Description :
1414	- // This internal methods reads the variable list of arguments ($p_options_list,
1415	- // $p_size) and generate an array with the options and values ($v_result_list).
1416	- // $v_requested_options contains the options that can be present and those that
1417	- // must be present.
1418	- // $v_requested_options is an array, with the option value as key, and 'optional',
1419	- // or 'mandatory' as value.
1420	- // Parameters :
1421	- // See above.
1422	- // Return Values :
1423	- // 1 on success.
1424	- // 0 on failure.
1425	- // --------------------------------------------------------------------------------
1426	- function privParseOptions(&$p_options_list, $p_size, &$v_result_list, $v_requested_options=false)
1427	- {
1428	- $v_result=1;
1429	-
1430	- // ----- Read the options
1431	- $i=0;
1432	- while ($i<$p_size) {
1433	-
1434	- // ----- Check if the option is supported
1435	- if (!isset($v_requested_options[$p_options_list[$i]])) {
1436	- // ----- Error log
1437	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid optional parameter '".$p_options_list[$i]."' for this method");
1438	-
1439	- // ----- Return
1440	- return PclZip::errorCode();
1441	- }
1442	-
1443	- // ----- Look for next option
1444	- switch ($p_options_list[$i]) {
1445	- // ----- Look for options that request a path value
1446	- case PCLZIP_OPT_PATH :
1447	- case PCLZIP_OPT_REMOVE_PATH :
1448	- case PCLZIP_OPT_ADD_PATH :
1449	- // ----- Check the number of parameters
1450	- if (($i+1) >= $p_size) {
1451	- // ----- Error log
1452	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1453	-
1454	- // ----- Return
1455	- return PclZip::errorCode();
1456	- }
1457	-
1458	- // ----- Get the value
1459	- $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
1460	- $i++;
1461	- break;
1462	-
1463	- case PCLZIP_OPT_TEMP_FILE_THRESHOLD :
1464	- // ----- Check the number of parameters
1465	- if (($i+1) >= $p_size) {
1466	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1467	- return PclZip::errorCode();
1468	- }
1469	-
1470	- // ----- Check for incompatible options
1471	- if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
1472	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
1473	- return PclZip::errorCode();
1474	- }
1475	-
1476	- // ----- Check the value
1477	- $v_value = $p_options_list[$i+1];
1478	- if ((!is_integer($v_value)) \|\| ($v_value<0)) {
1479	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Integer expected for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1480	- return PclZip::errorCode();
1481	- }
1482	-
1483	- // ----- Get the value (and convert it in bytes)
1484	- $v_result_list[$p_options_list[$i]] = $v_value*1048576;
1485	- $i++;
1486	- break;
1487	-
1488	- case PCLZIP_OPT_TEMP_FILE_ON :
1489	- // ----- Check for incompatible options
1490	- if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
1491	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
1492	- return PclZip::errorCode();
1493	- }
1494	-
1495	- $v_result_list[$p_options_list[$i]] = true;
1496	- break;
1497	-
1498	- case PCLZIP_OPT_TEMP_FILE_OFF :
1499	- // ----- Check for incompatible options
1500	- if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_ON])) {
1501	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_ON'");
1502	- return PclZip::errorCode();
1503	- }
1504	- // ----- Check for incompatible options
1505	- if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
1506	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_THRESHOLD'");
1507	- return PclZip::errorCode();
1508	- }
1509	-
1510	- $v_result_list[$p_options_list[$i]] = true;
1511	- break;
1512	-
1513	- case PCLZIP_OPT_EXTRACT_DIR_RESTRICTION :
1514	- // ----- Check the number of parameters
1515	- if (($i+1) >= $p_size) {
1516	- // ----- Error log
1517	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1518	-
1519	- // ----- Return
1520	- return PclZip::errorCode();
1521	- }
1522	-
1523	- // ----- Get the value
1524	- if ( is_string($p_options_list[$i+1])
1525	- && ($p_options_list[$i+1] != '')) {
1526	- $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
1527	- $i++;
1528	- }
1529	- else {
1530	- }
1531	- break;
1532	-
1533	- // ----- Look for options that request an array of string for value
1534	- case PCLZIP_OPT_BY_NAME :
1535	- // ----- Check the number of parameters
1536	- if (($i+1) >= $p_size) {
1537	- // ----- Error log
1538	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1539	-
1540	- // ----- Return
1541	- return PclZip::errorCode();
1542	- }
1543	-
1544	- // ----- Get the value
1545	- if (is_string($p_options_list[$i+1])) {
1546	- $v_result_list[$p_options_list[$i]][0] = $p_options_list[$i+1];
1547	- }
1548	- else if (is_array($p_options_list[$i+1])) {
1549	- $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
1550	- }
1551	- else {
1552	- // ----- Error log
1553	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1554	-
1555	- // ----- Return
1556	- return PclZip::errorCode();
1557	- }
1558	- $i++;
1559	- break;
1560	-
1561	- // ----- Look for options that request an EREG or PREG expression
1562	- case PCLZIP_OPT_BY_EREG :
1563	- // ereg() is deprecated starting with PHP 5.3. Move PCLZIP_OPT_BY_EREG
1564	- // to PCLZIP_OPT_BY_PREG
1565	- $p_options_list[$i] = PCLZIP_OPT_BY_PREG;
1566	- case PCLZIP_OPT_BY_PREG :
1567	- //case PCLZIP_OPT_CRYPT :
1568	- // ----- Check the number of parameters
1569	- if (($i+1) >= $p_size) {
1570	- // ----- Error log
1571	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1572	-
1573	- // ----- Return
1574	- return PclZip::errorCode();
1575	- }
1576	-
1577	- // ----- Get the value
1578	- if (is_string($p_options_list[$i+1])) {
1579	- $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
1580	- }
1581	- else {
1582	- // ----- Error log
1583	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1584	-
1585	- // ----- Return
1586	- return PclZip::errorCode();
1587	- }
1588	- $i++;
1589	- break;
1590	-
1591	- // ----- Look for options that takes a string
1592	- case PCLZIP_OPT_COMMENT :
1593	- case PCLZIP_OPT_ADD_COMMENT :
1594	- case PCLZIP_OPT_PREPEND_COMMENT :
1595	- // ----- Check the number of parameters
1596	- if (($i+1) >= $p_size) {
1597	- // ----- Error log
1598	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
1599	- "Missing parameter value for option '"
1600	- .PclZipUtilOptionText($p_options_list[$i])
1601	- ."'");
1602	-
1603	- // ----- Return
1604	- return PclZip::errorCode();
1605	- }
1606	-
1607	- // ----- Get the value
1608	- if (is_string($p_options_list[$i+1])) {
1609	- $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
1610	- }
1611	- else {
1612	- // ----- Error log
1613	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
1614	- "Wrong parameter value for option '"
1615	- .PclZipUtilOptionText($p_options_list[$i])
1616	- ."'");
1617	-
1618	- // ----- Return
1619	- return PclZip::errorCode();
1620	- }
1621	- $i++;
1622	- break;
1623	-
1624	- // ----- Look for options that request an array of index
1625	- case PCLZIP_OPT_BY_INDEX :
1626	- // ----- Check the number of parameters
1627	- if (($i+1) >= $p_size) {
1628	- // ----- Error log
1629	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1630	-
1631	- // ----- Return
1632	- return PclZip::errorCode();
1633	- }
1634	-
1635	- // ----- Get the value
1636	- $v_work_list = array();
1637	- if (is_string($p_options_list[$i+1])) {
1638	-
1639	- // ----- Remove spaces
1640	- $p_options_list[$i+1] = strtr($p_options_list[$i+1], ' ', '');
1641	-
1642	- // ----- Parse items
1643	- $v_work_list = explode(",", $p_options_list[$i+1]);
1644	- }
1645	- else if (is_integer($p_options_list[$i+1])) {
1646	- $v_work_list[0] = $p_options_list[$i+1].'-'.$p_options_list[$i+1];
1647	- }
1648	- else if (is_array($p_options_list[$i+1])) {
1649	- $v_work_list = $p_options_list[$i+1];
1650	- }
1651	- else {
1652	- // ----- Error log
1653	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Value must be integer, string or array for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1654	-
1655	- // ----- Return
1656	- return PclZip::errorCode();
1657	- }
1658	-
1659	- // ----- Reduce the index list
1660	- // each index item in the list must be a couple with a start and
1661	- // an end value : [0,3], [5-5], [8-10], ...
1662	- // ----- Check the format of each item
1663	- $v_sort_flag=false;
1664	- $v_sort_value=0;
1665	- for ($j=0; $j<sizeof($v_work_list); $j++) {
1666	- // ----- Explode the item
1667	- $v_item_list = explode("-", $v_work_list[$j]);
1668	- $v_size_item_list = sizeof($v_item_list);
1669	-
1670	- // ----- TBC : Here we might check that each item is a
1671	- // real integer ...
1672	-
1673	- // ----- Look for single value
1674	- if ($v_size_item_list == 1) {
1675	- // ----- Set the option value
1676	- $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
1677	- $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[0];
1678	- }
1679	- elseif ($v_size_item_list == 2) {
1680	- // ----- Set the option value
1681	- $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
1682	- $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[1];
1683	- }
1684	- else {
1685	- // ----- Error log
1686	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Too many values in index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1687	-
1688	- // ----- Return
1689	- return PclZip::errorCode();
1690	- }
1691	-
1692	-
1693	- // ----- Look for list sort
1694	- if ($v_result_list[$p_options_list[$i]][$j]['start'] < $v_sort_value) {
1695	- $v_sort_flag=true;
1696	-
1697	- // ----- TBC : An automatic sort should be writen ...
1698	- // ----- Error log
1699	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Invalid order of index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1700	-
1701	- // ----- Return
1702	- return PclZip::errorCode();
1703	- }
1704	- $v_sort_value = $v_result_list[$p_options_list[$i]][$j]['start'];
1705	- }
1706	-
1707	- // ----- Sort the items
1708	- if ($v_sort_flag) {
1709	- // TBC : To Be Completed
1710	- }
1711	-
1712	- // ----- Next option
1713	- $i++;
1714	- break;
1715	-
1716	- // ----- Look for options that request no value
1717	- case PCLZIP_OPT_REMOVE_ALL_PATH :
1718	- case PCLZIP_OPT_EXTRACT_AS_STRING :
1719	- case PCLZIP_OPT_NO_COMPRESSION :
1720	- case PCLZIP_OPT_EXTRACT_IN_OUTPUT :
1721	- case PCLZIP_OPT_REPLACE_NEWER :
1722	- case PCLZIP_OPT_STOP_ON_ERROR :
1723	- $v_result_list[$p_options_list[$i]] = true;
1724	- break;
1725	-
1726	- // ----- Look for options that request an octal value
1727	- case PCLZIP_OPT_SET_CHMOD :
1728	- // ----- Check the number of parameters
1729	- if (($i+1) >= $p_size) {
1730	- // ----- Error log
1731	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1732	-
1733	- // ----- Return
1734	- return PclZip::errorCode();
1735	- }
1736	-
1737	- // ----- Get the value
1738	- $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
1739	- $i++;
1740	- break;
1741	-
1742	- // ----- Look for options that request a call-back
1743	- case PCLZIP_CB_PRE_EXTRACT :
1744	- case PCLZIP_CB_POST_EXTRACT :
1745	- case PCLZIP_CB_PRE_ADD :
1746	- case PCLZIP_CB_POST_ADD :
1747	- /* for futur use
1748	- case PCLZIP_CB_PRE_DELETE :
1749	- case PCLZIP_CB_POST_DELETE :
1750	- case PCLZIP_CB_PRE_LIST :
1751	- case PCLZIP_CB_POST_LIST :
1752	- */
1753	- // ----- Check the number of parameters
1754	- if (($i+1) >= $p_size) {
1755	- // ----- Error log
1756	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1757	-
1758	- // ----- Return
1759	- return PclZip::errorCode();
1760	- }
1761	-
1762	- // ----- Get the value
1763	- $v_function_name = $p_options_list[$i+1];
1764	-
1765	- // ----- Check that the value is a valid existing function
1766	- if (!function_exists($v_function_name)) {
1767	- // ----- Error log
1768	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Function '".$v_function_name."()' is not an existing function for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1769	-
1770	- // ----- Return
1771	- return PclZip::errorCode();
1772	- }
1773	-
1774	- // ----- Set the attribute
1775	- $v_result_list[$p_options_list[$i]] = $v_function_name;
1776	- $i++;
1777	- break;
1778	-
1779	- default :
1780	- // ----- Error log
1781	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
1782	- "Unknown parameter '"
1783	- .$p_options_list[$i]."'");
1784	-
1785	- // ----- Return
1786	- return PclZip::errorCode();
1787	- }
1788	-
1789	- // ----- Next options
1790	- $i++;
1791	- }
1792	-
1793	- // ----- Look for mandatory options
1794	- if ($v_requested_options !== false) {
1795	- for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
1796	- // ----- Look for mandatory option
1797	- if ($v_requested_options[$key] == 'mandatory') {
1798	- // ----- Look if present
1799	- if (!isset($v_result_list[$key])) {
1800	- // ----- Error log
1801	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
1802	-
1803	- // ----- Return
1804	- return PclZip::errorCode();
1805	- }
1806	- }
1807	- }
1808	- }
1809	-
1810	- // ----- Look for default values
1811	- if (!isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
1812	-
1813	- }
1814	-
1815	- // ----- Return
1816	- return $v_result;
1817	- }
1818	- // --------------------------------------------------------------------------------
1819	-
1820	- // --------------------------------------------------------------------------------
1821	- // Function : privOptionDefaultThreshold()
1822	- // Description :
1823	- // Parameters :
1824	- // Return Values :
1825	- // --------------------------------------------------------------------------------
1826	- function privOptionDefaultThreshold(&$p_options)
1827	- {
1828	- $v_result=1;
1829	-
1830	- if (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
1831	- \|\| isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) {
1832	- return $v_result;
1833	- }
1834	-
1835	- // ----- Get 'memory_limit' configuration value
1836	- $v_memory_limit = ini_get('memory_limit');
1837	- $v_memory_limit = trim($v_memory_limit);
1838	- $last = strtolower(substr($v_memory_limit, -1));
1839	-
1840	- if($last == 'g')
1841	- //$v_memory_limit = $v_memory_limit10241024*1024;
1842	- $v_memory_limit = $v_memory_limit*1073741824;
1843	- if($last == 'm')
1844	- //$v_memory_limit = $v_memory_limit10241024;
1845	- $v_memory_limit = $v_memory_limit*1048576;
1846	- if($last == 'k')
1847	- $v_memory_limit = $v_memory_limit*1024;
1848	-
1849	- $p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] = floor($v_memory_limit*PCLZIP_TEMPORARY_FILE_RATIO);
1850	-
1851	-
1852	- // ----- Sanity check : No threshold if value lower than 1M
1853	- if ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] < 1048576) {
1854	- unset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]);
1855	- }
1856	-
1857	- // ----- Return
1858	- return $v_result;
1859	- }
1860	- // --------------------------------------------------------------------------------
1861	-
1862	- // --------------------------------------------------------------------------------
1863	- // Function : privFileDescrParseAtt()
1864	- // Description :
1865	- // Parameters :
1866	- // Return Values :
1867	- // 1 on success.
1868	- // 0 on failure.
1869	- // --------------------------------------------------------------------------------
1870	- function privFileDescrParseAtt(&$p_file_list, &$p_filedescr, $v_options, $v_requested_options=false)
1871	- {
1872	- $v_result=1;
1873	-
1874	- // ----- For each file in the list check the attributes
1875	- foreach ($p_file_list as $v_key => $v_value) {
1876	-
1877	- // ----- Check if the option is supported
1878	- if (!isset($v_requested_options[$v_key])) {
1879	- // ----- Error log
1880	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file attribute '".$v_key."' for this file");
1881	-
1882	- // ----- Return
1883	- return PclZip::errorCode();
1884	- }
1885	-
1886	- // ----- Look for attribute
1887	- switch ($v_key) {
1888	- case PCLZIP_ATT_FILE_NAME :
1889	- if (!is_string($v_value)) {
1890	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
1891	- return PclZip::errorCode();
1892	- }
1893	-
1894	- $p_filedescr['filename'] = PclZipUtilPathReduction($v_value);
1895	-
1896	- if ($p_filedescr['filename'] == '') {
1897	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty filename for attribute '".PclZipUtilOptionText($v_key)."'");
1898	- return PclZip::errorCode();
1899	- }
1900	-
1901	- break;
1902	-
1903	- case PCLZIP_ATT_FILE_NEW_SHORT_NAME :
1904	- if (!is_string($v_value)) {
1905	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
1906	- return PclZip::errorCode();
1907	- }
1908	-
1909	- $p_filedescr['new_short_name'] = PclZipUtilPathReduction($v_value);
1910	-
1911	- if ($p_filedescr['new_short_name'] == '') {
1912	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty short filename for attribute '".PclZipUtilOptionText($v_key)."'");
1913	- return PclZip::errorCode();
1914	- }
1915	- break;
1916	-
1917	- case PCLZIP_ATT_FILE_NEW_FULL_NAME :
1918	- if (!is_string($v_value)) {
1919	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
1920	- return PclZip::errorCode();
1921	- }
1922	-
1923	- $p_filedescr['new_full_name'] = PclZipUtilPathReduction($v_value);
1924	-
1925	- if ($p_filedescr['new_full_name'] == '') {
1926	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty full filename for attribute '".PclZipUtilOptionText($v_key)."'");
1927	- return PclZip::errorCode();
1928	- }
1929	- break;
1930	-
1931	- // ----- Look for options that takes a string
1932	- case PCLZIP_ATT_FILE_COMMENT :
1933	- if (!is_string($v_value)) {
1934	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
1935	- return PclZip::errorCode();
1936	- }
1937	-
1938	- $p_filedescr['comment'] = $v_value;
1939	- break;
1940	-
1941	- case PCLZIP_ATT_FILE_MTIME :
1942	- if (!is_integer($v_value)) {
1943	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". Integer expected for attribute '".PclZipUtilOptionText($v_key)."'");
1944	- return PclZip::errorCode();
1945	- }
1946	-
1947	- $p_filedescr['mtime'] = $v_value;
1948	- break;
1949	-
1950	- case PCLZIP_ATT_FILE_CONTENT :
1951	- $p_filedescr['content'] = $v_value;
1952	- break;
1953	-
1954	- default :
1955	- // ----- Error log
1956	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
1957	- "Unknown parameter '".$v_key."'");
1958	-
1959	- // ----- Return
1960	- return PclZip::errorCode();
1961	- }
1962	-
1963	- // ----- Look for mandatory options
1964	- if ($v_requested_options !== false) {
1965	- for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
1966	- // ----- Look for mandatory option
1967	- if ($v_requested_options[$key] == 'mandatory') {
1968	- // ----- Look if present
1969	- if (!isset($p_file_list[$key])) {
1970	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
1971	- return PclZip::errorCode();
1972	- }
1973	- }
1974	- }
1975	- }
1976	-
1977	- // end foreach
1978	- }
1979	-
1980	- // ----- Return
1981	- return $v_result;
1982	- }
1983	- // --------------------------------------------------------------------------------
1984	-
1985	- // --------------------------------------------------------------------------------
1986	- // Function : privFileDescrExpand()
1987	- // Description :
1988	- // This method look for each item of the list to see if its a file, a folder
1989	- // or a string to be added as file. For any other type of files (link, other)
1990	- // just ignore the item.
1991	- // Then prepare the information that will be stored for that file.
1992	- // When its a folder, expand the folder with all the files that are in that
1993	- // folder (recursively).
1994	- // Parameters :
1995	- // Return Values :
1996	- // 1 on success.
1997	- // 0 on failure.
1998	- // --------------------------------------------------------------------------------
1999	- function privFileDescrExpand(&$p_filedescr_list, &$p_options)
2000	- {
2001	- $v_result=1;
2002	-
2003	- // ----- Create a result list
2004	- $v_result_list = array();
2005	-
2006	- // ----- Look each entry
2007	- for ($i=0; $i<sizeof($p_filedescr_list); $i++) {
2008	-
2009	- // ----- Get filedescr
2010	- $v_descr = $p_filedescr_list[$i];
2011	-
2012	- // ----- Reduce the filename
2013	- $v_descr['filename'] = PclZipUtilTranslateWinPath($v_descr['filename'], false);
2014	- $v_descr['filename'] = PclZipUtilPathReduction($v_descr['filename']);
2015	-
2016	- // ----- Look for real file or folder
2017	- if (file_exists($v_descr['filename'])) {
2018	- if (@is_file($v_descr['filename'])) {
2019	- $v_descr['type'] = 'file';
2020	- }
2021	- else if (@is_dir($v_descr['filename'])) {
2022	- $v_descr['type'] = 'folder';
2023	- }
2024	- else if (@is_link($v_descr['filename'])) {
2025	- // skip
2026	- continue;
2027	- }
2028	- else {
2029	- // skip
2030	- continue;
2031	- }
2032	- }
2033	-
2034	- // ----- Look for string added as file
2035	- else if (isset($v_descr['content'])) {
2036	- $v_descr['type'] = 'virtual_file';
2037	- }
2038	-
2039	- // ----- Missing file
2040	- else {
2041	- // ----- Error log
2042	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$v_descr['filename']."' does not exist");
2043	-
2044	- // ----- Return
2045	- return PclZip::errorCode();
2046	- }
2047	-
2048	- // ----- Calculate the stored filename
2049	- $this->privCalculateStoredFilename($v_descr, $p_options);
2050	-
2051	- // ----- Add the descriptor in result list
2052	- $v_result_list[sizeof($v_result_list)] = $v_descr;
2053	-
2054	- // ----- Look for folder
2055	- if ($v_descr['type'] == 'folder') {
2056	- // ----- List of items in folder
2057	- $v_dirlist_descr = array();
2058	- $v_dirlist_nb = 0;
2059	- if ($v_folder_handler = @opendir($v_descr['filename'])) {
2060	- while (($v_item_handler = @readdir($v_folder_handler)) !== false) {
2061	-
2062	- // ----- Skip '.' and '..'
2063	- if (($v_item_handler == '.') \|\| ($v_item_handler == '..')) {
2064	- continue;
2065	- }
2066	-
2067	- // ----- Compose the full filename
2068	- $v_dirlist_descr[$v_dirlist_nb]['filename'] = $v_descr['filename'].'/'.$v_item_handler;
2069	-
2070	- // ----- Look for different stored filename
2071	- // Because the name of the folder was changed, the name of the
2072	- // files/sub-folders also change
2073	- if (($v_descr['stored_filename'] != $v_descr['filename'])
2074	- && (!isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))) {
2075	- if ($v_descr['stored_filename'] != '') {
2076	- $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_descr['stored_filename'].'/'.$v_item_handler;
2077	- }
2078	- else {
2079	- $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_item_handler;
2080	- }
2081	- }
2082	-
2083	- $v_dirlist_nb++;
2084	- }
2085	-
2086	- @closedir($v_folder_handler);
2087	- }
2088	- else {
2089	- // TBC : unable to open folder in read mode
2090	- }
2091	-
2092	- // ----- Expand each element of the list
2093	- if ($v_dirlist_nb != 0) {
2094	- // ----- Expand
2095	- if (($v_result = $this->privFileDescrExpand($v_dirlist_descr, $p_options)) != 1) {
2096	- return $v_result;
2097	- }
2098	-
2099	- // ----- Concat the resulting list
2100	- $v_result_list = array_merge($v_result_list, $v_dirlist_descr);
2101	- }
2102	- else {
2103	- }
2104	-
2105	- // ----- Free local array
2106	- unset($v_dirlist_descr);
2107	- }
2108	- }
2109	-
2110	- // ----- Get the result list
2111	- $p_filedescr_list = $v_result_list;
2112	-
2113	- // ----- Return
2114	- return $v_result;
2115	- }
2116	- // --------------------------------------------------------------------------------
2117	-
2118	- // --------------------------------------------------------------------------------
2119	- // Function : privCreate()
2120	- // Description :
2121	- // Parameters :
2122	- // Return Values :
2123	- // --------------------------------------------------------------------------------
2124	- function privCreate($p_filedescr_list, &$p_result_list, &$p_options)
2125	- {
2126	- $v_result=1;
2127	- $v_list_detail = array();
2128	-
2129	- // ----- Magic quotes trick
2130	- $this->privDisableMagicQuotes();
2131	-
2132	- // ----- Open the file in write mode
2133	- if (($v_result = $this->privOpenFd('wb')) != 1)
2134	- {
2135	- // ----- Return
2136	- return $v_result;
2137	- }
2138	-
2139	- // ----- Add the list of files
2140	- $v_result = $this->privAddList($p_filedescr_list, $p_result_list, $p_options);
2141	-
2142	- // ----- Close
2143	- $this->privCloseFd();
2144	-
2145	- // ----- Magic quotes trick
2146	- $this->privSwapBackMagicQuotes();
2147	-
2148	- // ----- Return
2149	- return $v_result;
2150	- }
2151	- // --------------------------------------------------------------------------------
2152	-
2153	- // --------------------------------------------------------------------------------
2154	- // Function : privAdd()
2155	- // Description :
2156	- // Parameters :
2157	- // Return Values :
2158	- // --------------------------------------------------------------------------------
2159	- function privAdd($p_filedescr_list, &$p_result_list, &$p_options)
2160	- {
2161	- $v_result=1;
2162	- $v_list_detail = array();
2163	-
2164	- // ----- Look if the archive exists or is empty
2165	- if ((!is_file($this->zipname)) \|\| (filesize($this->zipname) == 0))
2166	- {
2167	-
2168	- // ----- Do a create
2169	- $v_result = $this->privCreate($p_filedescr_list, $p_result_list, $p_options);
2170	-
2171	- // ----- Return
2172	- return $v_result;
2173	- }
2174	- // ----- Magic quotes trick
2175	- $this->privDisableMagicQuotes();
2176	-
2177	- // ----- Open the zip file
2178	- if (($v_result=$this->privOpenFd('rb')) != 1)
2179	- {
2180	- // ----- Magic quotes trick
2181	- $this->privSwapBackMagicQuotes();
2182	-
2183	- // ----- Return
2184	- return $v_result;
2185	- }
2186	-
2187	- // ----- Read the central directory informations
2188	- $v_central_dir = array();
2189	- if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
2190	- {
2191	- $this->privCloseFd();
2192	- $this->privSwapBackMagicQuotes();
2193	- return $v_result;
2194	- }
2195	-
2196	- // ----- Go to beginning of File
2197	- @rewind($this->zip_fd);
2198	-
2199	- // ----- Creates a temporay file
2200	- $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
2201	-
2202	- // ----- Open the temporary file in write mode
2203	- if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0)
2204	- {
2205	- $this->privCloseFd();
2206	- $this->privSwapBackMagicQuotes();
2207	-
2208	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_zip_temp_name.'\' in binary write mode');
2209	-
2210	- // ----- Return
2211	- return PclZip::errorCode();
2212	- }
2213	-
2214	- // ----- Copy the files from the archive to the temporary file
2215	- // TBC : Here I should better append the file and go back to erase the central dir
2216	- $v_size = $v_central_dir['offset'];
2217	- while ($v_size != 0)
2218	- {
2219	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
2220	- $v_buffer = fread($this->zip_fd, $v_read_size);
2221	- @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
2222	- $v_size -= $v_read_size;
2223	- }
2224	-
2225	- // ----- Swap the file descriptor
2226	- // Here is a trick : I swap the temporary fd with the zip fd, in order to use
2227	- // the following methods on the temporary fil and not the real archive
2228	- $v_swap = $this->zip_fd;
2229	- $this->zip_fd = $v_zip_temp_fd;
2230	- $v_zip_temp_fd = $v_swap;
2231	-
2232	- // ----- Add the files
2233	- $v_header_list = array();
2234	- if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
2235	- {
2236	- fclose($v_zip_temp_fd);
2237	- $this->privCloseFd();
2238	- @unlink($v_zip_temp_name);
2239	- $this->privSwapBackMagicQuotes();
2240	-
2241	- // ----- Return
2242	- return $v_result;
2243	- }
2244	-
2245	- // ----- Store the offset of the central dir
2246	- $v_offset = @ftell($this->zip_fd);
2247	-
2248	- // ----- Copy the block of file headers from the old archive
2249	- $v_size = $v_central_dir['size'];
2250	- while ($v_size != 0)
2251	- {
2252	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
2253	- $v_buffer = @fread($v_zip_temp_fd, $v_read_size);
2254	- @fwrite($this->zip_fd, $v_buffer, $v_read_size);
2255	- $v_size -= $v_read_size;
2256	- }
2257	-
2258	- // ----- Create the Central Dir files header
2259	- for ($i=0, $v_count=0; $i<sizeof($v_header_list); $i++)
2260	- {
2261	- // ----- Create the file header
2262	- if ($v_header_list[$i]['status'] == 'ok') {
2263	- if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
2264	- fclose($v_zip_temp_fd);
2265	- $this->privCloseFd();
2266	- @unlink($v_zip_temp_name);
2267	- $this->privSwapBackMagicQuotes();
2268	-
2269	- // ----- Return
2270	- return $v_result;
2271	- }
2272	- $v_count++;
2273	- }
2274	-
2275	- // ----- Transform the header to a 'usable' info
2276	- $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
2277	- }
2278	-
2279	- // ----- Zip file comment
2280	- $v_comment = $v_central_dir['comment'];
2281	- if (isset($p_options[PCLZIP_OPT_COMMENT])) {
2282	- $v_comment = $p_options[PCLZIP_OPT_COMMENT];
2283	- }
2284	- if (isset($p_options[PCLZIP_OPT_ADD_COMMENT])) {
2285	- $v_comment = $v_comment.$p_options[PCLZIP_OPT_ADD_COMMENT];
2286	- }
2287	- if (isset($p_options[PCLZIP_OPT_PREPEND_COMMENT])) {
2288	- $v_comment = $p_options[PCLZIP_OPT_PREPEND_COMMENT].$v_comment;
2289	- }
2290	-
2291	- // ----- Calculate the size of the central header
2292	- $v_size = @ftell($this->zip_fd)-$v_offset;
2293	-
2294	- // ----- Create the central dir footer
2295	- if (($v_result = $this->privWriteCentralHeader($v_count+$v_central_dir['entries'], $v_size, $v_offset, $v_comment)) != 1)
2296	- {
2297	- // ----- Reset the file list
2298	- unset($v_header_list);
2299	- $this->privSwapBackMagicQuotes();
2300	-
2301	- // ----- Return
2302	- return $v_result;
2303	- }
2304	-
2305	- // ----- Swap back the file descriptor
2306	- $v_swap = $this->zip_fd;
2307	- $this->zip_fd = $v_zip_temp_fd;
2308	- $v_zip_temp_fd = $v_swap;
2309	-
2310	- // ----- Close
2311	- $this->privCloseFd();
2312	-
2313	- // ----- Close the temporary file
2314	- @fclose($v_zip_temp_fd);
2315	-
2316	- // ----- Magic quotes trick
2317	- $this->privSwapBackMagicQuotes();
2318	-
2319	- // ----- Delete the zip file
2320	- // TBC : I should test the result ...
2321	- @unlink($this->zipname);
2322	-
2323	- // ----- Rename the temporary file
2324	- // TBC : I should test the result ...
2325	- //@rename($v_zip_temp_name, $this->zipname);
2326	- PclZipUtilRename($v_zip_temp_name, $this->zipname);
2327	-
2328	- // ----- Return
2329	- return $v_result;
2330	- }
2331	- // --------------------------------------------------------------------------------
2332	-
2333	- // --------------------------------------------------------------------------------
2334	- // Function : privOpenFd()
2335	- // Description :
2336	- // Parameters :
2337	- // --------------------------------------------------------------------------------
2338	- function privOpenFd($p_mode)
2339	- {
2340	- $v_result=1;
2341	-
2342	- // ----- Look if already open
2343	- if ($this->zip_fd != 0)
2344	- {
2345	- // ----- Error log
2346	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Zip file \''.$this->zipname.'\' already open');
2347	-
2348	- // ----- Return
2349	- return PclZip::errorCode();
2350	- }
2351	-
2352	- // ----- Open the zip file
2353	- if (($this->zip_fd = @fopen($this->zipname, $p_mode)) == 0)
2354	- {
2355	- // ----- Error log
2356	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in '.$p_mode.' mode');
2357	-
2358	- // ----- Return
2359	- return PclZip::errorCode();
2360	- }
2361	-
2362	- // ----- Return
2363	- return $v_result;
2364	- }
2365	- // --------------------------------------------------------------------------------
2366	-
2367	- // --------------------------------------------------------------------------------
2368	- // Function : privCloseFd()
2369	- // Description :
2370	- // Parameters :
2371	- // --------------------------------------------------------------------------------
2372	- function privCloseFd()
2373	- {
2374	- $v_result=1;
2375	-
2376	- if ($this->zip_fd != 0)
2377	- @fclose($this->zip_fd);
2378	- $this->zip_fd = 0;
2379	-
2380	- // ----- Return
2381	- return $v_result;
2382	- }
2383	- // --------------------------------------------------------------------------------
2384	-
2385	- // --------------------------------------------------------------------------------
2386	- // Function : privAddList()
2387	- // Description :
2388	- // $p_add_dir and $p_remove_dir will give the ability to memorize a path which is
2389	- // different from the real path of the file. This is usefull if you want to have PclTar
2390	- // running in any directory, and memorize relative path from an other directory.
2391	- // Parameters :
2392	- // $p_list : An array containing the file or directory names to add in the tar
2393	- // $p_result_list : list of added files with their properties (specially the status field)
2394	- // $p_add_dir : Path to add in the filename path archived
2395	- // $p_remove_dir : Path to remove in the filename path archived
2396	- // Return Values :
2397	- // --------------------------------------------------------------------------------
2398	-// function privAddList($p_list, &$p_result_list, $p_add_dir, $p_remove_dir, $p_remove_all_dir, &$p_options)
2399	- function privAddList($p_filedescr_list, &$p_result_list, &$p_options)
2400	- {
2401	- $v_result=1;
2402	-
2403	- // ----- Add the files
2404	- $v_header_list = array();
2405	- if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
2406	- {
2407	- // ----- Return
2408	- return $v_result;
2409	- }
2410	-
2411	- // ----- Store the offset of the central dir
2412	- $v_offset = @ftell($this->zip_fd);
2413	-
2414	- // ----- Create the Central Dir files header
2415	- for ($i=0,$v_count=0; $i<sizeof($v_header_list); $i++)
2416	- {
2417	- // ----- Create the file header
2418	- if ($v_header_list[$i]['status'] == 'ok') {
2419	- if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
2420	- // ----- Return
2421	- return $v_result;
2422	- }
2423	- $v_count++;
2424	- }
2425	-
2426	- // ----- Transform the header to a 'usable' info
2427	- $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
2428	- }
2429	-
2430	- // ----- Zip file comment
2431	- $v_comment = '';
2432	- if (isset($p_options[PCLZIP_OPT_COMMENT])) {
2433	- $v_comment = $p_options[PCLZIP_OPT_COMMENT];
2434	- }
2435	-
2436	- // ----- Calculate the size of the central header
2437	- $v_size = @ftell($this->zip_fd)-$v_offset;
2438	-
2439	- // ----- Create the central dir footer
2440	- if (($v_result = $this->privWriteCentralHeader($v_count, $v_size, $v_offset, $v_comment)) != 1)
2441	- {
2442	- // ----- Reset the file list
2443	- unset($v_header_list);
2444	-
2445	- // ----- Return
2446	- return $v_result;
2447	- }
2448	-
2449	- // ----- Return
2450	- return $v_result;
2451	- }
2452	- // --------------------------------------------------------------------------------
2453	-
2454	- // --------------------------------------------------------------------------------
2455	- // Function : privAddFileList()
2456	- // Description :
2457	- // Parameters :
2458	- // $p_filedescr_list : An array containing the file description
2459	- // or directory names to add in the zip
2460	- // $p_result_list : list of added files with their properties (specially the status field)
2461	- // Return Values :
2462	- // --------------------------------------------------------------------------------
2463	- function privAddFileList($p_filedescr_list, &$p_result_list, &$p_options)
2464	- {
2465	- $v_result=1;
2466	- $v_header = array();
2467	-
2468	- // ----- Recuperate the current number of elt in list
2469	- $v_nb = sizeof($p_result_list);
2470	-
2471	- // ----- Loop on the files
2472	- for ($j=0; ($j<sizeof($p_filedescr_list)) && ($v_result==1); $j++) {
2473	- // ----- Format the filename
2474	- $p_filedescr_list[$j]['filename']
2475	- = PclZipUtilTranslateWinPath($p_filedescr_list[$j]['filename'], false);
2476	-
2477	-
2478	- // ----- Skip empty file names
2479	- // TBC : Can this be possible ? not checked in DescrParseAtt ?
2480	- if ($p_filedescr_list[$j]['filename'] == "") {
2481	- continue;
2482	- }
2483	-
2484	- // ----- Check the filename
2485	- if ( ($p_filedescr_list[$j]['type'] != 'virtual_file')
2486	- && (!file_exists($p_filedescr_list[$j]['filename']))) {
2487	- PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$p_filedescr_list[$j]['filename']."' does not exist");
2488	- return PclZip::errorCode();
2489	- }
2490	-
2491	- // ----- Look if it is a file or a dir with no all path remove option
2492	- // or a dir with all its path removed
2493	-// if ( (is_file($p_filedescr_list[$j]['filename']))
2494	-// \|\| ( is_dir($p_filedescr_list[$j]['filename'])
2495	- if ( ($p_filedescr_list[$j]['type'] == 'file')
2496	- \|\| ($p_filedescr_list[$j]['type'] == 'virtual_file')
2497	- \|\| ( ($p_filedescr_list[$j]['type'] == 'folder')
2498	- && ( !isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])
2499	- \|\| !$p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))
2500	- ) {
2501	-
2502	- // ----- Add the file
2503	- $v_result = $this->privAddFile($p_filedescr_list[$j], $v_header,
2504	- $p_options);
2505	- if ($v_result != 1) {
2506	- return $v_result;
2507	- }
2508	-
2509	- // ----- Store the file infos
2510	- $p_result_list[$v_nb++] = $v_header;
2511	- }
2512	- }
2513	-
2514	- // ----- Return
2515	- return $v_result;
2516	- }
2517	- // --------------------------------------------------------------------------------
2518	-
2519	- // --------------------------------------------------------------------------------
2520	- // Function : privAddFile()
2521	- // Description :
2522	- // Parameters :
2523	- // Return Values :
2524	- // --------------------------------------------------------------------------------
2525	- function privAddFile($p_filedescr, &$p_header, &$p_options)
2526	- {
2527	- $v_result=1;
2528	-
2529	- // ----- Working variable
2530	- $p_filename = $p_filedescr['filename'];
2531	-
2532	- // TBC : Already done in the fileAtt check ... ?
2533	- if ($p_filename == "") {
2534	- // ----- Error log
2535	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file list parameter (invalid or empty list)");
2536	-
2537	- // ----- Return
2538	- return PclZip::errorCode();
2539	- }
2540	-
2541	- // ----- Look for a stored different filename
2542	- /* TBC : Removed
2543	- if (isset($p_filedescr['stored_filename'])) {
2544	- $v_stored_filename = $p_filedescr['stored_filename'];
2545	- }
2546	- else {
2547	- $v_stored_filename = $p_filedescr['stored_filename'];
2548	- }
2549	- */
2550	-
2551	- // ----- Set the file properties
2552	- clearstatcache();
2553	- $p_header['version'] = 20;
2554	- $p_header['version_extracted'] = 10;
2555	- $p_header['flag'] = 0;
2556	- $p_header['compression'] = 0;
2557	- $p_header['crc'] = 0;
2558	- $p_header['compressed_size'] = 0;
2559	- $p_header['filename_len'] = strlen($p_filename);
2560	- $p_header['extra_len'] = 0;
2561	- $p_header['disk'] = 0;
2562	- $p_header['internal'] = 0;
2563	- $p_header['offset'] = 0;
2564	- $p_header['filename'] = $p_filename;
2565	-// TBC : Removed $p_header['stored_filename'] = $v_stored_filename;
2566	- $p_header['stored_filename'] = $p_filedescr['stored_filename'];
2567	- $p_header['extra'] = '';
2568	- $p_header['status'] = 'ok';
2569	- $p_header['index'] = -1;
2570	-
2571	- // ----- Look for regular file
2572	- if ($p_filedescr['type']=='file') {
2573	- $p_header['external'] = 0x00000000;
2574	- $p_header['size'] = filesize($p_filename);
2575	- }
2576	-
2577	- // ----- Look for regular folder
2578	- else if ($p_filedescr['type']=='folder') {
2579	- $p_header['external'] = 0x00000010;
2580	- $p_header['mtime'] = filemtime($p_filename);
2581	- $p_header['size'] = filesize($p_filename);
2582	- }
2583	-
2584	- // ----- Look for virtual file
2585	- else if ($p_filedescr['type'] == 'virtual_file') {
2586	- $p_header['external'] = 0x00000000;
2587	- $p_header['size'] = strlen($p_filedescr['content']);
2588	- }
2589	-
2590	-
2591	- // ----- Look for filetime
2592	- if (isset($p_filedescr['mtime'])) {
2593	- $p_header['mtime'] = $p_filedescr['mtime'];
2594	- }
2595	- else if ($p_filedescr['type'] == 'virtual_file') {
2596	- $p_header['mtime'] = time();
2597	- }
2598	- else {
2599	- $p_header['mtime'] = filemtime($p_filename);
2600	- }
2601	-
2602	- // ------ Look for file comment
2603	- if (isset($p_filedescr['comment'])) {
2604	- $p_header['comment_len'] = strlen($p_filedescr['comment']);
2605	- $p_header['comment'] = $p_filedescr['comment'];
2606	- }
2607	- else {
2608	- $p_header['comment_len'] = 0;
2609	- $p_header['comment'] = '';
2610	- }
2611	-
2612	- // ----- Look for pre-add callback
2613	- if (isset($p_options[PCLZIP_CB_PRE_ADD])) {
2614	-
2615	- // ----- Generate a local information
2616	- $v_local_header = array();
2617	- $this->privConvertHeader2FileInfo($p_header, $v_local_header);
2618	-
2619	- // ----- Call the callback
2620	- // Here I do not use call_user_func() because I need to send a reference to the
2621	- // header.
2622	-// eval('$v_result = '.$p_options[PCLZIP_CB_PRE_ADD].'(PCLZIP_CB_PRE_ADD, $v_local_header);');
2623	- $v_result = $p_options[PCLZIP_CB_PRE_ADD](PCLZIP_CB_PRE_ADD, $v_local_header);
2624	- if ($v_result == 0) {
2625	- // ----- Change the file status
2626	- $p_header['status'] = "skipped";
2627	- $v_result = 1;
2628	- }
2629	-
2630	- // ----- Update the informations
2631	- // Only some fields can be modified
2632	- if ($p_header['stored_filename'] != $v_local_header['stored_filename']) {
2633	- $p_header['stored_filename'] = PclZipUtilPathReduction($v_local_header['stored_filename']);
2634	- }
2635	- }
2636	-
2637	- // ----- Look for empty stored filename
2638	- if ($p_header['stored_filename'] == "") {
2639	- $p_header['status'] = "filtered";
2640	- }
2641	-
2642	- // ----- Check the path length
2643	- if (strlen($p_header['stored_filename']) > 0xFF) {
2644	- $p_header['status'] = 'filename_too_long';
2645	- }
2646	-
2647	- // ----- Look if no error, or file not skipped
2648	- if ($p_header['status'] == 'ok') {
2649	-
2650	- // ----- Look for a file
2651	- if ($p_filedescr['type'] == 'file') {
2652	- // ----- Look for using temporary file to zip
2653	- if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
2654	- && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
2655	- \|\| (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
2656	- && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_header['size'])) ) ) {
2657	- $v_result = $this->privAddFileUsingTempFile($p_filedescr, $p_header, $p_options);
2658	- if ($v_result < PCLZIP_ERR_NO_ERROR) {
2659	- return $v_result;
2660	- }
2661	- }
2662	-
2663	- // ----- Use "in memory" zip algo
2664	- else {
2665	-
2666	- // ----- Open the source file
2667	- if (($v_file = @fopen($p_filename, "rb")) == 0) {
2668	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
2669	- return PclZip::errorCode();
2670	- }
2671	-
2672	- // ----- Read the file content
2673	- $v_content = @fread($v_file, $p_header['size']);
2674	-
2675	- // ----- Close the file
2676	- @fclose($v_file);
2677	-
2678	- // ----- Calculate the CRC
2679	- $p_header['crc'] = @crc32($v_content);
2680	-
2681	- // ----- Look for no compression
2682	- if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
2683	- // ----- Set header parameters
2684	- $p_header['compressed_size'] = $p_header['size'];
2685	- $p_header['compression'] = 0;
2686	- }
2687	-
2688	- // ----- Look for normal compression
2689	- else {
2690	- // ----- Compress the content
2691	- $v_content = @gzdeflate($v_content);
2692	-
2693	- // ----- Set header parameters
2694	- $p_header['compressed_size'] = strlen($v_content);
2695	- $p_header['compression'] = 8;
2696	- }
2697	-
2698	- // ----- Call the header generation
2699	- if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
2700	- @fclose($v_file);
2701	- return $v_result;
2702	- }
2703	-
2704	- // ----- Write the compressed (or not) content
2705	- @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
2706	-
2707	- }
2708	-
2709	- }
2710	-
2711	- // ----- Look for a virtual file (a file from string)
2712	- else if ($p_filedescr['type'] == 'virtual_file') {
2713	-
2714	- $v_content = $p_filedescr['content'];
2715	-
2716	- // ----- Calculate the CRC
2717	- $p_header['crc'] = @crc32($v_content);
2718	-
2719	- // ----- Look for no compression
2720	- if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
2721	- // ----- Set header parameters
2722	- $p_header['compressed_size'] = $p_header['size'];
2723	- $p_header['compression'] = 0;
2724	- }
2725	-
2726	- // ----- Look for normal compression
2727	- else {
2728	- // ----- Compress the content
2729	- $v_content = @gzdeflate($v_content);
2730	-
2731	- // ----- Set header parameters
2732	- $p_header['compressed_size'] = strlen($v_content);
2733	- $p_header['compression'] = 8;
2734	- }
2735	-
2736	- // ----- Call the header generation
2737	- if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
2738	- @fclose($v_file);
2739	- return $v_result;
2740	- }
2741	-
2742	- // ----- Write the compressed (or not) content
2743	- @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
2744	- }
2745	-
2746	- // ----- Look for a directory
2747	- else if ($p_filedescr['type'] == 'folder') {
2748	- // ----- Look for directory last '/'
2749	- if (@substr($p_header['stored_filename'], -1) != '/') {
2750	- $p_header['stored_filename'] .= '/';
2751	- }
2752	-
2753	- // ----- Set the file properties
2754	- $p_header['size'] = 0;
2755	- //$p_header['external'] = 0x41FF0010; // Value for a folder : to be checked
2756	- $p_header['external'] = 0x00000010; // Value for a folder : to be checked
2757	-
2758	- // ----- Call the header generation
2759	- if (($v_result = $this->privWriteFileHeader($p_header)) != 1)
2760	- {
2761	- return $v_result;
2762	- }
2763	- }
2764	- }
2765	-
2766	- // ----- Look for post-add callback
2767	- if (isset($p_options[PCLZIP_CB_POST_ADD])) {
2768	-
2769	- // ----- Generate a local information
2770	- $v_local_header = array();
2771	- $this->privConvertHeader2FileInfo($p_header, $v_local_header);
2772	-
2773	- // ----- Call the callback
2774	- // Here I do not use call_user_func() because I need to send a reference to the
2775	- // header.
2776	-// eval('$v_result = '.$p_options[PCLZIP_CB_POST_ADD].'(PCLZIP_CB_POST_ADD, $v_local_header);');
2777	- $v_result = $p_options[PCLZIP_CB_POST_ADD](PCLZIP_CB_POST_ADD, $v_local_header);
2778	- if ($v_result == 0) {
2779	- // ----- Ignored
2780	- $v_result = 1;
2781	- }
2782	-
2783	- // ----- Update the informations
2784	- // Nothing can be modified
2785	- }
2786	-
2787	- // ----- Return
2788	- return $v_result;
2789	- }
2790	- // --------------------------------------------------------------------------------
2791	-
2792	- // --------------------------------------------------------------------------------
2793	- // Function : privAddFileUsingTempFile()
2794	- // Description :
2795	- // Parameters :
2796	- // Return Values :
2797	- // --------------------------------------------------------------------------------
2798	- function privAddFileUsingTempFile($p_filedescr, &$p_header, &$p_options)
2799	- {
2800	- $v_result=PCLZIP_ERR_NO_ERROR;
2801	-
2802	- // ----- Working variable
2803	- $p_filename = $p_filedescr['filename'];
2804	-
2805	-
2806	- // ----- Open the source file
2807	- if (($v_file = @fopen($p_filename, "rb")) == 0) {
2808	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
2809	- return PclZip::errorCode();
2810	- }
2811	-
2812	- // ----- Creates a compressed temporary file
2813	- $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
2814	- if (($v_file_compressed = @gzopen($v_gzip_temp_name, "wb")) == 0) {
2815	- fclose($v_file);
2816	- PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
2817	- return PclZip::errorCode();
2818	- }
2819	-
2820	- // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
2821	- $v_size = filesize($p_filename);
2822	- while ($v_size != 0) {
2823	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
2824	- $v_buffer = @fread($v_file, $v_read_size);
2825	- //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
2826	- @gzputs($v_file_compressed, $v_buffer, $v_read_size);
2827	- $v_size -= $v_read_size;
2828	- }
2829	-
2830	- // ----- Close the file
2831	- @fclose($v_file);
2832	- @gzclose($v_file_compressed);
2833	-
2834	- // ----- Check the minimum file size
2835	- if (filesize($v_gzip_temp_name) < 18) {
2836	- PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'gzip temporary file \''.$v_gzip_temp_name.'\' has invalid filesize - should be minimum 18 bytes');
2837	- return PclZip::errorCode();
2838	- }
2839	-
2840	- // ----- Extract the compressed attributes
2841	- if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0) {
2842	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
2843	- return PclZip::errorCode();
2844	- }
2845	-
2846	- // ----- Read the gzip file header
2847	- $v_binary_data = @fread($v_file_compressed, 10);
2848	- $v_data_header = unpack('a1id1/a1id2/a1cm/a1flag/Vmtime/a1xfl/a1os', $v_binary_data);
2849	-
2850	- // ----- Check some parameters
2851	- $v_data_header['os'] = bin2hex($v_data_header['os']);
2852	-
2853	- // ----- Read the gzip file footer
2854	- @fseek($v_file_compressed, filesize($v_gzip_temp_name)-8);
2855	- $v_binary_data = @fread($v_file_compressed, 8);
2856	- $v_data_footer = unpack('Vcrc/Vcompressed_size', $v_binary_data);
2857	-
2858	- // ----- Set the attributes
2859	- $p_header['compression'] = ord($v_data_header['cm']);
2860	- //$p_header['mtime'] = $v_data_header['mtime'];
2861	- $p_header['crc'] = $v_data_footer['crc'];
2862	- $p_header['compressed_size'] = filesize($v_gzip_temp_name)-18;
2863	-
2864	- // ----- Close the file
2865	- @fclose($v_file_compressed);
2866	-
2867	- // ----- Call the header generation
2868	- if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
2869	- return $v_result;
2870	- }
2871	-
2872	- // ----- Add the compressed data
2873	- if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0)
2874	- {
2875	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
2876	- return PclZip::errorCode();
2877	- }
2878	-
2879	- // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
2880	- fseek($v_file_compressed, 10);
2881	- $v_size = $p_header['compressed_size'];
2882	- while ($v_size != 0)
2883	- {
2884	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
2885	- $v_buffer = @fread($v_file_compressed, $v_read_size);
2886	- //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
2887	- @fwrite($this->zip_fd, $v_buffer, $v_read_size);
2888	- $v_size -= $v_read_size;
2889	- }
2890	-
2891	- // ----- Close the file
2892	- @fclose($v_file_compressed);
2893	-
2894	- // ----- Unlink the temporary file
2895	- @unlink($v_gzip_temp_name);
2896	-
2897	- // ----- Return
2898	- return $v_result;
2899	- }
2900	- // --------------------------------------------------------------------------------
2901	-
2902	- // --------------------------------------------------------------------------------
2903	- // Function : privCalculateStoredFilename()
2904	- // Description :
2905	- // Based on file descriptor properties and global options, this method
2906	- // calculate the filename that will be stored in the archive.
2907	- // Parameters :
2908	- // Return Values :
2909	- // --------------------------------------------------------------------------------
2910	- function privCalculateStoredFilename(&$p_filedescr, &$p_options)
2911	- {
2912	- $v_result=1;
2913	-
2914	- // ----- Working variables
2915	- $p_filename = $p_filedescr['filename'];
2916	- if (isset($p_options[PCLZIP_OPT_ADD_PATH])) {
2917	- $p_add_dir = $p_options[PCLZIP_OPT_ADD_PATH];
2918	- }
2919	- else {
2920	- $p_add_dir = '';
2921	- }
2922	- if (isset($p_options[PCLZIP_OPT_REMOVE_PATH])) {
2923	- $p_remove_dir = $p_options[PCLZIP_OPT_REMOVE_PATH];
2924	- }
2925	- else {
2926	- $p_remove_dir = '';
2927	- }
2928	- if (isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
2929	- $p_remove_all_dir = $p_options[PCLZIP_OPT_REMOVE_ALL_PATH];
2930	- }
2931	- else {
2932	- $p_remove_all_dir = 0;
2933	- }
2934	-
2935	-
2936	- // ----- Look for full name change
2937	- if (isset($p_filedescr['new_full_name'])) {
2938	- // ----- Remove drive letter if any
2939	- $v_stored_filename = PclZipUtilTranslateWinPath($p_filedescr['new_full_name']);
2940	- }
2941	-
2942	- // ----- Look for path and/or short name change
2943	- else {
2944	-
2945	- // ----- Look for short name change
2946	- // Its when we cahnge just the filename but not the path
2947	- if (isset($p_filedescr['new_short_name'])) {
2948	- $v_path_info = pathinfo($p_filename);
2949	- $v_dir = '';
2950	- if ($v_path_info['dirname'] != '') {
2951	- $v_dir = $v_path_info['dirname'].'/';
2952	- }
2953	- $v_stored_filename = $v_dir.$p_filedescr['new_short_name'];
2954	- }
2955	- else {
2956	- // ----- Calculate the stored filename
2957	- $v_stored_filename = $p_filename;
2958	- }
2959	-
2960	- // ----- Look for all path to remove
2961	- if ($p_remove_all_dir) {
2962	- $v_stored_filename = basename($p_filename);
2963	- }
2964	- // ----- Look for partial path remove
2965	- else if ($p_remove_dir != "") {
2966	- if (substr($p_remove_dir, -1) != '/')
2967	- $p_remove_dir .= "/";
2968	-
2969	- if ( (substr($p_filename, 0, 2) == "./")
2970	- \|\| (substr($p_remove_dir, 0, 2) == "./")) {
2971	-
2972	- if ( (substr($p_filename, 0, 2) == "./")
2973	- && (substr($p_remove_dir, 0, 2) != "./")) {
2974	- $p_remove_dir = "./".$p_remove_dir;
2975	- }
2976	- if ( (substr($p_filename, 0, 2) != "./")
2977	- && (substr($p_remove_dir, 0, 2) == "./")) {
2978	- $p_remove_dir = substr($p_remove_dir, 2);
2979	- }
2980	- }
2981	-
2982	- $v_compare = PclZipUtilPathInclusion($p_remove_dir,
2983	- $v_stored_filename);
2984	- if ($v_compare > 0) {
2985	- if ($v_compare == 2) {
2986	- $v_stored_filename = "";
2987	- }
2988	- else {
2989	- $v_stored_filename = substr($v_stored_filename,
2990	- strlen($p_remove_dir));
2991	- }
2992	- }
2993	- }
2994	-
2995	- // ----- Remove drive letter if any
2996	- $v_stored_filename = PclZipUtilTranslateWinPath($v_stored_filename);
2997	-
2998	- // ----- Look for path to add
2999	- if ($p_add_dir != "") {
3000	- if (substr($p_add_dir, -1) == "/")
3001	- $v_stored_filename = $p_add_dir.$v_stored_filename;
3002	- else
3003	- $v_stored_filename = $p_add_dir."/".$v_stored_filename;
3004	- }
3005	- }
3006	-
3007	- // ----- Filename (reduce the path of stored name)
3008	- $v_stored_filename = PclZipUtilPathReduction($v_stored_filename);
3009	- $p_filedescr['stored_filename'] = $v_stored_filename;
3010	-
3011	- // ----- Return
3012	- return $v_result;
3013	- }
3014	- // --------------------------------------------------------------------------------
3015	-
3016	- // --------------------------------------------------------------------------------
3017	- // Function : privWriteFileHeader()
3018	- // Description :
3019	- // Parameters :
3020	- // Return Values :
3021	- // --------------------------------------------------------------------------------
3022	- function privWriteFileHeader(&$p_header)
3023	- {
3024	- $v_result=1;
3025	-
3026	- // ----- Store the offset position of the file
3027	- $p_header['offset'] = ftell($this->zip_fd);
3028	-
3029	- // ----- Transform UNIX mtime to DOS format mdate/mtime
3030	- $v_date = getdate($p_header['mtime']);
3031	- $v_mtime = ($v_date['hours']<<11) + ($v_date['minutes']<<5) + $v_date['seconds']/2;
3032	- $v_mdate = (($v_date['year']-1980)<<9) + ($v_date['mon']<<5) + $v_date['mday'];
3033	-
3034	- // ----- Packed data
3035	- $v_binary_data = pack("VvvvvvVVVvv", 0x04034b50,
3036	- $p_header['version_extracted'], $p_header['flag'],
3037	- $p_header['compression'], $v_mtime, $v_mdate,
3038	- $p_header['crc'], $p_header['compressed_size'],
3039	- $p_header['size'],
3040	- strlen($p_header['stored_filename']),
3041	- $p_header['extra_len']);
3042	-
3043	- // ----- Write the first 148 bytes of the header in the archive
3044	- fputs($this->zip_fd, $v_binary_data, 30);
3045	-
3046	- // ----- Write the variable fields
3047	- if (strlen($p_header['stored_filename']) != 0)
3048	- {
3049	- fputs($this->zip_fd, $p_header['stored_filename'], strlen($p_header['stored_filename']));
3050	- }
3051	- if ($p_header['extra_len'] != 0)
3052	- {
3053	- fputs($this->zip_fd, $p_header['extra'], $p_header['extra_len']);
3054	- }
3055	-
3056	- // ----- Return
3057	- return $v_result;
3058	- }
3059	- // --------------------------------------------------------------------------------
3060	-
3061	- // --------------------------------------------------------------------------------
3062	- // Function : privWriteCentralFileHeader()
3063	- // Description :
3064	- // Parameters :
3065	- // Return Values :
3066	- // --------------------------------------------------------------------------------
3067	- function privWriteCentralFileHeader(&$p_header)
3068	- {
3069	- $v_result=1;
3070	-
3071	- // TBC
3072	- //for(reset($p_header); $key = key($p_header); next($p_header)) {
3073	- //}
3074	-
3075	- // ----- Transform UNIX mtime to DOS format mdate/mtime
3076	- $v_date = getdate($p_header['mtime']);
3077	- $v_mtime = ($v_date['hours']<<11) + ($v_date['minutes']<<5) + $v_date['seconds']/2;
3078	- $v_mdate = (($v_date['year']-1980)<<9) + ($v_date['mon']<<5) + $v_date['mday'];
3079	-
3080	-
3081	- // ----- Packed data
3082	- $v_binary_data = pack("VvvvvvvVVVvvvvvVV", 0x02014b50,
3083	- $p_header['version'], $p_header['version_extracted'],
3084	- $p_header['flag'], $p_header['compression'],
3085	- $v_mtime, $v_mdate, $p_header['crc'],
3086	- $p_header['compressed_size'], $p_header['size'],
3087	- strlen($p_header['stored_filename']),
3088	- $p_header['extra_len'], $p_header['comment_len'],
3089	- $p_header['disk'], $p_header['internal'],
3090	- $p_header['external'], $p_header['offset']);
3091	-
3092	- // ----- Write the 42 bytes of the header in the zip file
3093	- fputs($this->zip_fd, $v_binary_data, 46);
3094	-
3095	- // ----- Write the variable fields
3096	- if (strlen($p_header['stored_filename']) != 0)
3097	- {
3098	- fputs($this->zip_fd, $p_header['stored_filename'], strlen($p_header['stored_filename']));
3099	- }
3100	- if ($p_header['extra_len'] != 0)
3101	- {
3102	- fputs($this->zip_fd, $p_header['extra'], $p_header['extra_len']);
3103	- }
3104	- if ($p_header['comment_len'] != 0)
3105	- {
3106	- fputs($this->zip_fd, $p_header['comment'], $p_header['comment_len']);
3107	- }
3108	-
3109	- // ----- Return
3110	- return $v_result;
3111	- }
3112	- // --------------------------------------------------------------------------------
3113	-
3114	- // --------------------------------------------------------------------------------
3115	- // Function : privWriteCentralHeader()
3116	- // Description :
3117	- // Parameters :
3118	- // Return Values :
3119	- // --------------------------------------------------------------------------------
3120	- function privWriteCentralHeader($p_nb_entries, $p_size, $p_offset, $p_comment)
3121	- {
3122	- $v_result=1;
3123	-
3124	- // ----- Packed data
3125	- $v_binary_data = pack("VvvvvVVv", 0x06054b50, 0, 0, $p_nb_entries,
3126	- $p_nb_entries, $p_size,
3127	- $p_offset, strlen($p_comment));
3128	-
3129	- // ----- Write the 22 bytes of the header in the zip file
3130	- fputs($this->zip_fd, $v_binary_data, 22);
3131	-
3132	- // ----- Write the variable fields
3133	- if (strlen($p_comment) != 0)
3134	- {
3135	- fputs($this->zip_fd, $p_comment, strlen($p_comment));
3136	- }
3137	-
3138	- // ----- Return
3139	- return $v_result;
3140	- }
3141	- // --------------------------------------------------------------------------------
3142	-
3143	- // --------------------------------------------------------------------------------
3144	- // Function : privList()
3145	- // Description :
3146	- // Parameters :
3147	- // Return Values :
3148	- // --------------------------------------------------------------------------------
3149	- function privList(&$p_list)
3150	- {
3151	- $v_result=1;
3152	-
3153	- // ----- Magic quotes trick
3154	- $this->privDisableMagicQuotes();
3155	-
3156	- // ----- Open the zip file
3157	- if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
3158	- {
3159	- // ----- Magic quotes trick
3160	- $this->privSwapBackMagicQuotes();
3161	-
3162	- // ----- Error log
3163	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
3164	-
3165	- // ----- Return
3166	- return PclZip::errorCode();
3167	- }
3168	-
3169	- // ----- Read the central directory informations
3170	- $v_central_dir = array();
3171	- if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
3172	- {
3173	- $this->privSwapBackMagicQuotes();
3174	- return $v_result;
3175	- }
3176	-
3177	- // ----- Go to beginning of Central Dir
3178	- @rewind($this->zip_fd);
3179	- if (@fseek($this->zip_fd, $v_central_dir['offset']))
3180	- {
3181	- $this->privSwapBackMagicQuotes();
3182	-
3183	- // ----- Error log
3184	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
3185	-
3186	- // ----- Return
3187	- return PclZip::errorCode();
3188	- }
3189	-
3190	- // ----- Read each entry
3191	- for ($i=0; $i<$v_central_dir['entries']; $i++)
3192	- {
3193	- // ----- Read the file header
3194	- if (($v_result = $this->privReadCentralFileHeader($v_header)) != 1)
3195	- {
3196	- $this->privSwapBackMagicQuotes();
3197	- return $v_result;
3198	- }
3199	- $v_header['index'] = $i;
3200	-
3201	- // ----- Get the only interesting attributes
3202	- $this->privConvertHeader2FileInfo($v_header, $p_list[$i]);
3203	- unset($v_header);
3204	- }
3205	-
3206	- // ----- Close the zip file
3207	- $this->privCloseFd();
3208	-
3209	- // ----- Magic quotes trick
3210	- $this->privSwapBackMagicQuotes();
3211	-
3212	- // ----- Return
3213	- return $v_result;
3214	- }
3215	- // --------------------------------------------------------------------------------
3216	-
3217	- // --------------------------------------------------------------------------------
3218	- // Function : privConvertHeader2FileInfo()
3219	- // Description :
3220	- // This function takes the file informations from the central directory
3221	- // entries and extract the interesting parameters that will be given back.
3222	- // The resulting file infos are set in the array $p_info
3223	- // $p_info['filename'] : Filename with full path. Given by user (add),
3224	- // extracted in the filesystem (extract).
3225	- // $p_info['stored_filename'] : Stored filename in the archive.
3226	- // $p_info['size'] = Size of the file.
3227	- // $p_info['compressed_size'] = Compressed size of the file.
3228	- // $p_info['mtime'] = Last modification date of the file.
3229	- // $p_info['comment'] = Comment associated with the file.
3230	- // $p_info['folder'] = true/false : indicates if the entry is a folder or not.
3231	- // $p_info['status'] = status of the action on the file.
3232	- // $p_info['crc'] = CRC of the file content.
3233	- // Parameters :
3234	- // Return Values :
3235	- // --------------------------------------------------------------------------------
3236	- function privConvertHeader2FileInfo($p_header, &$p_info)
3237	- {
3238	- $v_result=1;
3239	-
3240	- // ----- Get the interesting attributes
3241	- $v_temp_path = PclZipUtilPathReduction($p_header['filename']);
3242	- $p_info['filename'] = $v_temp_path;
3243	- $v_temp_path = PclZipUtilPathReduction($p_header['stored_filename']);
3244	- $p_info['stored_filename'] = $v_temp_path;
3245	- $p_info['size'] = $p_header['size'];
3246	- $p_info['compressed_size'] = $p_header['compressed_size'];
3247	- $p_info['mtime'] = $p_header['mtime'];
3248	- $p_info['comment'] = $p_header['comment'];
3249	- $p_info['folder'] = (($p_header['external']&0x00000010)==0x00000010);
3250	- $p_info['index'] = $p_header['index'];
3251	- $p_info['status'] = $p_header['status'];
3252	- $p_info['crc'] = $p_header['crc'];
3253	-
3254	- // ----- Return
3255	- return $v_result;
3256	- }
3257	- // --------------------------------------------------------------------------------
3258	-
3259	- // --------------------------------------------------------------------------------
3260	- // Function : privExtractByRule()
3261	- // Description :
3262	- // Extract a file or directory depending of rules (by index, by name, ...)
3263	- // Parameters :
3264	- // $p_file_list : An array where will be placed the properties of each
3265	- // extracted file
3266	- // $p_path : Path to add while writing the extracted files
3267	- // $p_remove_path : Path to remove (from the file memorized path) while writing the
3268	- // extracted files. If the path does not match the file path,
3269	- // the file is extracted with its memorized path.
3270	- // $p_remove_path does not apply to 'list' mode.
3271	- // $p_path and $p_remove_path are commulative.
3272	- // Return Values :
3273	- // 1 on success,0 or less on error (see error code list)
3274	- // --------------------------------------------------------------------------------
3275	- function privExtractByRule(&$p_file_list, $p_path, $p_remove_path, $p_remove_all_path, &$p_options)
3276	- {
3277	- $v_result=1;
3278	-
3279	- // ----- Magic quotes trick
3280	- $this->privDisableMagicQuotes();
3281	-
3282	- // ----- Check the path
3283	- if ( ($p_path == "")
3284	- \|\| ( (substr($p_path, 0, 1) != "/")
3285	- && (substr($p_path, 0, 3) != "../")
3286	- && (substr($p_path,1,2)!=":/")))
3287	- $p_path = "./".$p_path;
3288	-
3289	- // ----- Reduce the path last (and duplicated) '/'
3290	- if (($p_path != "./") && ($p_path != "/"))
3291	- {
3292	- // ----- Look for the path end '/'
3293	- while (substr($p_path, -1) == "/")
3294	- {
3295	- $p_path = substr($p_path, 0, strlen($p_path)-1);
3296	- }
3297	- }
3298	-
3299	- // ----- Look for path to remove format (should end by /)
3300	- if (($p_remove_path != "") && (substr($p_remove_path, -1) != '/'))
3301	- {
3302	- $p_remove_path .= '/';
3303	- }
3304	- $p_remove_path_size = strlen($p_remove_path);
3305	-
3306	- // ----- Open the zip file
3307	- if (($v_result = $this->privOpenFd('rb')) != 1)
3308	- {
3309	- $this->privSwapBackMagicQuotes();
3310	- return $v_result;
3311	- }
3312	-
3313	- // ----- Read the central directory informations
3314	- $v_central_dir = array();
3315	- if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
3316	- {
3317	- // ----- Close the zip file
3318	- $this->privCloseFd();
3319	- $this->privSwapBackMagicQuotes();
3320	-
3321	- return $v_result;
3322	- }
3323	-
3324	- // ----- Start at beginning of Central Dir
3325	- $v_pos_entry = $v_central_dir['offset'];
3326	-
3327	- // ----- Read each entry
3328	- $j_start = 0;
3329	- for ($i=0, $v_nb_extracted=0; $i<$v_central_dir['entries']; $i++)
3330	- {
3331	-
3332	- // ----- Read next Central dir entry
3333	- @rewind($this->zip_fd);
3334	- if (@fseek($this->zip_fd, $v_pos_entry))
3335	- {
3336	- // ----- Close the zip file
3337	- $this->privCloseFd();
3338	- $this->privSwapBackMagicQuotes();
3339	-
3340	- // ----- Error log
3341	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
3342	-
3343	- // ----- Return
3344	- return PclZip::errorCode();
3345	- }
3346	-
3347	- // ----- Read the file header
3348	- $v_header = array();
3349	- if (($v_result = $this->privReadCentralFileHeader($v_header)) != 1)
3350	- {
3351	- // ----- Close the zip file
3352	- $this->privCloseFd();
3353	- $this->privSwapBackMagicQuotes();
3354	-
3355	- return $v_result;
3356	- }
3357	-
3358	- // ----- Store the index
3359	- $v_header['index'] = $i;
3360	-
3361	- // ----- Store the file position
3362	- $v_pos_entry = ftell($this->zip_fd);
3363	-
3364	- // ----- Look for the specific extract rules
3365	- $v_extract = false;
3366	-
3367	- // ----- Look for extract by name rule
3368	- if ( (isset($p_options[PCLZIP_OPT_BY_NAME]))
3369	- && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
3370	-
3371	- // ----- Look if the filename is in the list
3372	- for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_extract); $j++) {
3373	-
3374	- // ----- Look for a directory
3375	- if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
3376	-
3377	- // ----- Look if the directory is in the filename path
3378	- if ( (strlen($v_header['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
3379	- && (substr($v_header['stored_filename'], 0, strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
3380	- $v_extract = true;
3381	- }
3382	- }
3383	- // ----- Look for a filename
3384	- elseif ($v_header['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
3385	- $v_extract = true;
3386	- }
3387	- }
3388	- }
3389	-
3390	- // ----- Look for extract by ereg rule
3391	- // ereg() is deprecated with PHP 5.3
3392	- /*
3393	- else if ( (isset($p_options[PCLZIP_OPT_BY_EREG]))
3394	- && ($p_options[PCLZIP_OPT_BY_EREG] != "")) {
3395	-
3396	- if (ereg($p_options[PCLZIP_OPT_BY_EREG], $v_header['stored_filename'])) {
3397	- $v_extract = true;
3398	- }
3399	- }
3400	- */
3401	-
3402	- // ----- Look for extract by preg rule
3403	- else if ( (isset($p_options[PCLZIP_OPT_BY_PREG]))
3404	- && ($p_options[PCLZIP_OPT_BY_PREG] != "")) {
3405	-
3406	- if (preg_match($p_options[PCLZIP_OPT_BY_PREG], $v_header['stored_filename'])) {
3407	- $v_extract = true;
3408	- }
3409	- }
3410	-
3411	- // ----- Look for extract by index rule
3412	- else if ( (isset($p_options[PCLZIP_OPT_BY_INDEX]))
3413	- && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
3414	-
3415	- // ----- Look if the index is in the list
3416	- for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_extract); $j++) {
3417	-
3418	- if (($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i<=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
3419	- $v_extract = true;
3420	- }
3421	- if ($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
3422	- $j_start = $j+1;
3423	- }
3424	-
3425	- if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start']>$i) {
3426	- break;
3427	- }
3428	- }
3429	- }
3430	-
3431	- // ----- Look for no rule, which means extract all the archive
3432	- else {
3433	- $v_extract = true;
3434	- }
3435	-
3436	- // ----- Check compression method
3437	- if ( ($v_extract)
3438	- && ( ($v_header['compression'] != 8)
3439	- && ($v_header['compression'] != 0))) {
3440	- $v_header['status'] = 'unsupported_compression';
3441	-
3442	- // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
3443	- if ( (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
3444	- && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
3445	-
3446	- $this->privSwapBackMagicQuotes();
3447	-
3448	- PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_COMPRESSION,
3449	- "Filename '".$v_header['stored_filename']."' is "
3450	- ."compressed by an unsupported compression "
3451	- ."method (".$v_header['compression'].") ");
3452	-
3453	- return PclZip::errorCode();
3454	- }
3455	- }
3456	-
3457	- // ----- Check encrypted files
3458	- if (($v_extract) && (($v_header['flag'] & 1) == 1)) {
3459	- $v_header['status'] = 'unsupported_encryption';
3460	-
3461	- // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
3462	- if ( (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
3463	- && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
3464	-
3465	- $this->privSwapBackMagicQuotes();
3466	-
3467	- PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION,
3468	- "Unsupported encryption for "
3469	- ." filename '".$v_header['stored_filename']
3470	- ."'");
3471	-
3472	- return PclZip::errorCode();
3473	- }
3474	- }
3475	-
3476	- // ----- Look for real extraction
3477	- if (($v_extract) && ($v_header['status'] != 'ok')) {
3478	- $v_result = $this->privConvertHeader2FileInfo($v_header,
3479	- $p_file_list[$v_nb_extracted++]);
3480	- if ($v_result != 1) {
3481	- $this->privCloseFd();
3482	- $this->privSwapBackMagicQuotes();
3483	- return $v_result;
3484	- }
3485	-
3486	- $v_extract = false;
3487	- }
3488	-
3489	- // ----- Look for real extraction
3490	- if ($v_extract)
3491	- {
3492	-
3493	- // ----- Go to the file position
3494	- @rewind($this->zip_fd);
3495	- if (@fseek($this->zip_fd, $v_header['offset']))
3496	- {
3497	- // ----- Close the zip file
3498	- $this->privCloseFd();
3499	-
3500	- $this->privSwapBackMagicQuotes();
3501	-
3502	- // ----- Error log
3503	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
3504	-
3505	- // ----- Return
3506	- return PclZip::errorCode();
3507	- }
3508	-
3509	- // ----- Look for extraction as string
3510	- if ($p_options[PCLZIP_OPT_EXTRACT_AS_STRING]) {
3511	-
3512	- $v_string = '';
3513	-
3514	- // ----- Extracting the file
3515	- $v_result1 = $this->privExtractFileAsString($v_header, $v_string, $p_options);
3516	- if ($v_result1 < 1) {
3517	- $this->privCloseFd();
3518	- $this->privSwapBackMagicQuotes();
3519	- return $v_result1;
3520	- }
3521	-
3522	- // ----- Get the only interesting attributes
3523	- if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted])) != 1)
3524	- {
3525	- // ----- Close the zip file
3526	- $this->privCloseFd();
3527	- $this->privSwapBackMagicQuotes();
3528	-
3529	- return $v_result;
3530	- }
3531	-
3532	- // ----- Set the file content
3533	- $p_file_list[$v_nb_extracted]['content'] = $v_string;
3534	-
3535	- // ----- Next extracted file
3536	- $v_nb_extracted++;
3537	-
3538	- // ----- Look for user callback abort
3539	- if ($v_result1 == 2) {
3540	- break;
3541	- }
3542	- }
3543	- // ----- Look for extraction in standard output
3544	- elseif ( (isset($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT]))
3545	- && ($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT])) {
3546	- // ----- Extracting the file in standard output
3547	- $v_result1 = $this->privExtractFileInOutput($v_header, $p_options);
3548	- if ($v_result1 < 1) {
3549	- $this->privCloseFd();
3550	- $this->privSwapBackMagicQuotes();
3551	- return $v_result1;
3552	- }
3553	-
3554	- // ----- Get the only interesting attributes
3555	- if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted++])) != 1) {
3556	- $this->privCloseFd();
3557	- $this->privSwapBackMagicQuotes();
3558	- return $v_result;
3559	- }
3560	-
3561	- // ----- Look for user callback abort
3562	- if ($v_result1 == 2) {
3563	- break;
3564	- }
3565	- }
3566	- // ----- Look for normal extraction
3567	- else {
3568	- // ----- Extracting the file
3569	- $v_result1 = $this->privExtractFile($v_header,
3570	- $p_path, $p_remove_path,
3571	- $p_remove_all_path,
3572	- $p_options);
3573	- if ($v_result1 < 1) {
3574	- $this->privCloseFd();
3575	- $this->privSwapBackMagicQuotes();
3576	- return $v_result1;
3577	- }
3578	-
3579	- // ----- Get the only interesting attributes
3580	- if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted++])) != 1)
3581	- {
3582	- // ----- Close the zip file
3583	- $this->privCloseFd();
3584	- $this->privSwapBackMagicQuotes();
3585	-
3586	- return $v_result;
3587	- }
3588	-
3589	- // ----- Look for user callback abort
3590	- if ($v_result1 == 2) {
3591	- break;
3592	- }
3593	- }
3594	- }
3595	- }
3596	-
3597	- // ----- Close the zip file
3598	- $this->privCloseFd();
3599	- $this->privSwapBackMagicQuotes();
3600	-
3601	- // ----- Return
3602	- return $v_result;
3603	- }
3604	- // --------------------------------------------------------------------------------
3605	-
3606	- // --------------------------------------------------------------------------------
3607	- // Function : privExtractFile()
3608	- // Description :
3609	- // Parameters :
3610	- // Return Values :
3611	- //
3612	- // 1 : ... ?
3613	- // PCLZIP_ERR_USER_ABORTED(2) : User ask for extraction stop in callback
3614	- // --------------------------------------------------------------------------------
3615	- function privExtractFile(&$p_entry, $p_path, $p_remove_path, $p_remove_all_path, &$p_options)
3616	- {
3617	- $v_result=1;
3618	-
3619	- // ----- Read the file header
3620	- if (($v_result = $this->privReadFileHeader($v_header)) != 1)
3621	- {
3622	- // ----- Return
3623	- return $v_result;
3624	- }
3625	-
3626	-
3627	- // ----- Check that the file header is coherent with $p_entry info
3628	- if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
3629	- // TBC
3630	- }
3631	-
3632	- // ----- Look for all path to remove
3633	- if ($p_remove_all_path == true) {
3634	- // ----- Look for folder entry that not need to be extracted
3635	- if (($p_entry['external']&0x00000010)==0x00000010) {
3636	-
3637	- $p_entry['status'] = "filtered";
3638	-
3639	- return $v_result;
3640	- }
3641	-
3642	- // ----- Get the basename of the path
3643	- $p_entry['filename'] = basename($p_entry['filename']);
3644	- }
3645	-
3646	- // ----- Look for path to remove
3647	- else if ($p_remove_path != "")
3648	- {
3649	- if (PclZipUtilPathInclusion($p_remove_path, $p_entry['filename']) == 2)
3650	- {
3651	-
3652	- // ----- Change the file status
3653	- $p_entry['status'] = "filtered";
3654	-
3655	- // ----- Return
3656	- return $v_result;
3657	- }
3658	-
3659	- $p_remove_path_size = strlen($p_remove_path);
3660	- if (substr($p_entry['filename'], 0, $p_remove_path_size) == $p_remove_path)
3661	- {
3662	-
3663	- // ----- Remove the path
3664	- $p_entry['filename'] = substr($p_entry['filename'], $p_remove_path_size);
3665	-
3666	- }
3667	- }
3668	-
3669	- // ----- Add the path
3670	- if ($p_path != '') {
3671	- $p_entry['filename'] = $p_path."/".$p_entry['filename'];
3672	- }
3673	-
3674	- // ----- Check a base_dir_restriction
3675	- if (isset($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION])) {
3676	- $v_inclusion
3677	- = PclZipUtilPathInclusion($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION],
3678	- $p_entry['filename']);
3679	- if ($v_inclusion == 0) {
3680	-
3681	- PclZip::privErrorLog(PCLZIP_ERR_DIRECTORY_RESTRICTION,
3682	- "Filename '".$p_entry['filename']."' is "
3683	- ."outside PCLZIP_OPT_EXTRACT_DIR_RESTRICTION");
3684	-
3685	- return PclZip::errorCode();
3686	- }
3687	- }
3688	-
3689	- // ----- Look for pre-extract callback
3690	- if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
3691	-
3692	- // ----- Generate a local information
3693	- $v_local_header = array();
3694	- $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
3695	-
3696	- // ----- Call the callback
3697	- // Here I do not use call_user_func() because I need to send a reference to the
3698	- // header.
3699	-// eval('$v_result = '.$p_options[PCLZIP_CB_PRE_EXTRACT].'(PCLZIP_CB_PRE_EXTRACT, $v_local_header);');
3700	- $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
3701	- if ($v_result == 0) {
3702	- // ----- Change the file status
3703	- $p_entry['status'] = "skipped";
3704	- $v_result = 1;
3705	- }
3706	-
3707	- // ----- Look for abort result
3708	- if ($v_result == 2) {
3709	- // ----- This status is internal and will be changed in 'skipped'
3710	- $p_entry['status'] = "aborted";
3711	- $v_result = PCLZIP_ERR_USER_ABORTED;
3712	- }
3713	-
3714	- // ----- Update the informations
3715	- // Only some fields can be modified
3716	- $p_entry['filename'] = $v_local_header['filename'];
3717	- }
3718	-
3719	-
3720	- // ----- Look if extraction should be done
3721	- if ($p_entry['status'] == 'ok') {
3722	-
3723	- // ----- Look for specific actions while the file exist
3724	- if (file_exists($p_entry['filename']))
3725	- {
3726	-
3727	- // ----- Look if file is a directory
3728	- if (is_dir($p_entry['filename']))
3729	- {
3730	-
3731	- // ----- Change the file status
3732	- $p_entry['status'] = "already_a_directory";
3733	-
3734	- // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
3735	- // For historical reason first PclZip implementation does not stop
3736	- // when this kind of error occurs.
3737	- if ( (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
3738	- && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
3739	-
3740	- PclZip::privErrorLog(PCLZIP_ERR_ALREADY_A_DIRECTORY,
3741	- "Filename '".$p_entry['filename']."' is "
3742	- ."already used by an existing directory");
3743	-
3744	- return PclZip::errorCode();
3745	- }
3746	- }
3747	- // ----- Look if file is write protected
3748	- else if (!is_writeable($p_entry['filename']))
3749	- {
3750	-
3751	- // ----- Change the file status
3752	- $p_entry['status'] = "write_protected";
3753	-
3754	- // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
3755	- // For historical reason first PclZip implementation does not stop
3756	- // when this kind of error occurs.
3757	- if ( (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
3758	- && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
3759	-
3760	- PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
3761	- "Filename '".$p_entry['filename']."' exists "
3762	- ."and is write protected");
3763	-
3764	- return PclZip::errorCode();
3765	- }
3766	- }
3767	-
3768	- // ----- Look if the extracted file is older
3769	- else if (filemtime($p_entry['filename']) > $p_entry['mtime'])
3770	- {
3771	- // ----- Change the file status
3772	- if ( (isset($p_options[PCLZIP_OPT_REPLACE_NEWER]))
3773	- && ($p_options[PCLZIP_OPT_REPLACE_NEWER]===true)) {
3774	- }
3775	- else {
3776	- $p_entry['status'] = "newer_exist";
3777	-
3778	- // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
3779	- // For historical reason first PclZip implementation does not stop
3780	- // when this kind of error occurs.
3781	- if ( (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
3782	- && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
3783	-
3784	- PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
3785	- "Newer version of '".$p_entry['filename']."' exists "
3786	- ."and option PCLZIP_OPT_REPLACE_NEWER is not selected");
3787	-
3788	- return PclZip::errorCode();
3789	- }
3790	- }
3791	- }
3792	- else {
3793	- }
3794	- }
3795	-
3796	- // ----- Check the directory availability and create it if necessary
3797	- else {
3798	- if ((($p_entry['external']&0x00000010)==0x00000010) \|\| (substr($p_entry['filename'], -1) == '/'))
3799	- $v_dir_to_check = $p_entry['filename'];
3800	- else if (!strstr($p_entry['filename'], "/"))
3801	- $v_dir_to_check = "";
3802	- else
3803	- $v_dir_to_check = dirname($p_entry['filename']);
3804	-
3805	- if (($v_result = $this->privDirCheck($v_dir_to_check, (($p_entry['external']&0x00000010)==0x00000010))) != 1) {
3806	-
3807	- // ----- Change the file status
3808	- $p_entry['status'] = "path_creation_fail";
3809	-
3810	- // ----- Return
3811	- //return $v_result;
3812	- $v_result = 1;
3813	- }
3814	- }
3815	- }
3816	-
3817	- // ----- Look if extraction should be done
3818	- if ($p_entry['status'] == 'ok') {
3819	-
3820	- // ----- Do the extraction (if not a folder)
3821	- if (!(($p_entry['external']&0x00000010)==0x00000010))
3822	- {
3823	- // ----- Look for not compressed file
3824	- if ($p_entry['compression'] == 0) {
3825	-
3826	- // ----- Opening destination file
3827	- if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0)
3828	- {
3829	-
3830	- // ----- Change the file status
3831	- $p_entry['status'] = "write_error";
3832	-
3833	- // ----- Return
3834	- return $v_result;
3835	- }
3836	-
3837	-
3838	- // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
3839	- $v_size = $p_entry['compressed_size'];
3840	- while ($v_size != 0)
3841	- {
3842	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
3843	- $v_buffer = @fread($this->zip_fd, $v_read_size);
3844	- /* Try to speed up the code
3845	- $v_binary_data = pack('a'.$v_read_size, $v_buffer);
3846	- @fwrite($v_dest_file, $v_binary_data, $v_read_size);
3847	- */
3848	- @fwrite($v_dest_file, $v_buffer, $v_read_size);
3849	- $v_size -= $v_read_size;
3850	- }
3851	-
3852	- // ----- Closing the destination file
3853	- fclose($v_dest_file);
3854	-
3855	- // ----- Change the file mtime
3856	- touch($p_entry['filename'], $p_entry['mtime']);
3857	-
3858	-
3859	- }
3860	- else {
3861	- // ----- TBC
3862	- // Need to be finished
3863	- if (($p_entry['flag'] & 1) == 1) {
3864	- PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION, 'File \''.$p_entry['filename'].'\' is encrypted. Encrypted files are not supported.');
3865	- return PclZip::errorCode();
3866	- }
3867	-
3868	-
3869	- // ----- Look for using temporary file to unzip
3870	- if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
3871	- && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
3872	- \|\| (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
3873	- && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_entry['size'])) ) ) {
3874	- $v_result = $this->privExtractFileUsingTempFile($p_entry, $p_options);
3875	- if ($v_result < PCLZIP_ERR_NO_ERROR) {
3876	- return $v_result;
3877	- }
3878	- }
3879	-
3880	- // ----- Look for extract in memory
3881	- else {
3882	-
3883	-
3884	- // ----- Read the compressed file in a buffer (one shot)
3885	- $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
3886	-
3887	- // ----- Decompress the file
3888	- $v_file_content = @gzinflate($v_buffer);
3889	- unset($v_buffer);
3890	- if ($v_file_content === FALSE) {
3891	-
3892	- // ----- Change the file status
3893	- // TBC
3894	- $p_entry['status'] = "error";
3895	-
3896	- return $v_result;
3897	- }
3898	-
3899	- // ----- Opening destination file
3900	- if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
3901	-
3902	- // ----- Change the file status
3903	- $p_entry['status'] = "write_error";
3904	-
3905	- return $v_result;
3906	- }
3907	-
3908	- // ----- Write the uncompressed data
3909	- @fwrite($v_dest_file, $v_file_content, $p_entry['size']);
3910	- unset($v_file_content);
3911	-
3912	- // ----- Closing the destination file
3913	- @fclose($v_dest_file);
3914	-
3915	- }
3916	-
3917	- // ----- Change the file mtime
3918	- @touch($p_entry['filename'], $p_entry['mtime']);
3919	- }
3920	-
3921	- // ----- Look for chmod option
3922	- if (isset($p_options[PCLZIP_OPT_SET_CHMOD])) {
3923	-
3924	- // ----- Change the mode of the file
3925	- @chmod($p_entry['filename'], $p_options[PCLZIP_OPT_SET_CHMOD]);
3926	- }
3927	-
3928	- }
3929	- }
3930	-
3931	- // ----- Change abort status
3932	- if ($p_entry['status'] == "aborted") {
3933	- $p_entry['status'] = "skipped";
3934	- }
3935	-
3936	- // ----- Look for post-extract callback
3937	- elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
3938	-
3939	- // ----- Generate a local information
3940	- $v_local_header = array();
3941	- $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
3942	-
3943	- // ----- Call the callback
3944	- // Here I do not use call_user_func() because I need to send a reference to the
3945	- // header.
3946	-// eval('$v_result = '.$p_options[PCLZIP_CB_POST_EXTRACT].'(PCLZIP_CB_POST_EXTRACT, $v_local_header);');
3947	- $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
3948	-
3949	- // ----- Look for abort result
3950	- if ($v_result == 2) {
3951	- $v_result = PCLZIP_ERR_USER_ABORTED;
3952	- }
3953	- }
3954	-
3955	- // ----- Return
3956	- return $v_result;
3957	- }
3958	- // --------------------------------------------------------------------------------
3959	-
3960	- // --------------------------------------------------------------------------------
3961	- // Function : privExtractFileUsingTempFile()
3962	- // Description :
3963	- // Parameters :
3964	- // Return Values :
3965	- // --------------------------------------------------------------------------------
3966	- function privExtractFileUsingTempFile(&$p_entry, &$p_options)
3967	- {
3968	- $v_result=1;
3969	-
3970	- // ----- Creates a temporary file
3971	- $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
3972	- if (($v_dest_file = @fopen($v_gzip_temp_name, "wb")) == 0) {
3973	- fclose($v_file);
3974	- PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
3975	- return PclZip::errorCode();
3976	- }
3977	-
3978	-
3979	- // ----- Write gz file format header
3980	- $v_binary_data = pack('va1a1Va1a1', 0x8b1f, Chr($p_entry['compression']), Chr(0x00), time(), Chr(0x00), Chr(3));
3981	- @fwrite($v_dest_file, $v_binary_data, 10);
3982	-
3983	- // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
3984	- $v_size = $p_entry['compressed_size'];
3985	- while ($v_size != 0)
3986	- {
3987	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
3988	- $v_buffer = @fread($this->zip_fd, $v_read_size);
3989	- //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
3990	- @fwrite($v_dest_file, $v_buffer, $v_read_size);
3991	- $v_size -= $v_read_size;
3992	- }
3993	-
3994	- // ----- Write gz file format footer
3995	- $v_binary_data = pack('VV', $p_entry['crc'], $p_entry['size']);
3996	- @fwrite($v_dest_file, $v_binary_data, 8);
3997	-
3998	- // ----- Close the temporary file
3999	- @fclose($v_dest_file);
4000	-
4001	- // ----- Opening destination file
4002	- if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
4003	- $p_entry['status'] = "write_error";
4004	- return $v_result;
4005	- }
4006	-
4007	- // ----- Open the temporary gz file
4008	- if (($v_src_file = @gzopen($v_gzip_temp_name, 'rb')) == 0) {
4009	- @fclose($v_dest_file);
4010	- $p_entry['status'] = "read_error";
4011	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
4012	- return PclZip::errorCode();
4013	- }
4014	-
4015	-
4016	- // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
4017	- $v_size = $p_entry['size'];
4018	- while ($v_size != 0) {
4019	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
4020	- $v_buffer = @gzread($v_src_file, $v_read_size);
4021	- //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
4022	- @fwrite($v_dest_file, $v_buffer, $v_read_size);
4023	- $v_size -= $v_read_size;
4024	- }
4025	- @fclose($v_dest_file);
4026	- @gzclose($v_src_file);
4027	-
4028	- // ----- Delete the temporary file
4029	- @unlink($v_gzip_temp_name);
4030	-
4031	- // ----- Return
4032	- return $v_result;
4033	- }
4034	- // --------------------------------------------------------------------------------
4035	-
4036	- // --------------------------------------------------------------------------------
4037	- // Function : privExtractFileInOutput()
4038	- // Description :
4039	- // Parameters :
4040	- // Return Values :
4041	- // --------------------------------------------------------------------------------
4042	- function privExtractFileInOutput(&$p_entry, &$p_options)
4043	- {
4044	- $v_result=1;
4045	-
4046	- // ----- Read the file header
4047	- if (($v_result = $this->privReadFileHeader($v_header)) != 1) {
4048	- return $v_result;
4049	- }
4050	-
4051	-
4052	- // ----- Check that the file header is coherent with $p_entry info
4053	- if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
4054	- // TBC
4055	- }
4056	-
4057	- // ----- Look for pre-extract callback
4058	- if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
4059	-
4060	- // ----- Generate a local information
4061	- $v_local_header = array();
4062	- $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
4063	-
4064	- // ----- Call the callback
4065	- // Here I do not use call_user_func() because I need to send a reference to the
4066	- // header.
4067	-// eval('$v_result = '.$p_options[PCLZIP_CB_PRE_EXTRACT].'(PCLZIP_CB_PRE_EXTRACT, $v_local_header);');
4068	- $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
4069	- if ($v_result == 0) {
4070	- // ----- Change the file status
4071	- $p_entry['status'] = "skipped";
4072	- $v_result = 1;
4073	- }
4074	-
4075	- // ----- Look for abort result
4076	- if ($v_result == 2) {
4077	- // ----- This status is internal and will be changed in 'skipped'
4078	- $p_entry['status'] = "aborted";
4079	- $v_result = PCLZIP_ERR_USER_ABORTED;
4080	- }
4081	-
4082	- // ----- Update the informations
4083	- // Only some fields can be modified
4084	- $p_entry['filename'] = $v_local_header['filename'];
4085	- }
4086	-
4087	- // ----- Trace
4088	-
4089	- // ----- Look if extraction should be done
4090	- if ($p_entry['status'] == 'ok') {
4091	-
4092	- // ----- Do the extraction (if not a folder)
4093	- if (!(($p_entry['external']&0x00000010)==0x00000010)) {
4094	- // ----- Look for not compressed file
4095	- if ($p_entry['compressed_size'] == $p_entry['size']) {
4096	-
4097	- // ----- Read the file in a buffer (one shot)
4098	- $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
4099	-
4100	- // ----- Send the file to the output
4101	- echo $v_buffer;
4102	- unset($v_buffer);
4103	- }
4104	- else {
4105	-
4106	- // ----- Read the compressed file in a buffer (one shot)
4107	- $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
4108	-
4109	- // ----- Decompress the file
4110	- $v_file_content = gzinflate($v_buffer);
4111	- unset($v_buffer);
4112	-
4113	- // ----- Send the file to the output
4114	- echo $v_file_content;
4115	- unset($v_file_content);
4116	- }
4117	- }
4118	- }
4119	-
4120	- // ----- Change abort status
4121	- if ($p_entry['status'] == "aborted") {
4122	- $p_entry['status'] = "skipped";
4123	- }
4124	-
4125	- // ----- Look for post-extract callback
4126	- elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
4127	-
4128	- // ----- Generate a local information
4129	- $v_local_header = array();
4130	- $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
4131	-
4132	- // ----- Call the callback
4133	- // Here I do not use call_user_func() because I need to send a reference to the
4134	- // header.
4135	-// eval('$v_result = '.$p_options[PCLZIP_CB_POST_EXTRACT].'(PCLZIP_CB_POST_EXTRACT, $v_local_header);');
4136	- $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
4137	-
4138	- // ----- Look for abort result
4139	- if ($v_result == 2) {
4140	- $v_result = PCLZIP_ERR_USER_ABORTED;
4141	- }
4142	- }
4143	-
4144	- return $v_result;
4145	- }
4146	- // --------------------------------------------------------------------------------
4147	-
4148	- // --------------------------------------------------------------------------------
4149	- // Function : privExtractFileAsString()
4150	- // Description :
4151	- // Parameters :
4152	- // Return Values :
4153	- // --------------------------------------------------------------------------------
4154	- function privExtractFileAsString(&$p_entry, &$p_string, &$p_options)
4155	- {
4156	- $v_result=1;
4157	-
4158	- // ----- Read the file header
4159	- $v_header = array();
4160	- if (($v_result = $this->privReadFileHeader($v_header)) != 1)
4161	- {
4162	- // ----- Return
4163	- return $v_result;
4164	- }
4165	-
4166	-
4167	- // ----- Check that the file header is coherent with $p_entry info
4168	- if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
4169	- // TBC
4170	- }
4171	-
4172	- // ----- Look for pre-extract callback
4173	- if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
4174	-
4175	- // ----- Generate a local information
4176	- $v_local_header = array();
4177	- $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
4178	-
4179	- // ----- Call the callback
4180	- // Here I do not use call_user_func() because I need to send a reference to the
4181	- // header.
4182	-// eval('$v_result = '.$p_options[PCLZIP_CB_PRE_EXTRACT].'(PCLZIP_CB_PRE_EXTRACT, $v_local_header);');
4183	- $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
4184	- if ($v_result == 0) {
4185	- // ----- Change the file status
4186	- $p_entry['status'] = "skipped";
4187	- $v_result = 1;
4188	- }
4189	-
4190	- // ----- Look for abort result
4191	- if ($v_result == 2) {
4192	- // ----- This status is internal and will be changed in 'skipped'
4193	- $p_entry['status'] = "aborted";
4194	- $v_result = PCLZIP_ERR_USER_ABORTED;
4195	- }
4196	-
4197	- // ----- Update the informations
4198	- // Only some fields can be modified
4199	- $p_entry['filename'] = $v_local_header['filename'];
4200	- }
4201	-
4202	-
4203	- // ----- Look if extraction should be done
4204	- if ($p_entry['status'] == 'ok') {
4205	-
4206	- // ----- Do the extraction (if not a folder)
4207	- if (!(($p_entry['external']&0x00000010)==0x00000010)) {
4208	- // ----- Look for not compressed file
4209	- // if ($p_entry['compressed_size'] == $p_entry['size'])
4210	- if ($p_entry['compression'] == 0) {
4211	-
4212	- // ----- Reading the file
4213	- $p_string = @fread($this->zip_fd, $p_entry['compressed_size']);
4214	- }
4215	- else {
4216	-
4217	- // ----- Reading the file
4218	- $v_data = @fread($this->zip_fd, $p_entry['compressed_size']);
4219	-
4220	- // ----- Decompress the file
4221	- if (($p_string = @gzinflate($v_data)) === FALSE) {
4222	- // TBC
4223	- }
4224	- }
4225	-
4226	- // ----- Trace
4227	- }
4228	- else {
4229	- // TBC : error : can not extract a folder in a string
4230	- }
4231	-
4232	- }
4233	-
4234	- // ----- Change abort status
4235	- if ($p_entry['status'] == "aborted") {
4236	- $p_entry['status'] = "skipped";
4237	- }
4238	-
4239	- // ----- Look for post-extract callback
4240	- elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
4241	-
4242	- // ----- Generate a local information
4243	- $v_local_header = array();
4244	- $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
4245	-
4246	- // ----- Swap the content to header
4247	- $v_local_header['content'] = $p_string;
4248	- $p_string = '';
4249	-
4250	- // ----- Call the callback
4251	- // Here I do not use call_user_func() because I need to send a reference to the
4252	- // header.
4253	-// eval('$v_result = '.$p_options[PCLZIP_CB_POST_EXTRACT].'(PCLZIP_CB_POST_EXTRACT, $v_local_header);');
4254	- $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
4255	-
4256	- // ----- Swap back the content to header
4257	- $p_string = $v_local_header['content'];
4258	- unset($v_local_header['content']);
4259	-
4260	- // ----- Look for abort result
4261	- if ($v_result == 2) {
4262	- $v_result = PCLZIP_ERR_USER_ABORTED;
4263	- }
4264	- }
4265	-
4266	- // ----- Return
4267	- return $v_result;
4268	- }
4269	- // --------------------------------------------------------------------------------
4270	-
4271	- // --------------------------------------------------------------------------------
4272	- // Function : privReadFileHeader()
4273	- // Description :
4274	- // Parameters :
4275	- // Return Values :
4276	- // --------------------------------------------------------------------------------
4277	- function privReadFileHeader(&$p_header)
4278	- {
4279	- $v_result=1;
4280	-
4281	- // ----- Read the 4 bytes signature
4282	- $v_binary_data = @fread($this->zip_fd, 4);
4283	- $v_data = unpack('Vid', $v_binary_data);
4284	-
4285	- // ----- Check signature
4286	- if ($v_data['id'] != 0x04034b50)
4287	- {
4288	-
4289	- // ----- Error log
4290	- PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Invalid archive structure');
4291	-
4292	- // ----- Return
4293	- return PclZip::errorCode();
4294	- }
4295	-
4296	- // ----- Read the first 42 bytes of the header
4297	- $v_binary_data = fread($this->zip_fd, 26);
4298	-
4299	- // ----- Look for invalid block size
4300	- if (strlen($v_binary_data) != 26)
4301	- {
4302	- $p_header['filename'] = "";
4303	- $p_header['status'] = "invalid_header";
4304	-
4305	- // ----- Error log
4306	- PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : ".strlen($v_binary_data));
4307	-
4308	- // ----- Return
4309	- return PclZip::errorCode();
4310	- }
4311	-
4312	- // ----- Extract the values
4313	- $v_data = unpack('vversion/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len', $v_binary_data);
4314	-
4315	- // ----- Get filename
4316	- $p_header['filename'] = fread($this->zip_fd, $v_data['filename_len']);
4317	-
4318	- // ----- Get extra_fields
4319	- if ($v_data['extra_len'] != 0) {
4320	- $p_header['extra'] = fread($this->zip_fd, $v_data['extra_len']);
4321	- }
4322	- else {
4323	- $p_header['extra'] = '';
4324	- }
4325	-
4326	- // ----- Extract properties
4327	- $p_header['version_extracted'] = $v_data['version'];
4328	- $p_header['compression'] = $v_data['compression'];
4329	- $p_header['size'] = $v_data['size'];
4330	- $p_header['compressed_size'] = $v_data['compressed_size'];
4331	- $p_header['crc'] = $v_data['crc'];
4332	- $p_header['flag'] = $v_data['flag'];
4333	- $p_header['filename_len'] = $v_data['filename_len'];
4334	-
4335	- // ----- Recuperate date in UNIX format
4336	- $p_header['mdate'] = $v_data['mdate'];
4337	- $p_header['mtime'] = $v_data['mtime'];
4338	- if ($p_header['mdate'] && $p_header['mtime'])
4339	- {
4340	- // ----- Extract time
4341	- $v_hour = ($p_header['mtime'] & 0xF800) >> 11;
4342	- $v_minute = ($p_header['mtime'] & 0x07E0) >> 5;
4343	- $v_seconde = ($p_header['mtime'] & 0x001F)*2;
4344	-
4345	- // ----- Extract date
4346	- $v_year = (($p_header['mdate'] & 0xFE00) >> 9) + 1980;
4347	- $v_month = ($p_header['mdate'] & 0x01E0) >> 5;
4348	- $v_day = $p_header['mdate'] & 0x001F;
4349	-
4350	- // ----- Get UNIX date format
4351	- $p_header['mtime'] = @mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
4352	-
4353	- }
4354	- else
4355	- {
4356	- $p_header['mtime'] = time();
4357	- }
4358	-
4359	- // TBC
4360	- //for(reset($v_data); $key = key($v_data); next($v_data)) {
4361	- //}
4362	-
4363	- // ----- Set the stored filename
4364	- $p_header['stored_filename'] = $p_header['filename'];
4365	-
4366	- // ----- Set the status field
4367	- $p_header['status'] = "ok";
4368	-
4369	- // ----- Return
4370	- return $v_result;
4371	- }
4372	- // --------------------------------------------------------------------------------
4373	-
4374	- // --------------------------------------------------------------------------------
4375	- // Function : privReadCentralFileHeader()
4376	- // Description :
4377	- // Parameters :
4378	- // Return Values :
4379	- // --------------------------------------------------------------------------------
4380	- function privReadCentralFileHeader(&$p_header)
4381	- {
4382	- $v_result=1;
4383	-
4384	- // ----- Read the 4 bytes signature
4385	- $v_binary_data = @fread($this->zip_fd, 4);
4386	- $v_data = unpack('Vid', $v_binary_data);
4387	-
4388	- // ----- Check signature
4389	- if ($v_data['id'] != 0x02014b50)
4390	- {
4391	-
4392	- // ----- Error log
4393	- PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Invalid archive structure');
4394	-
4395	- // ----- Return
4396	- return PclZip::errorCode();
4397	- }
4398	-
4399	- // ----- Read the first 42 bytes of the header
4400	- $v_binary_data = fread($this->zip_fd, 42);
4401	-
4402	- // ----- Look for invalid block size
4403	- if (strlen($v_binary_data) != 42)
4404	- {
4405	- $p_header['filename'] = "";
4406	- $p_header['status'] = "invalid_header";
4407	-
4408	- // ----- Error log
4409	- PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : ".strlen($v_binary_data));
4410	-
4411	- // ----- Return
4412	- return PclZip::errorCode();
4413	- }
4414	-
4415	- // ----- Extract the values
4416	- $p_header = unpack('vversion/vversion_extracted/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len/vcomment_len/vdisk/vinternal/Vexternal/Voffset', $v_binary_data);
4417	-
4418	- // ----- Get filename
4419	- if ($p_header['filename_len'] != 0)
4420	- $p_header['filename'] = fread($this->zip_fd, $p_header['filename_len']);
4421	- else
4422	- $p_header['filename'] = '';
4423	-
4424	- // ----- Get extra
4425	- if ($p_header['extra_len'] != 0)
4426	- $p_header['extra'] = fread($this->zip_fd, $p_header['extra_len']);
4427	- else
4428	- $p_header['extra'] = '';
4429	-
4430	- // ----- Get comment
4431	- if ($p_header['comment_len'] != 0)
4432	- $p_header['comment'] = fread($this->zip_fd, $p_header['comment_len']);
4433	- else
4434	- $p_header['comment'] = '';
4435	-
4436	- // ----- Extract properties
4437	-
4438	- // ----- Recuperate date in UNIX format
4439	- //if ($p_header['mdate'] && $p_header['mtime'])
4440	- // TBC : bug : this was ignoring time with 0/0/0
4441	- if (1)
4442	- {
4443	- // ----- Extract time
4444	- $v_hour = ($p_header['mtime'] & 0xF800) >> 11;
4445	- $v_minute = ($p_header['mtime'] & 0x07E0) >> 5;
4446	- $v_seconde = ($p_header['mtime'] & 0x001F)*2;
4447	-
4448	- // ----- Extract date
4449	- $v_year = (($p_header['mdate'] & 0xFE00) >> 9) + 1980;
4450	- $v_month = ($p_header['mdate'] & 0x01E0) >> 5;
4451	- $v_day = $p_header['mdate'] & 0x001F;
4452	-
4453	- // ----- Get UNIX date format
4454	- $p_header['mtime'] = @mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
4455	-
4456	- }
4457	- else
4458	- {
4459	- $p_header['mtime'] = time();
4460	- }
4461	-
4462	- // ----- Set the stored filename
4463	- $p_header['stored_filename'] = $p_header['filename'];
4464	-
4465	- // ----- Set default status to ok
4466	- $p_header['status'] = 'ok';
4467	-
4468	- // ----- Look if it is a directory
4469	- if (substr($p_header['filename'], -1) == '/') {
4470	- //$p_header['external'] = 0x41FF0010;
4471	- $p_header['external'] = 0x00000010;
4472	- }
4473	-
4474	-
4475	- // ----- Return
4476	- return $v_result;
4477	- }
4478	- // --------------------------------------------------------------------------------
4479	-
4480	- // --------------------------------------------------------------------------------
4481	- // Function : privCheckFileHeaders()
4482	- // Description :
4483	- // Parameters :
4484	- // Return Values :
4485	- // 1 on success,
4486	- // 0 on error;
4487	- // --------------------------------------------------------------------------------
4488	- function privCheckFileHeaders(&$p_local_header, &$p_central_header)
4489	- {
4490	- $v_result=1;
4491	-
4492	- // ----- Check the static values
4493	- // TBC
4494	- if ($p_local_header['filename'] != $p_central_header['filename']) {
4495	- }
4496	- if ($p_local_header['version_extracted'] != $p_central_header['version_extracted']) {
4497	- }
4498	- if ($p_local_header['flag'] != $p_central_header['flag']) {
4499	- }
4500	- if ($p_local_header['compression'] != $p_central_header['compression']) {
4501	- }
4502	- if ($p_local_header['mtime'] != $p_central_header['mtime']) {
4503	- }
4504	- if ($p_local_header['filename_len'] != $p_central_header['filename_len']) {
4505	- }
4506	-
4507	- // ----- Look for flag bit 3
4508	- if (($p_local_header['flag'] & 8) == 8) {
4509	- $p_local_header['size'] = $p_central_header['size'];
4510	- $p_local_header['compressed_size'] = $p_central_header['compressed_size'];
4511	- $p_local_header['crc'] = $p_central_header['crc'];
4512	- }
4513	-
4514	- // ----- Return
4515	- return $v_result;
4516	- }
4517	- // --------------------------------------------------------------------------------
4518	-
4519	- // --------------------------------------------------------------------------------
4520	- // Function : privReadEndCentralDir()
4521	- // Description :
4522	- // Parameters :
4523	- // Return Values :
4524	- // --------------------------------------------------------------------------------
4525	- function privReadEndCentralDir(&$p_central_dir)
4526	- {
4527	- $v_result=1;
4528	-
4529	- // ----- Go to the end of the zip file
4530	- $v_size = filesize($this->zipname);
4531	- @fseek($this->zip_fd, $v_size);
4532	- if (@ftell($this->zip_fd) != $v_size)
4533	- {
4534	- // ----- Error log
4535	- PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to go to the end of the archive \''.$this->zipname.'\'');
4536	-
4537	- // ----- Return
4538	- return PclZip::errorCode();
4539	- }
4540	-
4541	- // ----- First try : look if this is an archive with no commentaries (most of the time)
4542	- // in this case the end of central dir is at 22 bytes of the file end
4543	- $v_found = 0;
4544	- if ($v_size > 26) {
4545	- @fseek($this->zip_fd, $v_size-22);
4546	- if (($v_pos = @ftell($this->zip_fd)) != ($v_size-22))
4547	- {
4548	- // ----- Error log
4549	- PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to seek back to the middle of the archive \''.$this->zipname.'\'');
4550	-
4551	- // ----- Return
4552	- return PclZip::errorCode();
4553	- }
4554	-
4555	- // ----- Read for bytes
4556	- $v_binary_data = @fread($this->zip_fd, 4);
4557	- $v_data = @unpack('Vid', $v_binary_data);
4558	-
4559	- // ----- Check signature
4560	- if ($v_data['id'] == 0x06054b50) {
4561	- $v_found = 1;
4562	- }
4563	-
4564	- $v_pos = ftell($this->zip_fd);
4565	- }
4566	-
4567	- // ----- Go back to the maximum possible size of the Central Dir End Record
4568	- if (!$v_found) {
4569	- $v_maximum_size = 65557; // 0xFFFF + 22;
4570	- if ($v_maximum_size > $v_size)
4571	- $v_maximum_size = $v_size;
4572	- @fseek($this->zip_fd, $v_size-$v_maximum_size);
4573	- if (@ftell($this->zip_fd) != ($v_size-$v_maximum_size))
4574	- {
4575	- // ----- Error log
4576	- PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to seek back to the middle of the archive \''.$this->zipname.'\'');
4577	-
4578	- // ----- Return
4579	- return PclZip::errorCode();
4580	- }
4581	-
4582	- // ----- Read byte per byte in order to find the signature
4583	- $v_pos = ftell($this->zip_fd);
4584	- $v_bytes = 0x00000000;
4585	- while ($v_pos < $v_size)
4586	- {
4587	- // ----- Read a byte
4588	- $v_byte = @fread($this->zip_fd, 1);
4589	-
4590	- // ----- Add the byte
4591	- //$v_bytes = ($v_bytes << 8) \| Ord($v_byte);
4592	- // Note we mask the old value down such that once shifted we can never end up with more than a 32bit number
4593	- // Otherwise on systems where we have 64bit integers the check below for the magic number will fail.
4594	- $v_bytes = ( ($v_bytes & 0xFFFFFF) << 8) \| Ord($v_byte);
4595	-
4596	- // ----- Compare the bytes
4597	- if ($v_bytes == 0x504b0506)
4598	- {
4599	- $v_pos++;
4600	- break;
4601	- }
4602	-
4603	- $v_pos++;
4604	- }
4605	-
4606	- // ----- Look if not found end of central dir
4607	- if ($v_pos == $v_size)
4608	- {
4609	-
4610	- // ----- Error log
4611	- PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Unable to find End of Central Dir Record signature");
4612	-
4613	- // ----- Return
4614	- return PclZip::errorCode();
4615	- }
4616	- }
4617	-
4618	- // ----- Read the first 18 bytes of the header
4619	- $v_binary_data = fread($this->zip_fd, 18);
4620	-
4621	- // ----- Look for invalid block size
4622	- if (strlen($v_binary_data) != 18)
4623	- {
4624	-
4625	- // ----- Error log
4626	- PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid End of Central Dir Record size : ".strlen($v_binary_data));
4627	-
4628	- // ----- Return
4629	- return PclZip::errorCode();
4630	- }
4631	-
4632	- // ----- Extract the values
4633	- $v_data = unpack('vdisk/vdisk_start/vdisk_entries/ventries/Vsize/Voffset/vcomment_size', $v_binary_data);
4634	-
4635	- // ----- Check the global size
4636	- if (($v_pos + $v_data['comment_size'] + 18) != $v_size) {
4637	-
4638	- // ----- Removed in release 2.2 see readme file
4639	- // The check of the file size is a little too strict.
4640	- // Some bugs where found when a zip is encrypted/decrypted with 'crypt'.
4641	- // While decrypted, zip has training 0 bytes
4642	- if (0) {
4643	- // ----- Error log
4644	- PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT,
4645	- 'The central dir is not at the end of the archive.'
4646	- .' Some trailing bytes exists after the archive.');
4647	-
4648	- // ----- Return
4649	- return PclZip::errorCode();
4650	- }
4651	- }
4652	-
4653	- // ----- Get comment
4654	- if ($v_data['comment_size'] != 0) {
4655	- $p_central_dir['comment'] = fread($this->zip_fd, $v_data['comment_size']);
4656	- }
4657	- else
4658	- $p_central_dir['comment'] = '';
4659	-
4660	- $p_central_dir['entries'] = $v_data['entries'];
4661	- $p_central_dir['disk_entries'] = $v_data['disk_entries'];
4662	- $p_central_dir['offset'] = $v_data['offset'];
4663	- $p_central_dir['size'] = $v_data['size'];
4664	- $p_central_dir['disk'] = $v_data['disk'];
4665	- $p_central_dir['disk_start'] = $v_data['disk_start'];
4666	-
4667	- // TBC
4668	- //for(reset($p_central_dir); $key = key($p_central_dir); next($p_central_dir)) {
4669	- //}
4670	-
4671	- // ----- Return
4672	- return $v_result;
4673	- }
4674	- // --------------------------------------------------------------------------------
4675	-
4676	- // --------------------------------------------------------------------------------
4677	- // Function : privDeleteByRule()
4678	- // Description :
4679	- // Parameters :
4680	- // Return Values :
4681	- // --------------------------------------------------------------------------------
4682	- function privDeleteByRule(&$p_result_list, &$p_options)
4683	- {
4684	- $v_result=1;
4685	- $v_list_detail = array();
4686	-
4687	- // ----- Open the zip file
4688	- if (($v_result=$this->privOpenFd('rb')) != 1)
4689	- {
4690	- // ----- Return
4691	- return $v_result;
4692	- }
4693	-
4694	- // ----- Read the central directory informations
4695	- $v_central_dir = array();
4696	- if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
4697	- {
4698	- $this->privCloseFd();
4699	- return $v_result;
4700	- }
4701	-
4702	- // ----- Go to beginning of File
4703	- @rewind($this->zip_fd);
4704	-
4705	- // ----- Scan all the files
4706	- // ----- Start at beginning of Central Dir
4707	- $v_pos_entry = $v_central_dir['offset'];
4708	- @rewind($this->zip_fd);
4709	- if (@fseek($this->zip_fd, $v_pos_entry))
4710	- {
4711	- // ----- Close the zip file
4712	- $this->privCloseFd();
4713	-
4714	- // ----- Error log
4715	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
4716	-
4717	- // ----- Return
4718	- return PclZip::errorCode();
4719	- }
4720	-
4721	- // ----- Read each entry
4722	- $v_header_list = array();
4723	- $j_start = 0;
4724	- for ($i=0, $v_nb_extracted=0; $i<$v_central_dir['entries']; $i++)
4725	- {
4726	-
4727	- // ----- Read the file header
4728	- $v_header_list[$v_nb_extracted] = array();
4729	- if (($v_result = $this->privReadCentralFileHeader($v_header_list[$v_nb_extracted])) != 1)
4730	- {
4731	- // ----- Close the zip file
4732	- $this->privCloseFd();
4733	-
4734	- return $v_result;
4735	- }
4736	-
4737	-
4738	- // ----- Store the index
4739	- $v_header_list[$v_nb_extracted]['index'] = $i;
4740	-
4741	- // ----- Look for the specific extract rules
4742	- $v_found = false;
4743	-
4744	- // ----- Look for extract by name rule
4745	- if ( (isset($p_options[PCLZIP_OPT_BY_NAME]))
4746	- && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
4747	-
4748	- // ----- Look if the filename is in the list
4749	- for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_found); $j++) {
4750	-
4751	- // ----- Look for a directory
4752	- if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
4753	-
4754	- // ----- Look if the directory is in the filename path
4755	- if ( (strlen($v_header_list[$v_nb_extracted]['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
4756	- && (substr($v_header_list[$v_nb_extracted]['stored_filename'], 0, strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
4757	- $v_found = true;
4758	- }
4759	- elseif ( (($v_header_list[$v_nb_extracted]['external']&0x00000010)==0x00000010) /* Indicates a folder */
4760	- && ($v_header_list[$v_nb_extracted]['stored_filename'].'/' == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
4761	- $v_found = true;
4762	- }
4763	- }
4764	- // ----- Look for a filename
4765	- elseif ($v_header_list[$v_nb_extracted]['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
4766	- $v_found = true;
4767	- }
4768	- }
4769	- }
4770	-
4771	- // ----- Look for extract by ereg rule
4772	- // ereg() is deprecated with PHP 5.3
4773	- /*
4774	- else if ( (isset($p_options[PCLZIP_OPT_BY_EREG]))
4775	- && ($p_options[PCLZIP_OPT_BY_EREG] != "")) {
4776	-
4777	- if (ereg($p_options[PCLZIP_OPT_BY_EREG], $v_header_list[$v_nb_extracted]['stored_filename'])) {
4778	- $v_found = true;
4779	- }
4780	- }
4781	- */
4782	-
4783	- // ----- Look for extract by preg rule
4784	- else if ( (isset($p_options[PCLZIP_OPT_BY_PREG]))
4785	- && ($p_options[PCLZIP_OPT_BY_PREG] != "")) {
4786	-
4787	- if (preg_match($p_options[PCLZIP_OPT_BY_PREG], $v_header_list[$v_nb_extracted]['stored_filename'])) {
4788	- $v_found = true;
4789	- }
4790	- }
4791	-
4792	- // ----- Look for extract by index rule
4793	- else if ( (isset($p_options[PCLZIP_OPT_BY_INDEX]))
4794	- && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
4795	-
4796	- // ----- Look if the index is in the list
4797	- for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_found); $j++) {
4798	-
4799	- if (($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i<=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
4800	- $v_found = true;
4801	- }
4802	- if ($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
4803	- $j_start = $j+1;
4804	- }
4805	-
4806	- if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start']>$i) {
4807	- break;
4808	- }
4809	- }
4810	- }
4811	- else {
4812	- $v_found = true;
4813	- }
4814	-
4815	- // ----- Look for deletion
4816	- if ($v_found)
4817	- {
4818	- unset($v_header_list[$v_nb_extracted]);
4819	- }
4820	- else
4821	- {
4822	- $v_nb_extracted++;
4823	- }
4824	- }
4825	-
4826	- // ----- Look if something need to be deleted
4827	- if ($v_nb_extracted > 0) {
4828	-
4829	- // ----- Creates a temporay file
4830	- $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
4831	-
4832	- // ----- Creates a temporary zip archive
4833	- $v_temp_zip = new PclZip($v_zip_temp_name);
4834	-
4835	- // ----- Open the temporary zip file in write mode
4836	- if (($v_result = $v_temp_zip->privOpenFd('wb')) != 1) {
4837	- $this->privCloseFd();
4838	-
4839	- // ----- Return
4840	- return $v_result;
4841	- }
4842	-
4843	- // ----- Look which file need to be kept
4844	- for ($i=0; $i<sizeof($v_header_list); $i++) {
4845	-
4846	- // ----- Calculate the position of the header
4847	- @rewind($this->zip_fd);
4848	- if (@fseek($this->zip_fd, $v_header_list[$i]['offset'])) {
4849	- // ----- Close the zip file
4850	- $this->privCloseFd();
4851	- $v_temp_zip->privCloseFd();
4852	- @unlink($v_zip_temp_name);
4853	-
4854	- // ----- Error log
4855	- PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
4856	-
4857	- // ----- Return
4858	- return PclZip::errorCode();
4859	- }
4860	-
4861	- // ----- Read the file header
4862	- $v_local_header = array();
4863	- if (($v_result = $this->privReadFileHeader($v_local_header)) != 1) {
4864	- // ----- Close the zip file
4865	- $this->privCloseFd();
4866	- $v_temp_zip->privCloseFd();
4867	- @unlink($v_zip_temp_name);
4868	-
4869	- // ----- Return
4870	- return $v_result;
4871	- }
4872	-
4873	- // ----- Check that local file header is same as central file header
4874	- if ($this->privCheckFileHeaders($v_local_header,
4875	- $v_header_list[$i]) != 1) {
4876	- // TBC
4877	- }
4878	- unset($v_local_header);
4879	-
4880	- // ----- Write the file header
4881	- if (($v_result = $v_temp_zip->privWriteFileHeader($v_header_list[$i])) != 1) {
4882	- // ----- Close the zip file
4883	- $this->privCloseFd();
4884	- $v_temp_zip->privCloseFd();
4885	- @unlink($v_zip_temp_name);
4886	-
4887	- // ----- Return
4888	- return $v_result;
4889	- }
4890	-
4891	- // ----- Read/write the data block
4892	- if (($v_result = PclZipUtilCopyBlock($this->zip_fd, $v_temp_zip->zip_fd, $v_header_list[$i]['compressed_size'])) != 1) {
4893	- // ----- Close the zip file
4894	- $this->privCloseFd();
4895	- $v_temp_zip->privCloseFd();
4896	- @unlink($v_zip_temp_name);
4897	-
4898	- // ----- Return
4899	- return $v_result;
4900	- }
4901	- }
4902	-
4903	- // ----- Store the offset of the central dir
4904	- $v_offset = @ftell($v_temp_zip->zip_fd);
4905	-
4906	- // ----- Re-Create the Central Dir files header
4907	- for ($i=0; $i<sizeof($v_header_list); $i++) {
4908	- // ----- Create the file header
4909	- if (($v_result = $v_temp_zip->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
4910	- $v_temp_zip->privCloseFd();
4911	- $this->privCloseFd();
4912	- @unlink($v_zip_temp_name);
4913	-
4914	- // ----- Return
4915	- return $v_result;
4916	- }
4917	-
4918	- // ----- Transform the header to a 'usable' info
4919	- $v_temp_zip->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
4920	- }
4921	-
4922	-
4923	- // ----- Zip file comment
4924	- $v_comment = '';
4925	- if (isset($p_options[PCLZIP_OPT_COMMENT])) {
4926	- $v_comment = $p_options[PCLZIP_OPT_COMMENT];
4927	- }
4928	-
4929	- // ----- Calculate the size of the central header
4930	- $v_size = @ftell($v_temp_zip->zip_fd)-$v_offset;
4931	-
4932	- // ----- Create the central dir footer
4933	- if (($v_result = $v_temp_zip->privWriteCentralHeader(sizeof($v_header_list), $v_size, $v_offset, $v_comment)) != 1) {
4934	- // ----- Reset the file list
4935	- unset($v_header_list);
4936	- $v_temp_zip->privCloseFd();
4937	- $this->privCloseFd();
4938	- @unlink($v_zip_temp_name);
4939	-
4940	- // ----- Return
4941	- return $v_result;
4942	- }
4943	-
4944	- // ----- Close
4945	- $v_temp_zip->privCloseFd();
4946	- $this->privCloseFd();
4947	-
4948	- // ----- Delete the zip file
4949	- // TBC : I should test the result ...
4950	- @unlink($this->zipname);
4951	-
4952	- // ----- Rename the temporary file
4953	- // TBC : I should test the result ...
4954	- //@rename($v_zip_temp_name, $this->zipname);
4955	- PclZipUtilRename($v_zip_temp_name, $this->zipname);
4956	-
4957	- // ----- Destroy the temporary archive
4958	- unset($v_temp_zip);
4959	- }
4960	-
4961	- // ----- Remove every files : reset the file
4962	- else if ($v_central_dir['entries'] != 0) {
4963	- $this->privCloseFd();
4964	-
4965	- if (($v_result = $this->privOpenFd('wb')) != 1) {
4966	- return $v_result;
4967	- }
4968	-
4969	- if (($v_result = $this->privWriteCentralHeader(0, 0, 0, '')) != 1) {
4970	- return $v_result;
4971	- }
4972	-
4973	- $this->privCloseFd();
4974	- }
4975	-
4976	- // ----- Return
4977	- return $v_result;
4978	- }
4979	- // --------------------------------------------------------------------------------
4980	-
4981	- // --------------------------------------------------------------------------------
4982	- // Function : privDirCheck()
4983	- // Description :
4984	- // Check if a directory exists, if not it creates it and all the parents directory
4985	- // which may be useful.
4986	- // Parameters :
4987	- // $p_dir : Directory path to check.
4988	- // Return Values :
4989	- // 1 : OK
4990	- // -1 : Unable to create directory
4991	- // --------------------------------------------------------------------------------
4992	- function privDirCheck($p_dir, $p_is_dir=false)
4993	- {
4994	- $v_result = 1;
4995	-
4996	-
4997	- // ----- Remove the final '/'
4998	- if (($p_is_dir) && (substr($p_dir, -1)=='/'))
4999	- {
5000	- $p_dir = substr($p_dir, 0, strlen($p_dir)-1);
5001	- }
5002	-
5003	- // ----- Check the directory availability
5004	- if ((is_dir($p_dir)) \|\| ($p_dir == ""))
5005	- {
5006	- return 1;
5007	- }
5008	-
5009	- // ----- Extract parent directory
5010	- $p_parent_dir = dirname($p_dir);
5011	-
5012	- // ----- Just a check
5013	- if ($p_parent_dir != $p_dir)
5014	- {
5015	- // ----- Look for parent directory
5016	- if ($p_parent_dir != "")
5017	- {
5018	- if (($v_result = $this->privDirCheck($p_parent_dir)) != 1)
5019	- {
5020	- return $v_result;
5021	- }
5022	- }
5023	- }
5024	-
5025	- // ----- Create the directory
5026	- if (!@mkdir($p_dir, 0777))
5027	- {
5028	- // ----- Error log
5029	- PclZip::privErrorLog(PCLZIP_ERR_DIR_CREATE_FAIL, "Unable to create directory '$p_dir'");
5030	-
5031	- // ----- Return
5032	- return PclZip::errorCode();
5033	- }
5034	-
5035	- // ----- Return
5036	- return $v_result;
5037	- }
5038	- // --------------------------------------------------------------------------------
5039	-
5040	- // --------------------------------------------------------------------------------
5041	- // Function : privMerge()
5042	- // Description :
5043	- // If $p_archive_to_add does not exist, the function exit with a success result.
5044	- // Parameters :
5045	- // Return Values :
5046	- // --------------------------------------------------------------------------------
5047	- function privMerge(&$p_archive_to_add)
5048	- {
5049	- $v_result=1;
5050	-
5051	- // ----- Look if the archive_to_add exists
5052	- if (!is_file($p_archive_to_add->zipname))
5053	- {
5054	-
5055	- // ----- Nothing to merge, so merge is a success
5056	- $v_result = 1;
5057	-
5058	- // ----- Return
5059	- return $v_result;
5060	- }
5061	-
5062	- // ----- Look if the archive exists
5063	- if (!is_file($this->zipname))
5064	- {
5065	-
5066	- // ----- Do a duplicate
5067	- $v_result = $this->privDuplicate($p_archive_to_add->zipname);
5068	-
5069	- // ----- Return
5070	- return $v_result;
5071	- }
5072	-
5073	- // ----- Open the zip file
5074	- if (($v_result=$this->privOpenFd('rb')) != 1)
5075	- {
5076	- // ----- Return
5077	- return $v_result;
5078	- }
5079	-
5080	- // ----- Read the central directory informations
5081	- $v_central_dir = array();
5082	- if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
5083	- {
5084	- $this->privCloseFd();
5085	- return $v_result;
5086	- }
5087	-
5088	- // ----- Go to beginning of File
5089	- @rewind($this->zip_fd);
5090	-
5091	- // ----- Open the archive_to_add file
5092	- if (($v_result=$p_archive_to_add->privOpenFd('rb')) != 1)
5093	- {
5094	- $this->privCloseFd();
5095	-
5096	- // ----- Return
5097	- return $v_result;
5098	- }
5099	-
5100	- // ----- Read the central directory informations
5101	- $v_central_dir_to_add = array();
5102	- if (($v_result = $p_archive_to_add->privReadEndCentralDir($v_central_dir_to_add)) != 1)
5103	- {
5104	- $this->privCloseFd();
5105	- $p_archive_to_add->privCloseFd();
5106	-
5107	- return $v_result;
5108	- }
5109	-
5110	- // ----- Go to beginning of File
5111	- @rewind($p_archive_to_add->zip_fd);
5112	-
5113	- // ----- Creates a temporay file
5114	- $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
5115	-
5116	- // ----- Open the temporary file in write mode
5117	- if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0)
5118	- {
5119	- $this->privCloseFd();
5120	- $p_archive_to_add->privCloseFd();
5121	-
5122	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_zip_temp_name.'\' in binary write mode');
5123	-
5124	- // ----- Return
5125	- return PclZip::errorCode();
5126	- }
5127	-
5128	- // ----- Copy the files from the archive to the temporary file
5129	- // TBC : Here I should better append the file and go back to erase the central dir
5130	- $v_size = $v_central_dir['offset'];
5131	- while ($v_size != 0)
5132	- {
5133	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
5134	- $v_buffer = fread($this->zip_fd, $v_read_size);
5135	- @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
5136	- $v_size -= $v_read_size;
5137	- }
5138	-
5139	- // ----- Copy the files from the archive_to_add into the temporary file
5140	- $v_size = $v_central_dir_to_add['offset'];
5141	- while ($v_size != 0)
5142	- {
5143	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
5144	- $v_buffer = fread($p_archive_to_add->zip_fd, $v_read_size);
5145	- @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
5146	- $v_size -= $v_read_size;
5147	- }
5148	-
5149	- // ----- Store the offset of the central dir
5150	- $v_offset = @ftell($v_zip_temp_fd);
5151	-
5152	- // ----- Copy the block of file headers from the old archive
5153	- $v_size = $v_central_dir['size'];
5154	- while ($v_size != 0)
5155	- {
5156	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
5157	- $v_buffer = @fread($this->zip_fd, $v_read_size);
5158	- @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
5159	- $v_size -= $v_read_size;
5160	- }
5161	-
5162	- // ----- Copy the block of file headers from the archive_to_add
5163	- $v_size = $v_central_dir_to_add['size'];
5164	- while ($v_size != 0)
5165	- {
5166	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
5167	- $v_buffer = @fread($p_archive_to_add->zip_fd, $v_read_size);
5168	- @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
5169	- $v_size -= $v_read_size;
5170	- }
5171	-
5172	- // ----- Merge the file comments
5173	- $v_comment = $v_central_dir['comment'].' '.$v_central_dir_to_add['comment'];
5174	-
5175	- // ----- Calculate the size of the (new) central header
5176	- $v_size = @ftell($v_zip_temp_fd)-$v_offset;
5177	-
5178	- // ----- Swap the file descriptor
5179	- // Here is a trick : I swap the temporary fd with the zip fd, in order to use
5180	- // the following methods on the temporary fil and not the real archive fd
5181	- $v_swap = $this->zip_fd;
5182	- $this->zip_fd = $v_zip_temp_fd;
5183	- $v_zip_temp_fd = $v_swap;
5184	-
5185	- // ----- Create the central dir footer
5186	- if (($v_result = $this->privWriteCentralHeader($v_central_dir['entries']+$v_central_dir_to_add['entries'], $v_size, $v_offset, $v_comment)) != 1)
5187	- {
5188	- $this->privCloseFd();
5189	- $p_archive_to_add->privCloseFd();
5190	- @fclose($v_zip_temp_fd);
5191	- $this->zip_fd = null;
5192	-
5193	- // ----- Reset the file list
5194	- unset($v_header_list);
5195	-
5196	- // ----- Return
5197	- return $v_result;
5198	- }
5199	-
5200	- // ----- Swap back the file descriptor
5201	- $v_swap = $this->zip_fd;
5202	- $this->zip_fd = $v_zip_temp_fd;
5203	- $v_zip_temp_fd = $v_swap;
5204	-
5205	- // ----- Close
5206	- $this->privCloseFd();
5207	- $p_archive_to_add->privCloseFd();
5208	-
5209	- // ----- Close the temporary file
5210	- @fclose($v_zip_temp_fd);
5211	-
5212	- // ----- Delete the zip file
5213	- // TBC : I should test the result ...
5214	- @unlink($this->zipname);
5215	-
5216	- // ----- Rename the temporary file
5217	- // TBC : I should test the result ...
5218	- //@rename($v_zip_temp_name, $this->zipname);
5219	- PclZipUtilRename($v_zip_temp_name, $this->zipname);
5220	-
5221	- // ----- Return
5222	- return $v_result;
5223	- }
5224	- // --------------------------------------------------------------------------------
5225	-
5226	- // --------------------------------------------------------------------------------
5227	- // Function : privDuplicate()
5228	- // Description :
5229	- // Parameters :
5230	- // Return Values :
5231	- // --------------------------------------------------------------------------------
5232	- function privDuplicate($p_archive_filename)
5233	- {
5234	- $v_result=1;
5235	-
5236	- // ----- Look if the $p_archive_filename exists
5237	- if (!is_file($p_archive_filename))
5238	- {
5239	-
5240	- // ----- Nothing to duplicate, so duplicate is a success.
5241	- $v_result = 1;
5242	-
5243	- // ----- Return
5244	- return $v_result;
5245	- }
5246	-
5247	- // ----- Open the zip file
5248	- if (($v_result=$this->privOpenFd('wb')) != 1)
5249	- {
5250	- // ----- Return
5251	- return $v_result;
5252	- }
5253	-
5254	- // ----- Open the temporary file in write mode
5255	- if (($v_zip_temp_fd = @fopen($p_archive_filename, 'rb')) == 0)
5256	- {
5257	- $this->privCloseFd();
5258	-
5259	- PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive file \''.$p_archive_filename.'\' in binary write mode');
5260	-
5261	- // ----- Return
5262	- return PclZip::errorCode();
5263	- }
5264	-
5265	- // ----- Copy the files from the archive to the temporary file
5266	- // TBC : Here I should better append the file and go back to erase the central dir
5267	- $v_size = filesize($p_archive_filename);
5268	- while ($v_size != 0)
5269	- {
5270	- $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
5271	- $v_buffer = fread($v_zip_temp_fd, $v_read_size);
5272	- @fwrite($this->zip_fd, $v_buffer, $v_read_size);
5273	- $v_size -= $v_read_size;
5274	- }
5275	-
5276	- // ----- Close
5277	- $this->privCloseFd();
5278	-
5279	- // ----- Close the temporary file
5280	- @fclose($v_zip_temp_fd);
5281	-
5282	- // ----- Return
5283	- return $v_result;
5284	- }
5285	- // --------------------------------------------------------------------------------
5286	-
5287	- // --------------------------------------------------------------------------------
5288	- // Function : privErrorLog()
5289	- // Description :
5290	- // Parameters :
5291	- // --------------------------------------------------------------------------------
5292	- function privErrorLog($p_error_code=0, $p_error_string='')
5293	- {
5294	- if (PCLZIP_ERROR_EXTERNAL == 1) {
5295	- PclError($p_error_code, $p_error_string);
5296	- }
5297	- else {
5298	- $this->error_code = $p_error_code;
5299	- $this->error_string = $p_error_string;
5300	- }
5301	- }
5302	- // --------------------------------------------------------------------------------
5303	-
5304	- // --------------------------------------------------------------------------------
5305	- // Function : privErrorReset()
5306	- // Description :
5307	- // Parameters :
5308	- // --------------------------------------------------------------------------------
5309	- function privErrorReset()
5310	- {
5311	- if (PCLZIP_ERROR_EXTERNAL == 1) {
5312	- PclErrorReset();
5313	- }
5314	- else {
5315	- $this->error_code = 0;
5316	- $this->error_string = '';
5317	- }
5318	- }
5319	- // --------------------------------------------------------------------------------
5320	-
5321	- // --------------------------------------------------------------------------------
5322	- // Function : privDisableMagicQuotes()
5323	- // Description :
5324	- // Parameters :
5325	- // Return Values :
5326	- // --------------------------------------------------------------------------------
5327	- function privDisableMagicQuotes()
5328	- {
5329	- $v_result=1;
5330	-
5331	- // ----- Look if function exists
5332	- if ( (!function_exists("get_magic_quotes_runtime"))
5333	- \|\| (!function_exists("set_magic_quotes_runtime"))) {
5334	- return $v_result;
5335	- }
5336	-
5337	- // ----- Look if already done
5338	- if ($this->magic_quotes_status != -1) {
5339	- return $v_result;
5340	- }
5341	-
5342	- // ----- Get and memorize the magic_quote value
5343	- $this->magic_quotes_status = @get_magic_quotes_runtime();
5344	-
5345	- // ----- Disable magic_quotes
5346	- if ($this->magic_quotes_status == 1) {
5347	- @set_magic_quotes_runtime(0);
5348	- }
5349	-
5350	- // ----- Return
5351	- return $v_result;
5352	- }
5353	- // --------------------------------------------------------------------------------
5354	-
5355	- // --------------------------------------------------------------------------------
5356	- // Function : privSwapBackMagicQuotes()
5357	- // Description :
5358	- // Parameters :
5359	- // Return Values :
5360	- // --------------------------------------------------------------------------------
5361	- function privSwapBackMagicQuotes()
5362	- {
5363	- $v_result=1;
5364	-
5365	- // ----- Look if function exists
5366	- if ( (!function_exists("get_magic_quotes_runtime"))
5367	- \|\| (!function_exists("set_magic_quotes_runtime"))) {
5368	- return $v_result;
5369	- }
5370	-
5371	- // ----- Look if something to do
5372	- if ($this->magic_quotes_status != -1) {
5373	- return $v_result;
5374	- }
5375	-
5376	- // ----- Swap back magic_quotes
5377	- if ($this->magic_quotes_status == 1) {
5378	- @set_magic_quotes_runtime($this->magic_quotes_status);
5379	- }
5380	-
5381	- // ----- Return
5382	- return $v_result;
5383	- }
5384	- // --------------------------------------------------------------------------------
5385	-
5386	- }
5387	- // End of class
5388	- // --------------------------------------------------------------------------------
5389	-
5390	- // --------------------------------------------------------------------------------
5391	- // Function : PclZipUtilPathReduction()
5392	- // Description :
5393	- // Parameters :
5394	- // Return Values :
5395	- // --------------------------------------------------------------------------------
5396	- function PclZipUtilPathReduction($p_dir)
5397	- {
5398	- $v_result = "";
5399	-
5400	- // ----- Look for not empty path
5401	- if ($p_dir != "") {
5402	- // ----- Explode path by directory names
5403	- $v_list = explode("/", $p_dir);
5404	-
5405	- // ----- Study directories from last to first
5406	- $v_skip = 0;
5407	- for ($i=sizeof($v_list)-1; $i>=0; $i--) {
5408	- // ----- Look for current path
5409	- if ($v_list[$i] == ".") {
5410	- // ----- Ignore this directory
5411	- // Should be the first $i=0, but no check is done
5412	- }
5413	- else if ($v_list[$i] == "..") {
5414	- $v_skip++;
5415	- }
5416	- else if ($v_list[$i] == "") {
5417	- // ----- First '/' i.e. root slash
5418	- if ($i == 0) {
5419	- $v_result = "/".$v_result;
5420	- if ($v_skip > 0) {
5421	- // ----- It is an invalid path, so the path is not modified
5422	- // TBC
5423	- $v_result = $p_dir;
5424	- $v_skip = 0;
5425	- }
5426	- }
5427	- // ----- Last '/' i.e. indicates a directory
5428	- else if ($i == (sizeof($v_list)-1)) {
5429	- $v_result = $v_list[$i];
5430	- }
5431	- // ----- Double '/' inside the path
5432	- else {
5433	- // ----- Ignore only the double '//' in path,
5434	- // but not the first and last '/'
5435	- }
5436	- }
5437	- else {
5438	- // ----- Look for item to skip
5439	- if ($v_skip > 0) {
5440	- $v_skip--;
5441	- }
5442	- else {
5443	- $v_result = $v_list[$i].($i!=(sizeof($v_list)-1)?"/".$v_result:"");
5444	- }
5445	- }
5446	- }
5447	-
5448	- // ----- Look for skip
5449	- if ($v_skip > 0) {
5450	- while ($v_skip > 0) {
5451	- $v_result = '../'.$v_result;
5452	- $v_skip--;
5453	- }
5454	- }
5455	- }
5456	-
5457	- // ----- Return
5458	- return $v_result;
5459	- }
5460	- // --------------------------------------------------------------------------------
5461	-
5462	- // --------------------------------------------------------------------------------
5463	- // Function : PclZipUtilPathInclusion()
5464	- // Description :
5465	- // This function indicates if the path $p_path is under the $p_dir tree. Or,
5466	- // said in an other way, if the file or sub-dir $p_path is inside the dir
5467	- // $p_dir.
5468	- // The function indicates also if the path is exactly the same as the dir.
5469	- // This function supports path with duplicated '/' like '//', but does not
5470	- // support '.' or '..' statements.
5471	- // Parameters :
5472	- // Return Values :
5473	- // 0 if $p_path is not inside directory $p_dir
5474	- // 1 if $p_path is inside directory $p_dir
5475	- // 2 if $p_path is exactly the same as $p_dir
5476	- // --------------------------------------------------------------------------------
5477	- function PclZipUtilPathInclusion($p_dir, $p_path)
5478	- {
5479	- $v_result = 1;
5480	-
5481	- // ----- Look for path beginning by ./
5482	- if ( ($p_dir == '.')
5483	- \|\| ((strlen($p_dir) >=2) && (substr($p_dir, 0, 2) == './'))) {
5484	- $p_dir = PclZipUtilTranslateWinPath(getcwd(), FALSE).'/'.substr($p_dir, 1);
5485	- }
5486	- if ( ($p_path == '.')
5487	- \|\| ((strlen($p_path) >=2) && (substr($p_path, 0, 2) == './'))) {
5488	- $p_path = PclZipUtilTranslateWinPath(getcwd(), FALSE).'/'.substr($p_path, 1);
5489	- }
5490	-
5491	- // ----- Explode dir and path by directory separator
5492	- $v_list_dir = explode("/", $p_dir);
5493	- $v_list_dir_size = sizeof($v_list_dir);
5494	- $v_list_path = explode("/", $p_path);
5495	- $v_list_path_size = sizeof($v_list_path);
5496	-
5497	- // ----- Study directories paths
5498	- $i = 0;
5499	- $j = 0;
5500	- while (($i < $v_list_dir_size) && ($j < $v_list_path_size) && ($v_result)) {
5501	-
5502	- // ----- Look for empty dir (path reduction)
5503	- if ($v_list_dir[$i] == '') {
5504	- $i++;
5505	- continue;
5506	- }
5507	- if ($v_list_path[$j] == '') {
5508	- $j++;
5509	- continue;
5510	- }
5511	-
5512	- // ----- Compare the items
5513	- if (($v_list_dir[$i] != $v_list_path[$j]) && ($v_list_dir[$i] != '') && ( $v_list_path[$j] != '')) {
5514	- $v_result = 0;
5515	- }
5516	-
5517	- // ----- Next items
5518	- $i++;
5519	- $j++;
5520	- }
5521	-
5522	- // ----- Look if everything seems to be the same
5523	- if ($v_result) {
5524	- // ----- Skip all the empty items
5525	- while (($j < $v_list_path_size) && ($v_list_path[$j] == '')) $j++;
5526	- while (($i < $v_list_dir_size) && ($v_list_dir[$i] == '')) $i++;
5527	-
5528	- if (($i >= $v_list_dir_size) && ($j >= $v_list_path_size)) {
5529	- // ----- There are exactly the same
5530	- $v_result = 2;
5531	- }
5532	- else if ($i < $v_list_dir_size) {
5533	- // ----- The path is shorter than the dir
5534	- $v_result = 0;
5535	- }
5536	- }
5537	-
5538	- // ----- Return
5539	- return $v_result;
5540	- }
5541	- // --------------------------------------------------------------------------------
5542	-
5543	- // --------------------------------------------------------------------------------
5544	- // Function : PclZipUtilCopyBlock()
5545	- // Description :
5546	- // Parameters :
5547	- // $p_mode : read/write compression mode
5548	- // 0 : src & dest normal
5549	- // 1 : src gzip, dest normal
5550	- // 2 : src normal, dest gzip
5551	- // 3 : src & dest gzip
5552	- // Return Values :
5553	- // --------------------------------------------------------------------------------
5554	- function PclZipUtilCopyBlock($p_src, $p_dest, $p_size, $p_mode=0)
5555	- {
5556	- $v_result = 1;
5557	-
5558	- if ($p_mode==0)
5559	- {
5560	- while ($p_size != 0)
5561	- {
5562	- $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
5563	- $v_buffer = @fread($p_src, $v_read_size);
5564	- @fwrite($p_dest, $v_buffer, $v_read_size);
5565	- $p_size -= $v_read_size;
5566	- }
5567	- }
5568	- else if ($p_mode==1)
5569	- {
5570	- while ($p_size != 0)
5571	- {
5572	- $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
5573	- $v_buffer = @gzread($p_src, $v_read_size);
5574	- @fwrite($p_dest, $v_buffer, $v_read_size);
5575	- $p_size -= $v_read_size;
5576	- }
5577	- }
5578	- else if ($p_mode==2)
5579	- {
5580	- while ($p_size != 0)
5581	- {
5582	- $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
5583	- $v_buffer = @fread($p_src, $v_read_size);
5584	- @gzwrite($p_dest, $v_buffer, $v_read_size);
5585	- $p_size -= $v_read_size;
5586	- }
5587	- }
5588	- else if ($p_mode==3)
5589	- {
5590	- while ($p_size != 0)
5591	- {
5592	- $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
5593	- $v_buffer = @gzread($p_src, $v_read_size);
5594	- @gzwrite($p_dest, $v_buffer, $v_read_size);
5595	- $p_size -= $v_read_size;
5596	- }
5597	- }
5598	-
5599	- // ----- Return
5600	- return $v_result;
5601	- }
5602	- // --------------------------------------------------------------------------------
5603	-
5604	- // --------------------------------------------------------------------------------
5605	- // Function : PclZipUtilRename()
5606	- // Description :
5607	- // This function tries to do a simple rename() function. If it fails, it
5608	- // tries to copy the $p_src file in a new $p_dest file and then unlink the
5609	- // first one.
5610	- // Parameters :
5611	- // $p_src : Old filename
5612	- // $p_dest : New filename
5613	- // Return Values :
5614	- // 1 on success, 0 on failure.
5615	- // --------------------------------------------------------------------------------
5616	- function PclZipUtilRename($p_src, $p_dest)
5617	- {
5618	- $v_result = 1;
5619	-
5620	- // ----- Try to rename the files
5621	- if (!@rename($p_src, $p_dest)) {
5622	-
5623	- // ----- Try to copy & unlink the src
5624	- if (!@copy($p_src, $p_dest)) {
5625	- $v_result = 0;
5626	- }
5627	- else if (!@unlink($p_src)) {
5628	- $v_result = 0;
5629	- }
5630	- }
5631	-
5632	- // ----- Return
5633	- return $v_result;
5634	- }
5635	- // --------------------------------------------------------------------------------
5636	-
5637	- // --------------------------------------------------------------------------------
5638	- // Function : PclZipUtilOptionText()
5639	- // Description :
5640	- // Translate option value in text. Mainly for debug purpose.
5641	- // Parameters :
5642	- // $p_option : the option value.
5643	- // Return Values :
5644	- // The option text value.
5645	- // --------------------------------------------------------------------------------
5646	- function PclZipUtilOptionText($p_option)
5647	- {
5648	-
5649	- $v_list = get_defined_constants();
5650	- for (reset($v_list); $v_key = key($v_list); next($v_list)) {
5651	- $v_prefix = substr($v_key, 0, 10);
5652	- if (( ($v_prefix == 'PCLZIP_OPT')
5653	- \|\| ($v_prefix == 'PCLZIP_CB_')
5654	- \|\| ($v_prefix == 'PCLZIP_ATT'))
5655	- && ($v_list[$v_key] == $p_option)) {
5656	- return $v_key;
5657	- }
5658	- }
5659	-
5660	- $v_result = 'Unknown';
5661	-
5662	- return $v_result;
5663	- }
5664	- // --------------------------------------------------------------------------------
5665	-
5666	- // --------------------------------------------------------------------------------
5667	- // Function : PclZipUtilTranslateWinPath()
5668	- // Description :
5669	- // Translate windows path by replacing '\' by '/' and optionally removing
5670	- // drive letter.
5671	- // Parameters :
5672	- // $p_path : path to translate.
5673	- // $p_remove_disk_letter : true \| false
5674	- // Return Values :
5675	- // The path translated.
5676	- // --------------------------------------------------------------------------------
5677	- function PclZipUtilTranslateWinPath($p_path, $p_remove_disk_letter=true)
5678	- {
5679	- if (stristr(php_uname(), 'windows')) {
5680	- // ----- Look for potential disk letter
5681	- if (($p_remove_disk_letter) && (($v_position = strpos($p_path, ':')) != false)) {
5682	- $p_path = substr($p_path, $v_position+1);
5683	- }
5684	- // ----- Change potential windows directory separator
5685	- if ((strpos($p_path, '\\') > 0) \|\| (substr($p_path, 0,1) == '\\')) {
5686	- $p_path = strtr($p_path, '\\', '/');
5687	- }
5688	- }
5689	- return $p_path;
5690	- }
5691	- // --------------------------------------------------------------------------------
5692	-
5693	-
5694	-?>	1	+<?php
		2	+// --------------------------------------------------------------------------------
		3	+// PhpConcept Library - Zip Module 2.8.2
		4	+// --------------------------------------------------------------------------------
		5	+// License GNU/LGPL - Vincent Blavet - August 2009
		6	+// http://www.phpconcept.net
		7	+// --------------------------------------------------------------------------------
		8	+//
		9	+// Presentation :
		10	+// PclZip is a PHP library that manage ZIP archives.
		11	+// So far tests show that archives generated by PclZip are readable by
		12	+// WinZip application and other tools.
		13	+//
		14	+// Description :
		15	+// See readme.txt and http://www.phpconcept.net
		16	+//
		17	+// Warning :
		18	+// This library and the associated files are non commercial, non professional
		19	+// work.
		20	+// It should not have unexpected results. However if any damage is caused by
		21	+// this software the author can not be responsible.
		22	+// The use of this software is at the risk of the user.
		23	+//
		24	+// --------------------------------------------------------------------------------
		25	+// $Id: pclzip.lib.php,v 1.60 2009/09/30 21:01:04 vblavet Exp $
		26	+// --------------------------------------------------------------------------------
		27	+
		28	+ // ----- Constants
		29	+ if (!defined('PCLZIP_READ_BLOCK_SIZE')) {
		30	+ define( 'PCLZIP_READ_BLOCK_SIZE', 2048 );
		31	+ }
		32	+
		33	+ // ----- File list separator
		34	+ // In version 1.x of PclZip, the separator for file list is a space
		35	+ // (which is not a very smart choice, specifically for windows paths !).
		36	+ // A better separator should be a comma (,). This constant gives you the
		37	+ // abilty to change that.
		38	+ // However notice that changing this value, may have impact on existing
		39	+ // scripts, using space separated filenames.
		40	+ // Recommanded values for compatibility with older versions :
		41	+ //define( 'PCLZIP_SEPARATOR', ' ' );
		42	+ // Recommanded values for smart separation of filenames.
		43	+ if (!defined('PCLZIP_SEPARATOR')) {
		44	+ define( 'PCLZIP_SEPARATOR', ',' );
		45	+ }
		46	+
		47	+ // ----- Error configuration
		48	+ // 0 : PclZip Class integrated error handling
		49	+ // 1 : PclError external library error handling. By enabling this
		50	+ // you must ensure that you have included PclError library.
		51	+ // [2,...] : reserved for futur use
		52	+ if (!defined('PCLZIP_ERROR_EXTERNAL')) {
		53	+ define( 'PCLZIP_ERROR_EXTERNAL', 0 );
		54	+ }
		55	+
		56	+ // ----- Optional static temporary directory
		57	+ // By default temporary files are generated in the script current
		58	+ // path.
		59	+ // If defined :
		60	+ // - MUST BE terminated by a '/'.
		61	+ // - MUST be a valid, already created directory
		62	+ // Samples :
		63	+ // define( 'PCLZIP_TEMPORARY_DIR', '/temp/' );
		64	+ // define( 'PCLZIP_TEMPORARY_DIR', 'C:/Temp/' );
		65	+ if (!defined('PCLZIP_TEMPORARY_DIR')) {
		66	+ define( 'PCLZIP_TEMPORARY_DIR', '' );
		67	+ }
		68	+
		69	+ // ----- Optional threshold ratio for use of temporary files
		70	+ // Pclzip sense the size of the file to add/extract and decide to
		71	+ // use or not temporary file. The algorythm is looking for
		72	+ // memory_limit of PHP and apply a ratio.
		73	+ // threshold = memory_limit * ratio.
		74	+ // Recommended values are under 0.5. Default 0.47.
		75	+ // Samples :
		76	+ // define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.5 );
		77	+ if (!defined('PCLZIP_TEMPORARY_FILE_RATIO')) {
		78	+ define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.47 );
		79	+ }
		80	+
		81	+// --------------------------------------------------------------------------------
		82	+// *** UNDER THIS LINE NOTHING NEEDS TO BE MODIFIED ***
		83	+// --------------------------------------------------------------------------------
		84	+
		85	+ // ----- Global variables
		86	+ $g_pclzip_version = "2.8.2";
		87	+
		88	+ // ----- Error codes
		89	+ // -1 : Unable to open file in binary write mode
		90	+ // -2 : Unable to open file in binary read mode
		91	+ // -3 : Invalid parameters
		92	+ // -4 : File does not exist
		93	+ // -5 : Filename is too long (max. 255)
		94	+ // -6 : Not a valid zip file
		95	+ // -7 : Invalid extracted file size
		96	+ // -8 : Unable to create directory
		97	+ // -9 : Invalid archive extension
		98	+ // -10 : Invalid archive format
		99	+ // -11 : Unable to delete file (unlink)
		100	+ // -12 : Unable to rename file (rename)
		101	+ // -13 : Invalid header checksum
		102	+ // -14 : Invalid archive size
		103	+ define( 'PCLZIP_ERR_USER_ABORTED', 2 );
		104	+ define( 'PCLZIP_ERR_NO_ERROR', 0 );
		105	+ define( 'PCLZIP_ERR_WRITE_OPEN_FAIL', -1 );
		106	+ define( 'PCLZIP_ERR_READ_OPEN_FAIL', -2 );
		107	+ define( 'PCLZIP_ERR_INVALID_PARAMETER', -3 );
		108	+ define( 'PCLZIP_ERR_MISSING_FILE', -4 );
		109	+ define( 'PCLZIP_ERR_FILENAME_TOO_LONG', -5 );
		110	+ define( 'PCLZIP_ERR_INVALID_ZIP', -6 );
		111	+ define( 'PCLZIP_ERR_BAD_EXTRACTED_FILE', -7 );
		112	+ define( 'PCLZIP_ERR_DIR_CREATE_FAIL', -8 );
		113	+ define( 'PCLZIP_ERR_BAD_EXTENSION', -9 );
		114	+ define( 'PCLZIP_ERR_BAD_FORMAT', -10 );
		115	+ define( 'PCLZIP_ERR_DELETE_FILE_FAIL', -11 );
		116	+ define( 'PCLZIP_ERR_RENAME_FILE_FAIL', -12 );
		117	+ define( 'PCLZIP_ERR_BAD_CHECKSUM', -13 );
		118	+ define( 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP', -14 );
		119	+ define( 'PCLZIP_ERR_MISSING_OPTION_VALUE', -15 );
		120	+ define( 'PCLZIP_ERR_INVALID_OPTION_VALUE', -16 );
		121	+ define( 'PCLZIP_ERR_ALREADY_A_DIRECTORY', -17 );
		122	+ define( 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION', -18 );
		123	+ define( 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION', -19 );
		124	+ define( 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE', -20 );
		125	+ define( 'PCLZIP_ERR_DIRECTORY_RESTRICTION', -21 );
		126	+
		127	+ // ----- Options values
		128	+ define( 'PCLZIP_OPT_PATH', 77001 );
		129	+ define( 'PCLZIP_OPT_ADD_PATH', 77002 );
		130	+ define( 'PCLZIP_OPT_REMOVE_PATH', 77003 );
		131	+ define( 'PCLZIP_OPT_REMOVE_ALL_PATH', 77004 );
		132	+ define( 'PCLZIP_OPT_SET_CHMOD', 77005 );
		133	+ define( 'PCLZIP_OPT_EXTRACT_AS_STRING', 77006 );
		134	+ define( 'PCLZIP_OPT_NO_COMPRESSION', 77007 );
		135	+ define( 'PCLZIP_OPT_BY_NAME', 77008 );
		136	+ define( 'PCLZIP_OPT_BY_INDEX', 77009 );
		137	+ define( 'PCLZIP_OPT_BY_EREG', 77010 );
		138	+ define( 'PCLZIP_OPT_BY_PREG', 77011 );
		139	+ define( 'PCLZIP_OPT_COMMENT', 77012 );
		140	+ define( 'PCLZIP_OPT_ADD_COMMENT', 77013 );
		141	+ define( 'PCLZIP_OPT_PREPEND_COMMENT', 77014 );
		142	+ define( 'PCLZIP_OPT_EXTRACT_IN_OUTPUT', 77015 );
		143	+ define( 'PCLZIP_OPT_REPLACE_NEWER', 77016 );
		144	+ define( 'PCLZIP_OPT_STOP_ON_ERROR', 77017 );
		145	+ // Having big trouble with crypt. Need to multiply 2 long int
		146	+ // which is not correctly supported by PHP ...
		147	+ //define( 'PCLZIP_OPT_CRYPT', 77018 );
		148	+ define( 'PCLZIP_OPT_EXTRACT_DIR_RESTRICTION', 77019 );
		149	+ define( 'PCLZIP_OPT_TEMP_FILE_THRESHOLD', 77020 );
		150	+ define( 'PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD', 77020 ); // alias
		151	+ define( 'PCLZIP_OPT_TEMP_FILE_ON', 77021 );
		152	+ define( 'PCLZIP_OPT_ADD_TEMP_FILE_ON', 77021 ); // alias
		153	+ define( 'PCLZIP_OPT_TEMP_FILE_OFF', 77022 );
		154	+ define( 'PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022 ); // alias
		155	+
		156	+ // ----- File description attributes
		157	+ define( 'PCLZIP_ATT_FILE_NAME', 79001 );
		158	+ define( 'PCLZIP_ATT_FILE_NEW_SHORT_NAME', 79002 );
		159	+ define( 'PCLZIP_ATT_FILE_NEW_FULL_NAME', 79003 );
		160	+ define( 'PCLZIP_ATT_FILE_MTIME', 79004 );
		161	+ define( 'PCLZIP_ATT_FILE_CONTENT', 79005 );
		162	+ define( 'PCLZIP_ATT_FILE_COMMENT', 79006 );
		163	+
		164	+ // ----- Call backs values
		165	+ define( 'PCLZIP_CB_PRE_EXTRACT', 78001 );
		166	+ define( 'PCLZIP_CB_POST_EXTRACT', 78002 );
		167	+ define( 'PCLZIP_CB_PRE_ADD', 78003 );
		168	+ define( 'PCLZIP_CB_POST_ADD', 78004 );
		169	+ /* For futur use
		170	+ define( 'PCLZIP_CB_PRE_LIST', 78005 );
		171	+ define( 'PCLZIP_CB_POST_LIST', 78006 );
		172	+ define( 'PCLZIP_CB_PRE_DELETE', 78007 );
		173	+ define( 'PCLZIP_CB_POST_DELETE', 78008 );
		174	+ */
		175	+
		176	+ // --------------------------------------------------------------------------------
		177	+ // Class : PclZip
		178	+ // Description :
		179	+ // PclZip is the class that represent a Zip archive.
		180	+ // The public methods allow the manipulation of the archive.
		181	+ // Attributes :
		182	+ // Attributes must not be accessed directly.
		183	+ // Methods :
		184	+ // PclZip() : Object creator
		185	+ // create() : Creates the Zip archive
		186	+ // listContent() : List the content of the Zip archive
		187	+ // extract() : Extract the content of the archive
		188	+ // properties() : List the properties of the archive
		189	+ // --------------------------------------------------------------------------------
		190	+ class PclZip
		191	+ {
		192	+ // ----- Filename of the zip file
		193	+ var $zipname = '';
		194	+
		195	+ // ----- File descriptor of the zip file
		196	+ var $zip_fd = 0;
		197	+
		198	+ // ----- Internal error handling
		199	+ var $error_code = 1;
		200	+ var $error_string = '';
		201	+
		202	+ // ----- Current status of the magic_quotes_runtime
		203	+ // This value store the php configuration for magic_quotes
		204	+ // The class can then disable the magic_quotes and reset it after
		205	+ var $magic_quotes_status;
		206	+
		207	+ // --------------------------------------------------------------------------------
		208	+ // Function : PclZip()
		209	+ // Description :
		210	+ // Creates a PclZip object and set the name of the associated Zip archive
		211	+ // filename.
		212	+ // Note that no real action is taken, if the archive does not exist it is not
		213	+ // created. Use create() for that.
		214	+ // --------------------------------------------------------------------------------
		215	+ function PclZip($p_zipname)
		216	+ {
		217	+
		218	+ // ----- Tests the zlib
		219	+ if (!function_exists('gzopen'))
		220	+ {
		221	+ die('Abort '.basename(__FILE__).' : Missing zlib extensions');
		222	+ }
		223	+
		224	+ // ----- Set the attributes
		225	+ $this->zipname = $p_zipname;
		226	+ $this->zip_fd = 0;
		227	+ $this->magic_quotes_status = -1;
		228	+
		229	+ // ----- Return
		230	+ return;
		231	+ }
		232	+ // --------------------------------------------------------------------------------
		233	+
		234	+ // --------------------------------------------------------------------------------
		235	+ // Function :
		236	+ // create($p_filelist, $p_add_dir="", $p_remove_dir="")
		237	+ // create($p_filelist, $p_option, $p_option_value, ...)
		238	+ // Description :
		239	+ // This method supports two different synopsis. The first one is historical.
		240	+ // This method creates a Zip Archive. The Zip file is created in the
		241	+ // filesystem. The files and directories indicated in $p_filelist
		242	+ // are added in the archive. See the parameters description for the
		243	+ // supported format of $p_filelist.
		244	+ // When a directory is in the list, the directory and its content is added
		245	+ // in the archive.
		246	+ // In this synopsis, the function takes an optional variable list of
		247	+ // options. See bellow the supported options.
		248	+ // Parameters :
		249	+ // $p_filelist : An array containing file or directory names, or
		250	+ // a string containing one filename or one directory name, or
		251	+ // a string containing a list of filenames and/or directory
		252	+ // names separated by spaces.
		253	+ // $p_add_dir : A path to add before the real path of the archived file,
		254	+ // in order to have it memorized in the archive.
		255	+ // $p_remove_dir : A path to remove from the real path of the file to archive,
		256	+ // in order to have a shorter path memorized in the archive.
		257	+ // When $p_add_dir and $p_remove_dir are set, $p_remove_dir
		258	+ // is removed first, before $p_add_dir is added.
		259	+ // Options :
		260	+ // PCLZIP_OPT_ADD_PATH :
		261	+ // PCLZIP_OPT_REMOVE_PATH :
		262	+ // PCLZIP_OPT_REMOVE_ALL_PATH :
		263	+ // PCLZIP_OPT_COMMENT :
		264	+ // PCLZIP_CB_PRE_ADD :
		265	+ // PCLZIP_CB_POST_ADD :
		266	+ // Return Values :
		267	+ // 0 on failure,
		268	+ // The list of the added files, with a status of the add action.
		269	+ // (see PclZip::listContent() for list entry format)
		270	+ // --------------------------------------------------------------------------------
		271	+ function create($p_filelist)
		272	+ {
		273	+ $v_result=1;
		274	+
		275	+ // ----- Reset the error handler
		276	+ $this->privErrorReset();
		277	+
		278	+ // ----- Set default values
		279	+ $v_options = array();
		280	+ $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
		281	+
		282	+ // ----- Look for variable options arguments
		283	+ $v_size = func_num_args();
		284	+
		285	+ // ----- Look for arguments
		286	+ if ($v_size > 1) {
		287	+ // ----- Get the arguments
		288	+ $v_arg_list = func_get_args();
		289	+
		290	+ // ----- Remove from the options list the first argument
		291	+ array_shift($v_arg_list);
		292	+ $v_size--;
		293	+
		294	+ // ----- Look for first arg
		295	+ if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
		296	+
		297	+ // ----- Parse the options
		298	+ $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
		299	+ array (PCLZIP_OPT_REMOVE_PATH => 'optional',
		300	+ PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
		301	+ PCLZIP_OPT_ADD_PATH => 'optional',
		302	+ PCLZIP_CB_PRE_ADD => 'optional',
		303	+ PCLZIP_CB_POST_ADD => 'optional',
		304	+ PCLZIP_OPT_NO_COMPRESSION => 'optional',
		305	+ PCLZIP_OPT_COMMENT => 'optional',
		306	+ PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
		307	+ PCLZIP_OPT_TEMP_FILE_ON => 'optional',
		308	+ PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
		309	+ //, PCLZIP_OPT_CRYPT => 'optional'
		310	+ ));
		311	+ if ($v_result != 1) {
		312	+ return 0;
		313	+ }
		314	+ }
		315	+
		316	+ // ----- Look for 2 args
		317	+ // Here we need to support the first historic synopsis of the
		318	+ // method.
		319	+ else {
		320	+
		321	+ // ----- Get the first argument
		322	+ $v_options[PCLZIP_OPT_ADD_PATH] = $v_arg_list[0];
		323	+
		324	+ // ----- Look for the optional second argument
		325	+ if ($v_size == 2) {
		326	+ $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
		327	+ }
		328	+ else if ($v_size > 2) {
		329	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
		330	+ "Invalid number / type of arguments");
		331	+ return 0;
		332	+ }
		333	+ }
		334	+ }
		335	+
		336	+ // ----- Look for default option values
		337	+ $this->privOptionDefaultThreshold($v_options);
		338	+
		339	+ // ----- Init
		340	+ $v_string_list = array();
		341	+ $v_att_list = array();
		342	+ $v_filedescr_list = array();
		343	+ $p_result_list = array();
		344	+
		345	+ // ----- Look if the $p_filelist is really an array
		346	+ if (is_array($p_filelist)) {
		347	+
		348	+ // ----- Look if the first element is also an array
		349	+ // This will mean that this is a file description entry
		350	+ if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
		351	+ $v_att_list = $p_filelist;
		352	+ }
		353	+
		354	+ // ----- The list is a list of string names
		355	+ else {
		356	+ $v_string_list = $p_filelist;
		357	+ }
		358	+ }
		359	+
		360	+ // ----- Look if the $p_filelist is a string
		361	+ else if (is_string($p_filelist)) {
		362	+ // ----- Create a list from the string
		363	+ $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
		364	+ }
		365	+
		366	+ // ----- Invalid variable type for $p_filelist
		367	+ else {
		368	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_filelist");
		369	+ return 0;
		370	+ }
		371	+
		372	+ // ----- Reformat the string list
		373	+ if (sizeof($v_string_list) != 0) {
		374	+ foreach ($v_string_list as $v_string) {
		375	+ if ($v_string != '') {
		376	+ $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;
		377	+ }
		378	+ else {
		379	+ }
		380	+ }
		381	+ }
		382	+
		383	+ // ----- For each file in the list check the attributes
		384	+ $v_supported_attributes
		385	+ = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
		386	+ ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
		387	+ ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
		388	+ ,PCLZIP_ATT_FILE_MTIME => 'optional'
		389	+ ,PCLZIP_ATT_FILE_CONTENT => 'optional'
		390	+ ,PCLZIP_ATT_FILE_COMMENT => 'optional'
		391	+ );
		392	+ foreach ($v_att_list as $v_entry) {
		393	+ $v_result = $this->privFileDescrParseAtt($v_entry,
		394	+ $v_filedescr_list[],
		395	+ $v_options,
		396	+ $v_supported_attributes);
		397	+ if ($v_result != 1) {
		398	+ return 0;
		399	+ }
		400	+ }
		401	+
		402	+ // ----- Expand the filelist (expand directories)
		403	+ $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
		404	+ if ($v_result != 1) {
		405	+ return 0;
		406	+ }
		407	+
		408	+ // ----- Call the create fct
		409	+ $v_result = $this->privCreate($v_filedescr_list, $p_result_list, $v_options);
		410	+ if ($v_result != 1) {
		411	+ return 0;
		412	+ }
		413	+
		414	+ // ----- Return
		415	+ return $p_result_list;
		416	+ }
		417	+ // --------------------------------------------------------------------------------
		418	+
		419	+ // --------------------------------------------------------------------------------
		420	+ // Function :
		421	+ // add($p_filelist, $p_add_dir="", $p_remove_dir="")
		422	+ // add($p_filelist, $p_option, $p_option_value, ...)
		423	+ // Description :
		424	+ // This method supports two synopsis. The first one is historical.
		425	+ // This methods add the list of files in an existing archive.
		426	+ // If a file with the same name already exists, it is added at the end of the
		427	+ // archive, the first one is still present.
		428	+ // If the archive does not exist, it is created.
		429	+ // Parameters :
		430	+ // $p_filelist : An array containing file or directory names, or
		431	+ // a string containing one filename or one directory name, or
		432	+ // a string containing a list of filenames and/or directory
		433	+ // names separated by spaces.
		434	+ // $p_add_dir : A path to add before the real path of the archived file,
		435	+ // in order to have it memorized in the archive.
		436	+ // $p_remove_dir : A path to remove from the real path of the file to archive,
		437	+ // in order to have a shorter path memorized in the archive.
		438	+ // When $p_add_dir and $p_remove_dir are set, $p_remove_dir
		439	+ // is removed first, before $p_add_dir is added.
		440	+ // Options :
		441	+ // PCLZIP_OPT_ADD_PATH :
		442	+ // PCLZIP_OPT_REMOVE_PATH :
		443	+ // PCLZIP_OPT_REMOVE_ALL_PATH :
		444	+ // PCLZIP_OPT_COMMENT :
		445	+ // PCLZIP_OPT_ADD_COMMENT :
		446	+ // PCLZIP_OPT_PREPEND_COMMENT :
		447	+ // PCLZIP_CB_PRE_ADD :
		448	+ // PCLZIP_CB_POST_ADD :
		449	+ // Return Values :
		450	+ // 0 on failure,
		451	+ // The list of the added files, with a status of the add action.
		452	+ // (see PclZip::listContent() for list entry format)
		453	+ // --------------------------------------------------------------------------------
		454	+ function add($p_filelist)
		455	+ {
		456	+ $v_result=1;
		457	+
		458	+ // ----- Reset the error handler
		459	+ $this->privErrorReset();
		460	+
		461	+ // ----- Set default values
		462	+ $v_options = array();
		463	+ $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
		464	+
		465	+ // ----- Look for variable options arguments
		466	+ $v_size = func_num_args();
		467	+
		468	+ // ----- Look for arguments
		469	+ if ($v_size > 1) {
		470	+ // ----- Get the arguments
		471	+ $v_arg_list = func_get_args();
		472	+
		473	+ // ----- Remove form the options list the first argument
		474	+ array_shift($v_arg_list);
		475	+ $v_size--;
		476	+
		477	+ // ----- Look for first arg
		478	+ if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
		479	+
		480	+ // ----- Parse the options
		481	+ $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
		482	+ array (PCLZIP_OPT_REMOVE_PATH => 'optional',
		483	+ PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
		484	+ PCLZIP_OPT_ADD_PATH => 'optional',
		485	+ PCLZIP_CB_PRE_ADD => 'optional',
		486	+ PCLZIP_CB_POST_ADD => 'optional',
		487	+ PCLZIP_OPT_NO_COMPRESSION => 'optional',
		488	+ PCLZIP_OPT_COMMENT => 'optional',
		489	+ PCLZIP_OPT_ADD_COMMENT => 'optional',
		490	+ PCLZIP_OPT_PREPEND_COMMENT => 'optional',
		491	+ PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
		492	+ PCLZIP_OPT_TEMP_FILE_ON => 'optional',
		493	+ PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
		494	+ //, PCLZIP_OPT_CRYPT => 'optional'
		495	+ ));
		496	+ if ($v_result != 1) {
		497	+ return 0;
		498	+ }
		499	+ }
		500	+
		501	+ // ----- Look for 2 args
		502	+ // Here we need to support the first historic synopsis of the
		503	+ // method.
		504	+ else {
		505	+
		506	+ // ----- Get the first argument
		507	+ $v_options[PCLZIP_OPT_ADD_PATH] = $v_add_path = $v_arg_list[0];
		508	+
		509	+ // ----- Look for the optional second argument
		510	+ if ($v_size == 2) {
		511	+ $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
		512	+ }
		513	+ else if ($v_size > 2) {
		514	+ // ----- Error log
		515	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
		516	+
		517	+ // ----- Return
		518	+ return 0;
		519	+ }
		520	+ }
		521	+ }
		522	+
		523	+ // ----- Look for default option values
		524	+ $this->privOptionDefaultThreshold($v_options);
		525	+
		526	+ // ----- Init
		527	+ $v_string_list = array();
		528	+ $v_att_list = array();
		529	+ $v_filedescr_list = array();
		530	+ $p_result_list = array();
		531	+
		532	+ // ----- Look if the $p_filelist is really an array
		533	+ if (is_array($p_filelist)) {
		534	+
		535	+ // ----- Look if the first element is also an array
		536	+ // This will mean that this is a file description entry
		537	+ if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
		538	+ $v_att_list = $p_filelist;
		539	+ }
		540	+
		541	+ // ----- The list is a list of string names
		542	+ else {
		543	+ $v_string_list = $p_filelist;
		544	+ }
		545	+ }
		546	+
		547	+ // ----- Look if the $p_filelist is a string
		548	+ else if (is_string($p_filelist)) {
		549	+ // ----- Create a list from the string
		550	+ $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
		551	+ }
		552	+
		553	+ // ----- Invalid variable type for $p_filelist
		554	+ else {
		555	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type '".gettype($p_filelist)."' for p_filelist");
		556	+ return 0;
		557	+ }
		558	+
		559	+ // ----- Reformat the string list
		560	+ if (sizeof($v_string_list) != 0) {
		561	+ foreach ($v_string_list as $v_string) {
		562	+ $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;
		563	+ }
		564	+ }
		565	+
		566	+ // ----- For each file in the list check the attributes
		567	+ $v_supported_attributes
		568	+ = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
		569	+ ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
		570	+ ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
		571	+ ,PCLZIP_ATT_FILE_MTIME => 'optional'
		572	+ ,PCLZIP_ATT_FILE_CONTENT => 'optional'
		573	+ ,PCLZIP_ATT_FILE_COMMENT => 'optional'
		574	+ );
		575	+ foreach ($v_att_list as $v_entry) {
		576	+ $v_result = $this->privFileDescrParseAtt($v_entry,
		577	+ $v_filedescr_list[],
		578	+ $v_options,
		579	+ $v_supported_attributes);
		580	+ if ($v_result != 1) {
		581	+ return 0;
		582	+ }
		583	+ }
		584	+
		585	+ // ----- Expand the filelist (expand directories)
		586	+ $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
		587	+ if ($v_result != 1) {
		588	+ return 0;
		589	+ }
		590	+
		591	+ // ----- Call the create fct
		592	+ $v_result = $this->privAdd($v_filedescr_list, $p_result_list, $v_options);
		593	+ if ($v_result != 1) {
		594	+ return 0;
		595	+ }
		596	+
		597	+ // ----- Return
		598	+ return $p_result_list;
		599	+ }
		600	+ // --------------------------------------------------------------------------------
		601	+
		602	+ // --------------------------------------------------------------------------------
		603	+ // Function : listContent()
		604	+ // Description :
		605	+ // This public method, gives the list of the files and directories, with their
		606	+ // properties.
		607	+ // The properties of each entries in the list are (used also in other functions) :
		608	+ // filename : Name of the file. For a create or add action it is the filename
		609	+ // given by the user. For an extract function it is the filename
		610	+ // of the extracted file.
		611	+ // stored_filename : Name of the file / directory stored in the archive.
		612	+ // size : Size of the stored file.
		613	+ // compressed_size : Size of the file's data compressed in the archive
		614	+ // (without the headers overhead)
		615	+ // mtime : Last known modification date of the file (UNIX timestamp)
		616	+ // comment : Comment associated with the file
		617	+ // folder : true \| false
		618	+ // index : index of the file in the archive
		619	+ // status : status of the action (depending of the action) :
		620	+ // Values are :
		621	+ // ok : OK !
		622	+ // filtered : the file / dir is not extracted (filtered by user)
		623	+ // already_a_directory : the file can not be extracted because a
		624	+ // directory with the same name already exists
		625	+ // write_protected : the file can not be extracted because a file
		626	+ // with the same name already exists and is
		627	+ // write protected
		628	+ // newer_exist : the file was not extracted because a newer file exists
		629	+ // path_creation_fail : the file is not extracted because the folder
		630	+ // does not exist and can not be created
		631	+ // write_error : the file was not extracted because there was a
		632	+ // error while writing the file
		633	+ // read_error : the file was not extracted because there was a error
		634	+ // while reading the file
		635	+ // invalid_header : the file was not extracted because of an archive
		636	+ // format error (bad file header)
		637	+ // Note that each time a method can continue operating when there
		638	+ // is an action error on a file, the error is only logged in the file status.
		639	+ // Return Values :
		640	+ // 0 on an unrecoverable failure,
		641	+ // The list of the files in the archive.
		642	+ // --------------------------------------------------------------------------------
		643	+ function listContent()
		644	+ {
		645	+ $v_result=1;
		646	+
		647	+ // ----- Reset the error handler
		648	+ $this->privErrorReset();
		649	+
		650	+ // ----- Check archive
		651	+ if (!$this->privCheckFormat()) {
		652	+ return(0);
		653	+ }
		654	+
		655	+ // ----- Call the extracting fct
		656	+ $p_list = array();
		657	+ if (($v_result = $this->privList($p_list)) != 1)
		658	+ {
		659	+ unset($p_list);
		660	+ return(0);
		661	+ }
		662	+
		663	+ // ----- Return
		664	+ return $p_list;
		665	+ }
		666	+ // --------------------------------------------------------------------------------
		667	+
		668	+ // --------------------------------------------------------------------------------
		669	+ // Function :
		670	+ // extract($p_path="./", $p_remove_path="")
		671	+ // extract([$p_option, $p_option_value, ...])
		672	+ // Description :
		673	+ // This method supports two synopsis. The first one is historical.
		674	+ // This method extract all the files / directories from the archive to the
		675	+ // folder indicated in $p_path.
		676	+ // If you want to ignore the 'root' part of path of the memorized files
		677	+ // you can indicate this in the optional $p_remove_path parameter.
		678	+ // By default, if a newer file with the same name already exists, the
		679	+ // file is not extracted.
		680	+ //
		681	+ // If both PCLZIP_OPT_PATH and PCLZIP_OPT_ADD_PATH aoptions
		682	+ // are used, the path indicated in PCLZIP_OPT_ADD_PATH is append
		683	+ // at the end of the path value of PCLZIP_OPT_PATH.
		684	+ // Parameters :
		685	+ // $p_path : Path where the files and directories are to be extracted
		686	+ // $p_remove_path : First part ('root' part) of the memorized path
		687	+ // (if any similar) to remove while extracting.
		688	+ // Options :
		689	+ // PCLZIP_OPT_PATH :
		690	+ // PCLZIP_OPT_ADD_PATH :
		691	+ // PCLZIP_OPT_REMOVE_PATH :
		692	+ // PCLZIP_OPT_REMOVE_ALL_PATH :
		693	+ // PCLZIP_CB_PRE_EXTRACT :
		694	+ // PCLZIP_CB_POST_EXTRACT :
		695	+ // Return Values :
		696	+ // 0 or a negative value on failure,
		697	+ // The list of the extracted files, with a status of the action.
		698	+ // (see PclZip::listContent() for list entry format)
		699	+ // --------------------------------------------------------------------------------
		700	+ function extract()
		701	+ {
		702	+ $v_result=1;
		703	+
		704	+ // ----- Reset the error handler
		705	+ $this->privErrorReset();
		706	+
		707	+ // ----- Check archive
		708	+ if (!$this->privCheckFormat()) {
		709	+ return(0);
		710	+ }
		711	+
		712	+ // ----- Set default values
		713	+ $v_options = array();
		714	+// $v_path = "./";
		715	+ $v_path = '';
		716	+ $v_remove_path = "";
		717	+ $v_remove_all_path = false;
		718	+
		719	+ // ----- Look for variable options arguments
		720	+ $v_size = func_num_args();
		721	+
		722	+ // ----- Default values for option
		723	+ $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
		724	+
		725	+ // ----- Look for arguments
		726	+ if ($v_size > 0) {
		727	+ // ----- Get the arguments
		728	+ $v_arg_list = func_get_args();
		729	+
		730	+ // ----- Look for first arg
		731	+ if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
		732	+
		733	+ // ----- Parse the options
		734	+ $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
		735	+ array (PCLZIP_OPT_PATH => 'optional',
		736	+ PCLZIP_OPT_REMOVE_PATH => 'optional',
		737	+ PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
		738	+ PCLZIP_OPT_ADD_PATH => 'optional',
		739	+ PCLZIP_CB_PRE_EXTRACT => 'optional',
		740	+ PCLZIP_CB_POST_EXTRACT => 'optional',
		741	+ PCLZIP_OPT_SET_CHMOD => 'optional',
		742	+ PCLZIP_OPT_BY_NAME => 'optional',
		743	+ PCLZIP_OPT_BY_EREG => 'optional',
		744	+ PCLZIP_OPT_BY_PREG => 'optional',
		745	+ PCLZIP_OPT_BY_INDEX => 'optional',
		746	+ PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
		747	+ PCLZIP_OPT_EXTRACT_IN_OUTPUT => 'optional',
		748	+ PCLZIP_OPT_REPLACE_NEWER => 'optional'
		749	+ ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
		750	+ ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
		751	+ PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
		752	+ PCLZIP_OPT_TEMP_FILE_ON => 'optional',
		753	+ PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
		754	+ ));
		755	+ if ($v_result != 1) {
		756	+ return 0;
		757	+ }
		758	+
		759	+ // ----- Set the arguments
		760	+ if (isset($v_options[PCLZIP_OPT_PATH])) {
		761	+ $v_path = $v_options[PCLZIP_OPT_PATH];
		762	+ }
		763	+ if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {
		764	+ $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];
		765	+ }
		766	+ if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
		767	+ $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];
		768	+ }
		769	+ if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {
		770	+ // ----- Check for '/' in last path char
		771	+ if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {
		772	+ $v_path .= '/';
		773	+ }
		774	+ $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];
		775	+ }
		776	+ }
		777	+
		778	+ // ----- Look for 2 args
		779	+ // Here we need to support the first historic synopsis of the
		780	+ // method.
		781	+ else {
		782	+
		783	+ // ----- Get the first argument
		784	+ $v_path = $v_arg_list[0];
		785	+
		786	+ // ----- Look for the optional second argument
		787	+ if ($v_size == 2) {
		788	+ $v_remove_path = $v_arg_list[1];
		789	+ }
		790	+ else if ($v_size > 2) {
		791	+ // ----- Error log
		792	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
		793	+
		794	+ // ----- Return
		795	+ return 0;
		796	+ }
		797	+ }
		798	+ }
		799	+
		800	+ // ----- Look for default option values
		801	+ $this->privOptionDefaultThreshold($v_options);
		802	+
		803	+ // ----- Trace
		804	+
		805	+ // ----- Call the extracting fct
		806	+ $p_list = array();
		807	+ $v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path,
		808	+ $v_remove_all_path, $v_options);
		809	+ if ($v_result < 1) {
		810	+ unset($p_list);
		811	+ return(0);
		812	+ }
		813	+
		814	+ // ----- Return
		815	+ return $p_list;
		816	+ }
		817	+ // --------------------------------------------------------------------------------
		818	+
		819	+
		820	+ // --------------------------------------------------------------------------------
		821	+ // Function :
		822	+ // extractByIndex($p_index, $p_path="./", $p_remove_path="")
		823	+ // extractByIndex($p_index, [$p_option, $p_option_value, ...])
		824	+ // Description :
		825	+ // This method supports two synopsis. The first one is historical.
		826	+ // This method is doing a partial extract of the archive.
		827	+ // The extracted files or folders are identified by their index in the
		828	+ // archive (from 0 to n).
		829	+ // Note that if the index identify a folder, only the folder entry is
		830	+ // extracted, not all the files included in the archive.
		831	+ // Parameters :
		832	+ // $p_index : A single index (integer) or a string of indexes of files to
		833	+ // extract. The form of the string is "0,4-6,8-12" with only numbers
		834	+ // and '-' for range or ',' to separate ranges. No spaces or ';'
		835	+ // are allowed.
		836	+ // $p_path : Path where the files and directories are to be extracted
		837	+ // $p_remove_path : First part ('root' part) of the memorized path
		838	+ // (if any similar) to remove while extracting.
		839	+ // Options :
		840	+ // PCLZIP_OPT_PATH :
		841	+ // PCLZIP_OPT_ADD_PATH :
		842	+ // PCLZIP_OPT_REMOVE_PATH :
		843	+ // PCLZIP_OPT_REMOVE_ALL_PATH :
		844	+ // PCLZIP_OPT_EXTRACT_AS_STRING : The files are extracted as strings and
		845	+ // not as files.
		846	+ // The resulting content is in a new field 'content' in the file
		847	+ // structure.
		848	+ // This option must be used alone (any other options are ignored).
		849	+ // PCLZIP_CB_PRE_EXTRACT :
		850	+ // PCLZIP_CB_POST_EXTRACT :
		851	+ // Return Values :
		852	+ // 0 on failure,
		853	+ // The list of the extracted files, with a status of the action.
		854	+ // (see PclZip::listContent() for list entry format)
		855	+ // --------------------------------------------------------------------------------
		856	+ //function extractByIndex($p_index, options...)
		857	+ function extractByIndex($p_index)
		858	+ {
		859	+ $v_result=1;
		860	+
		861	+ // ----- Reset the error handler
		862	+ $this->privErrorReset();
		863	+
		864	+ // ----- Check archive
		865	+ if (!$this->privCheckFormat()) {
		866	+ return(0);
		867	+ }
		868	+
		869	+ // ----- Set default values
		870	+ $v_options = array();
		871	+// $v_path = "./";
		872	+ $v_path = '';
		873	+ $v_remove_path = "";
		874	+ $v_remove_all_path = false;
		875	+
		876	+ // ----- Look for variable options arguments
		877	+ $v_size = func_num_args();
		878	+
		879	+ // ----- Default values for option
		880	+ $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
		881	+
		882	+ // ----- Look for arguments
		883	+ if ($v_size > 1) {
		884	+ // ----- Get the arguments
		885	+ $v_arg_list = func_get_args();
		886	+
		887	+ // ----- Remove form the options list the first argument
		888	+ array_shift($v_arg_list);
		889	+ $v_size--;
		890	+
		891	+ // ----- Look for first arg
		892	+ if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
		893	+
		894	+ // ----- Parse the options
		895	+ $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
		896	+ array (PCLZIP_OPT_PATH => 'optional',
		897	+ PCLZIP_OPT_REMOVE_PATH => 'optional',
		898	+ PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
		899	+ PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
		900	+ PCLZIP_OPT_ADD_PATH => 'optional',
		901	+ PCLZIP_CB_PRE_EXTRACT => 'optional',
		902	+ PCLZIP_CB_POST_EXTRACT => 'optional',
		903	+ PCLZIP_OPT_SET_CHMOD => 'optional',
		904	+ PCLZIP_OPT_REPLACE_NEWER => 'optional'
		905	+ ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
		906	+ ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
		907	+ PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
		908	+ PCLZIP_OPT_TEMP_FILE_ON => 'optional',
		909	+ PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
		910	+ ));
		911	+ if ($v_result != 1) {
		912	+ return 0;
		913	+ }
		914	+
		915	+ // ----- Set the arguments
		916	+ if (isset($v_options[PCLZIP_OPT_PATH])) {
		917	+ $v_path = $v_options[PCLZIP_OPT_PATH];
		918	+ }
		919	+ if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {
		920	+ $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];
		921	+ }
		922	+ if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
		923	+ $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];
		924	+ }
		925	+ if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {
		926	+ // ----- Check for '/' in last path char
		927	+ if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {
		928	+ $v_path .= '/';
		929	+ }
		930	+ $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];
		931	+ }
		932	+ if (!isset($v_options[PCLZIP_OPT_EXTRACT_AS_STRING])) {
		933	+ $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
		934	+ }
		935	+ else {
		936	+ }
		937	+ }
		938	+
		939	+ // ----- Look for 2 args
		940	+ // Here we need to support the first historic synopsis of the
		941	+ // method.
		942	+ else {
		943	+
		944	+ // ----- Get the first argument
		945	+ $v_path = $v_arg_list[0];
		946	+
		947	+ // ----- Look for the optional second argument
		948	+ if ($v_size == 2) {
		949	+ $v_remove_path = $v_arg_list[1];
		950	+ }
		951	+ else if ($v_size > 2) {
		952	+ // ----- Error log
		953	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
		954	+
		955	+ // ----- Return
		956	+ return 0;
		957	+ }
		958	+ }
		959	+ }
		960	+
		961	+ // ----- Trace
		962	+
		963	+ // ----- Trick
		964	+ // Here I want to reuse extractByRule(), so I need to parse the $p_index
		965	+ // with privParseOptions()
		966	+ $v_arg_trick = array (PCLZIP_OPT_BY_INDEX, $p_index);
		967	+ $v_options_trick = array();
		968	+ $v_result = $this->privParseOptions($v_arg_trick, sizeof($v_arg_trick), $v_options_trick,
		969	+ array (PCLZIP_OPT_BY_INDEX => 'optional' ));
		970	+ if ($v_result != 1) {
		971	+ return 0;
		972	+ }
		973	+ $v_options[PCLZIP_OPT_BY_INDEX] = $v_options_trick[PCLZIP_OPT_BY_INDEX];
		974	+
		975	+ // ----- Look for default option values
		976	+ $this->privOptionDefaultThreshold($v_options);
		977	+
		978	+ // ----- Call the extracting fct
		979	+ if (($v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path, $v_remove_all_path, $v_options)) < 1) {
		980	+ return(0);
		981	+ }
		982	+
		983	+ // ----- Return
		984	+ return $p_list;
		985	+ }
		986	+ // --------------------------------------------------------------------------------
		987	+
		988	+ // --------------------------------------------------------------------------------
		989	+ // Function :
		990	+ // delete([$p_option, $p_option_value, ...])
		991	+ // Description :
		992	+ // This method removes files from the archive.
		993	+ // If no parameters are given, then all the archive is emptied.
		994	+ // Parameters :
		995	+ // None or optional arguments.
		996	+ // Options :
		997	+ // PCLZIP_OPT_BY_INDEX :
		998	+ // PCLZIP_OPT_BY_NAME :
		999	+ // PCLZIP_OPT_BY_EREG :
		1000	+ // PCLZIP_OPT_BY_PREG :
		1001	+ // Return Values :
		1002	+ // 0 on failure,
		1003	+ // The list of the files which are still present in the archive.
		1004	+ // (see PclZip::listContent() for list entry format)
		1005	+ // --------------------------------------------------------------------------------
		1006	+ function delete()
		1007	+ {
		1008	+ $v_result=1;
		1009	+
		1010	+ // ----- Reset the error handler
		1011	+ $this->privErrorReset();
		1012	+
		1013	+ // ----- Check archive
		1014	+ if (!$this->privCheckFormat()) {
		1015	+ return(0);
		1016	+ }
		1017	+
		1018	+ // ----- Set default values
		1019	+ $v_options = array();
		1020	+
		1021	+ // ----- Look for variable options arguments
		1022	+ $v_size = func_num_args();
		1023	+
		1024	+ // ----- Look for arguments
		1025	+ if ($v_size > 0) {
		1026	+ // ----- Get the arguments
		1027	+ $v_arg_list = func_get_args();
		1028	+
		1029	+ // ----- Parse the options
		1030	+ $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
		1031	+ array (PCLZIP_OPT_BY_NAME => 'optional',
		1032	+ PCLZIP_OPT_BY_EREG => 'optional',
		1033	+ PCLZIP_OPT_BY_PREG => 'optional',
		1034	+ PCLZIP_OPT_BY_INDEX => 'optional' ));
		1035	+ if ($v_result != 1) {
		1036	+ return 0;
		1037	+ }
		1038	+ }
		1039	+
		1040	+ // ----- Magic quotes trick
		1041	+ $this->privDisableMagicQuotes();
		1042	+
		1043	+ // ----- Call the delete fct
		1044	+ $v_list = array();
		1045	+ if (($v_result = $this->privDeleteByRule($v_list, $v_options)) != 1) {
		1046	+ $this->privSwapBackMagicQuotes();
		1047	+ unset($v_list);
		1048	+ return(0);
		1049	+ }
		1050	+
		1051	+ // ----- Magic quotes trick
		1052	+ $this->privSwapBackMagicQuotes();
		1053	+
		1054	+ // ----- Return
		1055	+ return $v_list;
		1056	+ }
		1057	+ // --------------------------------------------------------------------------------
		1058	+
		1059	+ // --------------------------------------------------------------------------------
		1060	+ // Function : deleteByIndex()
		1061	+ // Description :
		1062	+ // *** Deprecated ***
		1063	+ // delete(PCLZIP_OPT_BY_INDEX, $p_index) should be prefered.
		1064	+ // --------------------------------------------------------------------------------
		1065	+ function deleteByIndex($p_index)
		1066	+ {
		1067	+
		1068	+ $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index);
		1069	+
		1070	+ // ----- Return
		1071	+ return $p_list;
		1072	+ }
		1073	+ // --------------------------------------------------------------------------------
		1074	+
		1075	+ // --------------------------------------------------------------------------------
		1076	+ // Function : properties()
		1077	+ // Description :
		1078	+ // This method gives the properties of the archive.
		1079	+ // The properties are :
		1080	+ // nb : Number of files in the archive
		1081	+ // comment : Comment associated with the archive file
		1082	+ // status : not_exist, ok
		1083	+ // Parameters :
		1084	+ // None
		1085	+ // Return Values :
		1086	+ // 0 on failure,
		1087	+ // An array with the archive properties.
		1088	+ // --------------------------------------------------------------------------------
		1089	+ function properties()
		1090	+ {
		1091	+
		1092	+ // ----- Reset the error handler
		1093	+ $this->privErrorReset();
		1094	+
		1095	+ // ----- Magic quotes trick
		1096	+ $this->privDisableMagicQuotes();
		1097	+
		1098	+ // ----- Check archive
		1099	+ if (!$this->privCheckFormat()) {
		1100	+ $this->privSwapBackMagicQuotes();
		1101	+ return(0);
		1102	+ }
		1103	+
		1104	+ // ----- Default properties
		1105	+ $v_prop = array();
		1106	+ $v_prop['comment'] = '';
		1107	+ $v_prop['nb'] = 0;
		1108	+ $v_prop['status'] = 'not_exist';
		1109	+
		1110	+ // ----- Look if file exists
		1111	+ if (@is_file($this->zipname))
		1112	+ {
		1113	+ // ----- Open the zip file
		1114	+ if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
		1115	+ {
		1116	+ $this->privSwapBackMagicQuotes();
		1117	+
		1118	+ // ----- Error log
		1119	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
		1120	+
		1121	+ // ----- Return
		1122	+ return 0;
		1123	+ }
		1124	+
		1125	+ // ----- Read the central directory informations
		1126	+ $v_central_dir = array();
		1127	+ if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
		1128	+ {
		1129	+ $this->privSwapBackMagicQuotes();
		1130	+ return 0;
		1131	+ }
		1132	+
		1133	+ // ----- Close the zip file
		1134	+ $this->privCloseFd();
		1135	+
		1136	+ // ----- Set the user attributes
		1137	+ $v_prop['comment'] = $v_central_dir['comment'];
		1138	+ $v_prop['nb'] = $v_central_dir['entries'];
		1139	+ $v_prop['status'] = 'ok';
		1140	+ }
		1141	+
		1142	+ // ----- Magic quotes trick
		1143	+ $this->privSwapBackMagicQuotes();
		1144	+
		1145	+ // ----- Return
		1146	+ return $v_prop;
		1147	+ }
		1148	+ // --------------------------------------------------------------------------------
		1149	+
		1150	+ // --------------------------------------------------------------------------------
		1151	+ // Function : duplicate()
		1152	+ // Description :
		1153	+ // This method creates an archive by copying the content of an other one. If
		1154	+ // the archive already exist, it is replaced by the new one without any warning.
		1155	+ // Parameters :
		1156	+ // $p_archive : The filename of a valid archive, or
		1157	+ // a valid PclZip object.
		1158	+ // Return Values :
		1159	+ // 1 on success.
		1160	+ // 0 or a negative value on error (error code).
		1161	+ // --------------------------------------------------------------------------------
		1162	+ function duplicate($p_archive)
		1163	+ {
		1164	+ $v_result = 1;
		1165	+
		1166	+ // ----- Reset the error handler
		1167	+ $this->privErrorReset();
		1168	+
		1169	+ // ----- Look if the $p_archive is a PclZip object
		1170	+ if ((is_object($p_archive)) && (get_class($p_archive) == 'pclzip'))
		1171	+ {
		1172	+
		1173	+ // ----- Duplicate the archive
		1174	+ $v_result = $this->privDuplicate($p_archive->zipname);
		1175	+ }
		1176	+
		1177	+ // ----- Look if the $p_archive is a string (so a filename)
		1178	+ else if (is_string($p_archive))
		1179	+ {
		1180	+
		1181	+ // ----- Check that $p_archive is a valid zip file
		1182	+ // TBC : Should also check the archive format
		1183	+ if (!is_file($p_archive)) {
		1184	+ // ----- Error log
		1185	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "No file with filename '".$p_archive."'");
		1186	+ $v_result = PCLZIP_ERR_MISSING_FILE;
		1187	+ }
		1188	+ else {
		1189	+ // ----- Duplicate the archive
		1190	+ $v_result = $this->privDuplicate($p_archive);
		1191	+ }
		1192	+ }
		1193	+
		1194	+ // ----- Invalid variable
		1195	+ else
		1196	+ {
		1197	+ // ----- Error log
		1198	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
		1199	+ $v_result = PCLZIP_ERR_INVALID_PARAMETER;
		1200	+ }
		1201	+
		1202	+ // ----- Return
		1203	+ return $v_result;
		1204	+ }
		1205	+ // --------------------------------------------------------------------------------
		1206	+
		1207	+ // --------------------------------------------------------------------------------
		1208	+ // Function : merge()
		1209	+ // Description :
		1210	+ // This method merge the $p_archive_to_add archive at the end of the current
		1211	+ // one ($this).
		1212	+ // If the archive ($this) does not exist, the merge becomes a duplicate.
		1213	+ // If the $p_archive_to_add archive does not exist, the merge is a success.
		1214	+ // Parameters :
		1215	+ // $p_archive_to_add : It can be directly the filename of a valid zip archive,
		1216	+ // or a PclZip object archive.
		1217	+ // Return Values :
		1218	+ // 1 on success,
		1219	+ // 0 or negative values on error (see below).
		1220	+ // --------------------------------------------------------------------------------
		1221	+ function merge($p_archive_to_add)
		1222	+ {
		1223	+ $v_result = 1;
		1224	+
		1225	+ // ----- Reset the error handler
		1226	+ $this->privErrorReset();
		1227	+
		1228	+ // ----- Check archive
		1229	+ if (!$this->privCheckFormat()) {
		1230	+ return(0);
		1231	+ }
		1232	+
		1233	+ // ----- Look if the $p_archive_to_add is a PclZip object
		1234	+ if ((is_object($p_archive_to_add)) && (get_class($p_archive_to_add) == 'pclzip'))
		1235	+ {
		1236	+
		1237	+ // ----- Merge the archive
		1238	+ $v_result = $this->privMerge($p_archive_to_add);
		1239	+ }
		1240	+
		1241	+ // ----- Look if the $p_archive_to_add is a string (so a filename)
		1242	+ else if (is_string($p_archive_to_add))
		1243	+ {
		1244	+
		1245	+ // ----- Create a temporary archive
		1246	+ $v_object_archive = new PclZip($p_archive_to_add);
		1247	+
		1248	+ // ----- Merge the archive
		1249	+ $v_result = $this->privMerge($v_object_archive);
		1250	+ }
		1251	+
		1252	+ // ----- Invalid variable
		1253	+ else
		1254	+ {
		1255	+ // ----- Error log
		1256	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
		1257	+ $v_result = PCLZIP_ERR_INVALID_PARAMETER;
		1258	+ }
		1259	+
		1260	+ // ----- Return
		1261	+ return $v_result;
		1262	+ }
		1263	+ // --------------------------------------------------------------------------------
		1264	+
		1265	+
		1266	+
		1267	+ // --------------------------------------------------------------------------------
		1268	+ // Function : errorCode()
		1269	+ // Description :
		1270	+ // Parameters :
		1271	+ // --------------------------------------------------------------------------------
		1272	+ function errorCode()
		1273	+ {
		1274	+ if (PCLZIP_ERROR_EXTERNAL == 1) {
		1275	+ return(PclErrorCode());
		1276	+ }
		1277	+ else {
		1278	+ return($this->error_code);
		1279	+ }
		1280	+ }
		1281	+ // --------------------------------------------------------------------------------
		1282	+
		1283	+ // --------------------------------------------------------------------------------
		1284	+ // Function : errorName()
		1285	+ // Description :
		1286	+ // Parameters :
		1287	+ // --------------------------------------------------------------------------------
		1288	+ function errorName($p_with_code=false)
		1289	+ {
		1290	+ $v_name = array ( PCLZIP_ERR_NO_ERROR => 'PCLZIP_ERR_NO_ERROR',
		1291	+ PCLZIP_ERR_WRITE_OPEN_FAIL => 'PCLZIP_ERR_WRITE_OPEN_FAIL',
		1292	+ PCLZIP_ERR_READ_OPEN_FAIL => 'PCLZIP_ERR_READ_OPEN_FAIL',
		1293	+ PCLZIP_ERR_INVALID_PARAMETER => 'PCLZIP_ERR_INVALID_PARAMETER',
		1294	+ PCLZIP_ERR_MISSING_FILE => 'PCLZIP_ERR_MISSING_FILE',
		1295	+ PCLZIP_ERR_FILENAME_TOO_LONG => 'PCLZIP_ERR_FILENAME_TOO_LONG',
		1296	+ PCLZIP_ERR_INVALID_ZIP => 'PCLZIP_ERR_INVALID_ZIP',
		1297	+ PCLZIP_ERR_BAD_EXTRACTED_FILE => 'PCLZIP_ERR_BAD_EXTRACTED_FILE',
		1298	+ PCLZIP_ERR_DIR_CREATE_FAIL => 'PCLZIP_ERR_DIR_CREATE_FAIL',
		1299	+ PCLZIP_ERR_BAD_EXTENSION => 'PCLZIP_ERR_BAD_EXTENSION',
		1300	+ PCLZIP_ERR_BAD_FORMAT => 'PCLZIP_ERR_BAD_FORMAT',
		1301	+ PCLZIP_ERR_DELETE_FILE_FAIL => 'PCLZIP_ERR_DELETE_FILE_FAIL',
		1302	+ PCLZIP_ERR_RENAME_FILE_FAIL => 'PCLZIP_ERR_RENAME_FILE_FAIL',
		1303	+ PCLZIP_ERR_BAD_CHECKSUM => 'PCLZIP_ERR_BAD_CHECKSUM',
		1304	+ PCLZIP_ERR_INVALID_ARCHIVE_ZIP => 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP',
		1305	+ PCLZIP_ERR_MISSING_OPTION_VALUE => 'PCLZIP_ERR_MISSING_OPTION_VALUE',
		1306	+ PCLZIP_ERR_INVALID_OPTION_VALUE => 'PCLZIP_ERR_INVALID_OPTION_VALUE',
		1307	+ PCLZIP_ERR_UNSUPPORTED_COMPRESSION => 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION',
		1308	+ PCLZIP_ERR_UNSUPPORTED_ENCRYPTION => 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION'
		1309	+ ,PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE => 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE'
		1310	+ ,PCLZIP_ERR_DIRECTORY_RESTRICTION => 'PCLZIP_ERR_DIRECTORY_RESTRICTION'
		1311	+ );
		1312	+
		1313	+ if (isset($v_name[$this->error_code])) {
		1314	+ $v_value = $v_name[$this->error_code];
		1315	+ }
		1316	+ else {
		1317	+ $v_value = 'NoName';
		1318	+ }
		1319	+
		1320	+ if ($p_with_code) {
		1321	+ return($v_value.' ('.$this->error_code.')');
		1322	+ }
		1323	+ else {
		1324	+ return($v_value);
		1325	+ }
		1326	+ }
		1327	+ // --------------------------------------------------------------------------------
		1328	+
		1329	+ // --------------------------------------------------------------------------------
		1330	+ // Function : errorInfo()
		1331	+ // Description :
		1332	+ // Parameters :
		1333	+ // --------------------------------------------------------------------------------
		1334	+ function errorInfo($p_full=false)
		1335	+ {
		1336	+ if (PCLZIP_ERROR_EXTERNAL == 1) {
		1337	+ return(PclErrorString());
		1338	+ }
		1339	+ else {
		1340	+ if ($p_full) {
		1341	+ return($this->errorName(true)." : ".$this->error_string);
		1342	+ }
		1343	+ else {
		1344	+ return($this->error_string." [code ".$this->error_code."]");
		1345	+ }
		1346	+ }
		1347	+ }
		1348	+ // --------------------------------------------------------------------------------
		1349	+
		1350	+
		1351	+// --------------------------------------------------------------------------------
		1352	+// *** UNDER THIS LINE ARE DEFINED PRIVATE INTERNAL FUNCTIONS ***
		1353	+// *** ***
		1354	+// *** THESES FUNCTIONS MUST NOT BE USED DIRECTLY ***
		1355	+// --------------------------------------------------------------------------------
		1356	+
		1357	+
		1358	+
		1359	+ // --------------------------------------------------------------------------------
		1360	+ // Function : privCheckFormat()
		1361	+ // Description :
		1362	+ // This method check that the archive exists and is a valid zip archive.
		1363	+ // Several level of check exists. (futur)
		1364	+ // Parameters :
		1365	+ // $p_level : Level of check. Default 0.
		1366	+ // 0 : Check the first bytes (magic codes) (default value))
		1367	+ // 1 : 0 + Check the central directory (futur)
		1368	+ // 2 : 1 + Check each file header (futur)
		1369	+ // Return Values :
		1370	+ // true on success,
		1371	+ // false on error, the error code is set.
		1372	+ // --------------------------------------------------------------------------------
		1373	+ function privCheckFormat($p_level=0)
		1374	+ {
		1375	+ $v_result = true;
		1376	+
		1377	+ // ----- Reset the file system cache
		1378	+ clearstatcache();
		1379	+
		1380	+ // ----- Reset the error handler
		1381	+ $this->privErrorReset();
		1382	+
		1383	+ // ----- Look if the file exits
		1384	+ if (!is_file($this->zipname)) {
		1385	+ // ----- Error log
		1386	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "Missing archive file '".$this->zipname."'");
		1387	+ return(false);
		1388	+ }
		1389	+
		1390	+ // ----- Check that the file is readeable
		1391	+ if (!is_readable($this->zipname)) {
		1392	+ // ----- Error log
		1393	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to read archive '".$this->zipname."'");
		1394	+ return(false);
		1395	+ }
		1396	+
		1397	+ // ----- Check the magic code
		1398	+ // TBC
		1399	+
		1400	+ // ----- Check the central header
		1401	+ // TBC
		1402	+
		1403	+ // ----- Check each file header
		1404	+ // TBC
		1405	+
		1406	+ // ----- Return
		1407	+ return $v_result;
		1408	+ }
		1409	+ // --------------------------------------------------------------------------------
		1410	+
		1411	+ // --------------------------------------------------------------------------------
		1412	+ // Function : privParseOptions()
		1413	+ // Description :
		1414	+ // This internal methods reads the variable list of arguments ($p_options_list,
		1415	+ // $p_size) and generate an array with the options and values ($v_result_list).
		1416	+ // $v_requested_options contains the options that can be present and those that
		1417	+ // must be present.
		1418	+ // $v_requested_options is an array, with the option value as key, and 'optional',
		1419	+ // or 'mandatory' as value.
		1420	+ // Parameters :
		1421	+ // See above.
		1422	+ // Return Values :
		1423	+ // 1 on success.
		1424	+ // 0 on failure.
		1425	+ // --------------------------------------------------------------------------------
		1426	+ function privParseOptions(&$p_options_list, $p_size, &$v_result_list, $v_requested_options=false)
		1427	+ {
		1428	+ $v_result=1;
		1429	+
		1430	+ // ----- Read the options
		1431	+ $i=0;
		1432	+ while ($i<$p_size) {
		1433	+
		1434	+ // ----- Check if the option is supported
		1435	+ if (!isset($v_requested_options[$p_options_list[$i]])) {
		1436	+ // ----- Error log
		1437	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid optional parameter '".$p_options_list[$i]."' for this method");
		1438	+
		1439	+ // ----- Return
		1440	+ return PclZip::errorCode();
		1441	+ }
		1442	+
		1443	+ // ----- Look for next option
		1444	+ switch ($p_options_list[$i]) {
		1445	+ // ----- Look for options that request a path value
		1446	+ case PCLZIP_OPT_PATH :
		1447	+ case PCLZIP_OPT_REMOVE_PATH :
		1448	+ case PCLZIP_OPT_ADD_PATH :
		1449	+ // ----- Check the number of parameters
		1450	+ if (($i+1) >= $p_size) {
		1451	+ // ----- Error log
		1452	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1453	+
		1454	+ // ----- Return
		1455	+ return PclZip::errorCode();
		1456	+ }
		1457	+
		1458	+ // ----- Get the value
		1459	+ $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
		1460	+ $i++;
		1461	+ break;
		1462	+
		1463	+ case PCLZIP_OPT_TEMP_FILE_THRESHOLD :
		1464	+ // ----- Check the number of parameters
		1465	+ if (($i+1) >= $p_size) {
		1466	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1467	+ return PclZip::errorCode();
		1468	+ }
		1469	+
		1470	+ // ----- Check for incompatible options
		1471	+ if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
		1472	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
		1473	+ return PclZip::errorCode();
		1474	+ }
		1475	+
		1476	+ // ----- Check the value
		1477	+ $v_value = $p_options_list[$i+1];
		1478	+ if ((!is_integer($v_value)) \|\| ($v_value<0)) {
		1479	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Integer expected for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1480	+ return PclZip::errorCode();
		1481	+ }
		1482	+
		1483	+ // ----- Get the value (and convert it in bytes)
		1484	+ $v_result_list[$p_options_list[$i]] = $v_value*1048576;
		1485	+ $i++;
		1486	+ break;
		1487	+
		1488	+ case PCLZIP_OPT_TEMP_FILE_ON :
		1489	+ // ----- Check for incompatible options
		1490	+ if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
		1491	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
		1492	+ return PclZip::errorCode();
		1493	+ }
		1494	+
		1495	+ $v_result_list[$p_options_list[$i]] = true;
		1496	+ break;
		1497	+
		1498	+ case PCLZIP_OPT_TEMP_FILE_OFF :
		1499	+ // ----- Check for incompatible options
		1500	+ if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_ON])) {
		1501	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_ON'");
		1502	+ return PclZip::errorCode();
		1503	+ }
		1504	+ // ----- Check for incompatible options
		1505	+ if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
		1506	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_THRESHOLD'");
		1507	+ return PclZip::errorCode();
		1508	+ }
		1509	+
		1510	+ $v_result_list[$p_options_list[$i]] = true;
		1511	+ break;
		1512	+
		1513	+ case PCLZIP_OPT_EXTRACT_DIR_RESTRICTION :
		1514	+ // ----- Check the number of parameters
		1515	+ if (($i+1) >= $p_size) {
		1516	+ // ----- Error log
		1517	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1518	+
		1519	+ // ----- Return
		1520	+ return PclZip::errorCode();
		1521	+ }
		1522	+
		1523	+ // ----- Get the value
		1524	+ if ( is_string($p_options_list[$i+1])
		1525	+ && ($p_options_list[$i+1] != '')) {
		1526	+ $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
		1527	+ $i++;
		1528	+ }
		1529	+ else {
		1530	+ }
		1531	+ break;
		1532	+
		1533	+ // ----- Look for options that request an array of string for value
		1534	+ case PCLZIP_OPT_BY_NAME :
		1535	+ // ----- Check the number of parameters
		1536	+ if (($i+1) >= $p_size) {
		1537	+ // ----- Error log
		1538	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1539	+
		1540	+ // ----- Return
		1541	+ return PclZip::errorCode();
		1542	+ }
		1543	+
		1544	+ // ----- Get the value
		1545	+ if (is_string($p_options_list[$i+1])) {
		1546	+ $v_result_list[$p_options_list[$i]][0] = $p_options_list[$i+1];
		1547	+ }
		1548	+ else if (is_array($p_options_list[$i+1])) {
		1549	+ $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
		1550	+ }
		1551	+ else {
		1552	+ // ----- Error log
		1553	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1554	+
		1555	+ // ----- Return
		1556	+ return PclZip::errorCode();
		1557	+ }
		1558	+ $i++;
		1559	+ break;
		1560	+
		1561	+ // ----- Look for options that request an EREG or PREG expression
		1562	+ case PCLZIP_OPT_BY_EREG :
		1563	+ // ereg() is deprecated starting with PHP 5.3. Move PCLZIP_OPT_BY_EREG
		1564	+ // to PCLZIP_OPT_BY_PREG
		1565	+ $p_options_list[$i] = PCLZIP_OPT_BY_PREG;
		1566	+ case PCLZIP_OPT_BY_PREG :
		1567	+ //case PCLZIP_OPT_CRYPT :
		1568	+ // ----- Check the number of parameters
		1569	+ if (($i+1) >= $p_size) {
		1570	+ // ----- Error log
		1571	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1572	+
		1573	+ // ----- Return
		1574	+ return PclZip::errorCode();
		1575	+ }
		1576	+
		1577	+ // ----- Get the value
		1578	+ if (is_string($p_options_list[$i+1])) {
		1579	+ $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
		1580	+ }
		1581	+ else {
		1582	+ // ----- Error log
		1583	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1584	+
		1585	+ // ----- Return
		1586	+ return PclZip::errorCode();
		1587	+ }
		1588	+ $i++;
		1589	+ break;
		1590	+
		1591	+ // ----- Look for options that takes a string
		1592	+ case PCLZIP_OPT_COMMENT :
		1593	+ case PCLZIP_OPT_ADD_COMMENT :
		1594	+ case PCLZIP_OPT_PREPEND_COMMENT :
		1595	+ // ----- Check the number of parameters
		1596	+ if (($i+1) >= $p_size) {
		1597	+ // ----- Error log
		1598	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
		1599	+ "Missing parameter value for option '"
		1600	+ .PclZipUtilOptionText($p_options_list[$i])
		1601	+ ."'");
		1602	+
		1603	+ // ----- Return
		1604	+ return PclZip::errorCode();
		1605	+ }
		1606	+
		1607	+ // ----- Get the value
		1608	+ if (is_string($p_options_list[$i+1])) {
		1609	+ $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
		1610	+ }
		1611	+ else {
		1612	+ // ----- Error log
		1613	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
		1614	+ "Wrong parameter value for option '"
		1615	+ .PclZipUtilOptionText($p_options_list[$i])
		1616	+ ."'");
		1617	+
		1618	+ // ----- Return
		1619	+ return PclZip::errorCode();
		1620	+ }
		1621	+ $i++;
		1622	+ break;
		1623	+
		1624	+ // ----- Look for options that request an array of index
		1625	+ case PCLZIP_OPT_BY_INDEX :
		1626	+ // ----- Check the number of parameters
		1627	+ if (($i+1) >= $p_size) {
		1628	+ // ----- Error log
		1629	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1630	+
		1631	+ // ----- Return
		1632	+ return PclZip::errorCode();
		1633	+ }
		1634	+
		1635	+ // ----- Get the value
		1636	+ $v_work_list = array();
		1637	+ if (is_string($p_options_list[$i+1])) {
		1638	+
		1639	+ // ----- Remove spaces
		1640	+ $p_options_list[$i+1] = strtr($p_options_list[$i+1], ' ', '');
		1641	+
		1642	+ // ----- Parse items
		1643	+ $v_work_list = explode(",", $p_options_list[$i+1]);
		1644	+ }
		1645	+ else if (is_integer($p_options_list[$i+1])) {
		1646	+ $v_work_list[0] = $p_options_list[$i+1].'-'.$p_options_list[$i+1];
		1647	+ }
		1648	+ else if (is_array($p_options_list[$i+1])) {
		1649	+ $v_work_list = $p_options_list[$i+1];
		1650	+ }
		1651	+ else {
		1652	+ // ----- Error log
		1653	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Value must be integer, string or array for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1654	+
		1655	+ // ----- Return
		1656	+ return PclZip::errorCode();
		1657	+ }
		1658	+
		1659	+ // ----- Reduce the index list
		1660	+ // each index item in the list must be a couple with a start and
		1661	+ // an end value : [0,3], [5-5], [8-10], ...
		1662	+ // ----- Check the format of each item
		1663	+ $v_sort_flag=false;
		1664	+ $v_sort_value=0;
		1665	+ for ($j=0; $j<sizeof($v_work_list); $j++) {
		1666	+ // ----- Explode the item
		1667	+ $v_item_list = explode("-", $v_work_list[$j]);
		1668	+ $v_size_item_list = sizeof($v_item_list);
		1669	+
		1670	+ // ----- TBC : Here we might check that each item is a
		1671	+ // real integer ...
		1672	+
		1673	+ // ----- Look for single value
		1674	+ if ($v_size_item_list == 1) {
		1675	+ // ----- Set the option value
		1676	+ $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
		1677	+ $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[0];
		1678	+ }
		1679	+ elseif ($v_size_item_list == 2) {
		1680	+ // ----- Set the option value
		1681	+ $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
		1682	+ $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[1];
		1683	+ }
		1684	+ else {
		1685	+ // ----- Error log
		1686	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Too many values in index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1687	+
		1688	+ // ----- Return
		1689	+ return PclZip::errorCode();
		1690	+ }
		1691	+
		1692	+
		1693	+ // ----- Look for list sort
		1694	+ if ($v_result_list[$p_options_list[$i]][$j]['start'] < $v_sort_value) {
		1695	+ $v_sort_flag=true;
		1696	+
		1697	+ // ----- TBC : An automatic sort should be writen ...
		1698	+ // ----- Error log
		1699	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Invalid order of index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1700	+
		1701	+ // ----- Return
		1702	+ return PclZip::errorCode();
		1703	+ }
		1704	+ $v_sort_value = $v_result_list[$p_options_list[$i]][$j]['start'];
		1705	+ }
		1706	+
		1707	+ // ----- Sort the items
		1708	+ if ($v_sort_flag) {
		1709	+ // TBC : To Be Completed
		1710	+ }
		1711	+
		1712	+ // ----- Next option
		1713	+ $i++;
		1714	+ break;
		1715	+
		1716	+ // ----- Look for options that request no value
		1717	+ case PCLZIP_OPT_REMOVE_ALL_PATH :
		1718	+ case PCLZIP_OPT_EXTRACT_AS_STRING :
		1719	+ case PCLZIP_OPT_NO_COMPRESSION :
		1720	+ case PCLZIP_OPT_EXTRACT_IN_OUTPUT :
		1721	+ case PCLZIP_OPT_REPLACE_NEWER :
		1722	+ case PCLZIP_OPT_STOP_ON_ERROR :
		1723	+ $v_result_list[$p_options_list[$i]] = true;
		1724	+ break;
		1725	+
		1726	+ // ----- Look for options that request an octal value
		1727	+ case PCLZIP_OPT_SET_CHMOD :
		1728	+ // ----- Check the number of parameters
		1729	+ if (($i+1) >= $p_size) {
		1730	+ // ----- Error log
		1731	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1732	+
		1733	+ // ----- Return
		1734	+ return PclZip::errorCode();
		1735	+ }
		1736	+
		1737	+ // ----- Get the value
		1738	+ $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
		1739	+ $i++;
		1740	+ break;
		1741	+
		1742	+ // ----- Look for options that request a call-back
		1743	+ case PCLZIP_CB_PRE_EXTRACT :
		1744	+ case PCLZIP_CB_POST_EXTRACT :
		1745	+ case PCLZIP_CB_PRE_ADD :
		1746	+ case PCLZIP_CB_POST_ADD :
		1747	+ /* for futur use
		1748	+ case PCLZIP_CB_PRE_DELETE :
		1749	+ case PCLZIP_CB_POST_DELETE :
		1750	+ case PCLZIP_CB_PRE_LIST :
		1751	+ case PCLZIP_CB_POST_LIST :
		1752	+ */
		1753	+ // ----- Check the number of parameters
		1754	+ if (($i+1) >= $p_size) {
		1755	+ // ----- Error log
		1756	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1757	+
		1758	+ // ----- Return
		1759	+ return PclZip::errorCode();
		1760	+ }
		1761	+
		1762	+ // ----- Get the value
		1763	+ $v_function_name = $p_options_list[$i+1];
		1764	+
		1765	+ // ----- Check that the value is a valid existing function
		1766	+ if (!function_exists($v_function_name)) {
		1767	+ // ----- Error log
		1768	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Function '".$v_function_name."()' is not an existing function for option '".PclZipUtilOptionText($p_options_list[$i])."'");
		1769	+
		1770	+ // ----- Return
		1771	+ return PclZip::errorCode();
		1772	+ }
		1773	+
		1774	+ // ----- Set the attribute
		1775	+ $v_result_list[$p_options_list[$i]] = $v_function_name;
		1776	+ $i++;
		1777	+ break;
		1778	+
		1779	+ default :
		1780	+ // ----- Error log
		1781	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
		1782	+ "Unknown parameter '"
		1783	+ .$p_options_list[$i]."'");
		1784	+
		1785	+ // ----- Return
		1786	+ return PclZip::errorCode();
		1787	+ }
		1788	+
		1789	+ // ----- Next options
		1790	+ $i++;
		1791	+ }
		1792	+
		1793	+ // ----- Look for mandatory options
		1794	+ if ($v_requested_options !== false) {
		1795	+ for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
		1796	+ // ----- Look for mandatory option
		1797	+ if ($v_requested_options[$key] == 'mandatory') {
		1798	+ // ----- Look if present
		1799	+ if (!isset($v_result_list[$key])) {
		1800	+ // ----- Error log
		1801	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
		1802	+
		1803	+ // ----- Return
		1804	+ return PclZip::errorCode();
		1805	+ }
		1806	+ }
		1807	+ }
		1808	+ }
		1809	+
		1810	+ // ----- Look for default values
		1811	+ if (!isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
		1812	+
		1813	+ }
		1814	+
		1815	+ // ----- Return
		1816	+ return $v_result;
		1817	+ }
		1818	+ // --------------------------------------------------------------------------------
		1819	+
		1820	+ // --------------------------------------------------------------------------------
		1821	+ // Function : privOptionDefaultThreshold()
		1822	+ // Description :
		1823	+ // Parameters :
		1824	+ // Return Values :
		1825	+ // --------------------------------------------------------------------------------
		1826	+ function privOptionDefaultThreshold(&$p_options)
		1827	+ {
		1828	+ $v_result=1;
		1829	+
		1830	+ if (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
		1831	+ \|\| isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) {
		1832	+ return $v_result;
		1833	+ }
		1834	+
		1835	+ // ----- Get 'memory_limit' configuration value
		1836	+ $v_memory_limit = ini_get('memory_limit');
		1837	+ $v_memory_limit = trim($v_memory_limit);
		1838	+ $last = strtolower(substr($v_memory_limit, -1));
		1839	+
		1840	+ if($last == 'g')
		1841	+ //$v_memory_limit = $v_memory_limit10241024*1024;
		1842	+ $v_memory_limit = $v_memory_limit*1073741824;
		1843	+ if($last == 'm')
		1844	+ //$v_memory_limit = $v_memory_limit10241024;
		1845	+ $v_memory_limit = $v_memory_limit*1048576;
		1846	+ if($last == 'k')
		1847	+ $v_memory_limit = $v_memory_limit*1024;
		1848	+
		1849	+ $p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] = floor($v_memory_limit*PCLZIP_TEMPORARY_FILE_RATIO);
		1850	+
		1851	+
		1852	+ // ----- Sanity check : No threshold if value lower than 1M
		1853	+ if ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] < 1048576) {
		1854	+ unset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]);
		1855	+ }
		1856	+
		1857	+ // ----- Return
		1858	+ return $v_result;
		1859	+ }
		1860	+ // --------------------------------------------------------------------------------
		1861	+
		1862	+ // --------------------------------------------------------------------------------
		1863	+ // Function : privFileDescrParseAtt()
		1864	+ // Description :
		1865	+ // Parameters :
		1866	+ // Return Values :
		1867	+ // 1 on success.
		1868	+ // 0 on failure.
		1869	+ // --------------------------------------------------------------------------------
		1870	+ function privFileDescrParseAtt(&$p_file_list, &$p_filedescr, $v_options, $v_requested_options=false)
		1871	+ {
		1872	+ $v_result=1;
		1873	+
		1874	+ // ----- For each file in the list check the attributes
		1875	+ foreach ($p_file_list as $v_key => $v_value) {
		1876	+
		1877	+ // ----- Check if the option is supported
		1878	+ if (!isset($v_requested_options[$v_key])) {
		1879	+ // ----- Error log
		1880	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file attribute '".$v_key."' for this file");
		1881	+
		1882	+ // ----- Return
		1883	+ return PclZip::errorCode();
		1884	+ }
		1885	+
		1886	+ // ----- Look for attribute
		1887	+ switch ($v_key) {
		1888	+ case PCLZIP_ATT_FILE_NAME :
		1889	+ if (!is_string($v_value)) {
		1890	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
		1891	+ return PclZip::errorCode();
		1892	+ }
		1893	+
		1894	+ $p_filedescr['filename'] = PclZipUtilPathReduction($v_value);
		1895	+
		1896	+ if ($p_filedescr['filename'] == '') {
		1897	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty filename for attribute '".PclZipUtilOptionText($v_key)."'");
		1898	+ return PclZip::errorCode();
		1899	+ }
		1900	+
		1901	+ break;
		1902	+
		1903	+ case PCLZIP_ATT_FILE_NEW_SHORT_NAME :
		1904	+ if (!is_string($v_value)) {
		1905	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
		1906	+ return PclZip::errorCode();
		1907	+ }
		1908	+
		1909	+ $p_filedescr['new_short_name'] = PclZipUtilPathReduction($v_value);
		1910	+
		1911	+ if ($p_filedescr['new_short_name'] == '') {
		1912	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty short filename for attribute '".PclZipUtilOptionText($v_key)."'");
		1913	+ return PclZip::errorCode();
		1914	+ }
		1915	+ break;
		1916	+
		1917	+ case PCLZIP_ATT_FILE_NEW_FULL_NAME :
		1918	+ if (!is_string($v_value)) {
		1919	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
		1920	+ return PclZip::errorCode();
		1921	+ }
		1922	+
		1923	+ $p_filedescr['new_full_name'] = PclZipUtilPathReduction($v_value);
		1924	+
		1925	+ if ($p_filedescr['new_full_name'] == '') {
		1926	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty full filename for attribute '".PclZipUtilOptionText($v_key)."'");
		1927	+ return PclZip::errorCode();
		1928	+ }
		1929	+ break;
		1930	+
		1931	+ // ----- Look for options that takes a string
		1932	+ case PCLZIP_ATT_FILE_COMMENT :
		1933	+ if (!is_string($v_value)) {
		1934	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
		1935	+ return PclZip::errorCode();
		1936	+ }
		1937	+
		1938	+ $p_filedescr['comment'] = $v_value;
		1939	+ break;
		1940	+
		1941	+ case PCLZIP_ATT_FILE_MTIME :
		1942	+ if (!is_integer($v_value)) {
		1943	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". Integer expected for attribute '".PclZipUtilOptionText($v_key)."'");
		1944	+ return PclZip::errorCode();
		1945	+ }
		1946	+
		1947	+ $p_filedescr['mtime'] = $v_value;
		1948	+ break;
		1949	+
		1950	+ case PCLZIP_ATT_FILE_CONTENT :
		1951	+ $p_filedescr['content'] = $v_value;
		1952	+ break;
		1953	+
		1954	+ default :
		1955	+ // ----- Error log
		1956	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
		1957	+ "Unknown parameter '".$v_key."'");
		1958	+
		1959	+ // ----- Return
		1960	+ return PclZip::errorCode();
		1961	+ }
		1962	+
		1963	+ // ----- Look for mandatory options
		1964	+ if ($v_requested_options !== false) {
		1965	+ for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
		1966	+ // ----- Look for mandatory option
		1967	+ if ($v_requested_options[$key] == 'mandatory') {
		1968	+ // ----- Look if present
		1969	+ if (!isset($p_file_list[$key])) {
		1970	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
		1971	+ return PclZip::errorCode();
		1972	+ }
		1973	+ }
		1974	+ }
		1975	+ }
		1976	+
		1977	+ // end foreach
		1978	+ }
		1979	+
		1980	+ // ----- Return
		1981	+ return $v_result;
		1982	+ }
		1983	+ // --------------------------------------------------------------------------------
		1984	+
		1985	+ // --------------------------------------------------------------------------------
		1986	+ // Function : privFileDescrExpand()
		1987	+ // Description :
		1988	+ // This method look for each item of the list to see if its a file, a folder
		1989	+ // or a string to be added as file. For any other type of files (link, other)
		1990	+ // just ignore the item.
		1991	+ // Then prepare the information that will be stored for that file.
		1992	+ // When its a folder, expand the folder with all the files that are in that
		1993	+ // folder (recursively).
		1994	+ // Parameters :
		1995	+ // Return Values :
		1996	+ // 1 on success.
		1997	+ // 0 on failure.
		1998	+ // --------------------------------------------------------------------------------
		1999	+ function privFileDescrExpand(&$p_filedescr_list, &$p_options)
		2000	+ {
		2001	+ $v_result=1;
		2002	+
		2003	+ // ----- Create a result list
		2004	+ $v_result_list = array();
		2005	+
		2006	+ // ----- Look each entry
		2007	+ for ($i=0; $i<sizeof($p_filedescr_list); $i++) {
		2008	+
		2009	+ // ----- Get filedescr
		2010	+ $v_descr = $p_filedescr_list[$i];
		2011	+
		2012	+ // ----- Reduce the filename
		2013	+ $v_descr['filename'] = PclZipUtilTranslateWinPath($v_descr['filename'], false);
		2014	+ $v_descr['filename'] = PclZipUtilPathReduction($v_descr['filename']);
		2015	+
		2016	+ // ----- Look for real file or folder
		2017	+ if (file_exists($v_descr['filename'])) {
		2018	+ if (@is_file($v_descr['filename'])) {
		2019	+ $v_descr['type'] = 'file';
		2020	+ }
		2021	+ else if (@is_dir($v_descr['filename'])) {
		2022	+ $v_descr['type'] = 'folder';
		2023	+ }
		2024	+ else if (@is_link($v_descr['filename'])) {
		2025	+ // skip
		2026	+ continue;
		2027	+ }
		2028	+ else {
		2029	+ // skip
		2030	+ continue;
		2031	+ }
		2032	+ }
		2033	+
		2034	+ // ----- Look for string added as file
		2035	+ else if (isset($v_descr['content'])) {
		2036	+ $v_descr['type'] = 'virtual_file';
		2037	+ }
		2038	+
		2039	+ // ----- Missing file
		2040	+ else {
		2041	+ // ----- Error log
		2042	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$v_descr['filename']."' does not exist");
		2043	+
		2044	+ // ----- Return
		2045	+ return PclZip::errorCode();
		2046	+ }
		2047	+
		2048	+ // ----- Calculate the stored filename
		2049	+ $this->privCalculateStoredFilename($v_descr, $p_options);
		2050	+
		2051	+ // ----- Add the descriptor in result list
		2052	+ $v_result_list[sizeof($v_result_list)] = $v_descr;
		2053	+
		2054	+ // ----- Look for folder
		2055	+ if ($v_descr['type'] == 'folder') {
		2056	+ // ----- List of items in folder
		2057	+ $v_dirlist_descr = array();
		2058	+ $v_dirlist_nb = 0;
		2059	+ if ($v_folder_handler = @opendir($v_descr['filename'])) {
		2060	+ while (($v_item_handler = @readdir($v_folder_handler)) !== false) {
		2061	+
		2062	+ // ----- Skip '.' and '..'
		2063	+ if (($v_item_handler == '.') \|\| ($v_item_handler == '..')) {
		2064	+ continue;
		2065	+ }
		2066	+
		2067	+ // ----- Compose the full filename
		2068	+ $v_dirlist_descr[$v_dirlist_nb]['filename'] = $v_descr['filename'].'/'.$v_item_handler;
		2069	+
		2070	+ // ----- Look for different stored filename
		2071	+ // Because the name of the folder was changed, the name of the
		2072	+ // files/sub-folders also change
		2073	+ if (($v_descr['stored_filename'] != $v_descr['filename'])
		2074	+ && (!isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))) {
		2075	+ if ($v_descr['stored_filename'] != '') {
		2076	+ $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_descr['stored_filename'].'/'.$v_item_handler;
		2077	+ }
		2078	+ else {
		2079	+ $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_item_handler;
		2080	+ }
		2081	+ }
		2082	+
		2083	+ $v_dirlist_nb++;
		2084	+ }
		2085	+
		2086	+ @closedir($v_folder_handler);
		2087	+ }
		2088	+ else {
		2089	+ // TBC : unable to open folder in read mode
		2090	+ }
		2091	+
		2092	+ // ----- Expand each element of the list
		2093	+ if ($v_dirlist_nb != 0) {
		2094	+ // ----- Expand
		2095	+ if (($v_result = $this->privFileDescrExpand($v_dirlist_descr, $p_options)) != 1) {
		2096	+ return $v_result;
		2097	+ }
		2098	+
		2099	+ // ----- Concat the resulting list
		2100	+ $v_result_list = array_merge($v_result_list, $v_dirlist_descr);
		2101	+ }
		2102	+ else {
		2103	+ }
		2104	+
		2105	+ // ----- Free local array
		2106	+ unset($v_dirlist_descr);
		2107	+ }
		2108	+ }
		2109	+
		2110	+ // ----- Get the result list
		2111	+ $p_filedescr_list = $v_result_list;
		2112	+
		2113	+ // ----- Return
		2114	+ return $v_result;
		2115	+ }
		2116	+ // --------------------------------------------------------------------------------
		2117	+
		2118	+ // --------------------------------------------------------------------------------
		2119	+ // Function : privCreate()
		2120	+ // Description :
		2121	+ // Parameters :
		2122	+ // Return Values :
		2123	+ // --------------------------------------------------------------------------------
		2124	+ function privCreate($p_filedescr_list, &$p_result_list, &$p_options)
		2125	+ {
		2126	+ $v_result=1;
		2127	+ $v_list_detail = array();
		2128	+
		2129	+ // ----- Magic quotes trick
		2130	+ $this->privDisableMagicQuotes();
		2131	+
		2132	+ // ----- Open the file in write mode
		2133	+ if (($v_result = $this->privOpenFd('wb')) != 1)
		2134	+ {
		2135	+ // ----- Return
		2136	+ return $v_result;
		2137	+ }
		2138	+
		2139	+ // ----- Add the list of files
		2140	+ $v_result = $this->privAddList($p_filedescr_list, $p_result_list, $p_options);
		2141	+
		2142	+ // ----- Close
		2143	+ $this->privCloseFd();
		2144	+
		2145	+ // ----- Magic quotes trick
		2146	+ $this->privSwapBackMagicQuotes();
		2147	+
		2148	+ // ----- Return
		2149	+ return $v_result;
		2150	+ }
		2151	+ // --------------------------------------------------------------------------------
		2152	+
		2153	+ // --------------------------------------------------------------------------------
		2154	+ // Function : privAdd()
		2155	+ // Description :
		2156	+ // Parameters :
		2157	+ // Return Values :
		2158	+ // --------------------------------------------------------------------------------
		2159	+ function privAdd($p_filedescr_list, &$p_result_list, &$p_options)
		2160	+ {
		2161	+ $v_result=1;
		2162	+ $v_list_detail = array();
		2163	+
		2164	+ // ----- Look if the archive exists or is empty
		2165	+ if ((!is_file($this->zipname)) \|\| (filesize($this->zipname) == 0))
		2166	+ {
		2167	+
		2168	+ // ----- Do a create
		2169	+ $v_result = $this->privCreate($p_filedescr_list, $p_result_list, $p_options);
		2170	+
		2171	+ // ----- Return
		2172	+ return $v_result;
		2173	+ }
		2174	+ // ----- Magic quotes trick
		2175	+ $this->privDisableMagicQuotes();
		2176	+
		2177	+ // ----- Open the zip file
		2178	+ if (($v_result=$this->privOpenFd('rb')) != 1)
		2179	+ {
		2180	+ // ----- Magic quotes trick
		2181	+ $this->privSwapBackMagicQuotes();
		2182	+
		2183	+ // ----- Return
		2184	+ return $v_result;
		2185	+ }
		2186	+
		2187	+ // ----- Read the central directory informations
		2188	+ $v_central_dir = array();
		2189	+ if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
		2190	+ {
		2191	+ $this->privCloseFd();
		2192	+ $this->privSwapBackMagicQuotes();
		2193	+ return $v_result;
		2194	+ }
		2195	+
		2196	+ // ----- Go to beginning of File
		2197	+ @rewind($this->zip_fd);
		2198	+
		2199	+ // ----- Creates a temporay file
		2200	+ $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
		2201	+
		2202	+ // ----- Open the temporary file in write mode
		2203	+ if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0)
		2204	+ {
		2205	+ $this->privCloseFd();
		2206	+ $this->privSwapBackMagicQuotes();
		2207	+
		2208	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_zip_temp_name.'\' in binary write mode');
		2209	+
		2210	+ // ----- Return
		2211	+ return PclZip::errorCode();
		2212	+ }
		2213	+
		2214	+ // ----- Copy the files from the archive to the temporary file
		2215	+ // TBC : Here I should better append the file and go back to erase the central dir
		2216	+ $v_size = $v_central_dir['offset'];
		2217	+ while ($v_size != 0)
		2218	+ {
		2219	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		2220	+ $v_buffer = fread($this->zip_fd, $v_read_size);
		2221	+ @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
		2222	+ $v_size -= $v_read_size;
		2223	+ }
		2224	+
		2225	+ // ----- Swap the file descriptor
		2226	+ // Here is a trick : I swap the temporary fd with the zip fd, in order to use
		2227	+ // the following methods on the temporary fil and not the real archive
		2228	+ $v_swap = $this->zip_fd;
		2229	+ $this->zip_fd = $v_zip_temp_fd;
		2230	+ $v_zip_temp_fd = $v_swap;
		2231	+
		2232	+ // ----- Add the files
		2233	+ $v_header_list = array();
		2234	+ if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
		2235	+ {
		2236	+ fclose($v_zip_temp_fd);
		2237	+ $this->privCloseFd();
		2238	+ @unlink($v_zip_temp_name);
		2239	+ $this->privSwapBackMagicQuotes();
		2240	+
		2241	+ // ----- Return
		2242	+ return $v_result;
		2243	+ }
		2244	+
		2245	+ // ----- Store the offset of the central dir
		2246	+ $v_offset = @ftell($this->zip_fd);
		2247	+
		2248	+ // ----- Copy the block of file headers from the old archive
		2249	+ $v_size = $v_central_dir['size'];
		2250	+ while ($v_size != 0)
		2251	+ {
		2252	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		2253	+ $v_buffer = @fread($v_zip_temp_fd, $v_read_size);
		2254	+ @fwrite($this->zip_fd, $v_buffer, $v_read_size);
		2255	+ $v_size -= $v_read_size;
		2256	+ }
		2257	+
		2258	+ // ----- Create the Central Dir files header
		2259	+ for ($i=0, $v_count=0; $i<sizeof($v_header_list); $i++)
		2260	+ {
		2261	+ // ----- Create the file header
		2262	+ if ($v_header_list[$i]['status'] == 'ok') {
		2263	+ if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
		2264	+ fclose($v_zip_temp_fd);
		2265	+ $this->privCloseFd();
		2266	+ @unlink($v_zip_temp_name);
		2267	+ $this->privSwapBackMagicQuotes();
		2268	+
		2269	+ // ----- Return
		2270	+ return $v_result;
		2271	+ }
		2272	+ $v_count++;
		2273	+ }
		2274	+
		2275	+ // ----- Transform the header to a 'usable' info
		2276	+ $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
		2277	+ }
		2278	+
		2279	+ // ----- Zip file comment
		2280	+ $v_comment = $v_central_dir['comment'];
		2281	+ if (isset($p_options[PCLZIP_OPT_COMMENT])) {
		2282	+ $v_comment = $p_options[PCLZIP_OPT_COMMENT];
		2283	+ }
		2284	+ if (isset($p_options[PCLZIP_OPT_ADD_COMMENT])) {
		2285	+ $v_comment = $v_comment.$p_options[PCLZIP_OPT_ADD_COMMENT];
		2286	+ }
		2287	+ if (isset($p_options[PCLZIP_OPT_PREPEND_COMMENT])) {
		2288	+ $v_comment = $p_options[PCLZIP_OPT_PREPEND_COMMENT].$v_comment;
		2289	+ }
		2290	+
		2291	+ // ----- Calculate the size of the central header
		2292	+ $v_size = @ftell($this->zip_fd)-$v_offset;
		2293	+
		2294	+ // ----- Create the central dir footer
		2295	+ if (($v_result = $this->privWriteCentralHeader($v_count+$v_central_dir['entries'], $v_size, $v_offset, $v_comment)) != 1)
		2296	+ {
		2297	+ // ----- Reset the file list
		2298	+ unset($v_header_list);
		2299	+ $this->privSwapBackMagicQuotes();
		2300	+
		2301	+ // ----- Return
		2302	+ return $v_result;
		2303	+ }
		2304	+
		2305	+ // ----- Swap back the file descriptor
		2306	+ $v_swap = $this->zip_fd;
		2307	+ $this->zip_fd = $v_zip_temp_fd;
		2308	+ $v_zip_temp_fd = $v_swap;
		2309	+
		2310	+ // ----- Close
		2311	+ $this->privCloseFd();
		2312	+
		2313	+ // ----- Close the temporary file
		2314	+ @fclose($v_zip_temp_fd);
		2315	+
		2316	+ // ----- Magic quotes trick
		2317	+ $this->privSwapBackMagicQuotes();
		2318	+
		2319	+ // ----- Delete the zip file
		2320	+ // TBC : I should test the result ...
		2321	+ @unlink($this->zipname);
		2322	+
		2323	+ // ----- Rename the temporary file
		2324	+ // TBC : I should test the result ...
		2325	+ //@rename($v_zip_temp_name, $this->zipname);
		2326	+ PclZipUtilRename($v_zip_temp_name, $this->zipname);
		2327	+
		2328	+ // ----- Return
		2329	+ return $v_result;
		2330	+ }
		2331	+ // --------------------------------------------------------------------------------
		2332	+
		2333	+ // --------------------------------------------------------------------------------
		2334	+ // Function : privOpenFd()
		2335	+ // Description :
		2336	+ // Parameters :
		2337	+ // --------------------------------------------------------------------------------
		2338	+ function privOpenFd($p_mode)
		2339	+ {
		2340	+ $v_result=1;
		2341	+
		2342	+ // ----- Look if already open
		2343	+ if ($this->zip_fd != 0)
		2344	+ {
		2345	+ // ----- Error log
		2346	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Zip file \''.$this->zipname.'\' already open');
		2347	+
		2348	+ // ----- Return
		2349	+ return PclZip::errorCode();
		2350	+ }
		2351	+
		2352	+ // ----- Open the zip file
		2353	+ if (($this->zip_fd = @fopen($this->zipname, $p_mode)) == 0)
		2354	+ {
		2355	+ // ----- Error log
		2356	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in '.$p_mode.' mode');
		2357	+
		2358	+ // ----- Return
		2359	+ return PclZip::errorCode();
		2360	+ }
		2361	+
		2362	+ // ----- Return
		2363	+ return $v_result;
		2364	+ }
		2365	+ // --------------------------------------------------------------------------------
		2366	+
		2367	+ // --------------------------------------------------------------------------------
		2368	+ // Function : privCloseFd()
		2369	+ // Description :
		2370	+ // Parameters :
		2371	+ // --------------------------------------------------------------------------------
		2372	+ function privCloseFd()
		2373	+ {
		2374	+ $v_result=1;
		2375	+
		2376	+ if ($this->zip_fd != 0)
		2377	+ @fclose($this->zip_fd);
		2378	+ $this->zip_fd = 0;
		2379	+
		2380	+ // ----- Return
		2381	+ return $v_result;
		2382	+ }
		2383	+ // --------------------------------------------------------------------------------
		2384	+
		2385	+ // --------------------------------------------------------------------------------
		2386	+ // Function : privAddList()
		2387	+ // Description :
		2388	+ // $p_add_dir and $p_remove_dir will give the ability to memorize a path which is
		2389	+ // different from the real path of the file. This is usefull if you want to have PclTar
		2390	+ // running in any directory, and memorize relative path from an other directory.
		2391	+ // Parameters :
		2392	+ // $p_list : An array containing the file or directory names to add in the tar
		2393	+ // $p_result_list : list of added files with their properties (specially the status field)
		2394	+ // $p_add_dir : Path to add in the filename path archived
		2395	+ // $p_remove_dir : Path to remove in the filename path archived
		2396	+ // Return Values :
		2397	+ // --------------------------------------------------------------------------------
		2398	+// function privAddList($p_list, &$p_result_list, $p_add_dir, $p_remove_dir, $p_remove_all_dir, &$p_options)
		2399	+ function privAddList($p_filedescr_list, &$p_result_list, &$p_options)
		2400	+ {
		2401	+ $v_result=1;
		2402	+
		2403	+ // ----- Add the files
		2404	+ $v_header_list = array();
		2405	+ if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
		2406	+ {
		2407	+ // ----- Return
		2408	+ return $v_result;
		2409	+ }
		2410	+
		2411	+ // ----- Store the offset of the central dir
		2412	+ $v_offset = @ftell($this->zip_fd);
		2413	+
		2414	+ // ----- Create the Central Dir files header
		2415	+ for ($i=0,$v_count=0; $i<sizeof($v_header_list); $i++)
		2416	+ {
		2417	+ // ----- Create the file header
		2418	+ if ($v_header_list[$i]['status'] == 'ok') {
		2419	+ if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
		2420	+ // ----- Return
		2421	+ return $v_result;
		2422	+ }
		2423	+ $v_count++;
		2424	+ }
		2425	+
		2426	+ // ----- Transform the header to a 'usable' info
		2427	+ $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
		2428	+ }
		2429	+
		2430	+ // ----- Zip file comment
		2431	+ $v_comment = '';
		2432	+ if (isset($p_options[PCLZIP_OPT_COMMENT])) {
		2433	+ $v_comment = $p_options[PCLZIP_OPT_COMMENT];
		2434	+ }
		2435	+
		2436	+ // ----- Calculate the size of the central header
		2437	+ $v_size = @ftell($this->zip_fd)-$v_offset;
		2438	+
		2439	+ // ----- Create the central dir footer
		2440	+ if (($v_result = $this->privWriteCentralHeader($v_count, $v_size, $v_offset, $v_comment)) != 1)
		2441	+ {
		2442	+ // ----- Reset the file list
		2443	+ unset($v_header_list);
		2444	+
		2445	+ // ----- Return
		2446	+ return $v_result;
		2447	+ }
		2448	+
		2449	+ // ----- Return
		2450	+ return $v_result;
		2451	+ }
		2452	+ // --------------------------------------------------------------------------------
		2453	+
		2454	+ // --------------------------------------------------------------------------------
		2455	+ // Function : privAddFileList()
		2456	+ // Description :
		2457	+ // Parameters :
		2458	+ // $p_filedescr_list : An array containing the file description
		2459	+ // or directory names to add in the zip
		2460	+ // $p_result_list : list of added files with their properties (specially the status field)
		2461	+ // Return Values :
		2462	+ // --------------------------------------------------------------------------------
		2463	+ function privAddFileList($p_filedescr_list, &$p_result_list, &$p_options)
		2464	+ {
		2465	+ $v_result=1;
		2466	+ $v_header = array();
		2467	+
		2468	+ // ----- Recuperate the current number of elt in list
		2469	+ $v_nb = sizeof($p_result_list);
		2470	+
		2471	+ // ----- Loop on the files
		2472	+ for ($j=0; ($j<sizeof($p_filedescr_list)) && ($v_result==1); $j++) {
		2473	+ // ----- Format the filename
		2474	+ $p_filedescr_list[$j]['filename']
		2475	+ = PclZipUtilTranslateWinPath($p_filedescr_list[$j]['filename'], false);
		2476	+
		2477	+
		2478	+ // ----- Skip empty file names
		2479	+ // TBC : Can this be possible ? not checked in DescrParseAtt ?
		2480	+ if ($p_filedescr_list[$j]['filename'] == "") {
		2481	+ continue;
		2482	+ }
		2483	+
		2484	+ // ----- Check the filename
		2485	+ if ( ($p_filedescr_list[$j]['type'] != 'virtual_file')
		2486	+ && (!file_exists($p_filedescr_list[$j]['filename']))) {
		2487	+ PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$p_filedescr_list[$j]['filename']."' does not exist");
		2488	+ return PclZip::errorCode();
		2489	+ }
		2490	+
		2491	+ // ----- Look if it is a file or a dir with no all path remove option
		2492	+ // or a dir with all its path removed
		2493	+// if ( (is_file($p_filedescr_list[$j]['filename']))
		2494	+// \|\| ( is_dir($p_filedescr_list[$j]['filename'])
		2495	+ if ( ($p_filedescr_list[$j]['type'] == 'file')
		2496	+ \|\| ($p_filedescr_list[$j]['type'] == 'virtual_file')
		2497	+ \|\| ( ($p_filedescr_list[$j]['type'] == 'folder')
		2498	+ && ( !isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])
		2499	+ \|\| !$p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))
		2500	+ ) {
		2501	+
		2502	+ // ----- Add the file
		2503	+ $v_result = $this->privAddFile($p_filedescr_list[$j], $v_header,
		2504	+ $p_options);
		2505	+ if ($v_result != 1) {
		2506	+ return $v_result;
		2507	+ }
		2508	+
		2509	+ // ----- Store the file infos
		2510	+ $p_result_list[$v_nb++] = $v_header;
		2511	+ }
		2512	+ }
		2513	+
		2514	+ // ----- Return
		2515	+ return $v_result;
		2516	+ }
		2517	+ // --------------------------------------------------------------------------------
		2518	+
		2519	+ // --------------------------------------------------------------------------------
		2520	+ // Function : privAddFile()
		2521	+ // Description :
		2522	+ // Parameters :
		2523	+ // Return Values :
		2524	+ // --------------------------------------------------------------------------------
		2525	+ function privAddFile($p_filedescr, &$p_header, &$p_options)
		2526	+ {
		2527	+ $v_result=1;
		2528	+
		2529	+ // ----- Working variable
		2530	+ $p_filename = $p_filedescr['filename'];
		2531	+
		2532	+ // TBC : Already done in the fileAtt check ... ?
		2533	+ if ($p_filename == "") {
		2534	+ // ----- Error log
		2535	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file list parameter (invalid or empty list)");
		2536	+
		2537	+ // ----- Return
		2538	+ return PclZip::errorCode();
		2539	+ }
		2540	+
		2541	+ // ----- Look for a stored different filename
		2542	+ /* TBC : Removed
		2543	+ if (isset($p_filedescr['stored_filename'])) {
		2544	+ $v_stored_filename = $p_filedescr['stored_filename'];
		2545	+ }
		2546	+ else {
		2547	+ $v_stored_filename = $p_filedescr['stored_filename'];
		2548	+ }
		2549	+ */
		2550	+
		2551	+ // ----- Set the file properties
		2552	+ clearstatcache();
		2553	+ $p_header['version'] = 20;
		2554	+ $p_header['version_extracted'] = 10;
		2555	+ $p_header['flag'] = 0;
		2556	+ $p_header['compression'] = 0;
		2557	+ $p_header['crc'] = 0;
		2558	+ $p_header['compressed_size'] = 0;
		2559	+ $p_header['filename_len'] = strlen($p_filename);
		2560	+ $p_header['extra_len'] = 0;
		2561	+ $p_header['disk'] = 0;
		2562	+ $p_header['internal'] = 0;
		2563	+ $p_header['offset'] = 0;
		2564	+ $p_header['filename'] = $p_filename;
		2565	+// TBC : Removed $p_header['stored_filename'] = $v_stored_filename;
		2566	+ $p_header['stored_filename'] = $p_filedescr['stored_filename'];
		2567	+ $p_header['extra'] = '';
		2568	+ $p_header['status'] = 'ok';
		2569	+ $p_header['index'] = -1;
		2570	+
		2571	+ // ----- Look for regular file
		2572	+ if ($p_filedescr['type']=='file') {
		2573	+ $p_header['external'] = 0x00000000;
		2574	+ $p_header['size'] = filesize($p_filename);
		2575	+ }
		2576	+
		2577	+ // ----- Look for regular folder
		2578	+ else if ($p_filedescr['type']=='folder') {
		2579	+ $p_header['external'] = 0x00000010;
		2580	+ $p_header['mtime'] = filemtime($p_filename);
		2581	+ $p_header['size'] = filesize($p_filename);
		2582	+ }
		2583	+
		2584	+ // ----- Look for virtual file
		2585	+ else if ($p_filedescr['type'] == 'virtual_file') {
		2586	+ $p_header['external'] = 0x00000000;
		2587	+ $p_header['size'] = strlen($p_filedescr['content']);
		2588	+ }
		2589	+
		2590	+
		2591	+ // ----- Look for filetime
		2592	+ if (isset($p_filedescr['mtime'])) {
		2593	+ $p_header['mtime'] = $p_filedescr['mtime'];
		2594	+ }
		2595	+ else if ($p_filedescr['type'] == 'virtual_file') {
		2596	+ $p_header['mtime'] = time();
		2597	+ }
		2598	+ else {
		2599	+ $p_header['mtime'] = filemtime($p_filename);
		2600	+ }
		2601	+
		2602	+ // ------ Look for file comment
		2603	+ if (isset($p_filedescr['comment'])) {
		2604	+ $p_header['comment_len'] = strlen($p_filedescr['comment']);
		2605	+ $p_header['comment'] = $p_filedescr['comment'];
		2606	+ }
		2607	+ else {
		2608	+ $p_header['comment_len'] = 0;
		2609	+ $p_header['comment'] = '';
		2610	+ }
		2611	+
		2612	+ // ----- Look for pre-add callback
		2613	+ if (isset($p_options[PCLZIP_CB_PRE_ADD])) {
		2614	+
		2615	+ // ----- Generate a local information
		2616	+ $v_local_header = array();
		2617	+ $this->privConvertHeader2FileInfo($p_header, $v_local_header);
		2618	+
		2619	+ // ----- Call the callback
		2620	+ // Here I do not use call_user_func() because I need to send a reference to the
		2621	+ // header.
		2622	+// eval('$v_result = '.$p_options[PCLZIP_CB_PRE_ADD].'(PCLZIP_CB_PRE_ADD, $v_local_header);');
		2623	+ $v_result = $p_options[PCLZIP_CB_PRE_ADD](PCLZIP_CB_PRE_ADD, $v_local_header);
		2624	+ if ($v_result == 0) {
		2625	+ // ----- Change the file status
		2626	+ $p_header['status'] = "skipped";
		2627	+ $v_result = 1;
		2628	+ }
		2629	+
		2630	+ // ----- Update the informations
		2631	+ // Only some fields can be modified
		2632	+ if ($p_header['stored_filename'] != $v_local_header['stored_filename']) {
		2633	+ $p_header['stored_filename'] = PclZipUtilPathReduction($v_local_header['stored_filename']);
		2634	+ }
		2635	+ }
		2636	+
		2637	+ // ----- Look for empty stored filename
		2638	+ if ($p_header['stored_filename'] == "") {
		2639	+ $p_header['status'] = "filtered";
		2640	+ }
		2641	+
		2642	+ // ----- Check the path length
		2643	+ if (strlen($p_header['stored_filename']) > 0xFF) {
		2644	+ $p_header['status'] = 'filename_too_long';
		2645	+ }
		2646	+
		2647	+ // ----- Look if no error, or file not skipped
		2648	+ if ($p_header['status'] == 'ok') {
		2649	+
		2650	+ // ----- Look for a file
		2651	+ if ($p_filedescr['type'] == 'file') {
		2652	+ // ----- Look for using temporary file to zip
		2653	+ if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
		2654	+ && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
		2655	+ \|\| (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
		2656	+ && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_header['size'])) ) ) {
		2657	+ $v_result = $this->privAddFileUsingTempFile($p_filedescr, $p_header, $p_options);
		2658	+ if ($v_result < PCLZIP_ERR_NO_ERROR) {
		2659	+ return $v_result;
		2660	+ }
		2661	+ }
		2662	+
		2663	+ // ----- Use "in memory" zip algo
		2664	+ else {
		2665	+
		2666	+ // ----- Open the source file
		2667	+ if (($v_file = @fopen($p_filename, "rb")) == 0) {
		2668	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
		2669	+ return PclZip::errorCode();
		2670	+ }
		2671	+
		2672	+ // ----- Read the file content
		2673	+ $v_content = @fread($v_file, $p_header['size']);
		2674	+
		2675	+ // ----- Close the file
		2676	+ @fclose($v_file);
		2677	+
		2678	+ // ----- Calculate the CRC
		2679	+ $p_header['crc'] = @crc32($v_content);
		2680	+
		2681	+ // ----- Look for no compression
		2682	+ if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
		2683	+ // ----- Set header parameters
		2684	+ $p_header['compressed_size'] = $p_header['size'];
		2685	+ $p_header['compression'] = 0;
		2686	+ }
		2687	+
		2688	+ // ----- Look for normal compression
		2689	+ else {
		2690	+ // ----- Compress the content
		2691	+ $v_content = @gzdeflate($v_content);
		2692	+
		2693	+ // ----- Set header parameters
		2694	+ $p_header['compressed_size'] = strlen($v_content);
		2695	+ $p_header['compression'] = 8;
		2696	+ }
		2697	+
		2698	+ // ----- Call the header generation
		2699	+ if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
		2700	+ @fclose($v_file);
		2701	+ return $v_result;
		2702	+ }
		2703	+
		2704	+ // ----- Write the compressed (or not) content
		2705	+ @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
		2706	+
		2707	+ }
		2708	+
		2709	+ }
		2710	+
		2711	+ // ----- Look for a virtual file (a file from string)
		2712	+ else if ($p_filedescr['type'] == 'virtual_file') {
		2713	+
		2714	+ $v_content = $p_filedescr['content'];
		2715	+
		2716	+ // ----- Calculate the CRC
		2717	+ $p_header['crc'] = @crc32($v_content);
		2718	+
		2719	+ // ----- Look for no compression
		2720	+ if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
		2721	+ // ----- Set header parameters
		2722	+ $p_header['compressed_size'] = $p_header['size'];
		2723	+ $p_header['compression'] = 0;
		2724	+ }
		2725	+
		2726	+ // ----- Look for normal compression
		2727	+ else {
		2728	+ // ----- Compress the content
		2729	+ $v_content = @gzdeflate($v_content);
		2730	+
		2731	+ // ----- Set header parameters
		2732	+ $p_header['compressed_size'] = strlen($v_content);
		2733	+ $p_header['compression'] = 8;
		2734	+ }
		2735	+
		2736	+ // ----- Call the header generation
		2737	+ if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
		2738	+ @fclose($v_file);
		2739	+ return $v_result;
		2740	+ }
		2741	+
		2742	+ // ----- Write the compressed (or not) content
		2743	+ @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
		2744	+ }
		2745	+
		2746	+ // ----- Look for a directory
		2747	+ else if ($p_filedescr['type'] == 'folder') {
		2748	+ // ----- Look for directory last '/'
		2749	+ if (@substr($p_header['stored_filename'], -1) != '/') {
		2750	+ $p_header['stored_filename'] .= '/';
		2751	+ }
		2752	+
		2753	+ // ----- Set the file properties
		2754	+ $p_header['size'] = 0;
		2755	+ //$p_header['external'] = 0x41FF0010; // Value for a folder : to be checked
		2756	+ $p_header['external'] = 0x00000010; // Value for a folder : to be checked
		2757	+
		2758	+ // ----- Call the header generation
		2759	+ if (($v_result = $this->privWriteFileHeader($p_header)) != 1)
		2760	+ {
		2761	+ return $v_result;
		2762	+ }
		2763	+ }
		2764	+ }
		2765	+
		2766	+ // ----- Look for post-add callback
		2767	+ if (isset($p_options[PCLZIP_CB_POST_ADD])) {
		2768	+
		2769	+ // ----- Generate a local information
		2770	+ $v_local_header = array();
		2771	+ $this->privConvertHeader2FileInfo($p_header, $v_local_header);
		2772	+
		2773	+ // ----- Call the callback
		2774	+ // Here I do not use call_user_func() because I need to send a reference to the
		2775	+ // header.
		2776	+// eval('$v_result = '.$p_options[PCLZIP_CB_POST_ADD].'(PCLZIP_CB_POST_ADD, $v_local_header);');
		2777	+ $v_result = $p_options[PCLZIP_CB_POST_ADD](PCLZIP_CB_POST_ADD, $v_local_header);
		2778	+ if ($v_result == 0) {
		2779	+ // ----- Ignored
		2780	+ $v_result = 1;
		2781	+ }
		2782	+
		2783	+ // ----- Update the informations
		2784	+ // Nothing can be modified
		2785	+ }
		2786	+
		2787	+ // ----- Return
		2788	+ return $v_result;
		2789	+ }
		2790	+ // --------------------------------------------------------------------------------
		2791	+
		2792	+ // --------------------------------------------------------------------------------
		2793	+ // Function : privAddFileUsingTempFile()
		2794	+ // Description :
		2795	+ // Parameters :
		2796	+ // Return Values :
		2797	+ // --------------------------------------------------------------------------------
		2798	+ function privAddFileUsingTempFile($p_filedescr, &$p_header, &$p_options)
		2799	+ {
		2800	+ $v_result=PCLZIP_ERR_NO_ERROR;
		2801	+
		2802	+ // ----- Working variable
		2803	+ $p_filename = $p_filedescr['filename'];
		2804	+
		2805	+
		2806	+ // ----- Open the source file
		2807	+ if (($v_file = @fopen($p_filename, "rb")) == 0) {
		2808	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
		2809	+ return PclZip::errorCode();
		2810	+ }
		2811	+
		2812	+ // ----- Creates a compressed temporary file
		2813	+ $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
		2814	+ if (($v_file_compressed = @gzopen($v_gzip_temp_name, "wb")) == 0) {
		2815	+ fclose($v_file);
		2816	+ PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
		2817	+ return PclZip::errorCode();
		2818	+ }
		2819	+
		2820	+ // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
		2821	+ $v_size = filesize($p_filename);
		2822	+ while ($v_size != 0) {
		2823	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		2824	+ $v_buffer = @fread($v_file, $v_read_size);
		2825	+ //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
		2826	+ @gzputs($v_file_compressed, $v_buffer, $v_read_size);
		2827	+ $v_size -= $v_read_size;
		2828	+ }
		2829	+
		2830	+ // ----- Close the file
		2831	+ @fclose($v_file);
		2832	+ @gzclose($v_file_compressed);
		2833	+
		2834	+ // ----- Check the minimum file size
		2835	+ if (filesize($v_gzip_temp_name) < 18) {
		2836	+ PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'gzip temporary file \''.$v_gzip_temp_name.'\' has invalid filesize - should be minimum 18 bytes');
		2837	+ return PclZip::errorCode();
		2838	+ }
		2839	+
		2840	+ // ----- Extract the compressed attributes
		2841	+ if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0) {
		2842	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
		2843	+ return PclZip::errorCode();
		2844	+ }
		2845	+
		2846	+ // ----- Read the gzip file header
		2847	+ $v_binary_data = @fread($v_file_compressed, 10);
		2848	+ $v_data_header = unpack('a1id1/a1id2/a1cm/a1flag/Vmtime/a1xfl/a1os', $v_binary_data);
		2849	+
		2850	+ // ----- Check some parameters
		2851	+ $v_data_header['os'] = bin2hex($v_data_header['os']);
		2852	+
		2853	+ // ----- Read the gzip file footer
		2854	+ @fseek($v_file_compressed, filesize($v_gzip_temp_name)-8);
		2855	+ $v_binary_data = @fread($v_file_compressed, 8);
		2856	+ $v_data_footer = unpack('Vcrc/Vcompressed_size', $v_binary_data);
		2857	+
		2858	+ // ----- Set the attributes
		2859	+ $p_header['compression'] = ord($v_data_header['cm']);
		2860	+ //$p_header['mtime'] = $v_data_header['mtime'];
		2861	+ $p_header['crc'] = $v_data_footer['crc'];
		2862	+ $p_header['compressed_size'] = filesize($v_gzip_temp_name)-18;
		2863	+
		2864	+ // ----- Close the file
		2865	+ @fclose($v_file_compressed);
		2866	+
		2867	+ // ----- Call the header generation
		2868	+ if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
		2869	+ return $v_result;
		2870	+ }
		2871	+
		2872	+ // ----- Add the compressed data
		2873	+ if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0)
		2874	+ {
		2875	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
		2876	+ return PclZip::errorCode();
		2877	+ }
		2878	+
		2879	+ // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
		2880	+ fseek($v_file_compressed, 10);
		2881	+ $v_size = $p_header['compressed_size'];
		2882	+ while ($v_size != 0)
		2883	+ {
		2884	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		2885	+ $v_buffer = @fread($v_file_compressed, $v_read_size);
		2886	+ //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
		2887	+ @fwrite($this->zip_fd, $v_buffer, $v_read_size);
		2888	+ $v_size -= $v_read_size;
		2889	+ }
		2890	+
		2891	+ // ----- Close the file
		2892	+ @fclose($v_file_compressed);
		2893	+
		2894	+ // ----- Unlink the temporary file
		2895	+ @unlink($v_gzip_temp_name);
		2896	+
		2897	+ // ----- Return
		2898	+ return $v_result;
		2899	+ }
		2900	+ // --------------------------------------------------------------------------------
		2901	+
		2902	+ // --------------------------------------------------------------------------------
		2903	+ // Function : privCalculateStoredFilename()
		2904	+ // Description :
		2905	+ // Based on file descriptor properties and global options, this method
		2906	+ // calculate the filename that will be stored in the archive.
		2907	+ // Parameters :
		2908	+ // Return Values :
		2909	+ // --------------------------------------------------------------------------------
		2910	+ function privCalculateStoredFilename(&$p_filedescr, &$p_options)
		2911	+ {
		2912	+ $v_result=1;
		2913	+
		2914	+ // ----- Working variables
		2915	+ $p_filename = $p_filedescr['filename'];
		2916	+ if (isset($p_options[PCLZIP_OPT_ADD_PATH])) {
		2917	+ $p_add_dir = $p_options[PCLZIP_OPT_ADD_PATH];
		2918	+ }
		2919	+ else {
		2920	+ $p_add_dir = '';
		2921	+ }
		2922	+ if (isset($p_options[PCLZIP_OPT_REMOVE_PATH])) {
		2923	+ $p_remove_dir = $p_options[PCLZIP_OPT_REMOVE_PATH];
		2924	+ }
		2925	+ else {
		2926	+ $p_remove_dir = '';
		2927	+ }
		2928	+ if (isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
		2929	+ $p_remove_all_dir = $p_options[PCLZIP_OPT_REMOVE_ALL_PATH];
		2930	+ }
		2931	+ else {
		2932	+ $p_remove_all_dir = 0;
		2933	+ }
		2934	+
		2935	+
		2936	+ // ----- Look for full name change
		2937	+ if (isset($p_filedescr['new_full_name'])) {
		2938	+ // ----- Remove drive letter if any
		2939	+ $v_stored_filename = PclZipUtilTranslateWinPath($p_filedescr['new_full_name']);
		2940	+ }
		2941	+
		2942	+ // ----- Look for path and/or short name change
		2943	+ else {
		2944	+
		2945	+ // ----- Look for short name change
		2946	+ // Its when we cahnge just the filename but not the path
		2947	+ if (isset($p_filedescr['new_short_name'])) {
		2948	+ $v_path_info = pathinfo($p_filename);
		2949	+ $v_dir = '';
		2950	+ if ($v_path_info['dirname'] != '') {
		2951	+ $v_dir = $v_path_info['dirname'].'/';
		2952	+ }
		2953	+ $v_stored_filename = $v_dir.$p_filedescr['new_short_name'];
		2954	+ }
		2955	+ else {
		2956	+ // ----- Calculate the stored filename
		2957	+ $v_stored_filename = $p_filename;
		2958	+ }
		2959	+
		2960	+ // ----- Look for all path to remove
		2961	+ if ($p_remove_all_dir) {
		2962	+ $v_stored_filename = basename($p_filename);
		2963	+ }
		2964	+ // ----- Look for partial path remove
		2965	+ else if ($p_remove_dir != "") {
		2966	+ if (substr($p_remove_dir, -1) != '/')
		2967	+ $p_remove_dir .= "/";
		2968	+
		2969	+ if ( (substr($p_filename, 0, 2) == "./")
		2970	+ \|\| (substr($p_remove_dir, 0, 2) == "./")) {
		2971	+
		2972	+ if ( (substr($p_filename, 0, 2) == "./")
		2973	+ && (substr($p_remove_dir, 0, 2) != "./")) {
		2974	+ $p_remove_dir = "./".$p_remove_dir;
		2975	+ }
		2976	+ if ( (substr($p_filename, 0, 2) != "./")
		2977	+ && (substr($p_remove_dir, 0, 2) == "./")) {
		2978	+ $p_remove_dir = substr($p_remove_dir, 2);
		2979	+ }
		2980	+ }
		2981	+
		2982	+ $v_compare = PclZipUtilPathInclusion($p_remove_dir,
		2983	+ $v_stored_filename);
		2984	+ if ($v_compare > 0) {
		2985	+ if ($v_compare == 2) {
		2986	+ $v_stored_filename = "";
		2987	+ }
		2988	+ else {
		2989	+ $v_stored_filename = substr($v_stored_filename,
		2990	+ strlen($p_remove_dir));
		2991	+ }
		2992	+ }
		2993	+ }
		2994	+
		2995	+ // ----- Remove drive letter if any
		2996	+ $v_stored_filename = PclZipUtilTranslateWinPath($v_stored_filename);
		2997	+
		2998	+ // ----- Look for path to add
		2999	+ if ($p_add_dir != "") {
		3000	+ if (substr($p_add_dir, -1) == "/")
		3001	+ $v_stored_filename = $p_add_dir.$v_stored_filename;
		3002	+ else
		3003	+ $v_stored_filename = $p_add_dir."/".$v_stored_filename;
		3004	+ }
		3005	+ }
		3006	+
		3007	+ // ----- Filename (reduce the path of stored name)
		3008	+ $v_stored_filename = PclZipUtilPathReduction($v_stored_filename);
		3009	+ $p_filedescr['stored_filename'] = $v_stored_filename;
		3010	+
		3011	+ // ----- Return
		3012	+ return $v_result;
		3013	+ }
		3014	+ // --------------------------------------------------------------------------------
		3015	+
		3016	+ // --------------------------------------------------------------------------------
		3017	+ // Function : privWriteFileHeader()
		3018	+ // Description :
		3019	+ // Parameters :
		3020	+ // Return Values :
		3021	+ // --------------------------------------------------------------------------------
		3022	+ function privWriteFileHeader(&$p_header)
		3023	+ {
		3024	+ $v_result=1;
		3025	+
		3026	+ // ----- Store the offset position of the file
		3027	+ $p_header['offset'] = ftell($this->zip_fd);
		3028	+
		3029	+ // ----- Transform UNIX mtime to DOS format mdate/mtime
		3030	+ $v_date = getdate($p_header['mtime']);
		3031	+ $v_mtime = ($v_date['hours']<<11) + ($v_date['minutes']<<5) + $v_date['seconds']/2;
		3032	+ $v_mdate = (($v_date['year']-1980)<<9) + ($v_date['mon']<<5) + $v_date['mday'];
		3033	+
		3034	+ // ----- Packed data
		3035	+ $v_binary_data = pack("VvvvvvVVVvv", 0x04034b50,
		3036	+ $p_header['version_extracted'], $p_header['flag'],
		3037	+ $p_header['compression'], $v_mtime, $v_mdate,
		3038	+ $p_header['crc'], $p_header['compressed_size'],
		3039	+ $p_header['size'],
		3040	+ strlen($p_header['stored_filename']),
		3041	+ $p_header['extra_len']);
		3042	+
		3043	+ // ----- Write the first 148 bytes of the header in the archive
		3044	+ fputs($this->zip_fd, $v_binary_data, 30);
		3045	+
		3046	+ // ----- Write the variable fields
		3047	+ if (strlen($p_header['stored_filename']) != 0)
		3048	+ {
		3049	+ fputs($this->zip_fd, $p_header['stored_filename'], strlen($p_header['stored_filename']));
		3050	+ }
		3051	+ if ($p_header['extra_len'] != 0)
		3052	+ {
		3053	+ fputs($this->zip_fd, $p_header['extra'], $p_header['extra_len']);
		3054	+ }
		3055	+
		3056	+ // ----- Return
		3057	+ return $v_result;
		3058	+ }
		3059	+ // --------------------------------------------------------------------------------
		3060	+
		3061	+ // --------------------------------------------------------------------------------
		3062	+ // Function : privWriteCentralFileHeader()
		3063	+ // Description :
		3064	+ // Parameters :
		3065	+ // Return Values :
		3066	+ // --------------------------------------------------------------------------------
		3067	+ function privWriteCentralFileHeader(&$p_header)
		3068	+ {
		3069	+ $v_result=1;
		3070	+
		3071	+ // TBC
		3072	+ //for(reset($p_header); $key = key($p_header); next($p_header)) {
		3073	+ //}
		3074	+
		3075	+ // ----- Transform UNIX mtime to DOS format mdate/mtime
		3076	+ $v_date = getdate($p_header['mtime']);
		3077	+ $v_mtime = ($v_date['hours']<<11) + ($v_date['minutes']<<5) + $v_date['seconds']/2;
		3078	+ $v_mdate = (($v_date['year']-1980)<<9) + ($v_date['mon']<<5) + $v_date['mday'];
		3079	+
		3080	+
		3081	+ // ----- Packed data
		3082	+ $v_binary_data = pack("VvvvvvvVVVvvvvvVV", 0x02014b50,
		3083	+ $p_header['version'], $p_header['version_extracted'],
		3084	+ $p_header['flag'], $p_header['compression'],
		3085	+ $v_mtime, $v_mdate, $p_header['crc'],
		3086	+ $p_header['compressed_size'], $p_header['size'],
		3087	+ strlen($p_header['stored_filename']),
		3088	+ $p_header['extra_len'], $p_header['comment_len'],
		3089	+ $p_header['disk'], $p_header['internal'],
		3090	+ $p_header['external'], $p_header['offset']);
		3091	+
		3092	+ // ----- Write the 42 bytes of the header in the zip file
		3093	+ fputs($this->zip_fd, $v_binary_data, 46);
		3094	+
		3095	+ // ----- Write the variable fields
		3096	+ if (strlen($p_header['stored_filename']) != 0)
		3097	+ {
		3098	+ fputs($this->zip_fd, $p_header['stored_filename'], strlen($p_header['stored_filename']));
		3099	+ }
		3100	+ if ($p_header['extra_len'] != 0)
		3101	+ {
		3102	+ fputs($this->zip_fd, $p_header['extra'], $p_header['extra_len']);
		3103	+ }
		3104	+ if ($p_header['comment_len'] != 0)
		3105	+ {
		3106	+ fputs($this->zip_fd, $p_header['comment'], $p_header['comment_len']);
		3107	+ }
		3108	+
		3109	+ // ----- Return
		3110	+ return $v_result;
		3111	+ }
		3112	+ // --------------------------------------------------------------------------------
		3113	+
		3114	+ // --------------------------------------------------------------------------------
		3115	+ // Function : privWriteCentralHeader()
		3116	+ // Description :
		3117	+ // Parameters :
		3118	+ // Return Values :
		3119	+ // --------------------------------------------------------------------------------
		3120	+ function privWriteCentralHeader($p_nb_entries, $p_size, $p_offset, $p_comment)
		3121	+ {
		3122	+ $v_result=1;
		3123	+
		3124	+ // ----- Packed data
		3125	+ $v_binary_data = pack("VvvvvVVv", 0x06054b50, 0, 0, $p_nb_entries,
		3126	+ $p_nb_entries, $p_size,
		3127	+ $p_offset, strlen($p_comment));
		3128	+
		3129	+ // ----- Write the 22 bytes of the header in the zip file
		3130	+ fputs($this->zip_fd, $v_binary_data, 22);
		3131	+
		3132	+ // ----- Write the variable fields
		3133	+ if (strlen($p_comment) != 0)
		3134	+ {
		3135	+ fputs($this->zip_fd, $p_comment, strlen($p_comment));
		3136	+ }
		3137	+
		3138	+ // ----- Return
		3139	+ return $v_result;
		3140	+ }
		3141	+ // --------------------------------------------------------------------------------
		3142	+
		3143	+ // --------------------------------------------------------------------------------
		3144	+ // Function : privList()
		3145	+ // Description :
		3146	+ // Parameters :
		3147	+ // Return Values :
		3148	+ // --------------------------------------------------------------------------------
		3149	+ function privList(&$p_list)
		3150	+ {
		3151	+ $v_result=1;
		3152	+
		3153	+ // ----- Magic quotes trick
		3154	+ $this->privDisableMagicQuotes();
		3155	+
		3156	+ // ----- Open the zip file
		3157	+ if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
		3158	+ {
		3159	+ // ----- Magic quotes trick
		3160	+ $this->privSwapBackMagicQuotes();
		3161	+
		3162	+ // ----- Error log
		3163	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
		3164	+
		3165	+ // ----- Return
		3166	+ return PclZip::errorCode();
		3167	+ }
		3168	+
		3169	+ // ----- Read the central directory informations
		3170	+ $v_central_dir = array();
		3171	+ if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
		3172	+ {
		3173	+ $this->privSwapBackMagicQuotes();
		3174	+ return $v_result;
		3175	+ }
		3176	+
		3177	+ // ----- Go to beginning of Central Dir
		3178	+ @rewind($this->zip_fd);
		3179	+ if (@fseek($this->zip_fd, $v_central_dir['offset']))
		3180	+ {
		3181	+ $this->privSwapBackMagicQuotes();
		3182	+
		3183	+ // ----- Error log
		3184	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
		3185	+
		3186	+ // ----- Return
		3187	+ return PclZip::errorCode();
		3188	+ }
		3189	+
		3190	+ // ----- Read each entry
		3191	+ for ($i=0; $i<$v_central_dir['entries']; $i++)
		3192	+ {
		3193	+ // ----- Read the file header
		3194	+ if (($v_result = $this->privReadCentralFileHeader($v_header)) != 1)
		3195	+ {
		3196	+ $this->privSwapBackMagicQuotes();
		3197	+ return $v_result;
		3198	+ }
		3199	+ $v_header['index'] = $i;
		3200	+
		3201	+ // ----- Get the only interesting attributes
		3202	+ $this->privConvertHeader2FileInfo($v_header, $p_list[$i]);
		3203	+ unset($v_header);
		3204	+ }
		3205	+
		3206	+ // ----- Close the zip file
		3207	+ $this->privCloseFd();
		3208	+
		3209	+ // ----- Magic quotes trick
		3210	+ $this->privSwapBackMagicQuotes();
		3211	+
		3212	+ // ----- Return
		3213	+ return $v_result;
		3214	+ }
		3215	+ // --------------------------------------------------------------------------------
		3216	+
		3217	+ // --------------------------------------------------------------------------------
		3218	+ // Function : privConvertHeader2FileInfo()
		3219	+ // Description :
		3220	+ // This function takes the file informations from the central directory
		3221	+ // entries and extract the interesting parameters that will be given back.
		3222	+ // The resulting file infos are set in the array $p_info
		3223	+ // $p_info['filename'] : Filename with full path. Given by user (add),
		3224	+ // extracted in the filesystem (extract).
		3225	+ // $p_info['stored_filename'] : Stored filename in the archive.
		3226	+ // $p_info['size'] = Size of the file.
		3227	+ // $p_info['compressed_size'] = Compressed size of the file.
		3228	+ // $p_info['mtime'] = Last modification date of the file.
		3229	+ // $p_info['comment'] = Comment associated with the file.
		3230	+ // $p_info['folder'] = true/false : indicates if the entry is a folder or not.
		3231	+ // $p_info['status'] = status of the action on the file.
		3232	+ // $p_info['crc'] = CRC of the file content.
		3233	+ // Parameters :
		3234	+ // Return Values :
		3235	+ // --------------------------------------------------------------------------------
		3236	+ function privConvertHeader2FileInfo($p_header, &$p_info)
		3237	+ {
		3238	+ $v_result=1;
		3239	+
		3240	+ // ----- Get the interesting attributes
		3241	+ $v_temp_path = PclZipUtilPathReduction($p_header['filename']);
		3242	+ $p_info['filename'] = $v_temp_path;
		3243	+ $v_temp_path = PclZipUtilPathReduction($p_header['stored_filename']);
		3244	+ $p_info['stored_filename'] = $v_temp_path;
		3245	+ $p_info['size'] = $p_header['size'];
		3246	+ $p_info['compressed_size'] = $p_header['compressed_size'];
		3247	+ $p_info['mtime'] = $p_header['mtime'];
		3248	+ $p_info['comment'] = $p_header['comment'];
		3249	+ $p_info['folder'] = (($p_header['external']&0x00000010)==0x00000010);
		3250	+ $p_info['index'] = $p_header['index'];
		3251	+ $p_info['status'] = $p_header['status'];
		3252	+ $p_info['crc'] = $p_header['crc'];
		3253	+
		3254	+ // ----- Return
		3255	+ return $v_result;
		3256	+ }
		3257	+ // --------------------------------------------------------------------------------
		3258	+
		3259	+ // --------------------------------------------------------------------------------
		3260	+ // Function : privExtractByRule()
		3261	+ // Description :
		3262	+ // Extract a file or directory depending of rules (by index, by name, ...)
		3263	+ // Parameters :
		3264	+ // $p_file_list : An array where will be placed the properties of each
		3265	+ // extracted file
		3266	+ // $p_path : Path to add while writing the extracted files
		3267	+ // $p_remove_path : Path to remove (from the file memorized path) while writing the
		3268	+ // extracted files. If the path does not match the file path,
		3269	+ // the file is extracted with its memorized path.
		3270	+ // $p_remove_path does not apply to 'list' mode.
		3271	+ // $p_path and $p_remove_path are commulative.
		3272	+ // Return Values :
		3273	+ // 1 on success,0 or less on error (see error code list)
		3274	+ // --------------------------------------------------------------------------------
		3275	+ function privExtractByRule(&$p_file_list, $p_path, $p_remove_path, $p_remove_all_path, &$p_options)
		3276	+ {
		3277	+ $v_result=1;
		3278	+
		3279	+ // ----- Magic quotes trick
		3280	+ $this->privDisableMagicQuotes();
		3281	+
		3282	+ // ----- Check the path
		3283	+ if ( ($p_path == "")
		3284	+ \|\| ( (substr($p_path, 0, 1) != "/")
		3285	+ && (substr($p_path, 0, 3) != "../")
		3286	+ && (substr($p_path,1,2)!=":/")))
		3287	+ $p_path = "./".$p_path;
		3288	+
		3289	+ // ----- Reduce the path last (and duplicated) '/'
		3290	+ if (($p_path != "./") && ($p_path != "/"))
		3291	+ {
		3292	+ // ----- Look for the path end '/'
		3293	+ while (substr($p_path, -1) == "/")
		3294	+ {
		3295	+ $p_path = substr($p_path, 0, strlen($p_path)-1);
		3296	+ }
		3297	+ }
		3298	+
		3299	+ // ----- Look for path to remove format (should end by /)
		3300	+ if (($p_remove_path != "") && (substr($p_remove_path, -1) != '/'))
		3301	+ {
		3302	+ $p_remove_path .= '/';
		3303	+ }
		3304	+ $p_remove_path_size = strlen($p_remove_path);
		3305	+
		3306	+ // ----- Open the zip file
		3307	+ if (($v_result = $this->privOpenFd('rb')) != 1)
		3308	+ {
		3309	+ $this->privSwapBackMagicQuotes();
		3310	+ return $v_result;
		3311	+ }
		3312	+
		3313	+ // ----- Read the central directory informations
		3314	+ $v_central_dir = array();
		3315	+ if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
		3316	+ {
		3317	+ // ----- Close the zip file
		3318	+ $this->privCloseFd();
		3319	+ $this->privSwapBackMagicQuotes();
		3320	+
		3321	+ return $v_result;
		3322	+ }
		3323	+
		3324	+ // ----- Start at beginning of Central Dir
		3325	+ $v_pos_entry = $v_central_dir['offset'];
		3326	+
		3327	+ // ----- Read each entry
		3328	+ $j_start = 0;
		3329	+ for ($i=0, $v_nb_extracted=0; $i<$v_central_dir['entries']; $i++)
		3330	+ {
		3331	+
		3332	+ // ----- Read next Central dir entry
		3333	+ @rewind($this->zip_fd);
		3334	+ if (@fseek($this->zip_fd, $v_pos_entry))
		3335	+ {
		3336	+ // ----- Close the zip file
		3337	+ $this->privCloseFd();
		3338	+ $this->privSwapBackMagicQuotes();
		3339	+
		3340	+ // ----- Error log
		3341	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
		3342	+
		3343	+ // ----- Return
		3344	+ return PclZip::errorCode();
		3345	+ }
		3346	+
		3347	+ // ----- Read the file header
		3348	+ $v_header = array();
		3349	+ if (($v_result = $this->privReadCentralFileHeader($v_header)) != 1)
		3350	+ {
		3351	+ // ----- Close the zip file
		3352	+ $this->privCloseFd();
		3353	+ $this->privSwapBackMagicQuotes();
		3354	+
		3355	+ return $v_result;
		3356	+ }
		3357	+
		3358	+ // ----- Store the index
		3359	+ $v_header['index'] = $i;
		3360	+
		3361	+ // ----- Store the file position
		3362	+ $v_pos_entry = ftell($this->zip_fd);
		3363	+
		3364	+ // ----- Look for the specific extract rules
		3365	+ $v_extract = false;
		3366	+
		3367	+ // ----- Look for extract by name rule
		3368	+ if ( (isset($p_options[PCLZIP_OPT_BY_NAME]))
		3369	+ && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
		3370	+
		3371	+ // ----- Look if the filename is in the list
		3372	+ for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_extract); $j++) {
		3373	+
		3374	+ // ----- Look for a directory
		3375	+ if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
		3376	+
		3377	+ // ----- Look if the directory is in the filename path
		3378	+ if ( (strlen($v_header['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
		3379	+ && (substr($v_header['stored_filename'], 0, strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
		3380	+ $v_extract = true;
		3381	+ }
		3382	+ }
		3383	+ // ----- Look for a filename
		3384	+ elseif ($v_header['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
		3385	+ $v_extract = true;
		3386	+ }
		3387	+ }
		3388	+ }
		3389	+
		3390	+ // ----- Look for extract by ereg rule
		3391	+ // ereg() is deprecated with PHP 5.3
		3392	+ /*
		3393	+ else if ( (isset($p_options[PCLZIP_OPT_BY_EREG]))
		3394	+ && ($p_options[PCLZIP_OPT_BY_EREG] != "")) {
		3395	+
		3396	+ if (ereg($p_options[PCLZIP_OPT_BY_EREG], $v_header['stored_filename'])) {
		3397	+ $v_extract = true;
		3398	+ }
		3399	+ }
		3400	+ */
		3401	+
		3402	+ // ----- Look for extract by preg rule
		3403	+ else if ( (isset($p_options[PCLZIP_OPT_BY_PREG]))
		3404	+ && ($p_options[PCLZIP_OPT_BY_PREG] != "")) {
		3405	+
		3406	+ if (preg_match($p_options[PCLZIP_OPT_BY_PREG], $v_header['stored_filename'])) {
		3407	+ $v_extract = true;
		3408	+ }
		3409	+ }
		3410	+
		3411	+ // ----- Look for extract by index rule
		3412	+ else if ( (isset($p_options[PCLZIP_OPT_BY_INDEX]))
		3413	+ && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
		3414	+
		3415	+ // ----- Look if the index is in the list
		3416	+ for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_extract); $j++) {
		3417	+
		3418	+ if (($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i<=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
		3419	+ $v_extract = true;
		3420	+ }
		3421	+ if ($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
		3422	+ $j_start = $j+1;
		3423	+ }
		3424	+
		3425	+ if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start']>$i) {
		3426	+ break;
		3427	+ }
		3428	+ }
		3429	+ }
		3430	+
		3431	+ // ----- Look for no rule, which means extract all the archive
		3432	+ else {
		3433	+ $v_extract = true;
		3434	+ }
		3435	+
		3436	+ // ----- Check compression method
		3437	+ if ( ($v_extract)
		3438	+ && ( ($v_header['compression'] != 8)
		3439	+ && ($v_header['compression'] != 0))) {
		3440	+ $v_header['status'] = 'unsupported_compression';
		3441	+
		3442	+ // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
		3443	+ if ( (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
		3444	+ && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
		3445	+
		3446	+ $this->privSwapBackMagicQuotes();
		3447	+
		3448	+ PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_COMPRESSION,
		3449	+ "Filename '".$v_header['stored_filename']."' is "
		3450	+ ."compressed by an unsupported compression "
		3451	+ ."method (".$v_header['compression'].") ");
		3452	+
		3453	+ return PclZip::errorCode();
		3454	+ }
		3455	+ }
		3456	+
		3457	+ // ----- Check encrypted files
		3458	+ if (($v_extract) && (($v_header['flag'] & 1) == 1)) {
		3459	+ $v_header['status'] = 'unsupported_encryption';
		3460	+
		3461	+ // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
		3462	+ if ( (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
		3463	+ && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
		3464	+
		3465	+ $this->privSwapBackMagicQuotes();
		3466	+
		3467	+ PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION,
		3468	+ "Unsupported encryption for "
		3469	+ ." filename '".$v_header['stored_filename']
		3470	+ ."'");
		3471	+
		3472	+ return PclZip::errorCode();
		3473	+ }
		3474	+ }
		3475	+
		3476	+ // ----- Look for real extraction
		3477	+ if (($v_extract) && ($v_header['status'] != 'ok')) {
		3478	+ $v_result = $this->privConvertHeader2FileInfo($v_header,
		3479	+ $p_file_list[$v_nb_extracted++]);
		3480	+ if ($v_result != 1) {
		3481	+ $this->privCloseFd();
		3482	+ $this->privSwapBackMagicQuotes();
		3483	+ return $v_result;
		3484	+ }
		3485	+
		3486	+ $v_extract = false;
		3487	+ }
		3488	+
		3489	+ // ----- Look for real extraction
		3490	+ if ($v_extract)
		3491	+ {
		3492	+
		3493	+ // ----- Go to the file position
		3494	+ @rewind($this->zip_fd);
		3495	+ if (@fseek($this->zip_fd, $v_header['offset']))
		3496	+ {
		3497	+ // ----- Close the zip file
		3498	+ $this->privCloseFd();
		3499	+
		3500	+ $this->privSwapBackMagicQuotes();
		3501	+
		3502	+ // ----- Error log
		3503	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
		3504	+
		3505	+ // ----- Return
		3506	+ return PclZip::errorCode();
		3507	+ }
		3508	+
		3509	+ // ----- Look for extraction as string
		3510	+ if ($p_options[PCLZIP_OPT_EXTRACT_AS_STRING]) {
		3511	+
		3512	+ $v_string = '';
		3513	+
		3514	+ // ----- Extracting the file
		3515	+ $v_result1 = $this->privExtractFileAsString($v_header, $v_string, $p_options);
		3516	+ if ($v_result1 < 1) {
		3517	+ $this->privCloseFd();
		3518	+ $this->privSwapBackMagicQuotes();
		3519	+ return $v_result1;
		3520	+ }
		3521	+
		3522	+ // ----- Get the only interesting attributes
		3523	+ if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted])) != 1)
		3524	+ {
		3525	+ // ----- Close the zip file
		3526	+ $this->privCloseFd();
		3527	+ $this->privSwapBackMagicQuotes();
		3528	+
		3529	+ return $v_result;
		3530	+ }
		3531	+
		3532	+ // ----- Set the file content
		3533	+ $p_file_list[$v_nb_extracted]['content'] = $v_string;
		3534	+
		3535	+ // ----- Next extracted file
		3536	+ $v_nb_extracted++;
		3537	+
		3538	+ // ----- Look for user callback abort
		3539	+ if ($v_result1 == 2) {
		3540	+ break;
		3541	+ }
		3542	+ }
		3543	+ // ----- Look for extraction in standard output
		3544	+ elseif ( (isset($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT]))
		3545	+ && ($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT])) {
		3546	+ // ----- Extracting the file in standard output
		3547	+ $v_result1 = $this->privExtractFileInOutput($v_header, $p_options);
		3548	+ if ($v_result1 < 1) {
		3549	+ $this->privCloseFd();
		3550	+ $this->privSwapBackMagicQuotes();
		3551	+ return $v_result1;
		3552	+ }
		3553	+
		3554	+ // ----- Get the only interesting attributes
		3555	+ if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted++])) != 1) {
		3556	+ $this->privCloseFd();
		3557	+ $this->privSwapBackMagicQuotes();
		3558	+ return $v_result;
		3559	+ }
		3560	+
		3561	+ // ----- Look for user callback abort
		3562	+ if ($v_result1 == 2) {
		3563	+ break;
		3564	+ }
		3565	+ }
		3566	+ // ----- Look for normal extraction
		3567	+ else {
		3568	+ // ----- Extracting the file
		3569	+ $v_result1 = $this->privExtractFile($v_header,
		3570	+ $p_path, $p_remove_path,
		3571	+ $p_remove_all_path,
		3572	+ $p_options);
		3573	+ if ($v_result1 < 1) {
		3574	+ $this->privCloseFd();
		3575	+ $this->privSwapBackMagicQuotes();
		3576	+ return $v_result1;
		3577	+ }
		3578	+
		3579	+ // ----- Get the only interesting attributes
		3580	+ if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted++])) != 1)
		3581	+ {
		3582	+ // ----- Close the zip file
		3583	+ $this->privCloseFd();
		3584	+ $this->privSwapBackMagicQuotes();
		3585	+
		3586	+ return $v_result;
		3587	+ }
		3588	+
		3589	+ // ----- Look for user callback abort
		3590	+ if ($v_result1 == 2) {
		3591	+ break;
		3592	+ }
		3593	+ }
		3594	+ }
		3595	+ }
		3596	+
		3597	+ // ----- Close the zip file
		3598	+ $this->privCloseFd();
		3599	+ $this->privSwapBackMagicQuotes();
		3600	+
		3601	+ // ----- Return
		3602	+ return $v_result;
		3603	+ }
		3604	+ // --------------------------------------------------------------------------------
		3605	+
		3606	+ // --------------------------------------------------------------------------------
		3607	+ // Function : privExtractFile()
		3608	+ // Description :
		3609	+ // Parameters :
		3610	+ // Return Values :
		3611	+ //
		3612	+ // 1 : ... ?
		3613	+ // PCLZIP_ERR_USER_ABORTED(2) : User ask for extraction stop in callback
		3614	+ // --------------------------------------------------------------------------------
		3615	+ function privExtractFile(&$p_entry, $p_path, $p_remove_path, $p_remove_all_path, &$p_options)
		3616	+ {
		3617	+ $v_result=1;
		3618	+
		3619	+ // ----- Read the file header
		3620	+ if (($v_result = $this->privReadFileHeader($v_header)) != 1)
		3621	+ {
		3622	+ // ----- Return
		3623	+ return $v_result;
		3624	+ }
		3625	+
		3626	+
		3627	+ // ----- Check that the file header is coherent with $p_entry info
		3628	+ if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
		3629	+ // TBC
		3630	+ }
		3631	+
		3632	+ // ----- Look for all path to remove
		3633	+ if ($p_remove_all_path == true) {
		3634	+ // ----- Look for folder entry that not need to be extracted
		3635	+ if (($p_entry['external']&0x00000010)==0x00000010) {
		3636	+
		3637	+ $p_entry['status'] = "filtered";
		3638	+
		3639	+ return $v_result;
		3640	+ }
		3641	+
		3642	+ // ----- Get the basename of the path
		3643	+ $p_entry['filename'] = basename($p_entry['filename']);
		3644	+ }
		3645	+
		3646	+ // ----- Look for path to remove
		3647	+ else if ($p_remove_path != "")
		3648	+ {
		3649	+ if (PclZipUtilPathInclusion($p_remove_path, $p_entry['filename']) == 2)
		3650	+ {
		3651	+
		3652	+ // ----- Change the file status
		3653	+ $p_entry['status'] = "filtered";
		3654	+
		3655	+ // ----- Return
		3656	+ return $v_result;
		3657	+ }
		3658	+
		3659	+ $p_remove_path_size = strlen($p_remove_path);
		3660	+ if (substr($p_entry['filename'], 0, $p_remove_path_size) == $p_remove_path)
		3661	+ {
		3662	+
		3663	+ // ----- Remove the path
		3664	+ $p_entry['filename'] = substr($p_entry['filename'], $p_remove_path_size);
		3665	+
		3666	+ }
		3667	+ }
		3668	+
		3669	+ // ----- Add the path
		3670	+ if ($p_path != '') {
		3671	+ $p_entry['filename'] = $p_path."/".$p_entry['filename'];
		3672	+ }
		3673	+
		3674	+ // ----- Check a base_dir_restriction
		3675	+ if (isset($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION])) {
		3676	+ $v_inclusion
		3677	+ = PclZipUtilPathInclusion($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION],
		3678	+ $p_entry['filename']);
		3679	+ if ($v_inclusion == 0) {
		3680	+
		3681	+ PclZip::privErrorLog(PCLZIP_ERR_DIRECTORY_RESTRICTION,
		3682	+ "Filename '".$p_entry['filename']."' is "
		3683	+ ."outside PCLZIP_OPT_EXTRACT_DIR_RESTRICTION");
		3684	+
		3685	+ return PclZip::errorCode();
		3686	+ }
		3687	+ }
		3688	+
		3689	+ // ----- Look for pre-extract callback
		3690	+ if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
		3691	+
		3692	+ // ----- Generate a local information
		3693	+ $v_local_header = array();
		3694	+ $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
		3695	+
		3696	+ // ----- Call the callback
		3697	+ // Here I do not use call_user_func() because I need to send a reference to the
		3698	+ // header.
		3699	+// eval('$v_result = '.$p_options[PCLZIP_CB_PRE_EXTRACT].'(PCLZIP_CB_PRE_EXTRACT, $v_local_header);');
		3700	+ $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
		3701	+ if ($v_result == 0) {
		3702	+ // ----- Change the file status
		3703	+ $p_entry['status'] = "skipped";
		3704	+ $v_result = 1;
		3705	+ }
		3706	+
		3707	+ // ----- Look for abort result
		3708	+ if ($v_result == 2) {
		3709	+ // ----- This status is internal and will be changed in 'skipped'
		3710	+ $p_entry['status'] = "aborted";
		3711	+ $v_result = PCLZIP_ERR_USER_ABORTED;
		3712	+ }
		3713	+
		3714	+ // ----- Update the informations
		3715	+ // Only some fields can be modified
		3716	+ $p_entry['filename'] = $v_local_header['filename'];
		3717	+ }
		3718	+
		3719	+
		3720	+ // ----- Look if extraction should be done
		3721	+ if ($p_entry['status'] == 'ok') {
		3722	+
		3723	+ // ----- Look for specific actions while the file exist
		3724	+ if (file_exists($p_entry['filename']))
		3725	+ {
		3726	+
		3727	+ // ----- Look if file is a directory
		3728	+ if (is_dir($p_entry['filename']))
		3729	+ {
		3730	+
		3731	+ // ----- Change the file status
		3732	+ $p_entry['status'] = "already_a_directory";
		3733	+
		3734	+ // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
		3735	+ // For historical reason first PclZip implementation does not stop
		3736	+ // when this kind of error occurs.
		3737	+ if ( (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
		3738	+ && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
		3739	+
		3740	+ PclZip::privErrorLog(PCLZIP_ERR_ALREADY_A_DIRECTORY,
		3741	+ "Filename '".$p_entry['filename']."' is "
		3742	+ ."already used by an existing directory");
		3743	+
		3744	+ return PclZip::errorCode();
		3745	+ }
		3746	+ }
		3747	+ // ----- Look if file is write protected
		3748	+ else if (!is_writeable($p_entry['filename']))
		3749	+ {
		3750	+
		3751	+ // ----- Change the file status
		3752	+ $p_entry['status'] = "write_protected";
		3753	+
		3754	+ // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
		3755	+ // For historical reason first PclZip implementation does not stop
		3756	+ // when this kind of error occurs.
		3757	+ if ( (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
		3758	+ && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
		3759	+
		3760	+ PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
		3761	+ "Filename '".$p_entry['filename']."' exists "
		3762	+ ."and is write protected");
		3763	+
		3764	+ return PclZip::errorCode();
		3765	+ }
		3766	+ }
		3767	+
		3768	+ // ----- Look if the extracted file is older
		3769	+ else if (filemtime($p_entry['filename']) > $p_entry['mtime'])
		3770	+ {
		3771	+ // ----- Change the file status
		3772	+ if ( (isset($p_options[PCLZIP_OPT_REPLACE_NEWER]))
		3773	+ && ($p_options[PCLZIP_OPT_REPLACE_NEWER]===true)) {
		3774	+ }
		3775	+ else {
		3776	+ $p_entry['status'] = "newer_exist";
		3777	+
		3778	+ // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
		3779	+ // For historical reason first PclZip implementation does not stop
		3780	+ // when this kind of error occurs.
		3781	+ if ( (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
		3782	+ && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
		3783	+
		3784	+ PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
		3785	+ "Newer version of '".$p_entry['filename']."' exists "
		3786	+ ."and option PCLZIP_OPT_REPLACE_NEWER is not selected");
		3787	+
		3788	+ return PclZip::errorCode();
		3789	+ }
		3790	+ }
		3791	+ }
		3792	+ else {
		3793	+ }
		3794	+ }
		3795	+
		3796	+ // ----- Check the directory availability and create it if necessary
		3797	+ else {
		3798	+ if ((($p_entry['external']&0x00000010)==0x00000010) \|\| (substr($p_entry['filename'], -1) == '/'))
		3799	+ $v_dir_to_check = $p_entry['filename'];
		3800	+ else if (!strstr($p_entry['filename'], "/"))
		3801	+ $v_dir_to_check = "";
		3802	+ else
		3803	+ $v_dir_to_check = dirname($p_entry['filename']);
		3804	+
		3805	+ if (($v_result = $this->privDirCheck($v_dir_to_check, (($p_entry['external']&0x00000010)==0x00000010))) != 1) {
		3806	+
		3807	+ // ----- Change the file status
		3808	+ $p_entry['status'] = "path_creation_fail";
		3809	+
		3810	+ // ----- Return
		3811	+ //return $v_result;
		3812	+ $v_result = 1;
		3813	+ }
		3814	+ }
		3815	+ }
		3816	+
		3817	+ // ----- Look if extraction should be done
		3818	+ if ($p_entry['status'] == 'ok') {
		3819	+
		3820	+ // ----- Do the extraction (if not a folder)
		3821	+ if (!(($p_entry['external']&0x00000010)==0x00000010))
		3822	+ {
		3823	+ // ----- Look for not compressed file
		3824	+ if ($p_entry['compression'] == 0) {
		3825	+
		3826	+ // ----- Opening destination file
		3827	+ if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0)
		3828	+ {
		3829	+
		3830	+ // ----- Change the file status
		3831	+ $p_entry['status'] = "write_error";
		3832	+
		3833	+ // ----- Return
		3834	+ return $v_result;
		3835	+ }
		3836	+
		3837	+
		3838	+ // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
		3839	+ $v_size = $p_entry['compressed_size'];
		3840	+ while ($v_size != 0)
		3841	+ {
		3842	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		3843	+ $v_buffer = @fread($this->zip_fd, $v_read_size);
		3844	+ /* Try to speed up the code
		3845	+ $v_binary_data = pack('a'.$v_read_size, $v_buffer);
		3846	+ @fwrite($v_dest_file, $v_binary_data, $v_read_size);
		3847	+ */
		3848	+ @fwrite($v_dest_file, $v_buffer, $v_read_size);
		3849	+ $v_size -= $v_read_size;
		3850	+ }
		3851	+
		3852	+ // ----- Closing the destination file
		3853	+ fclose($v_dest_file);
		3854	+
		3855	+ // ----- Change the file mtime
		3856	+ touch($p_entry['filename'], $p_entry['mtime']);
		3857	+
		3858	+
		3859	+ }
		3860	+ else {
		3861	+ // ----- TBC
		3862	+ // Need to be finished
		3863	+ if (($p_entry['flag'] & 1) == 1) {
		3864	+ PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION, 'File \''.$p_entry['filename'].'\' is encrypted. Encrypted files are not supported.');
		3865	+ return PclZip::errorCode();
		3866	+ }
		3867	+
		3868	+
		3869	+ // ----- Look for using temporary file to unzip
		3870	+ if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
		3871	+ && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
		3872	+ \|\| (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
		3873	+ && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_entry['size'])) ) ) {
		3874	+ $v_result = $this->privExtractFileUsingTempFile($p_entry, $p_options);
		3875	+ if ($v_result < PCLZIP_ERR_NO_ERROR) {
		3876	+ return $v_result;
		3877	+ }
		3878	+ }
		3879	+
		3880	+ // ----- Look for extract in memory
		3881	+ else {
		3882	+
		3883	+
		3884	+ // ----- Read the compressed file in a buffer (one shot)
		3885	+ $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
		3886	+
		3887	+ // ----- Decompress the file
		3888	+ $v_file_content = @gzinflate($v_buffer);
		3889	+ unset($v_buffer);
		3890	+ if ($v_file_content === FALSE) {
		3891	+
		3892	+ // ----- Change the file status
		3893	+ // TBC
		3894	+ $p_entry['status'] = "error";
		3895	+
		3896	+ return $v_result;
		3897	+ }
		3898	+
		3899	+ // ----- Opening destination file
		3900	+ if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
		3901	+
		3902	+ // ----- Change the file status
		3903	+ $p_entry['status'] = "write_error";
		3904	+
		3905	+ return $v_result;
		3906	+ }
		3907	+
		3908	+ // ----- Write the uncompressed data
		3909	+ @fwrite($v_dest_file, $v_file_content, $p_entry['size']);
		3910	+ unset($v_file_content);
		3911	+
		3912	+ // ----- Closing the destination file
		3913	+ @fclose($v_dest_file);
		3914	+
		3915	+ }
		3916	+
		3917	+ // ----- Change the file mtime
		3918	+ @touch($p_entry['filename'], $p_entry['mtime']);
		3919	+ }
		3920	+
		3921	+ // ----- Look for chmod option
		3922	+ if (isset($p_options[PCLZIP_OPT_SET_CHMOD])) {
		3923	+
		3924	+ // ----- Change the mode of the file
		3925	+ @chmod($p_entry['filename'], $p_options[PCLZIP_OPT_SET_CHMOD]);
		3926	+ }
		3927	+
		3928	+ }
		3929	+ }
		3930	+
		3931	+ // ----- Change abort status
		3932	+ if ($p_entry['status'] == "aborted") {
		3933	+ $p_entry['status'] = "skipped";
		3934	+ }
		3935	+
		3936	+ // ----- Look for post-extract callback
		3937	+ elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
		3938	+
		3939	+ // ----- Generate a local information
		3940	+ $v_local_header = array();
		3941	+ $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
		3942	+
		3943	+ // ----- Call the callback
		3944	+ // Here I do not use call_user_func() because I need to send a reference to the
		3945	+ // header.
		3946	+// eval('$v_result = '.$p_options[PCLZIP_CB_POST_EXTRACT].'(PCLZIP_CB_POST_EXTRACT, $v_local_header);');
		3947	+ $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
		3948	+
		3949	+ // ----- Look for abort result
		3950	+ if ($v_result == 2) {
		3951	+ $v_result = PCLZIP_ERR_USER_ABORTED;
		3952	+ }
		3953	+ }
		3954	+
		3955	+ // ----- Return
		3956	+ return $v_result;
		3957	+ }
		3958	+ // --------------------------------------------------------------------------------
		3959	+
		3960	+ // --------------------------------------------------------------------------------
		3961	+ // Function : privExtractFileUsingTempFile()
		3962	+ // Description :
		3963	+ // Parameters :
		3964	+ // Return Values :
		3965	+ // --------------------------------------------------------------------------------
		3966	+ function privExtractFileUsingTempFile(&$p_entry, &$p_options)
		3967	+ {
		3968	+ $v_result=1;
		3969	+
		3970	+ // ----- Creates a temporary file
		3971	+ $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
		3972	+ if (($v_dest_file = @fopen($v_gzip_temp_name, "wb")) == 0) {
		3973	+ fclose($v_file);
		3974	+ PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
		3975	+ return PclZip::errorCode();
		3976	+ }
		3977	+
		3978	+
		3979	+ // ----- Write gz file format header
		3980	+ $v_binary_data = pack('va1a1Va1a1', 0x8b1f, Chr($p_entry['compression']), Chr(0x00), time(), Chr(0x00), Chr(3));
		3981	+ @fwrite($v_dest_file, $v_binary_data, 10);
		3982	+
		3983	+ // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
		3984	+ $v_size = $p_entry['compressed_size'];
		3985	+ while ($v_size != 0)
		3986	+ {
		3987	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		3988	+ $v_buffer = @fread($this->zip_fd, $v_read_size);
		3989	+ //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
		3990	+ @fwrite($v_dest_file, $v_buffer, $v_read_size);
		3991	+ $v_size -= $v_read_size;
		3992	+ }
		3993	+
		3994	+ // ----- Write gz file format footer
		3995	+ $v_binary_data = pack('VV', $p_entry['crc'], $p_entry['size']);
		3996	+ @fwrite($v_dest_file, $v_binary_data, 8);
		3997	+
		3998	+ // ----- Close the temporary file
		3999	+ @fclose($v_dest_file);
		4000	+
		4001	+ // ----- Opening destination file
		4002	+ if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
		4003	+ $p_entry['status'] = "write_error";
		4004	+ return $v_result;
		4005	+ }
		4006	+
		4007	+ // ----- Open the temporary gz file
		4008	+ if (($v_src_file = @gzopen($v_gzip_temp_name, 'rb')) == 0) {
		4009	+ @fclose($v_dest_file);
		4010	+ $p_entry['status'] = "read_error";
		4011	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
		4012	+ return PclZip::errorCode();
		4013	+ }
		4014	+
		4015	+
		4016	+ // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
		4017	+ $v_size = $p_entry['size'];
		4018	+ while ($v_size != 0) {
		4019	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		4020	+ $v_buffer = @gzread($v_src_file, $v_read_size);
		4021	+ //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
		4022	+ @fwrite($v_dest_file, $v_buffer, $v_read_size);
		4023	+ $v_size -= $v_read_size;
		4024	+ }
		4025	+ @fclose($v_dest_file);
		4026	+ @gzclose($v_src_file);
		4027	+
		4028	+ // ----- Delete the temporary file
		4029	+ @unlink($v_gzip_temp_name);
		4030	+
		4031	+ // ----- Return
		4032	+ return $v_result;
		4033	+ }
		4034	+ // --------------------------------------------------------------------------------
		4035	+
		4036	+ // --------------------------------------------------------------------------------
		4037	+ // Function : privExtractFileInOutput()
		4038	+ // Description :
		4039	+ // Parameters :
		4040	+ // Return Values :
		4041	+ // --------------------------------------------------------------------------------
		4042	+ function privExtractFileInOutput(&$p_entry, &$p_options)
		4043	+ {
		4044	+ $v_result=1;
		4045	+
		4046	+ // ----- Read the file header
		4047	+ if (($v_result = $this->privReadFileHeader($v_header)) != 1) {
		4048	+ return $v_result;
		4049	+ }
		4050	+
		4051	+
		4052	+ // ----- Check that the file header is coherent with $p_entry info
		4053	+ if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
		4054	+ // TBC
		4055	+ }
		4056	+
		4057	+ // ----- Look for pre-extract callback
		4058	+ if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
		4059	+
		4060	+ // ----- Generate a local information
		4061	+ $v_local_header = array();
		4062	+ $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
		4063	+
		4064	+ // ----- Call the callback
		4065	+ // Here I do not use call_user_func() because I need to send a reference to the
		4066	+ // header.
		4067	+// eval('$v_result = '.$p_options[PCLZIP_CB_PRE_EXTRACT].'(PCLZIP_CB_PRE_EXTRACT, $v_local_header);');
		4068	+ $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
		4069	+ if ($v_result == 0) {
		4070	+ // ----- Change the file status
		4071	+ $p_entry['status'] = "skipped";
		4072	+ $v_result = 1;
		4073	+ }
		4074	+
		4075	+ // ----- Look for abort result
		4076	+ if ($v_result == 2) {
		4077	+ // ----- This status is internal and will be changed in 'skipped'
		4078	+ $p_entry['status'] = "aborted";
		4079	+ $v_result = PCLZIP_ERR_USER_ABORTED;
		4080	+ }
		4081	+
		4082	+ // ----- Update the informations
		4083	+ // Only some fields can be modified
		4084	+ $p_entry['filename'] = $v_local_header['filename'];
		4085	+ }
		4086	+
		4087	+ // ----- Trace
		4088	+
		4089	+ // ----- Look if extraction should be done
		4090	+ if ($p_entry['status'] == 'ok') {
		4091	+
		4092	+ // ----- Do the extraction (if not a folder)
		4093	+ if (!(($p_entry['external']&0x00000010)==0x00000010)) {
		4094	+ // ----- Look for not compressed file
		4095	+ if ($p_entry['compressed_size'] == $p_entry['size']) {
		4096	+
		4097	+ // ----- Read the file in a buffer (one shot)
		4098	+ $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
		4099	+
		4100	+ // ----- Send the file to the output
		4101	+ echo $v_buffer;
		4102	+ unset($v_buffer);
		4103	+ }
		4104	+ else {
		4105	+
		4106	+ // ----- Read the compressed file in a buffer (one shot)
		4107	+ $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
		4108	+
		4109	+ // ----- Decompress the file
		4110	+ $v_file_content = gzinflate($v_buffer);
		4111	+ unset($v_buffer);
		4112	+
		4113	+ // ----- Send the file to the output
		4114	+ echo $v_file_content;
		4115	+ unset($v_file_content);
		4116	+ }
		4117	+ }
		4118	+ }
		4119	+
		4120	+ // ----- Change abort status
		4121	+ if ($p_entry['status'] == "aborted") {
		4122	+ $p_entry['status'] = "skipped";
		4123	+ }
		4124	+
		4125	+ // ----- Look for post-extract callback
		4126	+ elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
		4127	+
		4128	+ // ----- Generate a local information
		4129	+ $v_local_header = array();
		4130	+ $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
		4131	+
		4132	+ // ----- Call the callback
		4133	+ // Here I do not use call_user_func() because I need to send a reference to the
		4134	+ // header.
		4135	+// eval('$v_result = '.$p_options[PCLZIP_CB_POST_EXTRACT].'(PCLZIP_CB_POST_EXTRACT, $v_local_header);');
		4136	+ $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
		4137	+
		4138	+ // ----- Look for abort result
		4139	+ if ($v_result == 2) {
		4140	+ $v_result = PCLZIP_ERR_USER_ABORTED;
		4141	+ }
		4142	+ }
		4143	+
		4144	+ return $v_result;
		4145	+ }
		4146	+ // --------------------------------------------------------------------------------
		4147	+
		4148	+ // --------------------------------------------------------------------------------
		4149	+ // Function : privExtractFileAsString()
		4150	+ // Description :
		4151	+ // Parameters :
		4152	+ // Return Values :
		4153	+ // --------------------------------------------------------------------------------
		4154	+ function privExtractFileAsString(&$p_entry, &$p_string, &$p_options)
		4155	+ {
		4156	+ $v_result=1;
		4157	+
		4158	+ // ----- Read the file header
		4159	+ $v_header = array();
		4160	+ if (($v_result = $this->privReadFileHeader($v_header)) != 1)
		4161	+ {
		4162	+ // ----- Return
		4163	+ return $v_result;
		4164	+ }
		4165	+
		4166	+
		4167	+ // ----- Check that the file header is coherent with $p_entry info
		4168	+ if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
		4169	+ // TBC
		4170	+ }
		4171	+
		4172	+ // ----- Look for pre-extract callback
		4173	+ if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
		4174	+
		4175	+ // ----- Generate a local information
		4176	+ $v_local_header = array();
		4177	+ $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
		4178	+
		4179	+ // ----- Call the callback
		4180	+ // Here I do not use call_user_func() because I need to send a reference to the
		4181	+ // header.
		4182	+// eval('$v_result = '.$p_options[PCLZIP_CB_PRE_EXTRACT].'(PCLZIP_CB_PRE_EXTRACT, $v_local_header);');
		4183	+ $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
		4184	+ if ($v_result == 0) {
		4185	+ // ----- Change the file status
		4186	+ $p_entry['status'] = "skipped";
		4187	+ $v_result = 1;
		4188	+ }
		4189	+
		4190	+ // ----- Look for abort result
		4191	+ if ($v_result == 2) {
		4192	+ // ----- This status is internal and will be changed in 'skipped'
		4193	+ $p_entry['status'] = "aborted";
		4194	+ $v_result = PCLZIP_ERR_USER_ABORTED;
		4195	+ }
		4196	+
		4197	+ // ----- Update the informations
		4198	+ // Only some fields can be modified
		4199	+ $p_entry['filename'] = $v_local_header['filename'];
		4200	+ }
		4201	+
		4202	+
		4203	+ // ----- Look if extraction should be done
		4204	+ if ($p_entry['status'] == 'ok') {
		4205	+
		4206	+ // ----- Do the extraction (if not a folder)
		4207	+ if (!(($p_entry['external']&0x00000010)==0x00000010)) {
		4208	+ // ----- Look for not compressed file
		4209	+ // if ($p_entry['compressed_size'] == $p_entry['size'])
		4210	+ if ($p_entry['compression'] == 0) {
		4211	+
		4212	+ // ----- Reading the file
		4213	+ $p_string = @fread($this->zip_fd, $p_entry['compressed_size']);
		4214	+ }
		4215	+ else {
		4216	+
		4217	+ // ----- Reading the file
		4218	+ $v_data = @fread($this->zip_fd, $p_entry['compressed_size']);
		4219	+
		4220	+ // ----- Decompress the file
		4221	+ if (($p_string = @gzinflate($v_data)) === FALSE) {
		4222	+ // TBC
		4223	+ }
		4224	+ }
		4225	+
		4226	+ // ----- Trace
		4227	+ }
		4228	+ else {
		4229	+ // TBC : error : can not extract a folder in a string
		4230	+ }
		4231	+
		4232	+ }
		4233	+
		4234	+ // ----- Change abort status
		4235	+ if ($p_entry['status'] == "aborted") {
		4236	+ $p_entry['status'] = "skipped";
		4237	+ }
		4238	+
		4239	+ // ----- Look for post-extract callback
		4240	+ elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
		4241	+
		4242	+ // ----- Generate a local information
		4243	+ $v_local_header = array();
		4244	+ $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
		4245	+
		4246	+ // ----- Swap the content to header
		4247	+ $v_local_header['content'] = $p_string;
		4248	+ $p_string = '';
		4249	+
		4250	+ // ----- Call the callback
		4251	+ // Here I do not use call_user_func() because I need to send a reference to the
		4252	+ // header.
		4253	+// eval('$v_result = '.$p_options[PCLZIP_CB_POST_EXTRACT].'(PCLZIP_CB_POST_EXTRACT, $v_local_header);');
		4254	+ $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
		4255	+
		4256	+ // ----- Swap back the content to header
		4257	+ $p_string = $v_local_header['content'];
		4258	+ unset($v_local_header['content']);
		4259	+
		4260	+ // ----- Look for abort result
		4261	+ if ($v_result == 2) {
		4262	+ $v_result = PCLZIP_ERR_USER_ABORTED;
		4263	+ }
		4264	+ }
		4265	+
		4266	+ // ----- Return
		4267	+ return $v_result;
		4268	+ }
		4269	+ // --------------------------------------------------------------------------------
		4270	+
		4271	+ // --------------------------------------------------------------------------------
		4272	+ // Function : privReadFileHeader()
		4273	+ // Description :
		4274	+ // Parameters :
		4275	+ // Return Values :
		4276	+ // --------------------------------------------------------------------------------
		4277	+ function privReadFileHeader(&$p_header)
		4278	+ {
		4279	+ $v_result=1;
		4280	+
		4281	+ // ----- Read the 4 bytes signature
		4282	+ $v_binary_data = @fread($this->zip_fd, 4);
		4283	+ $v_data = unpack('Vid', $v_binary_data);
		4284	+
		4285	+ // ----- Check signature
		4286	+ if ($v_data['id'] != 0x04034b50)
		4287	+ {
		4288	+
		4289	+ // ----- Error log
		4290	+ PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Invalid archive structure');
		4291	+
		4292	+ // ----- Return
		4293	+ return PclZip::errorCode();
		4294	+ }
		4295	+
		4296	+ // ----- Read the first 42 bytes of the header
		4297	+ $v_binary_data = fread($this->zip_fd, 26);
		4298	+
		4299	+ // ----- Look for invalid block size
		4300	+ if (strlen($v_binary_data) != 26)
		4301	+ {
		4302	+ $p_header['filename'] = "";
		4303	+ $p_header['status'] = "invalid_header";
		4304	+
		4305	+ // ----- Error log
		4306	+ PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : ".strlen($v_binary_data));
		4307	+
		4308	+ // ----- Return
		4309	+ return PclZip::errorCode();
		4310	+ }
		4311	+
		4312	+ // ----- Extract the values
		4313	+ $v_data = unpack('vversion/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len', $v_binary_data);
		4314	+
		4315	+ // ----- Get filename
		4316	+ $p_header['filename'] = fread($this->zip_fd, $v_data['filename_len']);
		4317	+
		4318	+ // ----- Get extra_fields
		4319	+ if ($v_data['extra_len'] != 0) {
		4320	+ $p_header['extra'] = fread($this->zip_fd, $v_data['extra_len']);
		4321	+ }
		4322	+ else {
		4323	+ $p_header['extra'] = '';
		4324	+ }
		4325	+
		4326	+ // ----- Extract properties
		4327	+ $p_header['version_extracted'] = $v_data['version'];
		4328	+ $p_header['compression'] = $v_data['compression'];
		4329	+ $p_header['size'] = $v_data['size'];
		4330	+ $p_header['compressed_size'] = $v_data['compressed_size'];
		4331	+ $p_header['crc'] = $v_data['crc'];
		4332	+ $p_header['flag'] = $v_data['flag'];
		4333	+ $p_header['filename_len'] = $v_data['filename_len'];
		4334	+
		4335	+ // ----- Recuperate date in UNIX format
		4336	+ $p_header['mdate'] = $v_data['mdate'];
		4337	+ $p_header['mtime'] = $v_data['mtime'];
		4338	+ if ($p_header['mdate'] && $p_header['mtime'])
		4339	+ {
		4340	+ // ----- Extract time
		4341	+ $v_hour = ($p_header['mtime'] & 0xF800) >> 11;
		4342	+ $v_minute = ($p_header['mtime'] & 0x07E0) >> 5;
		4343	+ $v_seconde = ($p_header['mtime'] & 0x001F)*2;
		4344	+
		4345	+ // ----- Extract date
		4346	+ $v_year = (($p_header['mdate'] & 0xFE00) >> 9) + 1980;
		4347	+ $v_month = ($p_header['mdate'] & 0x01E0) >> 5;
		4348	+ $v_day = $p_header['mdate'] & 0x001F;
		4349	+
		4350	+ // ----- Get UNIX date format
		4351	+ $p_header['mtime'] = @mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
		4352	+
		4353	+ }
		4354	+ else
		4355	+ {
		4356	+ $p_header['mtime'] = time();
		4357	+ }
		4358	+
		4359	+ // TBC
		4360	+ //for(reset($v_data); $key = key($v_data); next($v_data)) {
		4361	+ //}
		4362	+
		4363	+ // ----- Set the stored filename
		4364	+ $p_header['stored_filename'] = $p_header['filename'];
		4365	+
		4366	+ // ----- Set the status field
		4367	+ $p_header['status'] = "ok";
		4368	+
		4369	+ // ----- Return
		4370	+ return $v_result;
		4371	+ }
		4372	+ // --------------------------------------------------------------------------------
		4373	+
		4374	+ // --------------------------------------------------------------------------------
		4375	+ // Function : privReadCentralFileHeader()
		4376	+ // Description :
		4377	+ // Parameters :
		4378	+ // Return Values :
		4379	+ // --------------------------------------------------------------------------------
		4380	+ function privReadCentralFileHeader(&$p_header)
		4381	+ {
		4382	+ $v_result=1;
		4383	+
		4384	+ // ----- Read the 4 bytes signature
		4385	+ $v_binary_data = @fread($this->zip_fd, 4);
		4386	+ $v_data = unpack('Vid', $v_binary_data);
		4387	+
		4388	+ // ----- Check signature
		4389	+ if ($v_data['id'] != 0x02014b50)
		4390	+ {
		4391	+
		4392	+ // ----- Error log
		4393	+ PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Invalid archive structure');
		4394	+
		4395	+ // ----- Return
		4396	+ return PclZip::errorCode();
		4397	+ }
		4398	+
		4399	+ // ----- Read the first 42 bytes of the header
		4400	+ $v_binary_data = fread($this->zip_fd, 42);
		4401	+
		4402	+ // ----- Look for invalid block size
		4403	+ if (strlen($v_binary_data) != 42)
		4404	+ {
		4405	+ $p_header['filename'] = "";
		4406	+ $p_header['status'] = "invalid_header";
		4407	+
		4408	+ // ----- Error log
		4409	+ PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : ".strlen($v_binary_data));
		4410	+
		4411	+ // ----- Return
		4412	+ return PclZip::errorCode();
		4413	+ }
		4414	+
		4415	+ // ----- Extract the values
		4416	+ $p_header = unpack('vversion/vversion_extracted/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len/vcomment_len/vdisk/vinternal/Vexternal/Voffset', $v_binary_data);
		4417	+
		4418	+ // ----- Get filename
		4419	+ if ($p_header['filename_len'] != 0)
		4420	+ $p_header['filename'] = fread($this->zip_fd, $p_header['filename_len']);
		4421	+ else
		4422	+ $p_header['filename'] = '';
		4423	+
		4424	+ // ----- Get extra
		4425	+ if ($p_header['extra_len'] != 0)
		4426	+ $p_header['extra'] = fread($this->zip_fd, $p_header['extra_len']);
		4427	+ else
		4428	+ $p_header['extra'] = '';
		4429	+
		4430	+ // ----- Get comment
		4431	+ if ($p_header['comment_len'] != 0)
		4432	+ $p_header['comment'] = fread($this->zip_fd, $p_header['comment_len']);
		4433	+ else
		4434	+ $p_header['comment'] = '';
		4435	+
		4436	+ // ----- Extract properties
		4437	+
		4438	+ // ----- Recuperate date in UNIX format
		4439	+ //if ($p_header['mdate'] && $p_header['mtime'])
		4440	+ // TBC : bug : this was ignoring time with 0/0/0
		4441	+ if (1)
		4442	+ {
		4443	+ // ----- Extract time
		4444	+ $v_hour = ($p_header['mtime'] & 0xF800) >> 11;
		4445	+ $v_minute = ($p_header['mtime'] & 0x07E0) >> 5;
		4446	+ $v_seconde = ($p_header['mtime'] & 0x001F)*2;
		4447	+
		4448	+ // ----- Extract date
		4449	+ $v_year = (($p_header['mdate'] & 0xFE00) >> 9) + 1980;
		4450	+ $v_month = ($p_header['mdate'] & 0x01E0) >> 5;
		4451	+ $v_day = $p_header['mdate'] & 0x001F;
		4452	+
		4453	+ // ----- Get UNIX date format
		4454	+ $p_header['mtime'] = @mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
		4455	+
		4456	+ }
		4457	+ else
		4458	+ {
		4459	+ $p_header['mtime'] = time();
		4460	+ }
		4461	+
		4462	+ // ----- Set the stored filename
		4463	+ $p_header['stored_filename'] = $p_header['filename'];
		4464	+
		4465	+ // ----- Set default status to ok
		4466	+ $p_header['status'] = 'ok';
		4467	+
		4468	+ // ----- Look if it is a directory
		4469	+ if (substr($p_header['filename'], -1) == '/') {
		4470	+ //$p_header['external'] = 0x41FF0010;
		4471	+ $p_header['external'] = 0x00000010;
		4472	+ }
		4473	+
		4474	+
		4475	+ // ----- Return
		4476	+ return $v_result;
		4477	+ }
		4478	+ // --------------------------------------------------------------------------------
		4479	+
		4480	+ // --------------------------------------------------------------------------------
		4481	+ // Function : privCheckFileHeaders()
		4482	+ // Description :
		4483	+ // Parameters :
		4484	+ // Return Values :
		4485	+ // 1 on success,
		4486	+ // 0 on error;
		4487	+ // --------------------------------------------------------------------------------
		4488	+ function privCheckFileHeaders(&$p_local_header, &$p_central_header)
		4489	+ {
		4490	+ $v_result=1;
		4491	+
		4492	+ // ----- Check the static values
		4493	+ // TBC
		4494	+ if ($p_local_header['filename'] != $p_central_header['filename']) {
		4495	+ }
		4496	+ if ($p_local_header['version_extracted'] != $p_central_header['version_extracted']) {
		4497	+ }
		4498	+ if ($p_local_header['flag'] != $p_central_header['flag']) {
		4499	+ }
		4500	+ if ($p_local_header['compression'] != $p_central_header['compression']) {
		4501	+ }
		4502	+ if ($p_local_header['mtime'] != $p_central_header['mtime']) {
		4503	+ }
		4504	+ if ($p_local_header['filename_len'] != $p_central_header['filename_len']) {
		4505	+ }
		4506	+
		4507	+ // ----- Look for flag bit 3
		4508	+ if (($p_local_header['flag'] & 8) == 8) {
		4509	+ $p_local_header['size'] = $p_central_header['size'];
		4510	+ $p_local_header['compressed_size'] = $p_central_header['compressed_size'];
		4511	+ $p_local_header['crc'] = $p_central_header['crc'];
		4512	+ }
		4513	+
		4514	+ // ----- Return
		4515	+ return $v_result;
		4516	+ }
		4517	+ // --------------------------------------------------------------------------------
		4518	+
		4519	+ // --------------------------------------------------------------------------------
		4520	+ // Function : privReadEndCentralDir()
		4521	+ // Description :
		4522	+ // Parameters :
		4523	+ // Return Values :
		4524	+ // --------------------------------------------------------------------------------
		4525	+ function privReadEndCentralDir(&$p_central_dir)
		4526	+ {
		4527	+ $v_result=1;
		4528	+
		4529	+ // ----- Go to the end of the zip file
		4530	+ $v_size = filesize($this->zipname);
		4531	+ @fseek($this->zip_fd, $v_size);
		4532	+ if (@ftell($this->zip_fd) != $v_size)
		4533	+ {
		4534	+ // ----- Error log
		4535	+ PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to go to the end of the archive \''.$this->zipname.'\'');
		4536	+
		4537	+ // ----- Return
		4538	+ return PclZip::errorCode();
		4539	+ }
		4540	+
		4541	+ // ----- First try : look if this is an archive with no commentaries (most of the time)
		4542	+ // in this case the end of central dir is at 22 bytes of the file end
		4543	+ $v_found = 0;
		4544	+ if ($v_size > 26) {
		4545	+ @fseek($this->zip_fd, $v_size-22);
		4546	+ if (($v_pos = @ftell($this->zip_fd)) != ($v_size-22))
		4547	+ {
		4548	+ // ----- Error log
		4549	+ PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to seek back to the middle of the archive \''.$this->zipname.'\'');
		4550	+
		4551	+ // ----- Return
		4552	+ return PclZip::errorCode();
		4553	+ }
		4554	+
		4555	+ // ----- Read for bytes
		4556	+ $v_binary_data = @fread($this->zip_fd, 4);
		4557	+ $v_data = @unpack('Vid', $v_binary_data);
		4558	+
		4559	+ // ----- Check signature
		4560	+ if ($v_data['id'] == 0x06054b50) {
		4561	+ $v_found = 1;
		4562	+ }
		4563	+
		4564	+ $v_pos = ftell($this->zip_fd);
		4565	+ }
		4566	+
		4567	+ // ----- Go back to the maximum possible size of the Central Dir End Record
		4568	+ if (!$v_found) {
		4569	+ $v_maximum_size = 65557; // 0xFFFF + 22;
		4570	+ if ($v_maximum_size > $v_size)
		4571	+ $v_maximum_size = $v_size;
		4572	+ @fseek($this->zip_fd, $v_size-$v_maximum_size);
		4573	+ if (@ftell($this->zip_fd) != ($v_size-$v_maximum_size))
		4574	+ {
		4575	+ // ----- Error log
		4576	+ PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to seek back to the middle of the archive \''.$this->zipname.'\'');
		4577	+
		4578	+ // ----- Return
		4579	+ return PclZip::errorCode();
		4580	+ }
		4581	+
		4582	+ // ----- Read byte per byte in order to find the signature
		4583	+ $v_pos = ftell($this->zip_fd);
		4584	+ $v_bytes = 0x00000000;
		4585	+ while ($v_pos < $v_size)
		4586	+ {
		4587	+ // ----- Read a byte
		4588	+ $v_byte = @fread($this->zip_fd, 1);
		4589	+
		4590	+ // ----- Add the byte
		4591	+ //$v_bytes = ($v_bytes << 8) \| Ord($v_byte);
		4592	+ // Note we mask the old value down such that once shifted we can never end up with more than a 32bit number
		4593	+ // Otherwise on systems where we have 64bit integers the check below for the magic number will fail.
		4594	+ $v_bytes = ( ($v_bytes & 0xFFFFFF) << 8) \| Ord($v_byte);
		4595	+
		4596	+ // ----- Compare the bytes
		4597	+ if ($v_bytes == 0x504b0506)
		4598	+ {
		4599	+ $v_pos++;
		4600	+ break;
		4601	+ }
		4602	+
		4603	+ $v_pos++;
		4604	+ }
		4605	+
		4606	+ // ----- Look if not found end of central dir
		4607	+ if ($v_pos == $v_size)
		4608	+ {
		4609	+
		4610	+ // ----- Error log
		4611	+ PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Unable to find End of Central Dir Record signature");
		4612	+
		4613	+ // ----- Return
		4614	+ return PclZip::errorCode();
		4615	+ }
		4616	+ }
		4617	+
		4618	+ // ----- Read the first 18 bytes of the header
		4619	+ $v_binary_data = fread($this->zip_fd, 18);
		4620	+
		4621	+ // ----- Look for invalid block size
		4622	+ if (strlen($v_binary_data) != 18)
		4623	+ {
		4624	+
		4625	+ // ----- Error log
		4626	+ PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid End of Central Dir Record size : ".strlen($v_binary_data));
		4627	+
		4628	+ // ----- Return
		4629	+ return PclZip::errorCode();
		4630	+ }
		4631	+
		4632	+ // ----- Extract the values
		4633	+ $v_data = unpack('vdisk/vdisk_start/vdisk_entries/ventries/Vsize/Voffset/vcomment_size', $v_binary_data);
		4634	+
		4635	+ // ----- Check the global size
		4636	+ if (($v_pos + $v_data['comment_size'] + 18) != $v_size) {
		4637	+
		4638	+ // ----- Removed in release 2.2 see readme file
		4639	+ // The check of the file size is a little too strict.
		4640	+ // Some bugs where found when a zip is encrypted/decrypted with 'crypt'.
		4641	+ // While decrypted, zip has training 0 bytes
		4642	+ if (0) {
		4643	+ // ----- Error log
		4644	+ PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT,
		4645	+ 'The central dir is not at the end of the archive.'
		4646	+ .' Some trailing bytes exists after the archive.');
		4647	+
		4648	+ // ----- Return
		4649	+ return PclZip::errorCode();
		4650	+ }
		4651	+ }
		4652	+
		4653	+ // ----- Get comment
		4654	+ if ($v_data['comment_size'] != 0) {
		4655	+ $p_central_dir['comment'] = fread($this->zip_fd, $v_data['comment_size']);
		4656	+ }
		4657	+ else
		4658	+ $p_central_dir['comment'] = '';
		4659	+
		4660	+ $p_central_dir['entries'] = $v_data['entries'];
		4661	+ $p_central_dir['disk_entries'] = $v_data['disk_entries'];
		4662	+ $p_central_dir['offset'] = $v_data['offset'];
		4663	+ $p_central_dir['size'] = $v_data['size'];
		4664	+ $p_central_dir['disk'] = $v_data['disk'];
		4665	+ $p_central_dir['disk_start'] = $v_data['disk_start'];
		4666	+
		4667	+ // TBC
		4668	+ //for(reset($p_central_dir); $key = key($p_central_dir); next($p_central_dir)) {
		4669	+ //}
		4670	+
		4671	+ // ----- Return
		4672	+ return $v_result;
		4673	+ }
		4674	+ // --------------------------------------------------------------------------------
		4675	+
		4676	+ // --------------------------------------------------------------------------------
		4677	+ // Function : privDeleteByRule()
		4678	+ // Description :
		4679	+ // Parameters :
		4680	+ // Return Values :
		4681	+ // --------------------------------------------------------------------------------
		4682	+ function privDeleteByRule(&$p_result_list, &$p_options)
		4683	+ {
		4684	+ $v_result=1;
		4685	+ $v_list_detail = array();
		4686	+
		4687	+ // ----- Open the zip file
		4688	+ if (($v_result=$this->privOpenFd('rb')) != 1)
		4689	+ {
		4690	+ // ----- Return
		4691	+ return $v_result;
		4692	+ }
		4693	+
		4694	+ // ----- Read the central directory informations
		4695	+ $v_central_dir = array();
		4696	+ if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
		4697	+ {
		4698	+ $this->privCloseFd();
		4699	+ return $v_result;
		4700	+ }
		4701	+
		4702	+ // ----- Go to beginning of File
		4703	+ @rewind($this->zip_fd);
		4704	+
		4705	+ // ----- Scan all the files
		4706	+ // ----- Start at beginning of Central Dir
		4707	+ $v_pos_entry = $v_central_dir['offset'];
		4708	+ @rewind($this->zip_fd);
		4709	+ if (@fseek($this->zip_fd, $v_pos_entry))
		4710	+ {
		4711	+ // ----- Close the zip file
		4712	+ $this->privCloseFd();
		4713	+
		4714	+ // ----- Error log
		4715	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
		4716	+
		4717	+ // ----- Return
		4718	+ return PclZip::errorCode();
		4719	+ }
		4720	+
		4721	+ // ----- Read each entry
		4722	+ $v_header_list = array();
		4723	+ $j_start = 0;
		4724	+ for ($i=0, $v_nb_extracted=0; $i<$v_central_dir['entries']; $i++)
		4725	+ {
		4726	+
		4727	+ // ----- Read the file header
		4728	+ $v_header_list[$v_nb_extracted] = array();
		4729	+ if (($v_result = $this->privReadCentralFileHeader($v_header_list[$v_nb_extracted])) != 1)
		4730	+ {
		4731	+ // ----- Close the zip file
		4732	+ $this->privCloseFd();
		4733	+
		4734	+ return $v_result;
		4735	+ }
		4736	+
		4737	+
		4738	+ // ----- Store the index
		4739	+ $v_header_list[$v_nb_extracted]['index'] = $i;
		4740	+
		4741	+ // ----- Look for the specific extract rules
		4742	+ $v_found = false;
		4743	+
		4744	+ // ----- Look for extract by name rule
		4745	+ if ( (isset($p_options[PCLZIP_OPT_BY_NAME]))
		4746	+ && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
		4747	+
		4748	+ // ----- Look if the filename is in the list
		4749	+ for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_found); $j++) {
		4750	+
		4751	+ // ----- Look for a directory
		4752	+ if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
		4753	+
		4754	+ // ----- Look if the directory is in the filename path
		4755	+ if ( (strlen($v_header_list[$v_nb_extracted]['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
		4756	+ && (substr($v_header_list[$v_nb_extracted]['stored_filename'], 0, strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
		4757	+ $v_found = true;
		4758	+ }
		4759	+ elseif ( (($v_header_list[$v_nb_extracted]['external']&0x00000010)==0x00000010) /* Indicates a folder */
		4760	+ && ($v_header_list[$v_nb_extracted]['stored_filename'].'/' == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
		4761	+ $v_found = true;
		4762	+ }
		4763	+ }
		4764	+ // ----- Look for a filename
		4765	+ elseif ($v_header_list[$v_nb_extracted]['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
		4766	+ $v_found = true;
		4767	+ }
		4768	+ }
		4769	+ }
		4770	+
		4771	+ // ----- Look for extract by ereg rule
		4772	+ // ereg() is deprecated with PHP 5.3
		4773	+ /*
		4774	+ else if ( (isset($p_options[PCLZIP_OPT_BY_EREG]))
		4775	+ && ($p_options[PCLZIP_OPT_BY_EREG] != "")) {
		4776	+
		4777	+ if (ereg($p_options[PCLZIP_OPT_BY_EREG], $v_header_list[$v_nb_extracted]['stored_filename'])) {
		4778	+ $v_found = true;
		4779	+ }
		4780	+ }
		4781	+ */
		4782	+
		4783	+ // ----- Look for extract by preg rule
		4784	+ else if ( (isset($p_options[PCLZIP_OPT_BY_PREG]))
		4785	+ && ($p_options[PCLZIP_OPT_BY_PREG] != "")) {
		4786	+
		4787	+ if (preg_match($p_options[PCLZIP_OPT_BY_PREG], $v_header_list[$v_nb_extracted]['stored_filename'])) {
		4788	+ $v_found = true;
		4789	+ }
		4790	+ }
		4791	+
		4792	+ // ----- Look for extract by index rule
		4793	+ else if ( (isset($p_options[PCLZIP_OPT_BY_INDEX]))
		4794	+ && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
		4795	+
		4796	+ // ----- Look if the index is in the list
		4797	+ for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_found); $j++) {
		4798	+
		4799	+ if (($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i<=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
		4800	+ $v_found = true;
		4801	+ }
		4802	+ if ($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
		4803	+ $j_start = $j+1;
		4804	+ }
		4805	+
		4806	+ if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start']>$i) {
		4807	+ break;
		4808	+ }
		4809	+ }
		4810	+ }
		4811	+ else {
		4812	+ $v_found = true;
		4813	+ }
		4814	+
		4815	+ // ----- Look for deletion
		4816	+ if ($v_found)
		4817	+ {
		4818	+ unset($v_header_list[$v_nb_extracted]);
		4819	+ }
		4820	+ else
		4821	+ {
		4822	+ $v_nb_extracted++;
		4823	+ }
		4824	+ }
		4825	+
		4826	+ // ----- Look if something need to be deleted
		4827	+ if ($v_nb_extracted > 0) {
		4828	+
		4829	+ // ----- Creates a temporay file
		4830	+ $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
		4831	+
		4832	+ // ----- Creates a temporary zip archive
		4833	+ $v_temp_zip = new PclZip($v_zip_temp_name);
		4834	+
		4835	+ // ----- Open the temporary zip file in write mode
		4836	+ if (($v_result = $v_temp_zip->privOpenFd('wb')) != 1) {
		4837	+ $this->privCloseFd();
		4838	+
		4839	+ // ----- Return
		4840	+ return $v_result;
		4841	+ }
		4842	+
		4843	+ // ----- Look which file need to be kept
		4844	+ for ($i=0; $i<sizeof($v_header_list); $i++) {
		4845	+
		4846	+ // ----- Calculate the position of the header
		4847	+ @rewind($this->zip_fd);
		4848	+ if (@fseek($this->zip_fd, $v_header_list[$i]['offset'])) {
		4849	+ // ----- Close the zip file
		4850	+ $this->privCloseFd();
		4851	+ $v_temp_zip->privCloseFd();
		4852	+ @unlink($v_zip_temp_name);
		4853	+
		4854	+ // ----- Error log
		4855	+ PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
		4856	+
		4857	+ // ----- Return
		4858	+ return PclZip::errorCode();
		4859	+ }
		4860	+
		4861	+ // ----- Read the file header
		4862	+ $v_local_header = array();
		4863	+ if (($v_result = $this->privReadFileHeader($v_local_header)) != 1) {
		4864	+ // ----- Close the zip file
		4865	+ $this->privCloseFd();
		4866	+ $v_temp_zip->privCloseFd();
		4867	+ @unlink($v_zip_temp_name);
		4868	+
		4869	+ // ----- Return
		4870	+ return $v_result;
		4871	+ }
		4872	+
		4873	+ // ----- Check that local file header is same as central file header
		4874	+ if ($this->privCheckFileHeaders($v_local_header,
		4875	+ $v_header_list[$i]) != 1) {
		4876	+ // TBC
		4877	+ }
		4878	+ unset($v_local_header);
		4879	+
		4880	+ // ----- Write the file header
		4881	+ if (($v_result = $v_temp_zip->privWriteFileHeader($v_header_list[$i])) != 1) {
		4882	+ // ----- Close the zip file
		4883	+ $this->privCloseFd();
		4884	+ $v_temp_zip->privCloseFd();
		4885	+ @unlink($v_zip_temp_name);
		4886	+
		4887	+ // ----- Return
		4888	+ return $v_result;
		4889	+ }
		4890	+
		4891	+ // ----- Read/write the data block
		4892	+ if (($v_result = PclZipUtilCopyBlock($this->zip_fd, $v_temp_zip->zip_fd, $v_header_list[$i]['compressed_size'])) != 1) {
		4893	+ // ----- Close the zip file
		4894	+ $this->privCloseFd();
		4895	+ $v_temp_zip->privCloseFd();
		4896	+ @unlink($v_zip_temp_name);
		4897	+
		4898	+ // ----- Return
		4899	+ return $v_result;
		4900	+ }
		4901	+ }
		4902	+
		4903	+ // ----- Store the offset of the central dir
		4904	+ $v_offset = @ftell($v_temp_zip->zip_fd);
		4905	+
		4906	+ // ----- Re-Create the Central Dir files header
		4907	+ for ($i=0; $i<sizeof($v_header_list); $i++) {
		4908	+ // ----- Create the file header
		4909	+ if (($v_result = $v_temp_zip->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
		4910	+ $v_temp_zip->privCloseFd();
		4911	+ $this->privCloseFd();
		4912	+ @unlink($v_zip_temp_name);
		4913	+
		4914	+ // ----- Return
		4915	+ return $v_result;
		4916	+ }
		4917	+
		4918	+ // ----- Transform the header to a 'usable' info
		4919	+ $v_temp_zip->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
		4920	+ }
		4921	+
		4922	+
		4923	+ // ----- Zip file comment
		4924	+ $v_comment = '';
		4925	+ if (isset($p_options[PCLZIP_OPT_COMMENT])) {
		4926	+ $v_comment = $p_options[PCLZIP_OPT_COMMENT];
		4927	+ }
		4928	+
		4929	+ // ----- Calculate the size of the central header
		4930	+ $v_size = @ftell($v_temp_zip->zip_fd)-$v_offset;
		4931	+
		4932	+ // ----- Create the central dir footer
		4933	+ if (($v_result = $v_temp_zip->privWriteCentralHeader(sizeof($v_header_list), $v_size, $v_offset, $v_comment)) != 1) {
		4934	+ // ----- Reset the file list
		4935	+ unset($v_header_list);
		4936	+ $v_temp_zip->privCloseFd();
		4937	+ $this->privCloseFd();
		4938	+ @unlink($v_zip_temp_name);
		4939	+
		4940	+ // ----- Return
		4941	+ return $v_result;
		4942	+ }
		4943	+
		4944	+ // ----- Close
		4945	+ $v_temp_zip->privCloseFd();
		4946	+ $this->privCloseFd();
		4947	+
		4948	+ // ----- Delete the zip file
		4949	+ // TBC : I should test the result ...
		4950	+ @unlink($this->zipname);
		4951	+
		4952	+ // ----- Rename the temporary file
		4953	+ // TBC : I should test the result ...
		4954	+ //@rename($v_zip_temp_name, $this->zipname);
		4955	+ PclZipUtilRename($v_zip_temp_name, $this->zipname);
		4956	+
		4957	+ // ----- Destroy the temporary archive
		4958	+ unset($v_temp_zip);
		4959	+ }
		4960	+
		4961	+ // ----- Remove every files : reset the file
		4962	+ else if ($v_central_dir['entries'] != 0) {
		4963	+ $this->privCloseFd();
		4964	+
		4965	+ if (($v_result = $this->privOpenFd('wb')) != 1) {
		4966	+ return $v_result;
		4967	+ }
		4968	+
		4969	+ if (($v_result = $this->privWriteCentralHeader(0, 0, 0, '')) != 1) {
		4970	+ return $v_result;
		4971	+ }
		4972	+
		4973	+ $this->privCloseFd();
		4974	+ }
		4975	+
		4976	+ // ----- Return
		4977	+ return $v_result;
		4978	+ }
		4979	+ // --------------------------------------------------------------------------------
		4980	+
		4981	+ // --------------------------------------------------------------------------------
		4982	+ // Function : privDirCheck()
		4983	+ // Description :
		4984	+ // Check if a directory exists, if not it creates it and all the parents directory
		4985	+ // which may be useful.
		4986	+ // Parameters :
		4987	+ // $p_dir : Directory path to check.
		4988	+ // Return Values :
		4989	+ // 1 : OK
		4990	+ // -1 : Unable to create directory
		4991	+ // --------------------------------------------------------------------------------
		4992	+ function privDirCheck($p_dir, $p_is_dir=false)
		4993	+ {
		4994	+ $v_result = 1;
		4995	+
		4996	+
		4997	+ // ----- Remove the final '/'
		4998	+ if (($p_is_dir) && (substr($p_dir, -1)=='/'))
		4999	+ {
		5000	+ $p_dir = substr($p_dir, 0, strlen($p_dir)-1);
		5001	+ }
		5002	+
		5003	+ // ----- Check the directory availability
		5004	+ if ((is_dir($p_dir)) \|\| ($p_dir == ""))
		5005	+ {
		5006	+ return 1;
		5007	+ }
		5008	+
		5009	+ // ----- Extract parent directory
		5010	+ $p_parent_dir = dirname($p_dir);
		5011	+
		5012	+ // ----- Just a check
		5013	+ if ($p_parent_dir != $p_dir)
		5014	+ {
		5015	+ // ----- Look for parent directory
		5016	+ if ($p_parent_dir != "")
		5017	+ {
		5018	+ if (($v_result = $this->privDirCheck($p_parent_dir)) != 1)
		5019	+ {
		5020	+ return $v_result;
		5021	+ }
		5022	+ }
		5023	+ }
		5024	+
		5025	+ // ----- Create the directory
		5026	+ if (!@mkdir($p_dir, 0777))
		5027	+ {
		5028	+ // ----- Error log
		5029	+ PclZip::privErrorLog(PCLZIP_ERR_DIR_CREATE_FAIL, "Unable to create directory '$p_dir'");
		5030	+
		5031	+ // ----- Return
		5032	+ return PclZip::errorCode();
		5033	+ }
		5034	+
		5035	+ // ----- Return
		5036	+ return $v_result;
		5037	+ }
		5038	+ // --------------------------------------------------------------------------------
		5039	+
		5040	+ // --------------------------------------------------------------------------------
		5041	+ // Function : privMerge()
		5042	+ // Description :
		5043	+ // If $p_archive_to_add does not exist, the function exit with a success result.
		5044	+ // Parameters :
		5045	+ // Return Values :
		5046	+ // --------------------------------------------------------------------------------
		5047	+ function privMerge(&$p_archive_to_add)
		5048	+ {
		5049	+ $v_result=1;
		5050	+
		5051	+ // ----- Look if the archive_to_add exists
		5052	+ if (!is_file($p_archive_to_add->zipname))
		5053	+ {
		5054	+
		5055	+ // ----- Nothing to merge, so merge is a success
		5056	+ $v_result = 1;
		5057	+
		5058	+ // ----- Return
		5059	+ return $v_result;
		5060	+ }
		5061	+
		5062	+ // ----- Look if the archive exists
		5063	+ if (!is_file($this->zipname))
		5064	+ {
		5065	+
		5066	+ // ----- Do a duplicate
		5067	+ $v_result = $this->privDuplicate($p_archive_to_add->zipname);
		5068	+
		5069	+ // ----- Return
		5070	+ return $v_result;
		5071	+ }
		5072	+
		5073	+ // ----- Open the zip file
		5074	+ if (($v_result=$this->privOpenFd('rb')) != 1)
		5075	+ {
		5076	+ // ----- Return
		5077	+ return $v_result;
		5078	+ }
		5079	+
		5080	+ // ----- Read the central directory informations
		5081	+ $v_central_dir = array();
		5082	+ if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
		5083	+ {
		5084	+ $this->privCloseFd();
		5085	+ return $v_result;
		5086	+ }
		5087	+
		5088	+ // ----- Go to beginning of File
		5089	+ @rewind($this->zip_fd);
		5090	+
		5091	+ // ----- Open the archive_to_add file
		5092	+ if (($v_result=$p_archive_to_add->privOpenFd('rb')) != 1)
		5093	+ {
		5094	+ $this->privCloseFd();
		5095	+
		5096	+ // ----- Return
		5097	+ return $v_result;
		5098	+ }
		5099	+
		5100	+ // ----- Read the central directory informations
		5101	+ $v_central_dir_to_add = array();
		5102	+ if (($v_result = $p_archive_to_add->privReadEndCentralDir($v_central_dir_to_add)) != 1)
		5103	+ {
		5104	+ $this->privCloseFd();
		5105	+ $p_archive_to_add->privCloseFd();
		5106	+
		5107	+ return $v_result;
		5108	+ }
		5109	+
		5110	+ // ----- Go to beginning of File
		5111	+ @rewind($p_archive_to_add->zip_fd);
		5112	+
		5113	+ // ----- Creates a temporay file
		5114	+ $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
		5115	+
		5116	+ // ----- Open the temporary file in write mode
		5117	+ if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0)
		5118	+ {
		5119	+ $this->privCloseFd();
		5120	+ $p_archive_to_add->privCloseFd();
		5121	+
		5122	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_zip_temp_name.'\' in binary write mode');
		5123	+
		5124	+ // ----- Return
		5125	+ return PclZip::errorCode();
		5126	+ }
		5127	+
		5128	+ // ----- Copy the files from the archive to the temporary file
		5129	+ // TBC : Here I should better append the file and go back to erase the central dir
		5130	+ $v_size = $v_central_dir['offset'];
		5131	+ while ($v_size != 0)
		5132	+ {
		5133	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		5134	+ $v_buffer = fread($this->zip_fd, $v_read_size);
		5135	+ @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
		5136	+ $v_size -= $v_read_size;
		5137	+ }
		5138	+
		5139	+ // ----- Copy the files from the archive_to_add into the temporary file
		5140	+ $v_size = $v_central_dir_to_add['offset'];
		5141	+ while ($v_size != 0)
		5142	+ {
		5143	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		5144	+ $v_buffer = fread($p_archive_to_add->zip_fd, $v_read_size);
		5145	+ @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
		5146	+ $v_size -= $v_read_size;
		5147	+ }
		5148	+
		5149	+ // ----- Store the offset of the central dir
		5150	+ $v_offset = @ftell($v_zip_temp_fd);
		5151	+
		5152	+ // ----- Copy the block of file headers from the old archive
		5153	+ $v_size = $v_central_dir['size'];
		5154	+ while ($v_size != 0)
		5155	+ {
		5156	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		5157	+ $v_buffer = @fread($this->zip_fd, $v_read_size);
		5158	+ @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
		5159	+ $v_size -= $v_read_size;
		5160	+ }
		5161	+
		5162	+ // ----- Copy the block of file headers from the archive_to_add
		5163	+ $v_size = $v_central_dir_to_add['size'];
		5164	+ while ($v_size != 0)
		5165	+ {
		5166	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		5167	+ $v_buffer = @fread($p_archive_to_add->zip_fd, $v_read_size);
		5168	+ @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
		5169	+ $v_size -= $v_read_size;
		5170	+ }
		5171	+
		5172	+ // ----- Merge the file comments
		5173	+ $v_comment = $v_central_dir['comment'].' '.$v_central_dir_to_add['comment'];
		5174	+
		5175	+ // ----- Calculate the size of the (new) central header
		5176	+ $v_size = @ftell($v_zip_temp_fd)-$v_offset;
		5177	+
		5178	+ // ----- Swap the file descriptor
		5179	+ // Here is a trick : I swap the temporary fd with the zip fd, in order to use
		5180	+ // the following methods on the temporary fil and not the real archive fd
		5181	+ $v_swap = $this->zip_fd;
		5182	+ $this->zip_fd = $v_zip_temp_fd;
		5183	+ $v_zip_temp_fd = $v_swap;
		5184	+
		5185	+ // ----- Create the central dir footer
		5186	+ if (($v_result = $this->privWriteCentralHeader($v_central_dir['entries']+$v_central_dir_to_add['entries'], $v_size, $v_offset, $v_comment)) != 1)
		5187	+ {
		5188	+ $this->privCloseFd();
		5189	+ $p_archive_to_add->privCloseFd();
		5190	+ @fclose($v_zip_temp_fd);
		5191	+ $this->zip_fd = null;
		5192	+
		5193	+ // ----- Reset the file list
		5194	+ unset($v_header_list);
		5195	+
		5196	+ // ----- Return
		5197	+ return $v_result;
		5198	+ }
		5199	+
		5200	+ // ----- Swap back the file descriptor
		5201	+ $v_swap = $this->zip_fd;
		5202	+ $this->zip_fd = $v_zip_temp_fd;
		5203	+ $v_zip_temp_fd = $v_swap;
		5204	+
		5205	+ // ----- Close
		5206	+ $this->privCloseFd();
		5207	+ $p_archive_to_add->privCloseFd();
		5208	+
		5209	+ // ----- Close the temporary file
		5210	+ @fclose($v_zip_temp_fd);
		5211	+
		5212	+ // ----- Delete the zip file
		5213	+ // TBC : I should test the result ...
		5214	+ @unlink($this->zipname);
		5215	+
		5216	+ // ----- Rename the temporary file
		5217	+ // TBC : I should test the result ...
		5218	+ //@rename($v_zip_temp_name, $this->zipname);
		5219	+ PclZipUtilRename($v_zip_temp_name, $this->zipname);
		5220	+
		5221	+ // ----- Return
		5222	+ return $v_result;
		5223	+ }
		5224	+ // --------------------------------------------------------------------------------
		5225	+
		5226	+ // --------------------------------------------------------------------------------
		5227	+ // Function : privDuplicate()
		5228	+ // Description :
		5229	+ // Parameters :
		5230	+ // Return Values :
		5231	+ // --------------------------------------------------------------------------------
		5232	+ function privDuplicate($p_archive_filename)
		5233	+ {
		5234	+ $v_result=1;
		5235	+
		5236	+ // ----- Look if the $p_archive_filename exists
		5237	+ if (!is_file($p_archive_filename))
		5238	+ {
		5239	+
		5240	+ // ----- Nothing to duplicate, so duplicate is a success.
		5241	+ $v_result = 1;
		5242	+
		5243	+ // ----- Return
		5244	+ return $v_result;
		5245	+ }
		5246	+
		5247	+ // ----- Open the zip file
		5248	+ if (($v_result=$this->privOpenFd('wb')) != 1)
		5249	+ {
		5250	+ // ----- Return
		5251	+ return $v_result;
		5252	+ }
		5253	+
		5254	+ // ----- Open the temporary file in write mode
		5255	+ if (($v_zip_temp_fd = @fopen($p_archive_filename, 'rb')) == 0)
		5256	+ {
		5257	+ $this->privCloseFd();
		5258	+
		5259	+ PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive file \''.$p_archive_filename.'\' in binary write mode');
		5260	+
		5261	+ // ----- Return
		5262	+ return PclZip::errorCode();
		5263	+ }
		5264	+
		5265	+ // ----- Copy the files from the archive to the temporary file
		5266	+ // TBC : Here I should better append the file and go back to erase the central dir
		5267	+ $v_size = filesize($p_archive_filename);
		5268	+ while ($v_size != 0)
		5269	+ {
		5270	+ $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
		5271	+ $v_buffer = fread($v_zip_temp_fd, $v_read_size);
		5272	+ @fwrite($this->zip_fd, $v_buffer, $v_read_size);
		5273	+ $v_size -= $v_read_size;
		5274	+ }
		5275	+
		5276	+ // ----- Close
		5277	+ $this->privCloseFd();
		5278	+
		5279	+ // ----- Close the temporary file
		5280	+ @fclose($v_zip_temp_fd);
		5281	+
		5282	+ // ----- Return
		5283	+ return $v_result;
		5284	+ }
		5285	+ // --------------------------------------------------------------------------------
		5286	+
		5287	+ // --------------------------------------------------------------------------------
		5288	+ // Function : privErrorLog()
		5289	+ // Description :
		5290	+ // Parameters :
		5291	+ // --------------------------------------------------------------------------------
		5292	+ function privErrorLog($p_error_code=0, $p_error_string='')
		5293	+ {
		5294	+ if (PCLZIP_ERROR_EXTERNAL == 1) {
		5295	+ PclError($p_error_code, $p_error_string);
		5296	+ }
		5297	+ else {
		5298	+ $this->error_code = $p_error_code;
		5299	+ $this->error_string = $p_error_string;
		5300	+ }
		5301	+ }
		5302	+ // --------------------------------------------------------------------------------
		5303	+
		5304	+ // --------------------------------------------------------------------------------
		5305	+ // Function : privErrorReset()
		5306	+ // Description :
		5307	+ // Parameters :
		5308	+ // --------------------------------------------------------------------------------
		5309	+ function privErrorReset()
		5310	+ {
		5311	+ if (PCLZIP_ERROR_EXTERNAL == 1) {
		5312	+ PclErrorReset();
		5313	+ }
		5314	+ else {
		5315	+ $this->error_code = 0;
		5316	+ $this->error_string = '';
		5317	+ }
		5318	+ }
		5319	+ // --------------------------------------------------------------------------------
		5320	+
		5321	+ // --------------------------------------------------------------------------------
		5322	+ // Function : privDisableMagicQuotes()
		5323	+ // Description :
		5324	+ // Parameters :
		5325	+ // Return Values :
		5326	+ // --------------------------------------------------------------------------------
		5327	+ function privDisableMagicQuotes()
		5328	+ {
		5329	+ $v_result=1;
		5330	+
		5331	+ // ----- Look if function exists
		5332	+ if ( (!function_exists("get_magic_quotes_runtime"))
		5333	+ \|\| (!function_exists("set_magic_quotes_runtime"))) {
		5334	+ return $v_result;
		5335	+ }
		5336	+
		5337	+ // ----- Look if already done
		5338	+ if ($this->magic_quotes_status != -1) {
		5339	+ return $v_result;
		5340	+ }
		5341	+
		5342	+ // ----- Get and memorize the magic_quote value
		5343	+ $this->magic_quotes_status = @get_magic_quotes_runtime();
		5344	+
		5345	+ // ----- Disable magic_quotes
		5346	+ if ($this->magic_quotes_status == 1) {
		5347	+ @set_magic_quotes_runtime(0);
		5348	+ }
		5349	+
		5350	+ // ----- Return
		5351	+ return $v_result;
		5352	+ }
		5353	+ // --------------------------------------------------------------------------------
		5354	+
		5355	+ // --------------------------------------------------------------------------------
		5356	+ // Function : privSwapBackMagicQuotes()
		5357	+ // Description :
		5358	+ // Parameters :
		5359	+ // Return Values :
		5360	+ // --------------------------------------------------------------------------------
		5361	+ function privSwapBackMagicQuotes()
		5362	+ {
		5363	+ $v_result=1;
		5364	+
		5365	+ // ----- Look if function exists
		5366	+ if ( (!function_exists("get_magic_quotes_runtime"))
		5367	+ \|\| (!function_exists("set_magic_quotes_runtime"))) {
		5368	+ return $v_result;
		5369	+ }
		5370	+
		5371	+ // ----- Look if something to do
		5372	+ if ($this->magic_quotes_status != -1) {
		5373	+ return $v_result;
		5374	+ }
		5375	+
		5376	+ // ----- Swap back magic_quotes
		5377	+ if ($this->magic_quotes_status == 1) {
		5378	+ @set_magic_quotes_runtime($this->magic_quotes_status);
		5379	+ }
		5380	+
		5381	+ // ----- Return
		5382	+ return $v_result;
		5383	+ }
		5384	+ // --------------------------------------------------------------------------------
		5385	+
		5386	+ }
		5387	+ // End of class
		5388	+ // --------------------------------------------------------------------------------
		5389	+
		5390	+ // --------------------------------------------------------------------------------
		5391	+ // Function : PclZipUtilPathReduction()
		5392	+ // Description :
		5393	+ // Parameters :
		5394	+ // Return Values :
		5395	+ // --------------------------------------------------------------------------------
		5396	+ function PclZipUtilPathReduction($p_dir)
		5397	+ {
		5398	+ $v_result = "";
		5399	+
		5400	+ // ----- Look for not empty path
		5401	+ if ($p_dir != "") {
		5402	+ // ----- Explode path by directory names
		5403	+ $v_list = explode("/", $p_dir);
		5404	+
		5405	+ // ----- Study directories from last to first
		5406	+ $v_skip = 0;
		5407	+ for ($i=sizeof($v_list)-1; $i>=0; $i--) {
		5408	+ // ----- Look for current path
		5409	+ if ($v_list[$i] == ".") {
		5410	+ // ----- Ignore this directory
		5411	+ // Should be the first $i=0, but no check is done
		5412	+ }
		5413	+ else if ($v_list[$i] == "..") {
		5414	+ $v_skip++;
		5415	+ }
		5416	+ else if ($v_list[$i] == "") {
		5417	+ // ----- First '/' i.e. root slash
		5418	+ if ($i == 0) {
		5419	+ $v_result = "/".$v_result;
		5420	+ if ($v_skip > 0) {
		5421	+ // ----- It is an invalid path, so the path is not modified
		5422	+ // TBC
		5423	+ $v_result = $p_dir;
		5424	+ $v_skip = 0;
		5425	+ }
		5426	+ }
		5427	+ // ----- Last '/' i.e. indicates a directory
		5428	+ else if ($i == (sizeof($v_list)-1)) {
		5429	+ $v_result = $v_list[$i];
		5430	+ }
		5431	+ // ----- Double '/' inside the path
		5432	+ else {
		5433	+ // ----- Ignore only the double '//' in path,
		5434	+ // but not the first and last '/'
		5435	+ }
		5436	+ }
		5437	+ else {
		5438	+ // ----- Look for item to skip
		5439	+ if ($v_skip > 0) {
		5440	+ $v_skip--;
		5441	+ }
		5442	+ else {
		5443	+ $v_result = $v_list[$i].($i!=(sizeof($v_list)-1)?"/".$v_result:"");
		5444	+ }
		5445	+ }
		5446	+ }
		5447	+
		5448	+ // ----- Look for skip
		5449	+ if ($v_skip > 0) {
		5450	+ while ($v_skip > 0) {
		5451	+ $v_result = '../'.$v_result;
		5452	+ $v_skip--;
		5453	+ }
		5454	+ }
		5455	+ }
		5456	+
		5457	+ // ----- Return
		5458	+ return $v_result;
		5459	+ }
		5460	+ // --------------------------------------------------------------------------------
		5461	+
		5462	+ // --------------------------------------------------------------------------------
		5463	+ // Function : PclZipUtilPathInclusion()
		5464	+ // Description :
		5465	+ // This function indicates if the path $p_path is under the $p_dir tree. Or,
		5466	+ // said in an other way, if the file or sub-dir $p_path is inside the dir
		5467	+ // $p_dir.
		5468	+ // The function indicates also if the path is exactly the same as the dir.
		5469	+ // This function supports path with duplicated '/' like '//', but does not
		5470	+ // support '.' or '..' statements.
		5471	+ // Parameters :
		5472	+ // Return Values :
		5473	+ // 0 if $p_path is not inside directory $p_dir
		5474	+ // 1 if $p_path is inside directory $p_dir
		5475	+ // 2 if $p_path is exactly the same as $p_dir
		5476	+ // --------------------------------------------------------------------------------
		5477	+ function PclZipUtilPathInclusion($p_dir, $p_path)
		5478	+ {
		5479	+ $v_result = 1;
		5480	+
		5481	+ // ----- Look for path beginning by ./
		5482	+ if ( ($p_dir == '.')
		5483	+ \|\| ((strlen($p_dir) >=2) && (substr($p_dir, 0, 2) == './'))) {
		5484	+ $p_dir = PclZipUtilTranslateWinPath(getcwd(), FALSE).'/'.substr($p_dir, 1);
		5485	+ }
		5486	+ if ( ($p_path == '.')
		5487	+ \|\| ((strlen($p_path) >=2) && (substr($p_path, 0, 2) == './'))) {
		5488	+ $p_path = PclZipUtilTranslateWinPath(getcwd(), FALSE).'/'.substr($p_path, 1);
		5489	+ }
		5490	+
		5491	+ // ----- Explode dir and path by directory separator
		5492	+ $v_list_dir = explode("/", $p_dir);
		5493	+ $v_list_dir_size = sizeof($v_list_dir);
		5494	+ $v_list_path = explode("/", $p_path);
		5495	+ $v_list_path_size = sizeof($v_list_path);
		5496	+
		5497	+ // ----- Study directories paths
		5498	+ $i = 0;
		5499	+ $j = 0;
		5500	+ while (($i < $v_list_dir_size) && ($j < $v_list_path_size) && ($v_result)) {
		5501	+
		5502	+ // ----- Look for empty dir (path reduction)
		5503	+ if ($v_list_dir[$i] == '') {
		5504	+ $i++;
		5505	+ continue;
		5506	+ }
		5507	+ if ($v_list_path[$j] == '') {
		5508	+ $j++;
		5509	+ continue;
		5510	+ }
		5511	+
		5512	+ // ----- Compare the items
		5513	+ if (($v_list_dir[$i] != $v_list_path[$j]) && ($v_list_dir[$i] != '') && ( $v_list_path[$j] != '')) {
		5514	+ $v_result = 0;
		5515	+ }
		5516	+
		5517	+ // ----- Next items
		5518	+ $i++;
		5519	+ $j++;
		5520	+ }
		5521	+
		5522	+ // ----- Look if everything seems to be the same
		5523	+ if ($v_result) {
		5524	+ // ----- Skip all the empty items
		5525	+ while (($j < $v_list_path_size) && ($v_list_path[$j] == '')) $j++;
		5526	+ while (($i < $v_list_dir_size) && ($v_list_dir[$i] == '')) $i++;
		5527	+
		5528	+ if (($i >= $v_list_dir_size) && ($j >= $v_list_path_size)) {
		5529	+ // ----- There are exactly the same
		5530	+ $v_result = 2;
		5531	+ }
		5532	+ else if ($i < $v_list_dir_size) {
		5533	+ // ----- The path is shorter than the dir
		5534	+ $v_result = 0;
		5535	+ }
		5536	+ }
		5537	+
		5538	+ // ----- Return
		5539	+ return $v_result;
		5540	+ }
		5541	+ // --------------------------------------------------------------------------------
		5542	+
		5543	+ // --------------------------------------------------------------------------------
		5544	+ // Function : PclZipUtilCopyBlock()
		5545	+ // Description :
		5546	+ // Parameters :
		5547	+ // $p_mode : read/write compression mode
		5548	+ // 0 : src & dest normal
		5549	+ // 1 : src gzip, dest normal
		5550	+ // 2 : src normal, dest gzip
		5551	+ // 3 : src & dest gzip
		5552	+ // Return Values :
		5553	+ // --------------------------------------------------------------------------------
		5554	+ function PclZipUtilCopyBlock($p_src, $p_dest, $p_size, $p_mode=0)
		5555	+ {
		5556	+ $v_result = 1;
		5557	+
		5558	+ if ($p_mode==0)
		5559	+ {
		5560	+ while ($p_size != 0)
		5561	+ {
		5562	+ $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
		5563	+ $v_buffer = @fread($p_src, $v_read_size);
		5564	+ @fwrite($p_dest, $v_buffer, $v_read_size);
		5565	+ $p_size -= $v_read_size;
		5566	+ }
		5567	+ }
		5568	+ else if ($p_mode==1)
		5569	+ {
		5570	+ while ($p_size != 0)
		5571	+ {
		5572	+ $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
		5573	+ $v_buffer = @gzread($p_src, $v_read_size);
		5574	+ @fwrite($p_dest, $v_buffer, $v_read_size);
		5575	+ $p_size -= $v_read_size;
		5576	+ }
		5577	+ }
		5578	+ else if ($p_mode==2)
		5579	+ {
		5580	+ while ($p_size != 0)
		5581	+ {
		5582	+ $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
		5583	+ $v_buffer = @fread($p_src, $v_read_size);
		5584	+ @gzwrite($p_dest, $v_buffer, $v_read_size);
		5585	+ $p_size -= $v_read_size;
		5586	+ }
		5587	+ }
		5588	+ else if ($p_mode==3)
		5589	+ {
		5590	+ while ($p_size != 0)
		5591	+ {
		5592	+ $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
		5593	+ $v_buffer = @gzread($p_src, $v_read_size);
		5594	+ @gzwrite($p_dest, $v_buffer, $v_read_size);
		5595	+ $p_size -= $v_read_size;
		5596	+ }
		5597	+ }
		5598	+
		5599	+ // ----- Return
		5600	+ return $v_result;
		5601	+ }
		5602	+ // --------------------------------------------------------------------------------
		5603	+
		5604	+ // --------------------------------------------------------------------------------
		5605	+ // Function : PclZipUtilRename()
		5606	+ // Description :
		5607	+ // This function tries to do a simple rename() function. If it fails, it
		5608	+ // tries to copy the $p_src file in a new $p_dest file and then unlink the
		5609	+ // first one.
		5610	+ // Parameters :
		5611	+ // $p_src : Old filename
		5612	+ // $p_dest : New filename
		5613	+ // Return Values :
		5614	+ // 1 on success, 0 on failure.
		5615	+ // --------------------------------------------------------------------------------
		5616	+ function PclZipUtilRename($p_src, $p_dest)
		5617	+ {
		5618	+ $v_result = 1;
		5619	+
		5620	+ // ----- Try to rename the files
		5621	+ if (!@rename($p_src, $p_dest)) {
		5622	+
		5623	+ // ----- Try to copy & unlink the src
		5624	+ if (!@copy($p_src, $p_dest)) {
		5625	+ $v_result = 0;
		5626	+ }
		5627	+ else if (!@unlink($p_src)) {
		5628	+ $v_result = 0;
		5629	+ }
		5630	+ }
		5631	+
		5632	+ // ----- Return
		5633	+ return $v_result;
		5634	+ }
		5635	+ // --------------------------------------------------------------------------------
		5636	+
		5637	+ // --------------------------------------------------------------------------------
		5638	+ // Function : PclZipUtilOptionText()
		5639	+ // Description :
		5640	+ // Translate option value in text. Mainly for debug purpose.
		5641	+ // Parameters :
		5642	+ // $p_option : the option value.
		5643	+ // Return Values :
		5644	+ // The option text value.
		5645	+ // --------------------------------------------------------------------------------
		5646	+ function PclZipUtilOptionText($p_option)
		5647	+ {
		5648	+
		5649	+ $v_list = get_defined_constants();
		5650	+ for (reset($v_list); $v_key = key($v_list); next($v_list)) {
		5651	+ $v_prefix = substr($v_key, 0, 10);
		5652	+ if (( ($v_prefix == 'PCLZIP_OPT')
		5653	+ \|\| ($v_prefix == 'PCLZIP_CB_')
		5654	+ \|\| ($v_prefix == 'PCLZIP_ATT'))
		5655	+ && ($v_list[$v_key] == $p_option)) {
		5656	+ return $v_key;
		5657	+ }
		5658	+ }
		5659	+
		5660	+ $v_result = 'Unknown';
		5661	+
		5662	+ return $v_result;
		5663	+ }
		5664	+ // --------------------------------------------------------------------------------
		5665	+
		5666	+ // --------------------------------------------------------------------------------
		5667	+ // Function : PclZipUtilTranslateWinPath()
		5668	+ // Description :
		5669	+ // Translate windows path by replacing '\' by '/' and optionally removing
		5670	+ // drive letter.
		5671	+ // Parameters :
		5672	+ // $p_path : path to translate.
		5673	+ // $p_remove_disk_letter : true \| false
		5674	+ // Return Values :
		5675	+ // The path translated.
		5676	+ // --------------------------------------------------------------------------------
		5677	+ function PclZipUtilTranslateWinPath($p_path, $p_remove_disk_letter=true)
		5678	+ {
		5679	+ if (stristr(php_uname(), 'windows')) {
		5680	+ // ----- Look for potential disk letter
		5681	+ if (($p_remove_disk_letter) && (($v_position = strpos($p_path, ':')) != false)) {
		5682	+ $p_path = substr($p_path, $v_position+1);
		5683	+ }
		5684	+ // ----- Change potential windows directory separator
		5685	+ if ((strpos($p_path, '\\') > 0) \|\| (substr($p_path, 0,1) == '\\')) {
		5686	+ $p_path = strtr($p_path, '\\', '/');
		5687	+ }
		5688	+ }
		5689	+ return $p_path;
		5690	+ }
		5691	+ // --------------------------------------------------------------------------------
		5692	+
		5693	+
		5694	+?>