IO::Uncompress::Unzip(3pm)

1IO::Uncompress::Unzip(3U)ser Contributed Perl DocumentatiIoOn::Uncompress::Unzip(3)
2
3
4

NAME

6       IO::Uncompress::Unzip - Read zip files/buffers
7

SYNOPSIS

9           use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
10
11           my $status = unzip $input => $output [,OPTS]
12               or die "unzip failed: $UnzipError\n";
13
14           my $z = IO::Uncompress::Unzip->new( $input [OPTS] )
15               or die "unzip failed: $UnzipError\n";
16
17           $status = $z->read($buffer)
18           $status = $z->read($buffer, $length)
19           $status = $z->read($buffer, $length, $offset)
20           $line = $z->getline()
21           $char = $z->getc()
22           $char = $z->ungetc()
23           $char = $z->opened()
24
25           $status = $z->inflateSync()
26
27           $data = $z->trailingData()
28           $status = $z->nextStream()
29           $data = $z->getHeaderInfo()
30           $z->tell()
31           $z->seek($position, $whence)
32           $z->binmode()
33           $z->fileno()
34           $z->eof()
35           $z->close()
36
37           $UnzipError ;
38
39           # IO::File mode
40
41           <$z>
42           read($z, $buffer);
43           read($z, $buffer, $length);
44           read($z, $buffer, $length, $offset);
45           tell($z)
46           seek($z, $position, $whence)
47           binmode($z)
48           fileno($z)
49           eof($z)
50           close($z)
51

DESCRIPTION

53       This module provides a Perl interface that allows the reading of zlib
54       files/buffers.
55
56       For writing zip files/buffers, see the companion module
57       IO::Compress::Zip.
58
59       The primary purpose of this module is to provide streaming read access
60       to zip files and buffers.
61
62       At present the following compression methods are supported by
63       IO::Uncompress::Unzip
64
65       Store (0)
66       Deflate (8)
67       Bzip2 (12)
68            To read Bzip2 content, the module "IO::Uncompress::Bunzip2" must
69            be installed.
70
71       Lzma (14)
72            To read LZMA content, the module "IO::Uncompress::UnLzma" must be
73            installed.
74
75       Xz (95)
76            To read Xz content, the module "IO::Uncompress::UnXz" must be
77            installed.
78
79       Zstandard (93)
80            To read Zstandard content, the module "IO::Uncompress::UnZstd"
81            must be installed.
82

Functional Interface

84       A top-level function, "unzip", is provided to carry out "one-shot"
85       uncompression between buffers and/or files. For finer control over the
86       uncompression process, see the "OO Interface" section.
87
88           use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
89
90           unzip $input_filename_or_reference => $output_filename_or_reference [,OPTS]
91               or die "unzip failed: $UnzipError\n";
92
93       The functional interface needs Perl5.005 or better.
94
95   unzip $input_filename_or_reference => $output_filename_or_reference [,
96       OPTS]
97       "unzip" expects at least two parameters, $input_filename_or_reference
98       and $output_filename_or_reference and zero or more optional parameters
99       (see "Optional Parameters")
100
101       The $input_filename_or_reference parameter
102
103       The parameter, $input_filename_or_reference, is used to define the
104       source of the compressed data.
105
106       It can take one of the following forms:
107
108       A filename
109            If the $input_filename_or_reference parameter is a simple scalar,
110            it is assumed to be a filename. This file will be opened for
111            reading and the input data will be read from it.
112
113       A filehandle
114            If the $input_filename_or_reference parameter is a filehandle, the
115            input data will be read from it.  The string '-' can be used as an
116            alias for standard input.
117
118       A scalar reference
119            If $input_filename_or_reference is a scalar reference, the input
120            data will be read from $$input_filename_or_reference.
121
122       An array reference
123            If $input_filename_or_reference is an array reference, each
124            element in the array must be a filename.
125
126            The input data will be read from each file in turn.
127
128            The complete array will be walked to ensure that it only contains
129            valid filenames before any data is uncompressed.
130
131       An Input FileGlob string
132            If $input_filename_or_reference is a string that is delimited by
133            the characters "<" and ">" "unzip" will assume that it is an input
134            fileglob string. The input is the list of files that match the
135            fileglob.
136
137            See File::GlobMapper for more details.
138
139       If the $input_filename_or_reference parameter is any other type,
140       "undef" will be returned.
141
142       The $output_filename_or_reference parameter
143
144       The parameter $output_filename_or_reference is used to control the
145       destination of the uncompressed data. This parameter can take one of
146       these forms.
147
148       A filename
149            If the $output_filename_or_reference parameter is a simple scalar,
150            it is assumed to be a filename.  This file will be opened for
151            writing and the uncompressed data will be written to it.
152
153       A filehandle
154            If the $output_filename_or_reference parameter is a filehandle,
155            the uncompressed data will be written to it.  The string '-' can
156            be used as an alias for standard output.
157
158       A scalar reference
159            If $output_filename_or_reference is a scalar reference, the
160            uncompressed data will be stored in
161            $$output_filename_or_reference.
162
163       An Array Reference
164            If $output_filename_or_reference is an array reference, the
165            uncompressed data will be pushed onto the array.
166
167       An Output FileGlob
168            If $output_filename_or_reference is a string that is delimited by
169            the characters "<" and ">" "unzip" will assume that it is an
170            output fileglob string. The output is the list of files that match
171            the fileglob.
172
173            When $output_filename_or_reference is an fileglob string,
174            $input_filename_or_reference must also be a fileglob string.
175            Anything else is an error.
176
177            See File::GlobMapper for more details.
178
179       If the $output_filename_or_reference parameter is any other type,
180       "undef" will be returned.
181
182   Notes
183       When $input_filename_or_reference maps to multiple compressed
184       files/buffers and $output_filename_or_reference is a single
185       file/buffer, after uncompression $output_filename_or_reference will
186       contain a concatenation of all the uncompressed data from each of the
187       input files/buffers.
188
189   Optional Parameters
190       The optional parameters for the one-shot function "unzip" are (for the
191       most part) identical to those used with the OO interface defined in the
192       "Constructor Options" section. The exceptions are listed below
193
194       "AutoClose => 0|1"
195            This option applies to any input or output data streams to "unzip"
196            that are filehandles.
197
198            If "AutoClose" is specified, and the value is true, it will result
199            in all input and/or output filehandles being closed once "unzip"
200            has completed.
201
202            This parameter defaults to 0.
203
204       "BinModeOut => 0|1"
205            This option is now a no-op. All files will be written  in binmode.
206
207       "Append => 0|1"
208            The behaviour of this option is dependent on the type of output
209            data stream.
210
211            •    A Buffer
212
213                 If "Append" is enabled, all uncompressed data will be append
214                 to the end of the output buffer. Otherwise the output buffer
215                 will be cleared before any uncompressed data is written to
216                 it.
217
218            •    A Filename
219
220                 If "Append" is enabled, the file will be opened in append
221                 mode. Otherwise the contents of the file, if any, will be
222                 truncated before any uncompressed data is written to it.
223
224            •    A Filehandle
225
226                 If "Append" is enabled, the filehandle will be positioned to
227                 the end of the file via a call to "seek" before any
228                 uncompressed data is written to it.  Otherwise the file
229                 pointer will not be moved.
230
231            When "Append" is specified, and set to true, it will append all
232            uncompressed data to the output data stream.
233
234            So when the output is a filehandle it will carry out a seek to the
235            eof before writing any uncompressed data. If the output is a
236            filename, it will be opened for appending. If the output is a
237            buffer, all uncompressed data will be appended to the existing
238            buffer.
239
240            Conversely when "Append" is not specified, or it is present and is
241            set to false, it will operate as follows.
242
243            When the output is a filename, it will truncate the contents of
244            the file before writing any uncompressed data. If the output is a
245            filehandle its position will not be changed. If the output is a
246            buffer, it will be wiped before any uncompressed data is output.
247
248            Defaults to 0.
249
250       "MultiStream => 0|1"
251            If the input file/buffer contains multiple compressed data
252            streams, this option will uncompress the whole lot as a single
253            data stream.
254
255            Defaults to 0.
256
257       "TrailingData => $scalar"
258            Returns the data, if any, that is present immediately after the
259            compressed data stream once uncompression is complete.
260
261            This option can be used when there is useful information
262            immediately following the compressed data stream, and you don't
263            know the length of the compressed data stream.
264
265            If the input is a buffer, "trailingData" will return everything
266            from the end of the compressed data stream to the end of the
267            buffer.
268
269            If the input is a filehandle, "trailingData" will return the data
270            that is left in the filehandle input buffer once the end of the
271            compressed data stream has been reached. You can then use the
272            filehandle to read the rest of the input file.
273
274            Don't bother using "trailingData" if the input is a filename.
275
276            If you know the length of the compressed data stream before you
277            start uncompressing, you can avoid having to use "trailingData" by
278            setting the "InputLength" option.
279
280   OneShot Examples
281       Say you have a zip file, "file1.zip", that only contains a single
282       member, you can read it and write the uncompressed data to the file
283       "file1.txt" like this.
284
285           use strict ;
286           use warnings ;
287           use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
288
289           my $input = "file1.zip";
290           my $output = "file1.txt";
291           unzip $input => $output
292               or die "unzip failed: $UnzipError\n";
293
294       If you have a zip file that contains multiple members and want to read
295       a specific member from the file, say "data1", use the "Name" option
296
297           use strict ;
298           use warnings ;
299           use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
300
301           my $input = "file1.zip";
302           my $output = "file1.txt";
303           unzip $input => $output, Name => "data1"
304               or die "unzip failed: $UnzipError\n";
305
306       Alternatively, if you want to read the  "data1" member into memory, use
307       a scalar reference for the "output" parameter.
308
309           use strict ;
310           use warnings ;
311           use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
312
313           my $input = "file1.zip";
314           my $output ;
315           unzip $input => \$output, Name => "data1"
316               or die "unzip failed: $UnzipError\n";
317           # $output now contains the uncompressed data
318
319       To read from an existing Perl filehandle, $input, and write the
320       uncompressed data to a buffer, $buffer.
321
322           use strict ;
323           use warnings ;
324           use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
325           use IO::File ;
326
327           my $input = IO::File->new( "<file1.zip" )
328               or die "Cannot open 'file1.zip': $!\n" ;
329           my $buffer ;
330           unzip $input => \$buffer
331               or die "unzip failed: $UnzipError\n";
332

