IO::Compress::Zip(3pm)

1IO::Compress::Zip(3pm) Perl Programmers Reference Guide IO::Compress::Zip(3pm)
2
3
4

NAME

6       IO::Compress::Zip - Write zip files/buffers
7

SYNOPSIS

9           use IO::Compress::Zip qw(zip $ZipError) ;
10
11           my $status = zip $input => $output [,OPTS]
12               or die "zip failed: $ZipError\n";
13
14           my $z = new IO::Compress::Zip $output [,OPTS]
15               or die "zip failed: $ZipError\n";
16
17           $z->print($string);
18           $z->printf($format, $string);
19           $z->write($string);
20           $z->syswrite($string [, $length, $offset]);
21           $z->flush();
22           $z->tell();
23           $z->eof();
24           $z->seek($position, $whence);
25           $z->binmode();
26           $z->fileno();
27           $z->opened();
28           $z->autoflush();
29           $z->input_line_number();
30           $z->newStream( [OPTS] );
31
32           $z->deflateParams();
33
34           $z->close() ;
35
36           $ZipError ;
37
38           # IO::File mode
39
40           print $z $string;
41           printf $z $format, $string;
42           tell $z
43           eof $z
44           seek $z, $position, $whence
45           binmode $z
46           fileno $z
47           close $z ;
48

DESCRIPTION

50       This module provides a Perl interface that allows writing zip
51       compressed data to files or buffer.
52
53       The primary purpose of this module is to provide streaming write access
54       to zip files and buffers. It is not a general-purpose file archiver. If
55       that is what you want, check out "Archive::Zip".
56
57       At present three compression methods are supported by
58       IO::Compress::Zip, namely Store (no compression at all), Deflate and
59       Bzip2.
60
61       Note that to create Bzip2 content, the module "IO::Compress::Bzip2"
62       must be installed.
63
64       For reading zip files/buffers, see the companion module
65       IO::Uncompress::Unzip.
66

Functional Interface

