1: <?php
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29: if (!defined('PCLZIP_READ_BLOCK_SIZE')) {
30: define( 'PCLZIP_READ_BLOCK_SIZE', 2048 );
31: }
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43: if (!defined('PCLZIP_SEPARATOR')) {
44: define( 'PCLZIP_SEPARATOR', ',' );
45: }
46:
47:
48:
49:
50:
51:
52: if (!defined('PCLZIP_ERROR_EXTERNAL')) {
53: define( 'PCLZIP_ERROR_EXTERNAL', 0 );
54: }
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65: if (!defined('PCLZIP_TEMPORARY_DIR')) {
66: define( 'PCLZIP_TEMPORARY_DIR', '' );
67: }
68:
69:
70:
71:
72:
73:
74:
75:
76:
77: if (!defined('PCLZIP_TEMPORARY_FILE_RATIO')) {
78: define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.47 );
79: }
80:
81:
82:
83:
84:
85:
86: $g_pclzip_version = "2.8.2";
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
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:
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:
146:
147:
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 );
151: define( 'PCLZIP_OPT_TEMP_FILE_ON', 77021 );
152: define( 'PCLZIP_OPT_ADD_TEMP_FILE_ON', 77021 );
153: define( 'PCLZIP_OPT_TEMP_FILE_OFF', 77022 );
154: define( 'PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022 );
155:
156:
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:
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: 170: 171: 172: 173: 174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190: class PclZip
191: {
192:
193: var $zipname = '';
194:
195:
196: var $zip_fd = 0;
197:
198:
199: var $error_code = 1;
200: var $error_string = '';
201:
202:
203:
204:
205: var $magic_quotes_status;
206:
207:
208:
209:
210:
211:
212:
213:
214:
215: function PclZip($p_zipname)
216: {
217:
218:
219: if (!function_exists('gzopen'))
220: {
221: die('Abort '.basename(__FILE__).' : Missing zlib extensions');
222: }
223:
224:
225: $this->zipname = $p_zipname;
226: $this->zip_fd = 0;
227: $this->magic_quotes_status = -1;
228:
229:
230: return;
231: }
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271: function create($p_filelist)
272: {
273: $v_result=1;
274:
275:
276: $this->privErrorReset();
277:
278:
279: $v_options = array();
280: $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
281:
282:
283: $v_size = func_num_args();
284:
285:
286: if ($v_size > 1) {
287:
288: $v_arg_list = func_get_args();
289:
290:
291: array_shift($v_arg_list);
292: $v_size--;
293:
294:
295: if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
296:
297:
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:
310: ));
311: if ($v_result != 1) {
312: return 0;
313: }
314: }
315:
316:
317:
318:
319: else {
320:
321:
322: $v_options[PCLZIP_OPT_ADD_PATH] = $v_arg_list[0];
323:
324:
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:
337: $this->privOptionDefaultThreshold($v_options);
338:
339:
340: $v_string_list = array();
341: $v_att_list = array();
342: $v_filedescr_list = array();
343: $p_result_list = array();
344:
345:
346: if (is_array($p_filelist)) {
347:
348:
349:
350: if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
351: $v_att_list = $p_filelist;
352: }
353:
354:
355: else {
356: $v_string_list = $p_filelist;
357: }
358: }
359:
360:
361: else if (is_string($p_filelist)) {
362:
363: $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
364: }
365:
366:
367: else {
368: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_filelist");
369: return 0;
370: }
371:
372:
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:
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:
403: $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
404: if ($v_result != 1) {
405: return 0;
406: }
407:
408:
409: $v_result = $this->privCreate($v_filedescr_list, $p_result_list, $v_options);
410: if ($v_result != 1) {
411: return 0;
412: }
413:
414:
415: return $p_result_list;
416: }
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454: function add($p_filelist)
455: {
456: $v_result=1;
457:
458:
459: $this->privErrorReset();
460:
461:
462: $v_options = array();
463: $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
464:
465:
466: $v_size = func_num_args();
467:
468:
469: if ($v_size > 1) {
470:
471: $v_arg_list = func_get_args();
472:
473:
474: array_shift($v_arg_list);
475: $v_size--;
476:
477:
478: if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
479:
480:
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:
495: ));
496: if ($v_result != 1) {
497: return 0;
498: }
499: }
500:
501:
502:
503:
504: else {
505:
506:
507: $v_options[PCLZIP_OPT_ADD_PATH] = $v_add_path = $v_arg_list[0];
508:
509:
510: if ($v_size == 2) {
511: $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
512: }
513: else if ($v_size > 2) {
514:
515: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
516:
517:
518: return 0;
519: }
520: }
521: }
522:
523:
524: $this->privOptionDefaultThreshold($v_options);
525:
526:
527: $v_string_list = array();
528: $v_att_list = array();
529: $v_filedescr_list = array();
530: $p_result_list = array();
531:
532:
533: if (is_array($p_filelist)) {
534:
535:
536:
537: if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
538: $v_att_list = $p_filelist;
539: }
540:
541:
542: else {
543: $v_string_list = $p_filelist;
544: }
545: }
546:
547:
548: else if (is_string($p_filelist)) {
549:
550: $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
551: }
552:
553:
554: else {
555: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type '".gettype($p_filelist)."' for p_filelist");
556: return 0;
557: }
558:
559:
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:
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:
586: $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
587: if ($v_result != 1) {
588: return 0;
589: }
590:
591:
592: $v_result = $this->privAdd($v_filedescr_list, $p_result_list, $v_options);
593: if ($v_result != 1) {
594: return 0;
595: }
596:
597:
598: return $p_result_list;
599: }
600:
601:
602:
603:
604:
605:
606:
607:
608:
609:
610:
611:
612:
613:
614:
615:
616:
617:
618:
619:
620:
621:
622:
623:
624:
625:
626:
627:
628:
629:
630:
631:
632:
633:
634:
635:
636:
637:
638:
639:
640:
641:
642:
643: function listContent()
644: {
645: $v_result=1;
646:
647:
648: $this->privErrorReset();
649:
650:
651: if (!$this->privCheckFormat()) {
652: return(0);
653: }
654:
655:
656: $p_list = array();
657: if (($v_result = $this->privList($p_list)) != 1)
658: {
659: unset($p_list);
660: return(0);
661: }
662:
663:
664: return $p_list;
665: }
666:
667:
668:
669:
670:
671:
672:
673:
674:
675:
676:
677:
678:
679:
680:
681:
682:
683:
684:
685:
686:
687:
688:
689:
690:
691:
692:
693:
694:
695:
696:
697:
698:
699:
700: function extract()
701: {
702: $v_result=1;
703:
704:
705: $this->privErrorReset();
706:
707:
708: if (!$this->privCheckFormat()) {
709: return(0);
710: }
711:
712:
713: $v_options = array();
714:
715: $v_path = '';
716: $v_remove_path = "";
717: $v_remove_all_path = false;
718:
719:
720: $v_size = func_num_args();
721:
722:
723: $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
724:
725:
726: if ($v_size > 0) {
727:
728: $v_arg_list = func_get_args();
729:
730:
731: if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
732:
733:
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:
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:
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:
779:
780:
781: else {
782:
783:
784: $v_path = $v_arg_list[0];
785:
786:
787: if ($v_size == 2) {
788: $v_remove_path = $v_arg_list[1];
789: }
790: else if ($v_size > 2) {
791:
792: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
793:
794:
795: return 0;
796: }
797: }
798: }
799:
800:
801: $this->privOptionDefaultThreshold($v_options);
802:
803:
804:
805:
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:
815: return $p_list;
816: }
817:
818:
819:
820:
821:
822:
823:
824:
825:
826:
827:
828:
829:
830:
831:
832:
833:
834:
835:
836:
837:
838:
839:
840:
841:
842:
843:
844:
845:
846:
847:
848:
849:
850:
851:
852:
853:
854:
855:
856:
857: function extractByIndex($p_index)
858: {
859: $v_result=1;
860:
861:
862: $this->privErrorReset();
863:
864:
865: if (!$this->privCheckFormat()) {
866: return(0);
867: }
868:
869:
870: $v_options = array();
871:
872: $v_path = '';
873: $v_remove_path = "";
874: $v_remove_all_path = false;
875:
876:
877: $v_size = func_num_args();
878:
879:
880: $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
881:
882:
883: if ($v_size > 1) {
884:
885: $v_arg_list = func_get_args();
886:
887:
888: array_shift($v_arg_list);
889: $v_size--;
890:
891:
892: if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
893:
894:
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:
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:
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:
940:
941:
942: else {
943:
944:
945: $v_path = $v_arg_list[0];
946:
947:
948: if ($v_size == 2) {
949: $v_remove_path = $v_arg_list[1];
950: }
951: else if ($v_size > 2) {
952:
953: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
954:
955:
956: return 0;
957: }
958: }
959: }
960:
961:
962:
963:
964:
965:
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:
976: $this->privOptionDefaultThreshold($v_options);
977:
978:
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:
984: return $p_list;
985: }
986:
987:
988:
989:
990:
991:
992:
993:
994:
995:
996:
997:
998:
999:
1000:
1001:
1002:
1003:
1004:
1005:
1006: function delete()
1007: {
1008: $v_result=1;
1009:
1010:
1011: $this->privErrorReset();
1012:
1013:
1014: if (!$this->privCheckFormat()) {
1015: return(0);
1016: }
1017:
1018:
1019: $v_options = array();
1020:
1021:
1022: $v_size = func_num_args();
1023:
1024:
1025: if ($v_size > 0) {
1026:
1027: $v_arg_list = func_get_args();
1028:
1029:
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:
1041: $this->privDisableMagicQuotes();
1042:
1043:
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:
1052: $this->privSwapBackMagicQuotes();
1053:
1054:
1055: return $v_list;
1056: }
1057:
1058:
1059:
1060:
1061:
1062:
1063:
1064:
1065: function deleteByIndex($p_index)
1066: {
1067:
1068: $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index);
1069:
1070:
1071: return $p_list;
1072: }
1073:
1074:
1075:
1076:
1077:
1078:
1079:
1080:
1081:
1082:
1083:
1084:
1085:
1086:
1087:
1088:
1089: function properties()
1090: {
1091:
1092:
1093: $this->privErrorReset();
1094:
1095:
1096: $this->privDisableMagicQuotes();
1097:
1098:
1099: if (!$this->privCheckFormat()) {
1100: $this->privSwapBackMagicQuotes();
1101: return(0);
1102: }
1103:
1104:
1105: $v_prop = array();
1106: $v_prop['comment'] = '';
1107: $v_prop['nb'] = 0;
1108: $v_prop['status'] = 'not_exist';
1109:
1110:
1111: if (@is_file($this->zipname))
1112: {
1113:
1114: if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
1115: {
1116: $this->privSwapBackMagicQuotes();
1117:
1118:
1119: PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
1120:
1121:
1122: return 0;
1123: }
1124:
1125:
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:
1134: $this->privCloseFd();
1135:
1136:
1137: $v_prop['comment'] = $v_central_dir['comment'];
1138: $v_prop['nb'] = $v_central_dir['entries'];
1139: $v_prop['status'] = 'ok';
1140: }
1141:
1142:
1143: $this->privSwapBackMagicQuotes();
1144:
1145:
1146: return $v_prop;
1147: }
1148:
1149:
1150:
1151:
1152:
1153:
1154:
1155:
1156:
1157:
1158:
1159:
1160:
1161:
1162: function duplicate($p_archive)
1163: {
1164: $v_result = 1;
1165:
1166:
1167: $this->privErrorReset();
1168:
1169:
1170: if ((is_object($p_archive)) && (get_class($p_archive) == 'pclzip'))
1171: {
1172:
1173:
1174: $v_result = $this->privDuplicate($p_archive->zipname);
1175: }
1176:
1177:
1178: else if (is_string($p_archive))
1179: {
1180:
1181:
1182:
1183: if (!is_file($p_archive)) {
1184:
1185: PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "No file with filename '".$p_archive."'");
1186: $v_result = PCLZIP_ERR_MISSING_FILE;
1187: }
1188: else {
1189:
1190: $v_result = $this->privDuplicate($p_archive);
1191: }
1192: }
1193:
1194:
1195: else
1196: {
1197:
1198: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
1199: $v_result = PCLZIP_ERR_INVALID_PARAMETER;
1200: }
1201:
1202:
1203: return $v_result;
1204: }
1205:
1206:
1207:
1208:
1209:
1210:
1211:
1212:
1213:
1214:
1215:
1216:
1217:
1218:
1219:
1220:
1221: function merge($p_archive_to_add)
1222: {
1223: $v_result = 1;
1224:
1225:
1226: $this->privErrorReset();
1227:
1228:
1229: if (!$this->privCheckFormat()) {
1230: return(0);
1231: }
1232:
1233:
1234: if ((is_object($p_archive_to_add)) && (get_class($p_archive_to_add) == 'pclzip'))
1235: {
1236:
1237:
1238: $v_result = $this->privMerge($p_archive_to_add);
1239: }
1240:
1241:
1242: else if (is_string($p_archive_to_add))
1243: {
1244:
1245:
1246: $v_object_archive = new PclZip($p_archive_to_add);
1247:
1248:
1249: $v_result = $this->privMerge($v_object_archive);
1250: }
1251:
1252:
1253: else
1254: {
1255:
1256: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
1257: $v_result = PCLZIP_ERR_INVALID_PARAMETER;
1258: }
1259:
1260:
1261: return $v_result;
1262: }
1263:
1264:
1265:
1266:
1267:
1268:
1269:
1270:
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:
1285:
1286:
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:
1331:
1332:
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:
1353:
1354:
1355:
1356:
1357:
1358:
1359:
1360:
1361:
1362:
1363:
1364:
1365:
1366:
1367:
1368:
1369:
1370:
1371:
1372:
1373: function privCheckFormat($p_level=0)
1374: {
1375: $v_result = true;
1376:
1377:
1378: clearstatcache();
1379:
1380:
1381: $this->privErrorReset();
1382:
1383:
1384: if (!is_file($this->zipname)) {
1385:
1386: PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "Missing archive file '".$this->zipname."'");
1387: return(false);
1388: }
1389:
1390:
1391: if (!is_readable($this->zipname)) {
1392:
1393: PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to read archive '".$this->zipname."'");
1394: return(false);
1395: }
1396:
1397:
1398:
1399:
1400:
1401:
1402:
1403:
1404:
1405:
1406:
1407: return $v_result;
1408: }
1409:
1410:
1411:
1412:
1413:
1414:
1415:
1416:
1417:
1418:
1419:
1420:
1421:
1422:
1423:
1424:
1425:
1426: function privParseOptions(&$p_options_list, $p_size, &$v_result_list, $v_requested_options=false)
1427: {
1428: $v_result=1;
1429:
1430:
1431: $i=0;
1432: while ($i<$p_size) {
1433:
1434:
1435: if (!isset($v_requested_options[$p_options_list[$i]])) {
1436:
1437: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid optional parameter '".$p_options_list[$i]."' for this method");
1438:
1439:
1440: return PclZip::errorCode();
1441: }
1442:
1443:
1444: switch ($p_options_list[$i]) {
1445:
1446: case PCLZIP_OPT_PATH :
1447: case PCLZIP_OPT_REMOVE_PATH :
1448: case PCLZIP_OPT_ADD_PATH :
1449:
1450: if (($i+1) >= $p_size) {
1451:
1452: PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1453:
1454:
1455: return PclZip::errorCode();
1456: }
1457:
1458:
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:
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:
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:
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:
1484: $v_result_list[$p_options_list[$i]] = $v_value*1048576;
1485: $i++;
1486: break;
1487:
1488: case PCLZIP_OPT_TEMP_FILE_ON :
1489:
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:
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:
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:
1515: if (($i+1) >= $p_size) {
1516:
1517: PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1518:
1519:
1520: return PclZip::errorCode();
1521: }
1522:
1523:
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:
1534: case PCLZIP_OPT_BY_NAME :
1535:
1536: if (($i+1) >= $p_size) {
1537:
1538: PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1539:
1540:
1541: return PclZip::errorCode();
1542: }
1543:
1544:
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:
1553: PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1554:
1555:
1556: return PclZip::errorCode();
1557: }
1558: $i++;
1559: break;
1560:
1561:
1562: case PCLZIP_OPT_BY_EREG :
1563:
1564:
1565: $p_options_list[$i] = PCLZIP_OPT_BY_PREG;
1566: case PCLZIP_OPT_BY_PREG :
1567:
1568:
1569: if (($i+1) >= $p_size) {
1570:
1571: PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1572:
1573:
1574: return PclZip::errorCode();
1575: }
1576:
1577:
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:
1583: PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1584:
1585:
1586: return PclZip::errorCode();
1587: }
1588: $i++;
1589: break;
1590:
1591:
1592: case PCLZIP_OPT_COMMENT :
1593: case PCLZIP_OPT_ADD_COMMENT :
1594: case PCLZIP_OPT_PREPEND_COMMENT :
1595:
1596: if (($i+1) >= $p_size) {
1597:
1598: PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
1599: "Missing parameter value for option '"
1600: .PclZipUtilOptionText($p_options_list[$i])
1601: ."'");
1602:
1603:
1604: return PclZip::errorCode();
1605: }
1606:
1607:
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:
1613: PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
1614: "Wrong parameter value for option '"
1615: .PclZipUtilOptionText($p_options_list[$i])
1616: ."'");
1617:
1618:
1619: return PclZip::errorCode();
1620: }
1621: $i++;
1622: break;
1623:
1624:
1625: case PCLZIP_OPT_BY_INDEX :
1626:
1627: if (($i+1) >= $p_size) {
1628:
1629: PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1630:
1631:
1632: return PclZip::errorCode();
1633: }
1634:
1635:
1636: $v_work_list = array();
1637: if (is_string($p_options_list[$i+1])) {
1638:
1639:
1640: $p_options_list[$i+1] = strtr($p_options_list[$i+1], ' ', '');
1641:
1642:
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:
1653: PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Value must be integer, string or array for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1654:
1655:
1656: return PclZip::errorCode();
1657: }
1658:
1659:
1660:
1661:
1662:
1663: $v_sort_flag=false;
1664: $v_sort_value=0;
1665: for ($j=0; $j<sizeof($v_work_list); $j++) {
1666:
1667: $v_item_list = explode("-", $v_work_list[$j]);
1668: $v_size_item_list = sizeof($v_item_list);
1669:
1670:
1671:
1672:
1673:
1674: if ($v_size_item_list == 1) {
1675:
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:
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:
1686: PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Too many values in index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1687:
1688:
1689: return PclZip::errorCode();
1690: }
1691:
1692:
1693:
1694: if ($v_result_list[$p_options_list[$i]][$j]['start'] < $v_sort_value) {
1695: $v_sort_flag=true;
1696:
1697:
1698:
1699: PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Invalid order of index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1700:
1701:
1702: return PclZip::errorCode();
1703: }
1704: $v_sort_value = $v_result_list[$p_options_list[$i]][$j]['start'];
1705: }
1706:
1707:
1708: if ($v_sort_flag) {
1709:
1710: }
1711:
1712:
1713: $i++;
1714: break;
1715:
1716:
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:
1727: case PCLZIP_OPT_SET_CHMOD :
1728:
1729: if (($i+1) >= $p_size) {
1730:
1731: PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1732:
1733:
1734: return PclZip::errorCode();
1735: }
1736:
1737:
1738: $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
1739: $i++;
1740: break;
1741:
1742:
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: 1748: 1749: 1750: 1751: 1752:
1753:
1754: if (($i+1) >= $p_size) {
1755:
1756: PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
1757:
1758:
1759: return PclZip::errorCode();
1760: }
1761:
1762:
1763: $v_function_name = $p_options_list[$i+1];
1764:
1765:
1766: if (!function_exists($v_function_name)) {
1767:
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:
1771: return PclZip::errorCode();
1772: }
1773:
1774:
1775: $v_result_list[$p_options_list[$i]] = $v_function_name;
1776: $i++;
1777: break;
1778:
1779: default :
1780:
1781: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
1782: "Unknown parameter '"
1783: .$p_options_list[$i]."'");
1784:
1785:
1786: return PclZip::errorCode();
1787: }
1788:
1789:
1790: $i++;
1791: }
1792:
1793:
1794: if ($v_requested_options !== false) {
1795: for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
1796:
1797: if ($v_requested_options[$key] == 'mandatory') {
1798:
1799: if (!isset($v_result_list[$key])) {
1800:
1801: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
1802:
1803:
1804: return PclZip::errorCode();
1805: }
1806: }
1807: }
1808: }
1809:
1810:
1811: if (!isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
1812:
1813: }
1814:
1815:
1816: return $v_result;
1817: }
1818:
1819:
1820:
1821:
1822:
1823:
1824:
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:
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:
1842: $v_memory_limit = $v_memory_limit*1073741824;
1843: if($last == 'm')
1844:
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:
1853: if ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] < 1048576) {
1854: unset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]);
1855: }
1856:
1857:
1858: return $v_result;
1859: }
1860:
1861:
1862:
1863:
1864:
1865:
1866:
1867:
1868:
1869:
1870: function privFileDescrParseAtt(&$p_file_list, &$p_filedescr, $v_options, $v_requested_options=false)
1871: {
1872: $v_result=1;
1873:
1874:
1875: foreach ($p_file_list as $v_key => $v_value) {
1876:
1877:
1878: if (!isset($v_requested_options[$v_key])) {
1879:
1880: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file attribute '".$v_key."' for this file");
1881:
1882:
1883: return PclZip::errorCode();
1884: }
1885:
1886:
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:
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:
1956: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
1957: "Unknown parameter '".$v_key."'");
1958:
1959:
1960: return PclZip::errorCode();
1961: }
1962:
1963:
1964: if ($v_requested_options !== false) {
1965: for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
1966:
1967: if ($v_requested_options[$key] == 'mandatory') {
1968:
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:
1978: }
1979:
1980:
1981: return $v_result;
1982: }
1983:
1984:
1985:
1986:
1987:
1988:
1989:
1990:
1991:
1992:
1993:
1994:
1995:
1996:
1997:
1998:
1999: function privFileDescrExpand(&$p_filedescr_list, &$p_options)
2000: {
2001: $v_result=1;
2002:
2003:
2004: $v_result_list = array();
2005:
2006:
2007: for ($i=0; $i<sizeof($p_filedescr_list); $i++) {
2008:
2009:
2010: $v_descr = $p_filedescr_list[$i];
2011:
2012:
2013: $v_descr['filename'] = PclZipUtilTranslateWinPath($v_descr['filename'], false);
2014: $v_descr['filename'] = PclZipUtilPathReduction($v_descr['filename']);
2015:
2016:
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:
2026: continue;
2027: }
2028: else {
2029:
2030: continue;
2031: }
2032: }
2033:
2034:
2035: else if (isset($v_descr['content'])) {
2036: $v_descr['type'] = 'virtual_file';
2037: }
2038:
2039:
2040: else {
2041:
2042: PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$v_descr['filename']."' does not exist");
2043:
2044:
2045: return PclZip::errorCode();
2046: }
2047:
2048:
2049: $this->privCalculateStoredFilename($v_descr, $p_options);
2050:
2051:
2052: $v_result_list[sizeof($v_result_list)] = $v_descr;
2053:
2054:
2055: if ($v_descr['type'] == 'folder') {
2056:
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:
2063: if (($v_item_handler == '.') || ($v_item_handler == '..')) {
2064: continue;
2065: }
2066:
2067:
2068: $v_dirlist_descr[$v_dirlist_nb]['filename'] = $v_descr['filename'].'/'.$v_item_handler;
2069:
2070:
2071:
2072:
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:
2090: }
2091:
2092:
2093: if ($v_dirlist_nb != 0) {
2094:
2095: if (($v_result = $this->privFileDescrExpand($v_dirlist_descr, $p_options)) != 1) {
2096: return $v_result;
2097: }
2098:
2099:
2100: $v_result_list = array_merge($v_result_list, $v_dirlist_descr);
2101: }
2102: else {
2103: }
2104:
2105:
2106: unset($v_dirlist_descr);
2107: }
2108: }
2109:
2110:
2111: $p_filedescr_list = $v_result_list;
2112:
2113:
2114: return $v_result;
2115: }
2116:
2117:
2118:
2119:
2120:
2121:
2122:
2123:
2124: function privCreate($p_filedescr_list, &$p_result_list, &$p_options)
2125: {
2126: $v_result=1;
2127: $v_list_detail = array();
2128:
2129:
2130: $this->privDisableMagicQuotes();
2131:
2132:
2133: if (($v_result = $this->privOpenFd('wb')) != 1)
2134: {
2135:
2136: return $v_result;
2137: }
2138:
2139:
2140: $v_result = $this->privAddList($p_filedescr_list, $p_result_list, $p_options);
2141:
2142:
2143: $this->privCloseFd();
2144:
2145:
2146: $this->privSwapBackMagicQuotes();
2147:
2148:
2149: return $v_result;
2150: }
2151:
2152:
2153:
2154:
2155:
2156:
2157:
2158:
2159: function privAdd($p_filedescr_list, &$p_result_list, &$p_options)
2160: {
2161: $v_result=1;
2162: $v_list_detail = array();
2163:
2164:
2165: if ((!is_file($this->zipname)) || (filesize($this->zipname) == 0))
2166: {
2167:
2168:
2169: $v_result = $this->privCreate($p_filedescr_list, $p_result_list, $p_options);
2170:
2171:
2172: return $v_result;
2173: }
2174:
2175: $this->privDisableMagicQuotes();
2176:
2177:
2178: if (($v_result=$this->privOpenFd('rb')) != 1)
2179: {
2180:
2181: $this->privSwapBackMagicQuotes();
2182:
2183:
2184: return $v_result;
2185: }
2186:
2187:
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:
2197: @rewind($this->zip_fd);
2198:
2199:
2200: $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
2201:
2202:
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:
2211: return PclZip::errorCode();
2212: }
2213:
2214:
2215:
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:
2226:
2227:
2228: $v_swap = $this->zip_fd;
2229: $this->zip_fd = $v_zip_temp_fd;
2230: $v_zip_temp_fd = $v_swap;
2231:
2232:
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:
2242: return $v_result;
2243: }
2244:
2245:
2246: $v_offset = @ftell($this->zip_fd);
2247:
2248:
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:
2259: for ($i=0, $v_count=0; $i<sizeof($v_header_list); $i++)
2260: {
2261:
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:
2270: return $v_result;
2271: }
2272: $v_count++;
2273: }
2274:
2275:
2276: $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
2277: }
2278:
2279:
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:
2292: $v_size = @ftell($this->zip_fd)-$v_offset;
2293:
2294:
2295: if (($v_result = $this->privWriteCentralHeader($v_count+$v_central_dir['entries'], $v_size, $v_offset, $v_comment)) != 1)
2296: {
2297:
2298: unset($v_header_list);
2299: $this->privSwapBackMagicQuotes();
2300:
2301:
2302: return $v_result;
2303: }
2304:
2305:
2306: $v_swap = $this->zip_fd;
2307: $this->zip_fd = $v_zip_temp_fd;
2308: $v_zip_temp_fd = $v_swap;
2309:
2310:
2311: $this->privCloseFd();
2312:
2313:
2314: @fclose($v_zip_temp_fd);
2315:
2316:
2317: $this->privSwapBackMagicQuotes();
2318:
2319:
2320:
2321: @unlink($this->zipname);
2322:
2323:
2324:
2325:
2326: PclZipUtilRename($v_zip_temp_name, $this->zipname);
2327:
2328:
2329: return $v_result;
2330: }
2331:
2332:
2333:
2334:
2335:
2336:
2337:
2338: function privOpenFd($p_mode)
2339: {
2340: $v_result=1;
2341:
2342:
2343: if ($this->zip_fd != 0)
2344: {
2345:
2346: PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Zip file \''.$this->zipname.'\' already open');
2347:
2348:
2349: return PclZip::errorCode();
2350: }
2351:
2352:
2353: if (($this->zip_fd = @fopen($this->zipname, $p_mode)) == 0)
2354: {
2355:
2356: PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in '.$p_mode.' mode');
2357:
2358:
2359: return PclZip::errorCode();
2360: }
2361:
2362:
2363: return $v_result;
2364: }
2365:
2366:
2367:
2368:
2369:
2370:
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:
2381: return $v_result;
2382: }
2383:
2384:
2385:
2386:
2387:
2388:
2389:
2390:
2391:
2392:
2393:
2394:
2395:
2396:
2397:
2398:
2399: function privAddList($p_filedescr_list, &$p_result_list, &$p_options)
2400: {
2401: $v_result=1;
2402:
2403:
2404: $v_header_list = array();
2405: if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
2406: {
2407:
2408: return $v_result;
2409: }
2410:
2411:
2412: $v_offset = @ftell($this->zip_fd);
2413:
2414:
2415: for ($i=0,$v_count=0; $i<sizeof($v_header_list); $i++)
2416: {
2417:
2418: if ($v_header_list[$i]['status'] == 'ok') {
2419: if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
2420:
2421: return $v_result;
2422: }
2423: $v_count++;
2424: }
2425:
2426:
2427: $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
2428: }
2429:
2430:
2431: $v_comment = '';
2432: if (isset($p_options[PCLZIP_OPT_COMMENT])) {
2433: $v_comment = $p_options[PCLZIP_OPT_COMMENT];
2434: }
2435:
2436:
2437: $v_size = @ftell($this->zip_fd)-$v_offset;
2438:
2439:
2440: if (($v_result = $this->privWriteCentralHeader($v_count, $v_size, $v_offset, $v_comment)) != 1)
2441: {
2442:
2443: unset($v_header_list);
2444:
2445:
2446: return $v_result;
2447: }
2448:
2449:
2450: return $v_result;
2451: }
2452:
2453:
2454:
2455:
2456:
2457:
2458:
2459:
2460:
2461:
2462:
2463: function privAddFileList($p_filedescr_list, &$p_result_list, &$p_options)
2464: {
2465: $v_result=1;
2466: $v_header = array();
2467:
2468:
2469: $v_nb = sizeof($p_result_list);
2470:
2471:
2472: for ($j=0; ($j<sizeof($p_filedescr_list)) && ($v_result==1); $j++) {
2473:
2474: $p_filedescr_list[$j]['filename']
2475: = PclZipUtilTranslateWinPath($p_filedescr_list[$j]['filename'], false);
2476:
2477:
2478:
2479:
2480: if ($p_filedescr_list[$j]['filename'] == "") {
2481: continue;
2482: }
2483:
2484:
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:
2492:
2493:
2494:
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:
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:
2510: $p_result_list[$v_nb++] = $v_header;
2511: }
2512: }
2513:
2514:
2515: return $v_result;
2516: }
2517:
2518:
2519:
2520:
2521:
2522:
2523:
2524:
2525: function privAddFile($p_filedescr, &$p_header, &$p_options)
2526: {
2527: $v_result=1;
2528:
2529:
2530: $p_filename = $p_filedescr['filename'];
2531:
2532:
2533: if ($p_filename == "") {
2534:
2535: PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file list parameter (invalid or empty list)");
2536:
2537:
2538: return PclZip::errorCode();
2539: }
2540:
2541:
2542: 2543: 2544: 2545: 2546: 2547: 2548: 2549:
2550:
2551:
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:
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:
2572: if ($p_filedescr['type']=='file') {
2573: $p_header['external'] = 0x00000000;
2574: $p_header['size'] = filesize($p_filename);
2575: }
2576:
2577:
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:
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:
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:
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:
2613: if (isset($p_options[PCLZIP_CB_PRE_ADD])) {
2614:
2615:
2616: $v_local_header = array();
2617: $this->privConvertHeader2FileInfo($p_header, $v_local_header);
2618:
2619:
2620:
2621:
2622:
2623: $v_result = $p_options[PCLZIP_CB_PRE_ADD](PCLZIP_CB_PRE_ADD, $v_local_header);
2624: if ($v_result == 0) {
2625:
2626: $p_header['status'] = "skipped";
2627: $v_result = 1;
2628: }
2629:
2630:
2631:
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:
2638: if ($p_header['stored_filename'] == "") {
2639: $p_header['status'] = "filtered";
2640: }
2641:
2642:
2643: if (strlen($p_header['stored_filename']) > 0xFF) {
2644: $p_header['status'] = 'filename_too_long';
2645: }
2646:
2647:
2648: if ($p_header['status'] == 'ok') {
2649:
2650:
2651: if ($p_filedescr['type'] == 'file') {
2652:
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:
2664: else {
2665:
2666:
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:
2673: $v_content = @fread($v_file, $p_header['size']);
2674:
2675:
2676: @fclose($v_file);
2677:
2678:
2679: $p_header['crc'] = @crc32($v_content);
2680:
2681:
2682: if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
2683:
2684: $p_header['compressed_size'] = $p_header['size'];
2685: $p_header['compression'] = 0;
2686: }
2687:
2688:
2689: else {
2690:
2691: $v_content = @gzdeflate($v_content);
2692:
2693:
2694: $p_header['compressed_size'] = strlen($v_content);
2695: $p_header['compression'] = 8;
2696: }
2697:
2698:
2699: if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
2700: @fclose($v_file);
2701: return $v_result;
2702: }
2703:
2704:
2705: @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
2706:
2707: }
2708:
2709: }
2710:
2711:
2712: else if ($p_filedescr['type'] == 'virtual_file') {
2713:
2714: $v_content = $p_filedescr['content'];
2715:
2716:
2717: $p_header['crc'] = @crc32($v_content);
2718:
2719:
2720: if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
2721:
2722: $p_header['compressed_size'] = $p_header['size'];
2723: $p_header['compression'] = 0;
2724: }
2725:
2726:
2727: else {
2728:
2729: $v_content = @gzdeflate($v_content);
2730:
2731:
2732: $p_header['compressed_size'] = strlen($v_content);
2733: $p_header['compression'] = 8;
2734: }
2735:
2736:
2737: if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
2738: @fclose($v_file);
2739: return $v_result;
2740: }
2741:
2742:
2743: @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
2744: }
2745:
2746:
2747: else if ($p_filedescr['type'] == 'folder') {
2748:
2749: if (@substr($p_header['stored_filename'], -1) != '/') {
2750: $p_header['stored_filename'] .= '/';
2751: }
2752:
2753:
2754: $p_header['size'] = 0;
2755:
2756: $p_header['external'] = 0x00000010;
2757:
2758:
2759: if (($v_result = $this->privWriteFileHeader($p_header)) != 1)
2760: {
2761: return $v_result;
2762: }
2763: }
2764: }
2765:
2766:
2767: if (isset($p_options[PCLZIP_CB_POST_ADD])) {
2768:
2769:
2770: $v_local_header = array();
2771: $this->privConvertHeader2FileInfo($p_header, $v_local_header);
2772:
2773:
2774:
2775:
2776:
2777: $v_result = $p_options[PCLZIP_CB_POST_ADD](PCLZIP_CB_POST_ADD, $v_local_header);
2778: if ($v_result == 0) {
2779:
2780: $v_result = 1;
2781: }
2782:
2783:
2784:
2785: }
2786:
2787:
2788: return $v_result;
2789: }
2790:
2791:
2792:
2793:
2794:
2795:
2796:
2797:
2798: function privAddFileUsingTempFile($p_filedescr, &$p_header, &$p_options)
2799: {
2800: $v_result=PCLZIP_ERR_NO_ERROR;
2801:
2802:
2803: $p_filename = $p_filedescr['filename'];
2804:
2805:
2806:
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:
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:
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:
2826: @gzputs($v_file_compressed, $v_buffer, $v_read_size);
2827: $v_size -= $v_read_size;
2828: }
2829:
2830:
2831: @fclose($v_file);
2832: @gzclose($v_file_compressed);
2833:
2834:
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:
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:
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:
2851: $v_data_header['os'] = bin2hex($v_data_header['os']);
2852:
2853:
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:
2859: $p_header['compression'] = ord($v_data_header['cm']);
2860:
2861: $p_header['crc'] = $v_data_footer['crc'];
2862: $p_header['compressed_size'] = filesize($v_gzip_temp_name)-18;
2863:
2864:
2865: @fclose($v_file_compressed);
2866:
2867:
2868: if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
2869: return $v_result;
2870: }
2871:
2872:
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:
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:
2887: @fwrite($this->zip_fd, $v_buffer, $v_read_size);
2888: $v_size -= $v_read_size;
2889: }
2890:
2891:
2892: @fclose($v_file_compressed);
2893:
2894:
2895: @unlink($v_gzip_temp_name);
2896:
2897:
2898: return $v_result;
2899: }
2900:
2901:
2902:
2903:
2904:
2905:
2906:
2907:
2908:
2909:
2910: function privCalculateStoredFilename(&$p_filedescr, &$p_options)
2911: {
2912: $v_result=1;
2913:
2914:
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:
2937: if (isset($p_filedescr['new_full_name'])) {
2938:
2939: $v_stored_filename = PclZipUtilTranslateWinPath($p_filedescr['new_full_name']);
2940: }
2941:
2942:
2943: else {
2944:
2945:
2946:
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:
2957: $v_stored_filename = $p_filename;
2958: }
2959:
2960:
2961: if ($p_remove_all_dir) {
2962: $v_stored_filename = basename($p_filename);
2963: }
2964:
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:
2996: $v_stored_filename = PclZipUtilTranslateWinPath($v_stored_filename);
2997:
2998:
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:
3008: $v_stored_filename = PclZipUtilPathReduction($v_stored_filename);
3009: $p_filedescr['stored_filename'] = $v_stored_filename;
3010:
3011:
3012: return $v_result;
3013: }
3014:
3015:
3016:
3017:
3018:
3019:
3020:
3021:
3022: function privWriteFileHeader(&$p_header)
3023: {
3024: $v_result=1;
3025:
3026:
3027: $p_header['offset'] = ftell($this->zip_fd);
3028:
3029:
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:
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:
3044: fputs($this->zip_fd, $v_binary_data, 30);
3045:
3046:
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:
3057: return $v_result;
3058: }
3059:
3060:
3061:
3062:
3063:
3064:
3065:
3066:
3067: function privWriteCentralFileHeader(&$p_header)
3068: {
3069: $v_result=1;
3070:
3071:
3072:
3073:
3074:
3075:
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:
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:
3093: fputs($this->zip_fd, $v_binary_data, 46);
3094:
3095:
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:
3110: return $v_result;
3111: }
3112:
3113:
3114:
3115:
3116:
3117:
3118:
3119:
3120: function privWriteCentralHeader($p_nb_entries, $p_size, $p_offset, $p_comment)
3121: {
3122: $v_result=1;
3123:
3124:
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:
3130: fputs($this->zip_fd, $v_binary_data, 22);
3131:
3132:
3133: if (strlen($p_comment) != 0)
3134: {
3135: fputs($this->zip_fd, $p_comment, strlen($p_comment));
3136: }
3137:
3138:
3139: return $v_result;
3140: }
3141:
3142:
3143:
3144:
3145:
3146:
3147:
3148:
3149: function privList(&$p_list)
3150: {
3151: $v_result=1;
3152:
3153:
3154: $this->privDisableMagicQuotes();
3155:
3156:
3157: if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
3158: {
3159:
3160: $this->privSwapBackMagicQuotes();
3161:
3162:
3163: PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
3164:
3165:
3166: return PclZip::errorCode();
3167: }
3168:
3169:
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:
3178: @rewind($this->zip_fd);
3179: if (@fseek($this->zip_fd, $v_central_dir['offset']))
3180: {
3181: $this->privSwapBackMagicQuotes();
3182:
3183:
3184: PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
3185:
3186:
3187: return PclZip::errorCode();
3188: }
3189:
3190:
3191: for ($i=0; $i<$v_central_dir['entries']; $i++)
3192: {
3193:
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:
3202: $this->privConvertHeader2FileInfo($v_header, $p_list[$i]);
3203: unset($v_header);
3204: }
3205:
3206:
3207: $this->privCloseFd();
3208:
3209:
3210: $this->privSwapBackMagicQuotes();
3211:
3212:
3213: return $v_result;
3214: }
3215:
3216:
3217:
3218:
3219:
3220:
3221:
3222:
3223:
3224:
3225:
3226:
3227:
3228:
3229:
3230:
3231:
3232:
3233:
3234:
3235:
3236: function privConvertHeader2FileInfo($p_header, &$p_info)
3237: {
3238: $v_result=1;
3239:
3240:
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:
3255: return $v_result;
3256: }
3257:
3258:
3259:
3260:
3261:
3262:
3263:
3264:
3265:
3266:
3267:
3268:
3269:
3270:
3271:
3272:
3273:
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:
3280: $this->privDisableMagicQuotes();
3281:
3282:
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:
3290: if (($p_path != "./") && ($p_path != "/"))
3291: {
3292:
3293: while (substr($p_path, -1) == "/")
3294: {
3295: $p_path = substr($p_path, 0, strlen($p_path)-1);
3296: }
3297: }
3298:
3299:
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:
3307: if (($v_result = $this->privOpenFd('rb')) != 1)
3308: {
3309: $this->privSwapBackMagicQuotes();
3310: return $v_result;
3311: }
3312:
3313:
3314: $v_central_dir = array();
3315: if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
3316: {
3317:
3318: $this->privCloseFd();
3319: $this->privSwapBackMagicQuotes();
3320:
3321: return $v_result;
3322: }
3323:
3324:
3325: $v_pos_entry = $v_central_dir['offset'];
3326:
3327:
3328: $j_start = 0;
3329: for ($i=0, $v_nb_extracted=0; $i<$v_central_dir['entries']; $i++)
3330: {
3331:
3332:
3333: @rewind($this->zip_fd);
3334: if (@fseek($this->zip_fd, $v_pos_entry))
3335: {
3336:
3337: $this->privCloseFd();
3338: $this->privSwapBackMagicQuotes();
3339:
3340:
3341: PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
3342:
3343:
3344: return PclZip::errorCode();
3345: }
3346:
3347:
3348: $v_header = array();
3349: if (($v_result = $this->privReadCentralFileHeader($v_header)) != 1)
3350: {
3351:
3352: $this->privCloseFd();
3353: $this->privSwapBackMagicQuotes();
3354:
3355: return $v_result;
3356: }
3357:
3358:
3359: $v_header['index'] = $i;
3360:
3361:
3362: $v_pos_entry = ftell($this->zip_fd);
3363:
3364:
3365: $v_extract = false;
3366:
3367:
3368: if ( (isset($p_options[PCLZIP_OPT_BY_NAME]))
3369: && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
3370:
3371:
3372: for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_extract); $j++) {
3373:
3374:
3375: if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
3376:
3377:
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:
3384: elseif ($v_header['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
3385: $v_extract = true;
3386: }
3387: }
3388: }
3389:
3390:
3391:
3392: 3393: 3394: 3395: 3396: 3397: 3398: 3399: 3400:
3401:
3402:
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:
3412: else if ( (isset($p_options[PCLZIP_OPT_BY_INDEX]))
3413: && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
3414:
3415:
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:
3432: else {
3433: $v_extract = true;
3434: }
3435:
3436:
3437: if ( ($v_extract)
3438: && ( ($v_header['compression'] != 8)
3439: && ($v_header['compression'] != 0))) {
3440: $v_header['status'] = 'unsupported_compression';
3441:
3442:
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:
3458: if (($v_extract) && (($v_header['flag'] & 1) == 1)) {
3459: $v_header['status'] = 'unsupported_encryption';
3460:
3461:
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:
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:
3490: if ($v_extract)
3491: {
3492:
3493:
3494: @rewind($this->zip_fd);
3495: if (@fseek($this->zip_fd, $v_header['offset']))
3496: {
3497:
3498: $this->privCloseFd();
3499:
3500: $this->privSwapBackMagicQuotes();
3501:
3502:
3503: PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
3504:
3505:
3506: return PclZip::errorCode();
3507: }
3508:
3509:
3510: if ($p_options[PCLZIP_OPT_EXTRACT_AS_STRING]) {
3511:
3512: $v_string = '';
3513:
3514:
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:
3523: if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted])) != 1)
3524: {
3525:
3526: $this->privCloseFd();
3527: $this->privSwapBackMagicQuotes();
3528:
3529: return $v_result;
3530: }
3531:
3532:
3533: $p_file_list[$v_nb_extracted]['content'] = $v_string;
3534:
3535:
3536: $v_nb_extracted++;
3537:
3538:
3539: if ($v_result1 == 2) {
3540: break;
3541: }
3542: }
3543:
3544: elseif ( (isset($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT]))
3545: && ($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT])) {
3546:
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:
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:
3562: if ($v_result1 == 2) {
3563: break;
3564: }
3565: }
3566:
3567: else {
3568:
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:
3580: if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted++])) != 1)
3581: {
3582:
3583: $this->privCloseFd();
3584: $this->privSwapBackMagicQuotes();
3585:
3586: return $v_result;
3587: }
3588:
3589:
3590: if ($v_result1 == 2) {
3591: break;
3592: }
3593: }
3594: }
3595: }
3596:
3597:
3598: $this->privCloseFd();
3599: $this->privSwapBackMagicQuotes();
3600:
3601:
3602: return $v_result;
3603: }
3604:
3605:
3606:
3607:
3608:
3609:
3610:
3611:
3612:
3613:
3614:
3615: function privExtractFile(&$p_entry, $p_path, $p_remove_path, $p_remove_all_path, &$p_options)
3616: {
3617: $v_result=1;
3618:
3619:
3620: if (($v_result = $this->privReadFileHeader($v_header)) != 1)
3621: {
3622:
3623: return $v_result;
3624: }
3625:
3626:
3627:
3628: if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
3629:
3630: }
3631:
3632:
3633: if ($p_remove_all_path == true) {
3634:
3635: if (($p_entry['external']&0x00000010)==0x00000010) {
3636:
3637: $p_entry['status'] = "filtered";
3638:
3639: return $v_result;
3640: }
3641:
3642:
3643: $p_entry['filename'] = basename($p_entry['filename']);
3644: }
3645:
3646:
3647: else if ($p_remove_path != "")
3648: {
3649: if (PclZipUtilPathInclusion($p_remove_path, $p_entry['filename']) == 2)
3650: {
3651:
3652:
3653: $p_entry['status'] = "filtered";
3654:
3655:
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:
3664: $p_entry['filename'] = substr($p_entry['filename'], $p_remove_path_size);
3665:
3666: }
3667: }
3668:
3669:
3670: if ($p_path != '') {
3671: $p_entry['filename'] = $p_path."/".$p_entry['filename'];
3672: }
3673:
3674:
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:
3690: if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
3691:
3692:
3693: $v_local_header = array();
3694: $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
3695:
3696:
3697:
3698:
3699:
3700: $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
3701: if ($v_result == 0) {
3702:
3703: $p_entry['status'] = "skipped";
3704: $v_result = 1;
3705: }
3706:
3707:
3708: if ($v_result == 2) {
3709:
3710: $p_entry['status'] = "aborted";
3711: $v_result = PCLZIP_ERR_USER_ABORTED;
3712: }
3713:
3714:
3715:
3716: $p_entry['filename'] = $v_local_header['filename'];
3717: }
3718:
3719:
3720:
3721: if ($p_entry['status'] == 'ok') {
3722:
3723:
3724: if (file_exists($p_entry['filename']))
3725: {
3726:
3727:
3728: if (is_dir($p_entry['filename']))
3729: {
3730:
3731:
3732: $p_entry['status'] = "already_a_directory";
3733:
3734:
3735:
3736:
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:
3748: else if (!is_writeable($p_entry['filename']))
3749: {
3750:
3751:
3752: $p_entry['status'] = "write_protected";
3753:
3754:
3755:
3756:
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:
3769: else if (filemtime($p_entry['filename']) > $p_entry['mtime'])
3770: {
3771:
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:
3779:
3780:
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:
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:
3808: $p_entry['status'] = "path_creation_fail";
3809:
3810:
3811:
3812: $v_result = 1;
3813: }
3814: }
3815: }
3816:
3817:
3818: if ($p_entry['status'] == 'ok') {
3819:
3820:
3821: if (!(($p_entry['external']&0x00000010)==0x00000010))
3822: {
3823:
3824: if ($p_entry['compression'] == 0) {
3825:
3826:
3827: if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0)
3828: {
3829:
3830:
3831: $p_entry['status'] = "write_error";
3832:
3833:
3834: return $v_result;
3835: }
3836:
3837:
3838:
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: 3845: 3846: 3847:
3848: @fwrite($v_dest_file, $v_buffer, $v_read_size);
3849: $v_size -= $v_read_size;
3850: }
3851:
3852:
3853: fclose($v_dest_file);
3854:
3855:
3856: touch($p_entry['filename'], $p_entry['mtime']);
3857:
3858:
3859: }
3860: else {
3861:
3862:
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:
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:
3881: else {
3882:
3883:
3884:
3885: $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
3886:
3887:
3888: $v_file_content = @gzinflate($v_buffer);
3889: unset($v_buffer);
3890: if ($v_file_content === FALSE) {
3891:
3892:
3893:
3894: $p_entry['status'] = "error";
3895:
3896: return $v_result;
3897: }
3898:
3899:
3900: if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
3901:
3902:
3903: $p_entry['status'] = "write_error";
3904:
3905: return $v_result;
3906: }
3907:
3908:
3909: @fwrite($v_dest_file, $v_file_content, $p_entry['size']);
3910: unset($v_file_content);
3911:
3912:
3913: @fclose($v_dest_file);
3914:
3915: }
3916:
3917:
3918: @touch($p_entry['filename'], $p_entry['mtime']);
3919: }
3920:
3921:
3922: if (isset($p_options[PCLZIP_OPT_SET_CHMOD])) {
3923:
3924:
3925: @chmod($p_entry['filename'], $p_options[PCLZIP_OPT_SET_CHMOD]);
3926: }
3927:
3928: }
3929: }
3930:
3931:
3932: if ($p_entry['status'] == "aborted") {
3933: $p_entry['status'] = "skipped";
3934: }
3935:
3936:
3937: elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
3938:
3939:
3940: $v_local_header = array();
3941: $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
3942:
3943:
3944:
3945:
3946:
3947: $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
3948:
3949:
3950: if ($v_result == 2) {
3951: $v_result = PCLZIP_ERR_USER_ABORTED;
3952: }
3953: }
3954:
3955:
3956: return $v_result;
3957: }
3958:
3959:
3960:
3961:
3962:
3963:
3964:
3965:
3966: function privExtractFileUsingTempFile(&$p_entry, &$p_options)
3967: {
3968: $v_result=1;
3969:
3970:
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:
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:
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:
3990: @fwrite($v_dest_file, $v_buffer, $v_read_size);
3991: $v_size -= $v_read_size;
3992: }
3993:
3994:
3995: $v_binary_data = pack('VV', $p_entry['crc'], $p_entry['size']);
3996: @fwrite($v_dest_file, $v_binary_data, 8);
3997:
3998:
3999: @fclose($v_dest_file);
4000:
4001:
4002: if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
4003: $p_entry['status'] = "write_error";
4004: return $v_result;
4005: }
4006:
4007:
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:
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:
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:
4029: @unlink($v_gzip_temp_name);
4030:
4031:
4032: return $v_result;
4033: }
4034:
4035:
4036:
4037:
4038:
4039:
4040:
4041:
4042: function privExtractFileInOutput(&$p_entry, &$p_options)
4043: {
4044: $v_result=1;
4045:
4046:
4047: if (($v_result = $this->privReadFileHeader($v_header)) != 1) {
4048: return $v_result;
4049: }
4050:
4051:
4052:
4053: if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
4054:
4055: }
4056:
4057:
4058: if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
4059:
4060:
4061: $v_local_header = array();
4062: $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
4063:
4064:
4065:
4066:
4067:
4068: $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
4069: if ($v_result == 0) {
4070:
4071: $p_entry['status'] = "skipped";
4072: $v_result = 1;
4073: }
4074:
4075:
4076: if ($v_result == 2) {
4077:
4078: $p_entry['status'] = "aborted";
4079: $v_result = PCLZIP_ERR_USER_ABORTED;
4080: }
4081:
4082:
4083:
4084: $p_entry['filename'] = $v_local_header['filename'];
4085: }
4086:
4087:
4088:
4089:
4090: if ($p_entry['status'] == 'ok') {
4091:
4092:
4093: if (!(($p_entry['external']&0x00000010)==0x00000010)) {
4094:
4095: if ($p_entry['compressed_size'] == $p_entry['size']) {
4096:
4097:
4098: $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
4099:
4100:
4101: echo $v_buffer;
4102: unset($v_buffer);
4103: }
4104: else {
4105:
4106:
4107: $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
4108:
4109:
4110: $v_file_content = gzinflate($v_buffer);
4111: unset($v_buffer);
4112:
4113:
4114: echo $v_file_content;
4115: unset($v_file_content);
4116: }
4117: }
4118: }
4119:
4120:
4121: if ($p_entry['status'] == "aborted") {
4122: $p_entry['status'] = "skipped";
4123: }
4124:
4125:
4126: elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
4127:
4128:
4129: $v_local_header = array();
4130: $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
4131:
4132:
4133:
4134:
4135:
4136: $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
4137:
4138:
4139: if ($v_result == 2) {
4140: $v_result = PCLZIP_ERR_USER_ABORTED;
4141: }
4142: }
4143:
4144: return $v_result;
4145: }
4146:
4147:
4148:
4149:
4150:
4151:
4152:
4153:
4154: function privExtractFileAsString(&$p_entry, &$p_string, &$p_options)
4155: {
4156: $v_result=1;
4157:
4158:
4159: $v_header = array();
4160: if (($v_result = $this->privReadFileHeader($v_header)) != 1)
4161: {
4162:
4163: return $v_result;
4164: }
4165:
4166:
4167:
4168: if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
4169:
4170: }
4171:
4172:
4173: if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
4174:
4175:
4176: $v_local_header = array();
4177: $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
4178:
4179:
4180:
4181:
4182:
4183: $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
4184: if ($v_result == 0) {
4185:
4186: $p_entry['status'] = "skipped";
4187: $v_result = 1;
4188: }
4189:
4190:
4191: if ($v_result == 2) {
4192:
4193: $p_entry['status'] = "aborted";
4194: $v_result = PCLZIP_ERR_USER_ABORTED;
4195: }
4196:
4197:
4198:
4199: $p_entry['filename'] = $v_local_header['filename'];
4200: }
4201:
4202:
4203:
4204: if ($p_entry['status'] == 'ok') {
4205:
4206:
4207: if (!(($p_entry['external']&0x00000010)==0x00000010)) {
4208:
4209:
4210: if ($p_entry['compression'] == 0) {
4211:
4212:
4213: $p_string = @fread($this->zip_fd, $p_entry['compressed_size']);
4214: }
4215: else {
4216:
4217:
4218: $v_data = @fread($this->zip_fd, $p_entry['compressed_size']);
4219:
4220:
4221: if (($p_string = @gzinflate($v_data)) === FALSE) {
4222:
4223: }
4224: }
4225:
4226:
4227: }
4228: else {
4229:
4230: }
4231:
4232: }
4233:
4234:
4235: if ($p_entry['status'] == "aborted") {
4236: $p_entry['status'] = "skipped";
4237: }
4238:
4239:
4240: elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
4241:
4242:
4243: $v_local_header = array();
4244: $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
4245:
4246:
4247: $v_local_header['content'] = $p_string;
4248: $p_string = '';
4249:
4250:
4251:
4252:
4253:
4254: $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
4255:
4256:
4257: $p_string = $v_local_header['content'];
4258: unset($v_local_header['content']);
4259:
4260:
4261: if ($v_result == 2) {
4262: $v_result = PCLZIP_ERR_USER_ABORTED;
4263: }
4264: }
4265:
4266:
4267: return $v_result;
4268: }
4269:
4270:
4271:
4272:
4273:
4274:
4275:
4276:
4277: function privReadFileHeader(&$p_header)
4278: {
4279: $v_result=1;
4280:
4281:
4282: $v_binary_data = @fread($this->zip_fd, 4);
4283: $v_data = unpack('Vid', $v_binary_data);
4284:
4285:
4286: if ($v_data['id'] != 0x04034b50)
4287: {
4288:
4289:
4290: PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Invalid archive structure');
4291:
4292:
4293: return PclZip::errorCode();
4294: }
4295:
4296:
4297: $v_binary_data = fread($this->zip_fd, 26);
4298:
4299:
4300: if (strlen($v_binary_data) != 26)
4301: {
4302: $p_header['filename'] = "";
4303: $p_header['status'] = "invalid_header";
4304:
4305:
4306: PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : ".strlen($v_binary_data));
4307:
4308:
4309: return PclZip::errorCode();
4310: }
4311:
4312:
4313: $v_data = unpack('vversion/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len', $v_binary_data);
4314:
4315:
4316: $p_header['filename'] = fread($this->zip_fd, $v_data['filename_len']);
4317:
4318:
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:
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:
4336: $p_header['mdate'] = $v_data['mdate'];
4337: $p_header['mtime'] = $v_data['mtime'];
4338: if ($p_header['mdate'] && $p_header['mtime'])
4339: {
4340:
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:
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:
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:
4360:
4361:
4362:
4363:
4364: $p_header['stored_filename'] = $p_header['filename'];
4365:
4366:
4367: $p_header['status'] = "ok";
4368:
4369:
4370: return $v_result;
4371: }
4372:
4373:
4374:
4375:
4376:
4377:
4378:
4379:
4380: function privReadCentralFileHeader(&$p_header)
4381: {
4382: $v_result=1;
4383:
4384:
4385: $v_binary_data = @fread($this->zip_fd, 4);
4386: $v_data = unpack('Vid', $v_binary_data);
4387:
4388:
4389: if ($v_data['id'] != 0x02014b50)
4390: {
4391:
4392:
4393: PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Invalid archive structure');
4394:
4395:
4396: return PclZip::errorCode();
4397: }
4398:
4399:
4400: $v_binary_data = fread($this->zip_fd, 42);
4401:
4402:
4403: if (strlen($v_binary_data) != 42)
4404: {
4405: $p_header['filename'] = "";
4406: $p_header['status'] = "invalid_header";
4407:
4408:
4409: PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : ".strlen($v_binary_data));
4410:
4411:
4412: return PclZip::errorCode();
4413: }
4414:
4415:
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:
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:
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:
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:
4437:
4438:
4439:
4440:
4441: if (1)
4442: {
4443:
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:
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:
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:
4463: $p_header['stored_filename'] = $p_header['filename'];
4464:
4465:
4466: $p_header['status'] = 'ok';
4467:
4468:
4469: if (substr($p_header['filename'], -1) == '/') {
4470:
4471: $p_header['external'] = 0x00000010;
4472: }
4473:
4474:
4475:
4476: return $v_result;
4477: }
4478:
4479:
4480:
4481:
4482:
4483:
4484:
4485:
4486:
4487:
4488: function privCheckFileHeaders(&$p_local_header, &$p_central_header)
4489: {
4490: $v_result=1;
4491:
4492:
4493:
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:
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:
4515: return $v_result;
4516: }
4517:
4518:
4519:
4520:
4521:
4522:
4523:
4524:
4525: function privReadEndCentralDir(&$p_central_dir)
4526: {
4527: $v_result=1;
4528:
4529:
4530: $v_size = filesize($this->zipname);
4531: @fseek($this->zip_fd, $v_size);
4532: if (@ftell($this->zip_fd) != $v_size)
4533: {
4534:
4535: PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to go to the end of the archive \''.$this->zipname.'\'');
4536:
4537:
4538: return PclZip::errorCode();
4539: }
4540:
4541:
4542:
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:
4549: PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to seek back to the middle of the archive \''.$this->zipname.'\'');
4550:
4551:
4552: return PclZip::errorCode();
4553: }
4554:
4555:
4556: $v_binary_data = @fread($this->zip_fd, 4);
4557: $v_data = @unpack('Vid', $v_binary_data);
4558:
4559:
4560: if ($v_data['id'] == 0x06054b50) {
4561: $v_found = 1;
4562: }
4563:
4564: $v_pos = ftell($this->zip_fd);
4565: }
4566:
4567:
4568: if (!$v_found) {
4569: $v_maximum_size = 65557;
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:
4576: PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to seek back to the middle of the archive \''.$this->zipname.'\'');
4577:
4578:
4579: return PclZip::errorCode();
4580: }
4581:
4582:
4583: $v_pos = ftell($this->zip_fd);
4584: $v_bytes = 0x00000000;
4585: while ($v_pos < $v_size)
4586: {
4587:
4588: $v_byte = @fread($this->zip_fd, 1);
4589:
4590:
4591:
4592:
4593:
4594: $v_bytes = ( ($v_bytes & 0xFFFFFF) << 8) | Ord($v_byte);
4595:
4596:
4597: if ($v_bytes == 0x504b0506)
4598: {
4599: $v_pos++;
4600: break;
4601: }
4602:
4603: $v_pos++;
4604: }
4605:
4606:
4607: if ($v_pos == $v_size)
4608: {
4609:
4610:
4611: PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Unable to find End of Central Dir Record signature");
4612:
4613:
4614: return PclZip::errorCode();
4615: }
4616: }
4617:
4618:
4619: $v_binary_data = fread($this->zip_fd, 18);
4620:
4621:
4622: if (strlen($v_binary_data) != 18)
4623: {
4624:
4625:
4626: PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid End of Central Dir Record size : ".strlen($v_binary_data));
4627:
4628:
4629: return PclZip::errorCode();
4630: }
4631:
4632:
4633: $v_data = unpack('vdisk/vdisk_start/vdisk_entries/ventries/Vsize/Voffset/vcomment_size', $v_binary_data);
4634:
4635:
4636: if (($v_pos + $v_data['comment_size'] + 18) != $v_size) {
4637:
4638:
4639:
4640:
4641:
4642: if (0) {
4643:
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:
4649: return PclZip::errorCode();
4650: }
4651: }
4652:
4653:
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:
4668:
4669:
4670:
4671:
4672: return $v_result;
4673: }
4674:
4675:
4676:
4677:
4678:
4679:
4680:
4681:
4682: function privDeleteByRule(&$p_result_list, &$p_options)
4683: {
4684: $v_result=1;
4685: $v_list_detail = array();
4686:
4687:
4688: if (($v_result=$this->privOpenFd('rb')) != 1)
4689: {
4690:
4691: return $v_result;
4692: }
4693:
4694:
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:
4703: @rewind($this->zip_fd);
4704:
4705:
4706:
4707: $v_pos_entry = $v_central_dir['offset'];
4708: @rewind($this->zip_fd);
4709: if (@fseek($this->zip_fd, $v_pos_entry))
4710: {
4711:
4712: $this->privCloseFd();
4713:
4714:
4715: PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
4716:
4717:
4718: return PclZip::errorCode();
4719: }
4720:
4721:
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:
4728: $v_header_list[$v_nb_extracted] = array();
4729: if (($v_result = $this->privReadCentralFileHeader($v_header_list[$v_nb_extracted])) != 1)
4730: {
4731:
4732: $this->privCloseFd();
4733:
4734: return $v_result;
4735: }
4736:
4737:
4738:
4739: $v_header_list[$v_nb_extracted]['index'] = $i;
4740:
4741:
4742: $v_found = false;
4743:
4744:
4745: if ( (isset($p_options[PCLZIP_OPT_BY_NAME]))
4746: && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
4747:
4748:
4749: for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_found); $j++) {
4750:
4751:
4752: if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
4753:
4754:
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)
4760: && ($v_header_list[$v_nb_extracted]['stored_filename'].'/' == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
4761: $v_found = true;
4762: }
4763: }
4764:
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:
4772:
4773: 4774: 4775: 4776: 4777: 4778: 4779: 4780: 4781:
4782:
4783:
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:
4793: else if ( (isset($p_options[PCLZIP_OPT_BY_INDEX]))
4794: && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
4795:
4796:
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:
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:
4827: if ($v_nb_extracted > 0) {
4828:
4829:
4830: $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
4831:
4832:
4833: $v_temp_zip = new PclZip($v_zip_temp_name);
4834:
4835:
4836: if (($v_result = $v_temp_zip->privOpenFd('wb')) != 1) {
4837: $this->privCloseFd();
4838:
4839:
4840: return $v_result;
4841: }
4842:
4843:
4844: for ($i=0; $i<sizeof($v_header_list); $i++) {
4845:
4846:
4847: @rewind($this->zip_fd);
4848: if (@fseek($this->zip_fd, $v_header_list[$i]['offset'])) {
4849:
4850: $this->privCloseFd();
4851: $v_temp_zip->privCloseFd();
4852: @unlink($v_zip_temp_name);
4853:
4854:
4855: PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
4856:
4857:
4858: return PclZip::errorCode();
4859: }
4860:
4861:
4862: $v_local_header = array();
4863: if (($v_result = $this->privReadFileHeader($v_local_header)) != 1) {
4864:
4865: $this->privCloseFd();
4866: $v_temp_zip->privCloseFd();
4867: @unlink($v_zip_temp_name);
4868:
4869:
4870: return $v_result;
4871: }
4872:
4873:
4874: if ($this->privCheckFileHeaders($v_local_header,
4875: $v_header_list[$i]) != 1) {
4876:
4877: }
4878: unset($v_local_header);
4879:
4880:
4881: if (($v_result = $v_temp_zip->privWriteFileHeader($v_header_list[$i])) != 1) {
4882:
4883: $this->privCloseFd();
4884: $v_temp_zip->privCloseFd();
4885: @unlink($v_zip_temp_name);
4886:
4887:
4888: return $v_result;
4889: }
4890:
4891:
4892: if (($v_result = PclZipUtilCopyBlock($this->zip_fd, $v_temp_zip->zip_fd, $v_header_list[$i]['compressed_size'])) != 1) {
4893:
4894: $this->privCloseFd();
4895: $v_temp_zip->privCloseFd();
4896: @unlink($v_zip_temp_name);
4897:
4898:
4899: return $v_result;
4900: }
4901: }
4902:
4903:
4904: $v_offset = @ftell($v_temp_zip->zip_fd);
4905:
4906:
4907: for ($i=0; $i<sizeof($v_header_list); $i++) {
4908:
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:
4915: return $v_result;
4916: }
4917:
4918:
4919: $v_temp_zip->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
4920: }
4921:
4922:
4923:
4924: $v_comment = '';
4925: if (isset($p_options[PCLZIP_OPT_COMMENT])) {
4926: $v_comment = $p_options[PCLZIP_OPT_COMMENT];
4927: }
4928:
4929:
4930: $v_size = @ftell($v_temp_zip->zip_fd)-$v_offset;
4931:
4932:
4933: if (($v_result = $v_temp_zip->privWriteCentralHeader(sizeof($v_header_list), $v_size, $v_offset, $v_comment)) != 1) {
4934:
4935: unset($v_header_list);
4936: $v_temp_zip->privCloseFd();
4937: $this->privCloseFd();
4938: @unlink($v_zip_temp_name);
4939:
4940:
4941: return $v_result;
4942: }
4943:
4944:
4945: $v_temp_zip->privCloseFd();
4946: $this->privCloseFd();
4947:
4948:
4949:
4950: @unlink($this->zipname);
4951:
4952:
4953:
4954:
4955: PclZipUtilRename($v_zip_temp_name, $this->zipname);
4956:
4957:
4958: unset($v_temp_zip);
4959: }
4960:
4961:
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:
4977: return $v_result;
4978: }
4979:
4980:
4981:
4982:
4983:
4984:
4985:
4986:
4987:
4988:
4989:
4990:
4991:
4992: function privDirCheck($p_dir, $p_is_dir=false)
4993: {
4994: $v_result = 1;
4995:
4996:
4997:
4998: if (($p_is_dir) && (substr($p_dir, -1)=='/'))
4999: {
5000: $p_dir = substr($p_dir, 0, strlen($p_dir)-1);
5001: }
5002:
5003:
5004: if ((is_dir($p_dir)) || ($p_dir == ""))
5005: {
5006: return 1;
5007: }
5008:
5009:
5010: $p_parent_dir = dirname($p_dir);
5011:
5012:
5013: if ($p_parent_dir != $p_dir)
5014: {
5015:
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:
5026: if (!@mkdir($p_dir, 0777))
5027: {
5028:
5029: PclZip::privErrorLog(PCLZIP_ERR_DIR_CREATE_FAIL, "Unable to create directory '$p_dir'");
5030:
5031:
5032: return PclZip::errorCode();
5033: }
5034:
5035:
5036: return $v_result;
5037: }
5038:
5039:
5040:
5041:
5042:
5043:
5044:
5045:
5046:
5047: function privMerge(&$p_archive_to_add)
5048: {
5049: $v_result=1;
5050:
5051:
5052: if (!is_file($p_archive_to_add->zipname))
5053: {
5054:
5055:
5056: $v_result = 1;
5057:
5058:
5059: return $v_result;
5060: }
5061:
5062:
5063: if (!is_file($this->zipname))
5064: {
5065:
5066:
5067: $v_result = $this->privDuplicate($p_archive_to_add->zipname);
5068:
5069:
5070: return $v_result;
5071: }
5072:
5073:
5074: if (($v_result=$this->privOpenFd('rb')) != 1)
5075: {
5076:
5077: return $v_result;
5078: }
5079:
5080:
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:
5089: @rewind($this->zip_fd);
5090:
5091:
5092: if (($v_result=$p_archive_to_add->privOpenFd('rb')) != 1)
5093: {
5094: $this->privCloseFd();
5095:
5096:
5097: return $v_result;
5098: }
5099:
5100:
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:
5111: @rewind($p_archive_to_add->zip_fd);
5112:
5113:
5114: $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
5115:
5116:
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:
5125: return PclZip::errorCode();
5126: }
5127:
5128:
5129:
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:
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:
5150: $v_offset = @ftell($v_zip_temp_fd);
5151:
5152:
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:
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:
5173: $v_comment = $v_central_dir['comment'].' '.$v_central_dir_to_add['comment'];
5174:
5175:
5176: $v_size = @ftell($v_zip_temp_fd)-$v_offset;
5177:
5178:
5179:
5180:
5181: $v_swap = $this->zip_fd;
5182: $this->zip_fd = $v_zip_temp_fd;
5183: $v_zip_temp_fd = $v_swap;
5184:
5185:
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:
5194: unset($v_header_list);
5195:
5196:
5197: return $v_result;
5198: }
5199:
5200:
5201: $v_swap = $this->zip_fd;
5202: $this->zip_fd = $v_zip_temp_fd;
5203: $v_zip_temp_fd = $v_swap;
5204:
5205:
5206: $this->privCloseFd();
5207: $p_archive_to_add->privCloseFd();
5208:
5209:
5210: @fclose($v_zip_temp_fd);
5211:
5212:
5213:
5214: @unlink($this->zipname);
5215:
5216:
5217:
5218:
5219: PclZipUtilRename($v_zip_temp_name, $this->zipname);
5220:
5221:
5222: return $v_result;
5223: }
5224:
5225:
5226:
5227:
5228:
5229:
5230:
5231:
5232: function privDuplicate($p_archive_filename)
5233: {
5234: $v_result=1;
5235:
5236:
5237: if (!is_file($p_archive_filename))
5238: {
5239:
5240:
5241: $v_result = 1;
5242:
5243:
5244: return $v_result;
5245: }
5246:
5247:
5248: if (($v_result=$this->privOpenFd('wb')) != 1)
5249: {
5250:
5251: return $v_result;
5252: }
5253:
5254:
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:
5262: return PclZip::errorCode();
5263: }
5264:
5265:
5266:
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:
5277: $this->privCloseFd();
5278:
5279:
5280: @fclose($v_zip_temp_fd);
5281:
5282:
5283: return $v_result;
5284: }
5285:
5286:
5287:
5288:
5289:
5290:
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:
5306:
5307:
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:
5323:
5324:
5325:
5326:
5327: function privDisableMagicQuotes()
5328: {
5329: $v_result=1;
5330:
5331:
5332: if ( (!function_exists("get_magic_quotes_runtime"))
5333: || (!function_exists("set_magic_quotes_runtime"))) {
5334: return $v_result;
5335: }
5336:
5337:
5338: if ($this->magic_quotes_status != -1) {
5339: return $v_result;
5340: }
5341:
5342:
5343: $this->magic_quotes_status = @get_magic_quotes_runtime();
5344:
5345:
5346: if ($this->magic_quotes_status == 1) {
5347: @set_magic_quotes_runtime(0);
5348: }
5349:
5350:
5351: return $v_result;
5352: }
5353:
5354:
5355:
5356:
5357:
5358:
5359:
5360:
5361: function privSwapBackMagicQuotes()
5362: {
5363: $v_result=1;
5364:
5365:
5366: if ( (!function_exists("get_magic_quotes_runtime"))
5367: || (!function_exists("set_magic_quotes_runtime"))) {
5368: return $v_result;
5369: }
5370:
5371:
5372: if ($this->magic_quotes_status != -1) {
5373: return $v_result;
5374: }
5375:
5376:
5377: if ($this->magic_quotes_status == 1) {
5378: @set_magic_quotes_runtime($this->magic_quotes_status);
5379: }
5380:
5381:
5382: return $v_result;
5383: }
5384:
5385:
5386: }
5387:
5388:
5389:
5390:
5391:
5392:
5393:
5394:
5395:
5396: function PclZipUtilPathReduction($p_dir)
5397: {
5398: $v_result = "";
5399:
5400:
5401: if ($p_dir != "") {
5402:
5403: $v_list = explode("/", $p_dir);
5404:
5405:
5406: $v_skip = 0;
5407: for ($i=sizeof($v_list)-1; $i>=0; $i--) {
5408:
5409: if ($v_list[$i] == ".") {
5410:
5411:
5412: }
5413: else if ($v_list[$i] == "..") {
5414: $v_skip++;
5415: }
5416: else if ($v_list[$i] == "") {
5417:
5418: if ($i == 0) {
5419: $v_result = "/".$v_result;
5420: if ($v_skip > 0) {
5421:
5422:
5423: $v_result = $p_dir;
5424: $v_skip = 0;
5425: }
5426: }
5427:
5428: else if ($i == (sizeof($v_list)-1)) {
5429: $v_result = $v_list[$i];
5430: }
5431:
5432: else {
5433:
5434:
5435: }
5436: }
5437: else {
5438:
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:
5449: if ($v_skip > 0) {
5450: while ($v_skip > 0) {
5451: $v_result = '../'.$v_result;
5452: $v_skip--;
5453: }
5454: }
5455: }
5456:
5457:
5458: return $v_result;
5459: }
5460:
5461:
5462:
5463:
5464:
5465:
5466:
5467:
5468:
5469:
5470:
5471:
5472:
5473:
5474:
5475:
5476:
5477: function PclZipUtilPathInclusion($p_dir, $p_path)
5478: {
5479: $v_result = 1;
5480:
5481:
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:
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:
5498: $i = 0;
5499: $j = 0;
5500: while (($i < $v_list_dir_size) && ($j < $v_list_path_size) && ($v_result)) {
5501:
5502:
5503: if ($v_list_dir[$i] == '') {
5504: $i++;
5505: continue;
5506: }
5507: if ($v_list_path[$j] == '') {
5508: $j++;
5509: continue;
5510: }
5511:
5512:
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:
5518: $i++;
5519: $j++;
5520: }
5521:
5522:
5523: if ($v_result) {
5524:
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:
5530: $v_result = 2;
5531: }
5532: else if ($i < $v_list_dir_size) {
5533:
5534: $v_result = 0;
5535: }
5536: }
5537:
5538:
5539: return $v_result;
5540: }
5541:
5542:
5543:
5544:
5545:
5546:
5547:
5548:
5549:
5550:
5551:
5552:
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:
5600: return $v_result;
5601: }
5602:
5603:
5604:
5605:
5606:
5607:
5608:
5609:
5610:
5611:
5612:
5613:
5614:
5615:
5616: function PclZipUtilRename($p_src, $p_dest)
5617: {
5618: $v_result = 1;
5619:
5620:
5621: if (!@rename($p_src, $p_dest)) {
5622:
5623:
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:
5633: return $v_result;
5634: }
5635:
5636:
5637:
5638:
5639:
5640:
5641:
5642:
5643:
5644:
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:
5668:
5669:
5670:
5671:
5672:
5673:
5674:
5675:
5676:
5677: function PclZipUtilTranslateWinPath($p_path, $p_remove_disk_letter=true)
5678: {
5679: if (stristr(php_uname(), 'windows')) {
5680:
5681: if (($p_remove_disk_letter) && (($v_position = strpos($p_path, ':')) != false)) {
5682: $p_path = substr($p_path, $v_position+1);
5683: }
5684:
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: ?>
5695: