Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

pclzip.lib.php @ 31941

Last change on this file since 31941 was 4829, checked in by plg, 14 years ago

feature 1408 added: upload a zip archive containing photos, needs more tests
(on windows operating system) but "yeah it already rocks" :-)

pclzip 2.8.2 included because the low memory usage features is missing from
pclzip 2.8.1 included in Piwigo core.

File size: 198.1 KB

Line
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	?>

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: extensions/upload_form/include/pclzip.lib.php @ 31941

Download in other formats: