1 package IO::Uncompress::Unzip;
11 use IO::Uncompress::RawInflate ;
12 use IO::Compress::Base::Common qw(:Status createSelfTiedObject);
13 use IO::Uncompress::Adapter::Identity;
17 our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $UnzipError);
19 $VERSION = '2.000_08';
22 @ISA = qw(Exporter IO::Uncompress::RawInflate);
23 @EXPORT_OK = qw( $UnzipError unzip );
24 %EXPORT_TAGS = %IO::Uncompress::RawInflate::EXPORT_TAGS ;
25 push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
26 Exporter::export_ok_tags('all');
32 my $obj = createSelfTiedObject($class, \$UnzipError);
33 $obj->_create(undef, 0, @_);
38 my $obj = createSelfTiedObject(undef, \$UnzipError);
39 return $obj->_inf(@_) ;
44 use IO::Compress::Base::Common qw(:Parse);
49 'Name' => [1, 1, Parse_any, undef],
51 # 'Streaming' => [1, 1, Parse_boolean, 1],
60 # unzip always needs crc32
61 $got->value('CRC32' => 1);
63 *$self->{UnzipData}{Name} = $got->value('Name');
74 $self->smartReadExact(\$magic, 4);
76 *$self->{HeaderPending} = $magic ;
78 return $self->HeaderError("Minimum header size is " .
80 if length $magic != 4 ;
82 return $self->HeaderError("Bad Magic")
83 if ! _isZipMagic($magic) ;
85 *$self->{Type} = 'zip';
97 my $name = *$self->{UnzipData}{Name} ;
98 my $hdr = $self->_readZipHeader($magic) ;
102 if (! defined $name || $hdr->{Name} eq $name)
109 if (*$self->{ZipData}{Streaming}) {
114 my $status = $self->smartRead(\$b, 1024 * 16);
120 $status = *$self->{Uncomp}->uncompr(\$b, \$temp_buf, 0, $out);
122 return $self->saveErrorString(undef, *$self->{Uncomp}{Error},
123 *$self->{Uncomp}{ErrorNo})
124 if $self->saveStatus($status) == STATUS_ERROR;
126 if ($status == STATUS_ENDSTREAM) {
127 *$self->{Uncomp}->reset();
128 $self->pushBack($b) ;
134 $self->smartReadExact(\$buffer, $hdr->{TrailerLength})
135 or return $self->saveErrorString(undef, "Truncated file");
138 my $c = $hdr->{CompressedLength};
139 $self->smartReadExact(\$buffer, $c)
140 or return $self->saveErrorString(undef, "Truncated file");
144 $self->chkTrailer($buffer) == STATUS_OK
145 or return $self->saveErrorString(undef, "Truncated file");
147 $hdr = $self->_readFullZipHeader();
149 return $self->saveErrorString(undef, "Cannot find '$name'")
150 if $self->smartEof();
161 my ($sig, $CRC32, $cSize, $uSize) ;
162 if (*$self->{ZipData}{Streaming}) {
163 ($sig, $CRC32, $cSize, $uSize) = unpack("V V V V", $trailer) ;
164 return $self->TrailerError("Data Descriptor signature, got $sig")
165 if $sig != 0x08074b50;
168 ($CRC32, $cSize, $uSize) =
169 (*$self->{ZipData}{Crc32},
170 *$self->{ZipData}{CompressedLen},
171 *$self->{ZipData}{UnCompressedLen});
174 if (*$self->{Strict}) {
175 #return $self->TrailerError("CRC mismatch")
176 # if $CRC32 != *$self->{Uncomp}->crc32() ;
178 my $exp_isize = *$self->{Uncomp}->compressedBytes();
179 return $self->TrailerError("CSIZE mismatch. Got $cSize"
180 . ", expected $exp_isize")
181 if $cSize != $exp_isize ;
183 $exp_isize = *$self->{Uncomp}->uncompressedBytes();
184 return $self->TrailerError("USIZE mismatch. Got $uSize"
185 . ", expected $exp_isize")
186 if $uSize != $exp_isize ;
189 my $reachedEnd = STATUS_ERROR ;
190 # check for central directory or end of central directory
194 my $got = $self->smartRead(\$magic, 4);
196 return $self->saveErrorString(STATUS_ERROR, "Truncated file")
197 if $got != 4 && *$self->{Strict};
203 return STATUS_ERROR ;
206 $self->pushBack($magic) ;
210 my $sig = unpack("V", $magic) ;
212 if ($sig == 0x02014b50)
214 if ($self->skipCentralDirectory($magic) != STATUS_OK ) {
215 if (*$self->{Strict}) {
216 return STATUS_ERROR ;
224 elsif ($sig == 0x06054b50)
226 if ($self->skipEndCentralDirectory($magic) != STATUS_OK) {
227 if (*$self->{Strict}) {
228 return STATUS_ERROR ;
235 # $reachedEnd = STATUS_OK ;
239 elsif ($sig == 0x04034b50)
241 $self->pushBack($magic) ;
247 $self->pushBack($magic) ;
255 sub skipCentralDirectory
261 $self->smartReadExact(\$buffer, 46 - 4)
262 or return $self->TrailerError("Minimum header size is " .
265 my $keep = $magic . $buffer ;
266 *$self->{HeaderPending} = $keep ;
268 #my $versionMadeBy = unpack ("v", substr($buffer, 4-4, 2));
269 #my $extractVersion = unpack ("v", substr($buffer, 6-4, 2));
270 #my $gpFlag = unpack ("v", substr($buffer, 8-4, 2));
271 #my $compressedMethod = unpack ("v", substr($buffer, 10-4, 2));
272 #my $lastModTime = unpack ("V", substr($buffer, 12-4, 4));
273 #my $crc32 = unpack ("V", substr($buffer, 16-4, 4));
274 #my $compressedLength = unpack ("V", substr($buffer, 20-4, 4));
275 #my $uncompressedLength = unpack ("V", substr($buffer, 24-4, 4));
276 my $filename_length = unpack ("v", substr($buffer, 28-4, 2));
277 my $extra_length = unpack ("v", substr($buffer, 30-4, 2));
278 my $comment_length = unpack ("v", substr($buffer, 32-4, 2));
279 #my $disk_start = unpack ("v", substr($buffer, 34-4, 2));
280 #my $int_file_attrib = unpack ("v", substr($buffer, 36-4, 2));
281 #my $ext_file_attrib = unpack ("V", substr($buffer, 38-4, 2));
282 #my $lcl_hdr_offset = unpack ("V", substr($buffer, 42-4, 2));
288 if ($filename_length)
290 $self->smartReadExact(\$filename, $filename_length)
291 or return $self->TrailerError("xxx");
297 $self->smartReadExact(\$extraField, $extra_length)
298 or return $self->TrailerError("xxx");
299 $keep .= $extraField ;
304 $self->smartReadExact(\$comment, $comment_length)
305 or return $self->TrailerError("xxx");
312 sub skipEndCentralDirectory
318 $self->smartReadExact(\$buffer, 22 - 4)
319 or return $self->TrailerError("Minimum header size is " .
322 my $keep = $magic . $buffer ;
323 *$self->{HeaderPending} = $keep ;
325 #my $diskNumber = unpack ("v", substr($buffer, 4-4, 2));
326 #my $cntrlDirDiskNo = unpack ("v", substr($buffer, 6-4, 2));
327 #my $entriesInThisCD = unpack ("v", substr($buffer, 8-4, 2));
328 #my $entriesInCD = unpack ("v", substr($buffer, 10-4, 2));
329 #my $sizeOfCD = unpack ("V", substr($buffer, 12-4, 2));
330 #my $offsetToCD = unpack ("V", substr($buffer, 16-4, 2));
331 my $comment_length = unpack ("v", substr($buffer, 20-4, 2));
337 $self->smartReadExact(\$comment, $comment_length)
338 or return $self->TrailerError("xxx");
351 return 0 if length $buffer < 4 ;
352 my $sig = unpack("V", $buffer) ;
353 return $sig == 0x04034b50 ;
357 sub _readFullZipHeader($)
362 $self->smartReadExact(\$magic, 4);
364 *$self->{HeaderPending} = $magic ;
366 return $self->HeaderError("Minimum header size is " .
368 if length $magic != 4 ;
371 return $self->HeaderError("Bad Magic")
372 if ! _isZipMagic($magic) ;
374 my $status = $self->_readZipHeader($magic);
375 delete *$self->{Transparent} if ! defined $status ;
379 sub _readZipHeader($)
381 my ($self, $magic) = @_ ;
385 $self->smartReadExact(\$buffer, 30 - 4)
386 or return $self->HeaderError("Minimum header size is " .
389 my $keep = $magic . $buffer ;
390 *$self->{HeaderPending} = $keep ;
392 my $extractVersion = unpack ("v", substr($buffer, 4-4, 2));
393 my $gpFlag = unpack ("v", substr($buffer, 6-4, 2));
394 my $compressedMethod = unpack ("v", substr($buffer, 8-4, 2));
395 my $lastModTime = unpack ("V", substr($buffer, 10-4, 4));
396 my $crc32 = unpack ("V", substr($buffer, 14-4, 4));
397 my $compressedLength = unpack ("V", substr($buffer, 18-4, 4));
398 my $uncompressedLength = unpack ("V", substr($buffer, 22-4, 4));
399 my $filename_length = unpack ("v", substr($buffer, 26-4, 2));
400 my $extra_length = unpack ("v", substr($buffer, 28-4, 2));
404 my $streamingMode = ($gpFlag & 0x08) ? 1 : 0 ;
406 return $self->HeaderError("Streamed Stored content not supported")
407 if $streamingMode && $compressedMethod == 0 ;
409 *$self->{ZipData}{Streaming} = $streamingMode;
411 if (! $streamingMode) {
412 *$self->{ZipData}{Streaming} = 0;
413 *$self->{ZipData}{Crc32} = $crc32;
414 *$self->{ZipData}{CompressedLen} = $compressedLength;
415 *$self->{ZipData}{UnCompressedLen} = $uncompressedLength;
416 *$self->{CompressedInputLengthRemaining} =
417 *$self->{CompressedInputLength} = $compressedLength;
421 if ($filename_length)
423 $self->smartReadExact(\$filename, $filename_length)
424 or return $self->HeaderError("xxx");
430 $self->smartReadExact(\$extraField, $extra_length)
431 or return $self->HeaderError("xxx");
432 $keep .= $extraField ;
435 if ($compressedMethod == 8)
437 *$self->{Type} = 'zip';
439 elsif ($compressedMethod == 0)
441 # TODO -- add support for reading uncompressed
443 *$self->{Type} = 'zipStored';
445 my $obj = IO::Uncompress::Adapter::Identity::mkUncompObject(# $got->value('CRC32'),
446 # $got->value('ADLER32'),
449 *$self->{Uncomp} = $obj;
454 return $self->HeaderError("Unsupported Compression format $compressedMethod");
459 'FingerprintLength' => 4,
460 #'HeaderLength' => $compressedMethod == 8 ? length $keep : 0,
461 'HeaderLength' => length $keep,
462 'TrailerLength' => $streamingMode ? 16 : 0,
464 'CompressedLength' => $compressedLength ,
465 'UncompressedLength' => $uncompressedLength ,
468 'Time' => _dosToUnixTime($lastModTime),
469 'Stream' => $streamingMode,
471 'MethodID' => $compressedMethod,
472 'MethodName' => $compressedMethod == 8
474 : $compressedMethod == 0
478 # 'TextFlag' => $flag & GZIP_FLG_FTEXT ? 1 : 0,
479 # 'HeaderCRCFlag' => $flag & GZIP_FLG_FHCRC ? 1 : 0,
480 # 'NameFlag' => $flag & GZIP_FLG_FNAME ? 1 : 0,
481 # 'CommentFlag' => $flag & GZIP_FLG_FCOMMENT ? 1 : 0,
482 # 'ExtraFlag' => $flag & GZIP_FLG_FEXTRA ? 1 : 0,
483 # 'Comment' => $comment,
485 # 'OsName' => defined $GZIP_OS_Names{$os}
486 # ? $GZIP_OS_Names{$os} : "Unknown",
487 # 'HeaderCRC' => $HeaderCRC,
489 # 'ExtraFlags' => $xfl,
490 # 'ExtraFieldRaw' => $EXTRA,
491 # 'ExtraField' => [ @EXTRA ],
500 #use Time::Local 'timelocal_nocheck';
501 use Time::Local 'timelocal';
505 my $year = ( ( $dt >> 25 ) & 0x7f ) + 80;
506 my $mon = ( ( $dt >> 21 ) & 0x0f ) - 1;
507 my $mday = ( ( $dt >> 16 ) & 0x1f );
509 my $hour = ( ( $dt >> 11 ) & 0x1f );
510 my $min = ( ( $dt >> 5 ) & 0x3f );
511 my $sec = ( ( $dt << 1 ) & 0x3e );
515 eval { timelocal( $sec, $min, $hour, $mday, $mon, $year ); };
530 IO::Uncompress::Unzip - Perl interface to read zip files/buffers
535 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
537 my $status = unzip $input => $output [,OPTS]
538 or die "unzip failed: $UnzipError\n";
540 my $z = new IO::Uncompress::Unzip $input [OPTS]
541 or die "unzip failed: $UnzipError\n";
543 $status = $z->read($buffer)
544 $status = $z->read($buffer, $length)
545 $status = $z->read($buffer, $length, $offset)
546 $line = $z->getline()
551 $status = $z->inflateSync()
554 $data = $z->getHeaderInfo()
556 $z->seek($position, $whence)
568 read($z, $buffer, $length);
569 read($z, $buffer, $length, $offset);
571 seek($z, $position, $whence)
582 B<WARNING -- This is a Beta release>.
586 =item * DO NOT use in production code.
588 =item * The documentation is incomplete in places.
590 =item * Parts of the interface defined here are tentative.
592 =item * Please report any problems you find.
600 This module provides a Perl interface that allows the reading of
603 For writing zip files/buffers, see the companion module IO::Compress::Zip.
607 =head1 Functional Interface
609 A top-level function, C<unzip>, is provided to carry out
610 "one-shot" uncompression between buffers and/or files. For finer
611 control over the uncompression process, see the L</"OO Interface">
614 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
616 unzip $input => $output [,OPTS]
617 or die "unzip failed: $UnzipError\n";
621 The functional interface needs Perl5.005 or better.
624 =head2 unzip $input => $output [, OPTS]
627 C<unzip> expects at least two parameters, C<$input> and C<$output>.
629 =head3 The C<$input> parameter
631 The parameter, C<$input>, is used to define the source of
634 It can take one of the following forms:
640 If the C<$input> parameter is a simple scalar, it is assumed to be a
641 filename. This file will be opened for reading and the input data
642 will be read from it.
646 If the C<$input> parameter is a filehandle, the input data will be
648 The string '-' can be used as an alias for standard input.
650 =item A scalar reference
652 If C<$input> is a scalar reference, the input data will be read
655 =item An array reference
657 If C<$input> is an array reference, each element in the array must be a
660 The input data will be read from each file in turn.
662 The complete array will be walked to ensure that it only
663 contains valid filenames before any data is uncompressed.
667 =item An Input FileGlob string
669 If C<$input> is a string that is delimited by the characters "<" and ">"
670 C<unzip> will assume that it is an I<input fileglob string>. The
671 input is the list of files that match the fileglob.
673 If the fileglob does not match any files ...
675 See L<File::GlobMapper|File::GlobMapper> for more details.
680 If the C<$input> parameter is any other type, C<undef> will be returned.
684 =head3 The C<$output> parameter
686 The parameter C<$output> is used to control the destination of the
687 uncompressed data. This parameter can take one of these forms.
693 If the C<$output> parameter is a simple scalar, it is assumed to be a
694 filename. This file will be opened for writing and the uncompressed
695 data will be written to it.
699 If the C<$output> parameter is a filehandle, the uncompressed data
700 will be written to it.
701 The string '-' can be used as an alias for standard output.
704 =item A scalar reference
706 If C<$output> is a scalar reference, the uncompressed data will be
707 stored in C<$$output>.
711 =item An Array Reference
713 If C<$output> is an array reference, the uncompressed data will be
714 pushed onto the array.
716 =item An Output FileGlob
718 If C<$output> is a string that is delimited by the characters "<" and ">"
719 C<unzip> will assume that it is an I<output fileglob string>. The
720 output is the list of files that match the fileglob.
722 When C<$output> is an fileglob string, C<$input> must also be a fileglob
723 string. Anything else is an error.
727 If the C<$output> parameter is any other type, C<undef> will be returned.
733 When C<$input> maps to multiple files/buffers and C<$output> is a single
734 file/buffer the uncompressed input files/buffers will all be stored
735 in C<$output> as a single uncompressed stream.
739 =head2 Optional Parameters
741 Unless specified below, the optional parameters for C<unzip>,
742 C<OPTS>, are the same as those used with the OO interface defined in the
743 L</"Constructor Options"> section below.
747 =item AutoClose =E<gt> 0|1
749 This option applies to any input or output data streams to
750 C<unzip> that are filehandles.
752 If C<AutoClose> is specified, and the value is true, it will result in all
753 input and/or output filehandles being closed once C<unzip> has
756 This parameter defaults to 0.
760 =item BinModeOut =E<gt> 0|1
762 When writing to a file or filehandle, set C<binmode> before writing to the
771 =item -Append =E<gt> 0|1
775 =item -MultiStream =E<gt> 0|1
777 Creates a new stream after each file.
790 To read the contents of the file C<file1.txt.zip> and write the
791 compressed data to the file C<file1.txt>.
795 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
797 my $input = "file1.txt.zip";
798 my $output = "file1.txt";
799 unzip $input => $output
800 or die "unzip failed: $UnzipError\n";
803 To read from an existing Perl filehandle, C<$input>, and write the
804 uncompressed data to a buffer, C<$buffer>.
808 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
811 my $input = new IO::File "<file1.txt.zip"
812 or die "Cannot open 'file1.txt.zip': $!\n" ;
814 unzip $input => \$buffer
815 or die "unzip failed: $UnzipError\n";
817 To uncompress all files in the directory "/my/home" that match "*.txt.zip" and store the compressed data in the same directory
821 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
823 unzip '</my/home/*.txt.zip>' => '</my/home/#1.txt>'
824 or die "unzip failed: $UnzipError\n";
826 and if you want to compress each file one at a time, this will do the trick
830 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
832 for my $input ( glob "/my/home/*.txt.zip" )
835 $output =~ s/.zip// ;
836 unzip $input => $output
837 or die "Error compressing '$input': $UnzipError\n";
844 The format of the constructor for IO::Uncompress::Unzip is shown below
847 my $z = new IO::Uncompress::Unzip $input [OPTS]
848 or die "IO::Uncompress::Unzip failed: $UnzipError\n";
850 Returns an C<IO::Uncompress::Unzip> object on success and undef on failure.
851 The variable C<$UnzipError> will contain an error message on failure.
853 If you are running Perl 5.005 or better the object, C<$z>, returned from
854 IO::Uncompress::Unzip can be used exactly like an L<IO::File|IO::File> filehandle.
855 This means that all normal input file operations can be carried out with
856 C<$z>. For example, to read a line from a compressed file/buffer you can
857 use either of these forms
859 $line = $z->getline();
862 The mandatory parameter C<$input> is used to determine the source of the
863 compressed data. This parameter can take one of three forms.
869 If the C<$input> parameter is a scalar, it is assumed to be a filename. This
870 file will be opened for reading and the compressed data will be read from it.
874 If the C<$input> parameter is a filehandle, the compressed data will be
876 The string '-' can be used as an alias for standard input.
879 =item A scalar reference
881 If C<$input> is a scalar reference, the compressed data will be read from
886 =head2 Constructor Options
889 The option names defined below are case insensitive and can be optionally
890 prefixed by a '-'. So all of the following are valid
897 OPTS is a combination of the following options:
901 =item -AutoClose =E<gt> 0|1
903 This option is only valid when the C<$input> parameter is a filehandle. If
904 specified, and the value is true, it will result in the file being closed once
905 either the C<close> method is called or the IO::Uncompress::Unzip object is
908 This parameter defaults to 0.
910 =item -MultiStream =E<gt> 0|1
914 Allows multiple concatenated compressed streams to be treated as a single
915 compressed stream. Decompression will stop once either the end of the
916 file/buffer is reached, an error is encountered (premature eof, corrupt
917 compressed data) or the end of a stream is not immediately followed by the
918 start of another stream.
920 This parameter defaults to 0.
924 =item -Prime =E<gt> $string
926 This option will uncompress the contents of C<$string> before processing the
929 This option can be useful when the compressed data is embedded in another
930 file/data structure and it is not possible to work out where the compressed
931 data begins without having to read the first few bytes. If this is the
932 case, the uncompression can be I<primed> with these bytes using this
935 =item -Transparent =E<gt> 0|1
937 If this option is set and the input file or buffer is not compressed data,
938 the module will allow reading of it anyway.
940 This option defaults to 1.
942 =item -BlockSize =E<gt> $num
944 When reading the compressed input data, IO::Uncompress::Unzip will read it in
945 blocks of C<$num> bytes.
947 This option defaults to 4096.
949 =item -InputLength =E<gt> $size
951 When present this option will limit the number of compressed bytes read
952 from the input file/buffer to C<$size>. This option can be used in the
953 situation where there is useful data directly after the compressed data
954 stream and you know beforehand the exact length of the compressed data
957 This option is mostly used when reading from a filehandle, in which case
958 the file pointer will be left pointing to the first byte directly after the
959 compressed data stream.
963 This option defaults to off.
965 =item -Append =E<gt> 0|1
967 This option controls what the C<read> method does with uncompressed data.
969 If set to 1, all uncompressed data will be appended to the output parameter
970 of the C<read> method.
972 If set to 0, the contents of the output parameter of the C<read> method
973 will be overwritten by the uncompressed data.
977 =item -Strict =E<gt> 0|1
981 This option controls whether the extra checks defined below are used when
982 carrying out the decompression. When Strict is on, the extra tests are
983 carried out, when Strict is off they are not.
985 The default for this option is off.
1012 $status = $z->read($buffer)
1014 Reads a block of compressed data (the size the the compressed block is
1015 determined by the C<Buffer> option in the constructor), uncompresses it and
1016 writes any uncompressed data into C<$buffer>. If the C<Append> parameter is
1017 set in the constructor, the uncompressed data will be appended to the
1018 C<$buffer> parameter. Otherwise C<$buffer> will be overwritten.
1020 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
1021 or a negative number on error.
1027 $status = $z->read($buffer, $length)
1028 $status = $z->read($buffer, $length, $offset)
1030 $status = read($z, $buffer, $length)
1031 $status = read($z, $buffer, $length, $offset)
1033 Attempt to read C<$length> bytes of uncompressed data into C<$buffer>.
1035 The main difference between this form of the C<read> method and the
1036 previous one, is that this one will attempt to return I<exactly> C<$length>
1037 bytes. The only circumstances that this function will not is if end-of-file
1038 or an IO error is encountered.
1040 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
1041 or a negative number on error.
1048 $line = $z->getline()
1051 Reads a single line.
1053 This method fully supports the use of of the variable C<$/>
1054 (or C<$INPUT_RECORD_SEPARATOR> or C<$RS> when C<English> is in use) to
1055 determine what constitutes an end of line. Both paragraph mode and file
1056 slurp mode are supported.
1065 Read a single character.
1071 $char = $z->ungetc($string)
1079 $status = $z->inflateSync()
1084 =head2 getHeaderInfo
1088 $hdr = $z->getHeaderInfo();
1089 @hdrs = $z->getHeaderInfo();
1091 This method returns either a hash reference (in scalar context) or a list
1092 or hash references (in array context) that contains information about each
1093 of the header fields in the compressed data stream(s).
1105 Returns the uncompressed file offset.
1116 Returns true if the end of the compressed input stream has been reached.
1122 $z->seek($position, $whence);
1123 seek($z, $position, $whence);
1128 Provides a sub-set of the C<seek> functionality, with the restriction
1129 that it is only legal to seek forward in the input file/buffer.
1130 It is a fatal error to attempt to seek backward.
1134 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
1135 SEEK_CUR or SEEK_END.
1137 Returns 1 on success, 0 on failure.
1146 This is a noop provided for completeness.
1152 Returns true if the object currently refers to a opened file/buffer.
1156 my $prev = $z->autoflush()
1157 my $prev = $z->autoflush(EXPR)
1159 If the C<$z> object is associated with a file or a filehandle, this method
1160 returns the current autoflush setting for the underlying filehandle. If
1161 C<EXPR> is present, and is non-zero, it will enable flushing after every
1162 write/print operation.
1164 If C<$z> is associated with a buffer, this method has no effect and always
1167 B<Note> that the special variable C<$|> B<cannot> be used to set or
1168 retrieve the autoflush setting.
1170 =head2 input_line_number
1172 $z->input_line_number()
1173 $z->input_line_number(EXPR)
1177 Returns the current uncompressed line number. If C<EXPR> is present it has
1178 the effect of setting the line number. Note that setting the line number
1179 does not change the current position within the file/buffer being read.
1181 The contents of C<$/> are used to to determine what constitutes a line
1191 If the C<$z> object is associated with a file or a filehandle, this method
1192 will return the underlying file descriptor.
1194 If the C<$z> object is is associated with a buffer, this method will
1204 Closes the output file/buffer.
1208 For most versions of Perl this method will be automatically invoked if
1209 the IO::Uncompress::Unzip object is destroyed (either explicitly or by the
1210 variable with the reference to the object going out of scope). The
1211 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
1212 these cases, the C<close> method will be called automatically, but
1213 not until global destruction of all live objects when the program is
1216 Therefore, if you want your scripts to be able to run on all versions
1217 of Perl, you should call C<close> explicitly and not rely on automatic
1220 Returns true on success, otherwise 0.
1222 If the C<AutoClose> option has been enabled when the IO::Uncompress::Unzip
1223 object was created, and the object is associated with a file, the
1224 underlying file will also be closed.
1231 No symbolic constants are required by this IO::Uncompress::Unzip at present.
1237 Imports C<unzip> and C<$UnzipError>.
1240 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
1251 L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
1253 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
1255 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
1256 L<Archive::Tar|Archive::Tar>,
1257 L<IO::Zlib|IO::Zlib>
1260 For RFC 1950, 1951 and 1952 see
1261 F<http://www.faqs.org/rfcs/rfc1950.html>,
1262 F<http://www.faqs.org/rfcs/rfc1951.html> and
1263 F<http://www.faqs.org/rfcs/rfc1952.html>
1265 The I<zlib> compression library was written by Jean-loup Gailly
1266 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
1268 The primary site for the I<zlib> compression library is
1269 F<http://www.zlib.org>.
1271 The primary site for gzip is F<http://www.gzip.org>.
1281 The I<IO::Uncompress::Unzip> module was written by Paul Marquess,
1286 =head1 MODIFICATION HISTORY
1288 See the Changes file.
1290 =head1 COPYRIGHT AND LICENSE
1293 Copyright (c) 2005-2006 Paul Marquess. All rights reserved.
1295 This program is free software; you can redistribute it and/or
1296 modify it under the same terms as Perl itself.