OO Interface

334   Constructor
335       The format of the constructor for IO::Uncompress::Unzip is shown below
336
337           my $z = IO::Uncompress::Unzip->new( $input [OPTS] )
338               or die "IO::Uncompress::Unzip failed: $UnzipError\n";
339
340       The constructor takes one mandatory parameter, $input, defined below,
341       and zero or more "OPTS", defined in "Constructor Options".
342
343       Returns an "IO::Uncompress::Unzip" object on success and undef on
344       failure.  The variable $UnzipError will contain an error message on
345       failure.
346
347       If you are running Perl 5.005 or better the object, $z, returned from
348       IO::Uncompress::Unzip can be used exactly like an IO::File filehandle.
349       This means that all normal input file operations can be carried out
350       with $z.  For example, to read a line from a compressed file/buffer you
351       can use either of these forms
352
353           $line = $z->getline();
354           $line = <$z>;
355
356       Below is a simple exaple of using the OO interface to read the
357       compressed file "myfile.zip" and write its contents to stdout.
358
359           my $filename = "myfile.zip";
360           my $z = IO::Uncompress::Unzip->new($filename)
361               or die "IO::Uncompress::Unzip failed: $UnzipError\n";
362
363           while (<$z>) {
364               print $_;
365           }
366           $z->close();
367
368       See "EXAMPLES" for further examples
369
370       The mandatory parameter $input is used to determine the source of the
371       compressed data. This parameter can take one of three forms.
372
373       A filename
374            If the $input parameter is a scalar, it is assumed to be a
375            filename. This file will be opened for reading and the compressed
376            data will be read from it.
377
378       A filehandle
379            If the $input parameter is a filehandle, the compressed data will
380            be read from it.  The string '-' can be used as an alias for
381            standard input.
382
383       A scalar reference
384            If $input is a scalar reference, the compressed data will be read
385            from $$input.
386
387   Constructor Options
388       The option names defined below are case insensitive and can be
389       optionally prefixed by a '-'.  So all of the following are valid
390
391           -AutoClose
392           -autoclose
393           AUTOCLOSE
394           autoclose
395
396       OPTS is a combination of the following options:
397
398       "Name => "membername""
399            Open "membername" from the zip file for reading.
400
401       "Efs => 0| 1"
402            When this option is set to true AND the zip archive being read has
403            the "Language Encoding Flag" (EFS) set, the member name is assumed
404            to be encoded in UTF-8.
405
406            If the member name in the zip archive is not valid UTF-8 when this
407            optionn is true, the script will die with an error message.
408
409            Note that this option only works with Perl 5.8.4 or better.
410
411            This option defaults to false.
412
413       "AutoClose => 0|1"
414            This option is only valid when the $input parameter is a
415            filehandle. If specified, and the value is true, it will result in
416            the file being closed once either the "close" method is called or
417            the IO::Uncompress::Unzip object is destroyed.
418
419            This parameter defaults to 0.
420
421       "MultiStream => 0|1"
422            Treats the complete zip file/buffer as a single compressed data
423            stream. When reading in multi-stream mode each member of the zip
424            file/buffer will be uncompressed in turn until the end of the
425            file/buffer is encountered.
426
427            This parameter defaults to 0.
428
429       "Prime => $string"
430            This option will uncompress the contents of $string before
431            processing the input file/buffer.
432
433            This option can be useful when the compressed data is embedded in
434            another file/data structure and it is not possible to work out
435            where the compressed data begins without having to read the first
436            few bytes. If this is the case, the uncompression can be primed
437            with these bytes using this option.
438
439       "Transparent => 0|1"
440            If this option is set and the input file/buffer is not compressed
441            data, the module will allow reading of it anyway.
442
443            In addition, if the input file/buffer does contain compressed data
444            and there is non-compressed data immediately following it, setting
445            this option will make this module treat the whole file/buffer as a
446            single data stream.
447
448            This option defaults to 1.
449
450       "BlockSize => $num"
451            When reading the compressed input data, IO::Uncompress::Unzip will
452            read it in blocks of $num bytes.
453
454            This option defaults to 4096.
455
456       "InputLength => $size"
457            When present this option will limit the number of compressed bytes
458            read from the input file/buffer to $size. This option can be used
459            in the situation where there is useful data directly after the
460            compressed data stream and you know beforehand the exact length of
461            the compressed data stream.
462
463            This option is mostly used when reading from a filehandle, in
464            which case the file pointer will be left pointing to the first
465            byte directly after the compressed data stream.
466
467            This option defaults to off.
468
469       "Append => 0|1"
470            This option controls what the "read" method does with uncompressed
471            data.
472
473            If set to 1, all uncompressed data will be appended to the output
474            parameter of the "read" method.
475
476            If set to 0, the contents of the output parameter of the "read"
477            method will be overwritten by the uncompressed data.
478
479            Defaults to 0.
480
481       "Strict => 0|1"
482            This option controls whether the extra checks defined below are
483            used when carrying out the decompression. When Strict is on, the
484            extra tests are carried out, when Strict is off they are not.
485
486            The default for this option is off.
487