68       A top-level function, "zip", is provided to carry out "one-shot"
69       compression between buffers and/or files. For finer control over the
70       compression process, see the "OO Interface" section.
71
72           use IO::Compress::Zip qw(zip $ZipError) ;
73
74           zip $input => $output [,OPTS]
75               or die "zip failed: $ZipError\n";
76
77       The functional interface needs Perl5.005 or better.
78
79   zip $input => $output [, OPTS]
80       "zip" expects at least two parameters, $input and $output.
81
82       The $input parameter
83
84       The parameter, $input, is used to define the source of the uncompressed
85       data.
86
87       It can take one of the following forms:
88
89       A filename
90            If the $input parameter is a simple scalar, it is assumed to be a
91            filename. This file will be opened for reading and the input data
92            will be read from it.
93
94       A filehandle
95            If the $input parameter is a filehandle, the input data will be
96            read from it.  The string '-' can be used as an alias for standard
97            input.
98
99       A scalar reference
100            If $input is a scalar reference, the input data will be read from
101            $$input.
102
103       An array reference
104            If $input is an array reference, each element in the array must be
105            a filename.
106
107            The input data will be read from each file in turn.
108
109            The complete array will be walked to ensure that it only contains
110            valid filenames before any data is compressed.
111
112       An Input FileGlob string
113            If $input is a string that is delimited by the characters "<" and
114            ">" "zip" will assume that it is an input fileglob string. The
115            input is the list of files that match the fileglob.
116
117            If the fileglob does not match any files ...
118
119            See File::GlobMapper for more details.
120
121       If the $input parameter is any other type, "undef" will be returned.
122
123       In addition, if $input is a simple filename, the default values for the
124       "Name", "Time", "ExtAttr" and "exTime" options will be sourced from
125       that file.
126
127       If you do not want to use these defaults they can be overridden by
128       explicitly setting the "Name", "Time", "ExtAttr" and "exTime" options
129       or by setting the "Minimal" parameter.
130
131       The $output parameter
132
133       The parameter $output is used to control the destination of the
134       compressed data. This parameter can take one of these forms.
135
136       A filename
137            If the $output parameter is a simple scalar, it is assumed to be a
138            filename.  This file will be opened for writing and the compressed
139            data will be written to it.
140
141       A filehandle
142            If the $output parameter is a filehandle, the compressed data will
143            be written to it.  The string '-' can be used as an alias for
144            standard output.
145
146       A scalar reference
147            If $output is a scalar reference, the compressed data will be
148            stored in $$output.
149
150       An Array Reference
151            If $output is an array reference, the compressed data will be
152            pushed onto the array.
153
154       An Output FileGlob
155            If $output is a string that is delimited by the characters "<" and
156            ">" "zip" will assume that it is an output fileglob string. The
157            output is the list of files that match the fileglob.
158
159            When $output is an fileglob string, $input must also be a fileglob
160            string. Anything else is an error.
161
162       If the $output parameter is any other type, "undef" will be returned.
163
164   Notes
165       When $input maps to multiple files/buffers and $output is a single
166       file/buffer the input files/buffers will each be stored in $output as a
167       distinct entry.
168
169   Optional Parameters
170       Unless specified below, the optional parameters for "zip", "OPTS", are
171       the same as those used with the OO interface defined in the
172       "Constructor Options" section below.
173
174       "AutoClose => 0|1"
175            This option applies to any input or output data streams to "zip"
176            that are filehandles.
177
178            If "AutoClose" is specified, and the value is true, it will result
179            in all input and/or output filehandles being closed once "zip" has
180            completed.
181
182            This parameter defaults to 0.
183
184       "BinModeIn => 0|1"
185            When reading from a file or filehandle, set "binmode" before
186            reading.
187
188            Defaults to 0.
189
190       "Append => 0|1"
191            The behaviour of this option is dependent on the type of output
192            data stream.
193
194            ·    A Buffer
195
196                 If "Append" is enabled, all compressed data will be append to
197                 the end of the output buffer. Otherwise the output buffer
198                 will be cleared before any compressed data is written to it.
199
200            ·    A Filename
201
202                 If "Append" is enabled, the file will be opened in append
203                 mode. Otherwise the contents of the file, if any, will be
204                 truncated before any compressed data is written to it.
205
206            ·    A Filehandle
207
208                 If "Append" is enabled, the filehandle will be positioned to
209                 the end of the file via a call to "seek" before any
210                 compressed data is written to it.  Otherwise the file pointer
211                 will not be moved.
212
213            When "Append" is specified, and set to true, it will append all
214            compressed data to the output data stream.
215
216            So when the output is a filehandle it will carry out a seek to the
217            eof before writing any compressed data. If the output is a
218            filename, it will be opened for appending. If the output is a
219            buffer, all compressed data will be appened to the existing
220            buffer.
221
222            Conversely when "Append" is not specified, or it is present and is
223            set to false, it will operate as follows.
224
225            When the output is a filename, it will truncate the contents of
226            the file before writing any compressed data. If the output is a
227            filehandle its position will not be changed. If the output is a
228            buffer, it will be wiped before any compressed data is output.
229
230            Defaults to 0.
231
232   Examples
233       To read the contents of the file "file1.txt" and write the compressed
234       data to the file "file1.txt.zip".
235
236           use strict ;
237           use warnings ;
238           use IO::Compress::Zip qw(zip $ZipError) ;
239
240           my $input = "file1.txt";
241           zip $input => "$input.zip"
242               or die "zip failed: $ZipError\n";
243
244       To read from an existing Perl filehandle, $input, and write the
245       compressed data to a buffer, $buffer.
246
247           use strict ;
248           use warnings ;
249           use IO::Compress::Zip qw(zip $ZipError) ;
250           use IO::File ;
251
252           my $input = new IO::File "<file1.txt"
253               or die "Cannot open 'file1.txt': $!\n" ;
254           my $buffer ;
255           zip $input => \$buffer
256               or die "zip failed: $ZipError\n";
257
258       To compress all files in the directory "/my/home" that match "*.txt"
259       and store the compressed data in the same directory
260
261           use strict ;
262           use warnings ;
263           use IO::Compress::Zip qw(zip $ZipError) ;
264
265           zip '</my/home/*.txt>' => '<*.zip>'
266               or die "zip failed: $ZipError\n";
267
268       and if you want to compress each file one at a time, this will do the
269       trick
270
271           use strict ;
272           use warnings ;
273           use IO::Compress::Zip qw(zip $ZipError) ;
274
275           for my $input ( glob "/my/home/*.txt" )
276           {
277               my $output = "$input.zip" ;
278               zip $input => $output
279                   or die "Error compressing '$input': $ZipError\n";
280           }
281

OO Interface

283   Constructor
284       The format of the constructor for "IO::Compress::Zip" is shown below
285
286           my $z = new IO::Compress::Zip $output [,OPTS]
287               or die "IO::Compress::Zip failed: $ZipError\n";
288
289       It returns an "IO::Compress::Zip" object on success and undef on
290       failure.  The variable $ZipError will contain an error message on
291       failure.
292
293       If you are running Perl 5.005 or better the object, $z, returned from
294       IO::Compress::Zip can be used exactly like an IO::File filehandle.
295       This means that all normal output file operations can be carried out
296       with $z.  For example, to write to a compressed file/buffer you can use
297       either of these forms
298
299           $z->print("hello world\n");
300           print $z "hello world\n";
301
302       The mandatory parameter $output is used to control the destination of
303       the compressed data. This parameter can take one of these forms.
304
305       A filename
306            If the $output parameter is a simple scalar, it is assumed to be a
307            filename. This file will be opened for writing and the compressed
308            data will be written to it.
309
310       A filehandle
311            If the $output parameter is a filehandle, the compressed data will
312            be written to it.  The string '-' can be used as an alias for
313            standard output.
314
315       A scalar reference
316            If $output is a scalar reference, the compressed data will be
317            stored in $$output.
318
319       If the $output parameter is any other type, "IO::Compress::Zip"::new
320       will return undef.
321
322   Constructor Options
323       "OPTS" is any combination of the following options:
324
325       "AutoClose => 0|1"
326            This option is only valid when the $output parameter is a
327            filehandle. If specified, and the value is true, it will result in
328            the $output being closed once either the "close" method is called
329            or the "IO::Compress::Zip" object is destroyed.
330
331            This parameter defaults to 0.
332
333       "Append => 0|1"
334            Opens $output in append mode.
335
336            The behaviour of this option is dependent on the type of $output.
337
338            ·    A Buffer
339
340                 If $output is a buffer and "Append" is enabled, all
341                 compressed data will be append to the end of $output.
342                 Otherwise $output will be cleared before any data is written
343                 to it.
344
345            ·    A Filename
346
347                 If $output is a filename and "Append" is enabled, the file
348                 will be opened in append mode. Otherwise the contents of the
349                 file, if any, will be truncated before any compressed data is
350                 written to it.
351
352            ·    A Filehandle
353
354                 If $output is a filehandle, the file pointer will be
355                 positioned to the end of the file via a call to "seek" before
356                 any compressed data is written to it.  Otherwise the file
357                 pointer will not be moved.
358
359            This parameter defaults to 0.
360
361       "Name => $string"
362            Stores the contents of $string in the zip filename header field.
363            If "Name" is not specified, no zip filename field will be created.
364
365       "Time => $number"
366            Sets the last modified time field in the zip header to $number.
367
368            This field defaults to the time the "IO::Compress::Zip" object was
369            created if this option is not specified.
370
371       "ExtAttr => $attr"
372            This option controls the "external file attributes" field in the
373            central header of the zip file. This is a 4 byte field.
374
375            If you are running a Unix derivative this value defaults to
376
377                0666 << 16
378
379            This should allow read/write access to any files that are
380            extracted from the zip file/buffer.
381
382            For all other systems it defaults to 0.
383
384       "exTime => [$atime, $mtime, $ctime]"
385            This option expects an array reference with exactly three
386            elements: $atime, "mtime" and $ctime. These correspond to the last
387            access time, last modification time and creation time
388            respectively.
389
390            It uses these values to set the extended timestamp field (ID is
391            "UT") in the local zip header using the three values, $atime,
392            $mtime, $ctime. In addition it sets the extended timestamp field
393            in the central zip header using $mtime.
394
395            If any of the three values is "undef" that time value will not be
396            used.  So, for example, to set only the $mtime you would use this
397
398                exTime => [undef, $mtime, undef]
399
400            If the "Minimal" option is set to true, this option will be
401            ignored.
402
403            By default no extended time field is created.
404
405       "exUnix2 => [$uid, $gid]"
406            This option expects an array reference with exactly two elements:
407            $uid and $gid. These values correspond to the numeric user ID and
408            group ID of the owner of the files respectively.
409
410            When the "exUnix2" option is present it will trigger the creation
411            of a Unix2 extra field (ID is "Ux") in the local zip. This will be
412            populated with $uid and $gid. In addition an empty Unix2 extra
413            field will also be created in the central zip header
414
415            If the "Minimal" option is set to true, this option will be
416            ignored.
417
418            By default no Unix2 extra field is created.
419
420       "Comment => $comment"
421            Stores the contents of $comment in the Central File Header of the
422            zip file.
423
424            By default, no comment field is written to the zip file.
425
426       "ZipComment => $comment"
427            Stores the contents of $comment in the End of Central Directory
428            record of the zip file.
429
430            By default, no comment field is written to the zip file.
431
432       "Method => $method"
433            Controls which compression method is used. At present three
434            compression methods are supported, namely Store (no compression at
435            all), Deflate and Bzip2.
436
437            The symbols, ZIP_CM_STORE, ZIP_CM_DEFLATE and ZIP_CM_BZIP2 are
438            used to select the compression method.
439
440            These constants are not imported by "IO::Compress::Zip" by
441            default.
442
443                use IO::Compress::Zip qw(:zip_method);
444                use IO::Compress::Zip qw(:constants);
445                use IO::Compress::Zip qw(:all);
446
447            Note that to create Bzip2 content, the module
448            "IO::Compress::Bzip2" must be installed. A fatal error will be
449            thrown if you attempt to create Bzip2 content when
450            "IO::Compress::Bzip2" is not available.
451
452            The default method is ZIP_CM_DEFLATE.
453
454       "Stream => 0|1"
455            This option controls whether the zip file/buffer output is created
456            in streaming mode.
457
458            Note that when outputting to a file with streaming mode disabled
459            ("Stream" is 0), the output file must be seekable.
460
461            The default is 1.
462
463       "Zip64 => 0|1"
464            Create a Zip64 zip file/buffer. This option should only be used if
465            you want to store files larger than 4 Gig.
466
467            If you intend to manipulate the Zip64 zip files created with this
468            module using an external zip/unzip make sure that it supports
469            Zip64.
470
471            In particular, if you are using Info-Zip you need to have zip
472            version 3.x or better to update a Zip64 archive and unzip version
473            6.x to read a zip64 archive.
474
475            The default is 0.
476
477       "TextFlag => 0|1"
478            This parameter controls the setting of a bit in the zip central
479            header. It is used to signal that the data stored in the zip
480            file/buffer is probably text.
481
482            The default is 0.
483
484       "ExtraFieldLocal => $data" =item "ExtraFieldCentral => $data"
485            The "ExtraFieldLocal" option is used to store additional metadata
486            in the local header for the zip file/buffer. The
487            "ExtraFieldCentral" does the same for the matching central header.
488
489            An extra field consists of zero or more subfields. Each subfield
490            consists of a two byte header followed by the subfield data.
491
492            The list of subfields can be supplied in any of the following
493            formats
494
495                ExtraFieldLocal => [$id1, $data1,
496                                    $id2, $data2,
497                                     ...
498                                   ]
499
500                ExtraFieldLocal => [ [$id1 => $data1],
501                                     [$id2 => $data2],
502                                     ...
503                                   ]
504
505                ExtraFieldLocal => { $id1 => $data1,
506                                     $id2 => $data2,
507                                     ...
508                                   }
509
510            Where $id1, $id2 are two byte subfield ID's.
511
512            If you use the hash syntax, you have no control over the order in
513            which the ExtraSubFields are stored, plus you cannot have
514            SubFields with duplicate ID.
515
516            Alternatively the list of subfields can by supplied as a scalar,
517            thus
518
519                ExtraField => $rawdata
520
521            The Extended Time field (ID "UT"), set using the "exTime" option,
522            and the Unix2 extra field (ID "Ux), set using the "exUnix2"
523            option, are examples of extra fields.
524
525            If the "Minimal" option is set to true, this option will be
526            ignored.
527
528            The maximum size of an extra field 65535 bytes.
529
530       "Minimal => 1|0"
531            If specified, this option will disable the creation of all extra
532            fields in the zip local and central headers. So the "exTime",
533            "exUnix2", "ExtraFieldLocal" and "ExtraFieldCentral" options will
534            be ignored.
535
536            This parameter defaults to 0.
537
538       "BlockSize100K => number"
539            Specify the number of 100K blocks bzip2 uses during compression.
540
541            Valid values are from 1 to 9, where 9 is best compression.
542
543            This option is only valid if the "Method" is ZIP_CM_BZIP2. It is
544            ignored otherwise.
545
546            The default is 1.
547
548       "WorkFactor => number"
549            Specifies how much effort bzip2 should take before resorting to a
550            slower fallback compression algorithm.
551
552            Valid values range from 0 to 250, where 0 means use the default
553            value 30.
554
555            This option is only valid if the "Method" is ZIP_CM_BZIP2. It is
556            ignored otherwise.
557
558            The default is 0.
559
560       -Level
561            Defines the compression level used by zlib. The value should
562            either be a number between 0 and 9 (0 means no compression and 9
563            is maximum compression), or one of the symbolic constants defined
564            below.
565
566               Z_NO_COMPRESSION
567               Z_BEST_SPEED
568               Z_BEST_COMPRESSION
569               Z_DEFAULT_COMPRESSION
570
571            The default is Z_DEFAULT_COMPRESSION.
572
573            Note, these constants are not imported by "IO::Compress::Zip" by
574            default.
575
576                use IO::Compress::Zip qw(:strategy);
577                use IO::Compress::Zip qw(:constants);
578                use IO::Compress::Zip qw(:all);
579
580       -Strategy
581            Defines the strategy used to tune the compression. Use one of the
582            symbolic constants defined below.
583
584               Z_FILTERED
585               Z_HUFFMAN_ONLY
586               Z_RLE
587               Z_FIXED
588               Z_DEFAULT_STRATEGY
589
590            The default is Z_DEFAULT_STRATEGY.
591
592       "Strict => 0|1"
593            This is a placeholder option.
594
595   Examples
596       TODO
597

Methods

599   print
600       Usage is
601
602           $z->print($data)
603           print $z $data
604
605       Compresses and outputs the contents of the $data parameter. This has
606       the same behaviour as the "print" built-in.
607
608       Returns true if successful.
609
610   printf
611       Usage is
612
613           $z->printf($format, $data)
614           printf $z $format, $data
615
616       Compresses and outputs the contents of the $data parameter.
617
618       Returns true if successful.
619
620   syswrite
621       Usage is
622
623           $z->syswrite $data
624           $z->syswrite $data, $length
625           $z->syswrite $data, $length, $offset
626
627       Compresses and outputs the contents of the $data parameter.
628
629       Returns the number of uncompressed bytes written, or "undef" if
630       unsuccessful.
631
632   write
633       Usage is
634
635           $z->write $data
636           $z->write $data, $length
637           $z->write $data, $length, $offset
638
639       Compresses and outputs the contents of the $data parameter.
640
641       Returns the number of uncompressed bytes written, or "undef" if
642       unsuccessful.
643
644   flush
645       Usage is
646
647           $z->flush;
648           $z->flush($flush_type);
649
650       Flushes any pending compressed data to the output file/buffer.
651
652       This method takes an optional parameter, $flush_type, that controls how
653       the flushing will be carried out. By default the $flush_type used is
654       "Z_FINISH". Other valid values for $flush_type are "Z_NO_FLUSH",
655       "Z_SYNC_FLUSH", "Z_FULL_FLUSH" and "Z_BLOCK". It is strongly
656       recommended that you only set the "flush_type" parameter if you fully
657       understand the implications of what it does - overuse of "flush" can
658       seriously degrade the level of compression achieved. See the "zlib"
659       documentation for details.
660
661       Returns true on success.
662
663   tell
664       Usage is
665
666           $z->tell()
667           tell $z
668
669       Returns the uncompressed file offset.
670
671   eof
672       Usage is
673
674           $z->eof();
675           eof($z);
676
677       Returns true if the "close" method has been called.
678
679   seek
680           $z->seek($position, $whence);
681           seek($z, $position, $whence);
682
683       Provides a sub-set of the "seek" functionality, with the restriction
684       that it is only legal to seek forward in the output file/buffer.  It is
685       a fatal error to attempt to seek backward.
686
687       Empty parts of the file/buffer will have NULL (0x00) bytes written to
688       them.
689
690       The $whence parameter takes one the usual values, namely SEEK_SET,
691       SEEK_CUR or SEEK_END.
692
693       Returns 1 on success, 0 on failure.
694
695   binmode
696       Usage is
697
698           $z->binmode
699           binmode $z ;
700
701       This is a noop provided for completeness.
702
703   opened
704           $z->opened()
705
706       Returns true if the object currently refers to a opened file/buffer.
707
708   autoflush
709           my $prev = $z->autoflush()
710           my $prev = $z->autoflush(EXPR)
711
712       If the $z object is associated with a file or a filehandle, this method
713       returns the current autoflush setting for the underlying filehandle. If
714       "EXPR" is present, and is non-zero, it will enable flushing after every
715       write/print operation.
716
717       If $z is associated with a buffer, this method has no effect and always
718       returns "undef".
719
720       Note that the special variable $| cannot be used to set or retrieve the
721       autoflush setting.
722
723   input_line_number
724           $z->input_line_number()
725           $z->input_line_number(EXPR)
726
727       This method always returns "undef" when compressing.
728
729   fileno
730           $z->fileno()
731           fileno($z)
732
733       If the $z object is associated with a file or a filehandle, "fileno"
734       will return the underlying file descriptor. Once the "close" method is
735       called "fileno" will return "undef".
736
737       If the $z object is is associated with a buffer, this method will
738       return "undef".
739
740   close
741           $z->close() ;
742           close $z ;
743
744       Flushes any pending compressed data and then closes the output
745       file/buffer.
746
747       For most versions of Perl this method will be automatically invoked if
748       the IO::Compress::Zip object is destroyed (either explicitly or by the
749       variable with the reference to the object going out of scope). The
750       exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In these
751       cases, the "close" method will be called automatically, but not until
752       global destruction of all live objects when the program is terminating.
753
754       Therefore, if you want your scripts to be able to run on all versions
755       of Perl, you should call "close" explicitly and not rely on automatic
756       closing.
757
758       Returns true on success, otherwise 0.
759
760       If the "AutoClose" option has been enabled when the IO::Compress::Zip
761       object was created, and the object is associated with a file, the
762       underlying file will also be closed.
763
764   newStream([OPTS])
765       Usage is
766
767           $z->newStream( [OPTS] )
768
769       Closes the current compressed data stream and starts a new one.
770
771       OPTS consists of any of the the options that are available when
772       creating the $z object.
773
774       See the "Constructor Options" section for more details.
775
776   deflateParams
777       Usage is
778
779           $z->deflateParams
780
781       TODO
782

Importing

784       A number of symbolic constants are required by some methods in
785       "IO::Compress::Zip". None are imported by default.
786
787       :all Imports "zip", $ZipError and all symbolic constants that can be
788            used by "IO::Compress::Zip". Same as doing this
789
790                use IO::Compress::Zip qw(zip $ZipError :constants) ;
791
792       :constants
793            Import all symbolic constants. Same as doing this
794
795                use IO::Compress::Zip qw(:flush :level :strategy :zip_method) ;
796
797       :flush
798            These symbolic constants are used by the "flush" method.
799
800                Z_NO_FLUSH
801                Z_PARTIAL_FLUSH
802                Z_SYNC_FLUSH
803                Z_FULL_FLUSH
804                Z_FINISH
805                Z_BLOCK
806
807       :level
808            These symbolic constants are used by the "Level" option in the
809            constructor.
810
811                Z_NO_COMPRESSION
812                Z_BEST_SPEED
813                Z_BEST_COMPRESSION
814                Z_DEFAULT_COMPRESSION
815
816       :strategy
817            These symbolic constants are used by the "Strategy" option in the
818            constructor.
819
820                Z_FILTERED
821                Z_HUFFMAN_ONLY
822                Z_RLE
823                Z_FIXED
824                Z_DEFAULT_STRATEGY
825
826       :zip_method
827            These symbolic constants are used by the "Method" option in the
828            constructor.
829
830                ZIP_CM_STORE
831                ZIP_CM_DEFLATE
832                ZIP_CM_BZIP2
833

EXAMPLES

835   Apache::GZip Revisited
836       See IO::Compress::FAQ
837
838   Working with Net::FTP
839       See IO::Compress::FAQ
840

AUTHOR

868       This module was written by Paul Marquess, pmqs@cpan.org.
869

MODIFICATION HISTORY

871       See the Changes file.
872

COPYRIGHT AND LICENSE

874       Copyright (c) 2005-2010 Paul Marquess. All rights reserved.
875
876       This program is free software; you can redistribute it and/or modify it
877       under the same terms as Perl itself.
878
879
880
881perl v5.12.4                      2011-06-07            IO::Compress::Zip(3pm)