Methods

489   read
490       Usage is
491
492           $status = $z->read($buffer)
493
494       Reads a block of compressed data (the size of the compressed block is
495       determined by the "Buffer" option in the constructor), uncompresses it
496       and writes any uncompressed data into $buffer. If the "Append"
497       parameter is set in the constructor, the uncompressed data will be
498       appended to the $buffer parameter. Otherwise $buffer will be
499       overwritten.
500
501       Returns the number of uncompressed bytes written to $buffer, zero if
502       eof or a negative number on error.
503
504   read
505       Usage is
506
507           $status = $z->read($buffer, $length)
508           $status = $z->read($buffer, $length, $offset)
509
510           $status = read($z, $buffer, $length)
511           $status = read($z, $buffer, $length, $offset)
512
513       Attempt to read $length bytes of uncompressed data into $buffer.
514
515       The main difference between this form of the "read" method and the
516       previous one, is that this one will attempt to return exactly $length
517       bytes. The only circumstances that this function will not is if end-of-
518       file or an IO error is encountered.
519
520       Returns the number of uncompressed bytes written to $buffer, zero if
521       eof or a negative number on error.
522
523   getline
524       Usage is
525
526           $line = $z->getline()
527           $line = <$z>
528
529       Reads a single line.
530
531       This method fully supports the use of the variable $/ (or
532       $INPUT_RECORD_SEPARATOR or $RS when "English" is in use) to determine
533       what constitutes an end of line. Paragraph mode, record mode and file
534       slurp mode are all supported.
535
536   getc
537       Usage is
538
539           $char = $z->getc()
540
541       Read a single character.
542
543   ungetc
544       Usage is
545
546           $char = $z->ungetc($string)
547
548   inflateSync
549       Usage is
550
551           $status = $z->inflateSync()
552
553       TODO
554
555   getHeaderInfo
556       Usage is
557
558           $hdr  = $z->getHeaderInfo();
559           @hdrs = $z->getHeaderInfo();
560
561       This method returns either a hash reference (in scalar context) or a
562       list or hash references (in array context) that contains information
563       about each of the header fields in the compressed data stream(s).
564
565   tell
566       Usage is
567
568           $z->tell()
569           tell $z
570
571       Returns the uncompressed file offset.
572
573   eof
574       Usage is
575
576           $z->eof();
577           eof($z);
578
579       Returns true if the end of the compressed input stream has been
580       reached.
581
582   seek
583           $z->seek($position, $whence);
584           seek($z, $position, $whence);
585
586       Provides a sub-set of the "seek" functionality, with the restriction
587       that it is only legal to seek forward in the input file/buffer.  It is
588       a fatal error to attempt to seek backward.
589
590       Note that the implementation of "seek" in this module does not provide
591       true random access to a compressed file/buffer. It  works by
592       uncompressing data from the current offset in the file/buffer until it
593       reaches the uncompressed offset specified in the parameters to "seek".
594       For very small files this may be acceptable behaviour. For large files
595       it may cause an unacceptable delay.
596
597       The $whence parameter takes one the usual values, namely SEEK_SET,
598       SEEK_CUR or SEEK_END.
599
600       Returns 1 on success, 0 on failure.
601
602   binmode
603       Usage is
604
605           $z->binmode
606           binmode $z ;
607
608       This is a noop provided for completeness.
609
610   opened
611           $z->opened()
612
613       Returns true if the object currently refers to a opened file/buffer.
614
615   autoflush
616           my $prev = $z->autoflush()
617           my $prev = $z->autoflush(EXPR)
618
619       If the $z object is associated with a file or a filehandle, this method
620       returns the current autoflush setting for the underlying filehandle. If
621       "EXPR" is present, and is non-zero, it will enable flushing after every
622       write/print operation.
623
624       If $z is associated with a buffer, this method has no effect and always
625       returns "undef".
626
627       Note that the special variable $| cannot be used to set or retrieve the
628       autoflush setting.
629
630   input_line_number
631           $z->input_line_number()
632           $z->input_line_number(EXPR)
633
634       Returns the current uncompressed line number. If "EXPR" is present it
635       has the effect of setting the line number. Note that setting the line
636       number does not change the current position within the file/buffer
637       being read.
638
639       The contents of $/ are used to determine what constitutes a line
640       terminator.
641
642   fileno
643           $z->fileno()
644           fileno($z)
645
646       If the $z object is associated with a file or a filehandle, "fileno"
647       will return the underlying file descriptor. Once the "close" method is
648       called "fileno" will return "undef".
649
650       If the $z object is associated with a buffer, this method will return
651       "undef".
652
653   close
654           $z->close() ;
655           close $z ;
656
657       Closes the output file/buffer.
658
659       For most versions of Perl this method will be automatically invoked if
660       the IO::Uncompress::Unzip object is destroyed (either explicitly or by
661       the variable with the reference to the object going out of scope). The
662       exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In these
663       cases, the "close" method will be called automatically, but not until
664       global destruction of all live objects when the program is terminating.
665
666       Therefore, if you want your scripts to be able to run on all versions
667       of Perl, you should call "close" explicitly and not rely on automatic
668       closing.
669
670       Returns true on success, otherwise 0.
671
672       If the "AutoClose" option has been enabled when the
673       IO::Uncompress::Unzip object was created, and the object is associated
674       with a file, the underlying file will also be closed.
675
676   nextStream
677       Usage is
678
679           my $status = $z->nextStream();
680
681       Skips to the next compressed data stream in the input file/buffer. If a
682       new compressed data stream is found, the eof marker will be cleared and
683       $.  will be reset to 0.
684
685       If trailing data is present immediately after the zip archive and the
686       "Transparent" option is enabled, this method will consider that
687       trailing data to be another member of the zip archive.
688
689       Returns 1 if a new stream was found, 0 if none was found, and -1 if an
690       error was encountered.
691
692   trailingData
693       Usage is
694
695           my $data = $z->trailingData();
696
697       Returns the data, if any, that is present immediately after the
698       compressed data stream once uncompression is complete. It only makes
699       sense to call this method once the end of the compressed data stream
700       has been encountered.
701
702       This option can be used when there is useful information immediately
703       following the compressed data stream, and you don't know the length of
704       the compressed data stream.
705
706       If the input is a buffer, "trailingData" will return everything from
707       the end of the compressed data stream to the end of the buffer.
708
709       If the input is a filehandle, "trailingData" will return the data that
710       is left in the filehandle input buffer once the end of the compressed
711       data stream has been reached. You can then use the filehandle to read
712       the rest of the input file.
713
714       Don't bother using "trailingData" if the input is a filename.
715
716       If you know the length of the compressed data stream before you start
717       uncompressing, you can avoid having to use "trailingData" by setting
718       the "InputLength" option in the constructor.
719

Importing

721       No symbolic constants are required by IO::Uncompress::Unzip at present.
722
723       :all Imports "unzip" and $UnzipError.  Same as doing this
724
725                use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
726

EXAMPLES

728   Simple Read
729       Say you have a zip file, "file1.zip", that only contains a single
730       member, you can read it and write the uncompressed data to the file
731       "file1.txt" like this.
732
733           use strict ;
734           use warnings ;
735           use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
736
737           my $filename = "file1.zip";
738           my $z = IO::Uncompress::Unzip->new($filename)
739               or die "IO::Uncompress::Unzip failed: $UnzipError\n";
740           open my $out, ">", "file1.txt";
741
742           while (<$z>) {
743               print $out $_;
744           }
745           $z->close();
746
747       If you have a zip file that contains multiple members and want to read
748       a specific member from the file, say "data1", use the "Name" option
749       when constructing the
750
751           use strict ;
752           use warnings ;
753           use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
754
755           my $filename = "file1.zip";
756           my $z = IO::Uncompress::Unzip->new($filename, Name => "data1")
757               or die "IO::Uncompress::Unzip failed: $UnzipError\n";
758
759   Walking through a zip file
760       The code below can be used to traverse a zip file, one compressed data
761       stream at a time.
762
763           use IO::Uncompress::Unzip qw($UnzipError);
764
765           my $zipfile = "somefile.zip";
766           my $u = IO::Uncompress::Unzip->new( $zipfile )
767               or die "Cannot open $zipfile: $UnzipError";
768
769           my $status;
770           for ($status = 1; $status > 0; $status = $u->nextStream())
771           {
772
773               my $name = $u->getHeaderInfo()->{Name};
774               warn "Processing member $name\n" ;
775
776               my $buff;
777               while (($status = $u->read($buff)) > 0) {
778                   # Do something here
779               }
780
781               last if $status < 0;
782           }
783
784           die "Error processing $zipfile: $!\n"
785               if $status < 0 ;
786
787       Each individual compressed data stream is read until the logical end-
788       of-file is reached. Then "nextStream" is called. This will skip to the
789       start of the next compressed data stream and clear the end-of-file
790       flag.
791
792       It is also worth noting that "nextStream" can be called at any time --
793       you don't have to wait until you have exhausted a compressed data
794       stream before skipping to the next one.
795
796   Unzipping a complete zip file to disk
797       Daniel S. Sterling has written a script that uses
798       "IO::Uncompress::UnZip" to read a zip file and unzip its contents to
799       disk.
800
801       The script is available from <https://gist.github.com/eqhmcow/5389877>
802
803   Working with Net::FTP
804       See IO::Compress::FAQ
805

SUPPORT

807       General feedback/questions/bug reports should be sent to
808       <https://github.com/pmqs/IO-Compress/issues> (preferred) or
809       <https://rt.cpan.org/Public/Dist/Display.html?Name=IO-Compress>.
810

AUTHOR

843       This module was written by Paul Marquess, "pmqs@cpan.org".
844

MODIFICATION HISTORY

846       See the Changes file.
847

COPYRIGHT AND LICENSE

849       Copyright (c) 2005-2023 Paul Marquess. All rights reserved.
850
851       This program is free software; you can redistribute it and/or modify it
852       under the same terms as Perl itself.
853
854
855
856perl v5.38.0                      2023-07-26          IO::Uncompress::Unzip(3)