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;
14 use IO::Compress::Zlib::Extra;
15 use IO::Compress::Zip::Constants;
17 use Compress::Raw::Zlib qw(crc32) ;
21 eval { require IO::Uncompress::Adapter::Bunzip2 ;
22 import IO::Uncompress::Adapter::Bunzip2 } ;
28 our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $UnzipError, %headerLookup);
33 @ISA = qw(Exporter IO::Uncompress::RawInflate);
34 @EXPORT_OK = qw( $UnzipError unzip );
35 %EXPORT_TAGS = %IO::Uncompress::RawInflate::EXPORT_TAGS ;
36 push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
37 Exporter::export_ok_tags('all');
40 ZIP_CENTRAL_HDR_SIG, \&skipCentralDirectory,
41 ZIP_END_CENTRAL_HDR_SIG, \&skipEndCentralDirectory,
42 ZIP64_END_CENTRAL_REC_HDR_SIG, \&skipCentralDirectory64Rec,
43 ZIP64_END_CENTRAL_LOC_HDR_SIG, \&skipCentralDirectory64Loc,
44 ZIP64_ARCHIVE_EXTRA_SIG, \&skipArchiveExtra,
45 ZIP64_DIGITAL_SIGNATURE_SIG, \&skipDigitalSignature,
51 my $obj = createSelfTiedObject($class, \$UnzipError);
52 $obj->_create(undef, 0, @_);
57 my $obj = createSelfTiedObject(undef, \$UnzipError);
58 return $obj->_inf(@_) ;
63 use IO::Compress::Base::Common qw(:Parse);
68 'Name' => [1, 1, Parse_any, undef],
70 # 'Streaming' => [1, 1, Parse_boolean, 1],
79 # unzip always needs crc32
80 $got->value('CRC32' => 1);
82 *$self->{UnzipData}{Name} = $got->value('Name');
93 $self->smartReadExact(\$magic, 4);
95 *$self->{HeaderPending} = $magic ;
97 return $self->HeaderError("Minimum header size is " .
99 if length $magic != 4 ;
101 return $self->HeaderError("Bad Magic")
102 if ! _isZipMagic($magic) ;
104 *$self->{Type} = 'zip';
116 my $name = *$self->{UnzipData}{Name} ;
117 my $hdr = $self->_readZipHeader($magic) ;
121 if (! defined $name || $hdr->{Name} eq $name)
128 if (*$self->{ZipData}{Streaming}) {
133 my $status = $self->smartRead(\$b, 1024 * 16);
139 $status = *$self->{Uncomp}->uncompr(\$b, \$temp_buf, 0, $out);
141 return $self->saveErrorString(undef, *$self->{Uncomp}{Error},
142 *$self->{Uncomp}{ErrorNo})
143 if $self->saveStatus($status) == STATUS_ERROR;
145 if ($status == STATUS_ENDSTREAM) {
146 *$self->{Uncomp}->reset();
147 $self->pushBack($b) ;
153 $self->smartReadExact(\$buffer, $hdr->{TrailerLength})
154 or return $self->saveErrorString(undef, "Truncated file");
157 my $c = $hdr->{CompressedLength}->get32bit();
158 $self->smartReadExact(\$buffer, $c)
159 or return $self->saveErrorString(undef, "Truncated file");
163 $self->chkTrailer($buffer) == STATUS_OK
164 or return $self->saveErrorString(undef, "Truncated file");
166 $hdr = $self->_readFullZipHeader();
168 return $self->saveErrorString(undef, "Cannot find '$name'")
169 if $self->smartEof();
180 my ($sig, $CRC32, $cSize, $uSize) ;
181 my ($cSizeHi, $uSizeHi) = (0, 0);
182 if (*$self->{ZipData}{Streaming}) {
183 $sig = unpack ("V", substr($trailer, 0, 4));
184 $CRC32 = unpack ("V", substr($trailer, 4, 4));
186 if (*$self->{ZipData}{Zip64} ) {
187 $cSize = U64::newUnpack_V64 substr($trailer, 8, 8);
188 $uSize = U64::newUnpack_V64 substr($trailer, 16, 8);
191 $cSize = U64::newUnpack_V32 substr($trailer, 8, 4);
192 $uSize = U64::newUnpack_V32 substr($trailer, 12, 4);
195 return $self->TrailerError("Data Descriptor signature, got $sig")
196 if $sig != ZIP_DATA_HDR_SIG;
199 ($CRC32, $cSize, $uSize) =
200 (*$self->{ZipData}{Crc32},
201 *$self->{ZipData}{CompressedLen},
202 *$self->{ZipData}{UnCompressedLen});
205 if (*$self->{Strict}) {
206 return $self->TrailerError("CRC mismatch")
207 if $CRC32 != *$self->{ZipData}{CRC32} ;
209 return $self->TrailerError("CSIZE mismatch.")
210 if ! $cSize->equal(*$self->{CompSize});
212 return $self->TrailerError("USIZE mismatch.")
213 if ! $uSize->equal(*$self->{UnCompSize});
216 my $reachedEnd = STATUS_ERROR ;
217 # check for central directory or end of central directory
221 my $got = $self->smartRead(\$magic, 4);
223 return $self->saveErrorString(STATUS_ERROR, "Truncated file")
224 if $got != 4 && *$self->{Strict};
230 return STATUS_ERROR ;
233 $self->pushBack($magic) ;
237 my $sig = unpack("V", $magic) ;
240 if ($hdr = $headerLookup{$sig})
242 if (&$hdr($self, $magic) != STATUS_OK ) {
243 if (*$self->{Strict}) {
244 return STATUS_ERROR ;
252 if ($sig == ZIP_END_CENTRAL_HDR_SIG)
258 elsif ($sig == ZIP_LOCAL_HDR_SIG)
260 $self->pushBack($magic) ;
266 $self->pushBack($magic) ;
274 sub skipCentralDirectory
280 $self->smartReadExact(\$buffer, 46 - 4)
281 or return $self->TrailerError("Minimum header size is " .
284 my $keep = $magic . $buffer ;
285 *$self->{HeaderPending} = $keep ;
287 #my $versionMadeBy = unpack ("v", substr($buffer, 4-4, 2));
288 #my $extractVersion = unpack ("v", substr($buffer, 6-4, 2));
289 #my $gpFlag = unpack ("v", substr($buffer, 8-4, 2));
290 #my $compressedMethod = unpack ("v", substr($buffer, 10-4, 2));
291 #my $lastModTime = unpack ("V", substr($buffer, 12-4, 4));
292 #my $crc32 = unpack ("V", substr($buffer, 16-4, 4));
293 my $compressedLength = unpack ("V", substr($buffer, 20-4, 4));
294 my $uncompressedLength = unpack ("V", substr($buffer, 24-4, 4));
295 my $filename_length = unpack ("v", substr($buffer, 28-4, 2));
296 my $extra_length = unpack ("v", substr($buffer, 30-4, 2));
297 my $comment_length = unpack ("v", substr($buffer, 32-4, 2));
298 #my $disk_start = unpack ("v", substr($buffer, 34-4, 2));
299 #my $int_file_attrib = unpack ("v", substr($buffer, 36-4, 2));
300 #my $ext_file_attrib = unpack ("V", substr($buffer, 38-4, 2));
301 #my $lcl_hdr_offset = unpack ("V", substr($buffer, 42-4, 2));
307 if ($filename_length)
309 $self->smartReadExact(\$filename, $filename_length)
310 or return $self->TruncatedTrailer("filename");
316 $self->smartReadExact(\$extraField, $extra_length)
317 or return $self->TruncatedTrailer("extra");
318 $keep .= $extraField ;
323 $self->smartReadExact(\$comment, $comment_length)
324 or return $self->TruncatedTrailer("comment");
337 $self->smartReadExact(\$buffer, 4)
338 or return $self->TrailerError("Minimum header size is " .
341 my $keep = $magic . $buffer ;
343 my $size = unpack ("V", $buffer);
345 $self->smartReadExact(\$buffer, $size)
346 or return $self->TrailerError("Minimum header size is " .
350 *$self->{HeaderPending} = $keep ;
356 sub skipCentralDirectory64Rec
362 $self->smartReadExact(\$buffer, 8)
363 or return $self->TrailerError("Minimum header size is " .
366 my $keep = $magic . $buffer ;
368 my ($sizeLo, $sizeHi) = unpack ("V V", $buffer);
370 # TODO - take SizeHi into account
371 $self->smartReadExact(\$buffer, $sizeLo)
372 or return $self->TrailerError("Minimum header size is " .
373 $sizeLo . " bytes") ;
376 *$self->{HeaderPending} = $keep ;
378 #my $versionMadeBy = unpack ("v", substr($buffer, 0, 2));
379 #my $extractVersion = unpack ("v", substr($buffer, 2, 2));
380 #my $diskNumber = unpack ("V", substr($buffer, 4, 4));
381 #my $cntrlDirDiskNo = unpack ("V", substr($buffer, 8, 4));
382 #my $entriesInThisCD = unpack ("V V", substr($buffer, 12, 8));
383 #my $entriesInCD = unpack ("V V", substr($buffer, 20, 8));
384 #my $sizeOfCD = unpack ("V V", substr($buffer, 28, 8));
385 #my $offsetToCD = unpack ("V V", substr($buffer, 36, 8));
390 sub skipCentralDirectory64Loc
396 $self->smartReadExact(\$buffer, 20 - 4)
397 or return $self->TrailerError("Minimum header size is " .
400 my $keep = $magic . $buffer ;
401 *$self->{HeaderPending} = $keep ;
403 #my $startCdDisk = unpack ("V", substr($buffer, 4-4, 4));
404 #my $offsetToCD = unpack ("V V", substr($buffer, 8-4, 8));
405 #my $diskCount = unpack ("V", substr($buffer, 16-4, 4));
410 sub skipEndCentralDirectory
416 $self->smartReadExact(\$buffer, 22 - 4)
417 or return $self->TrailerError("Minimum header size is " .
420 my $keep = $magic . $buffer ;
421 *$self->{HeaderPending} = $keep ;
423 #my $diskNumber = unpack ("v", substr($buffer, 4-4, 2));
424 #my $cntrlDirDiskNo = unpack ("v", substr($buffer, 6-4, 2));
425 #my $entriesInThisCD = unpack ("v", substr($buffer, 8-4, 2));
426 #my $entriesInCD = unpack ("v", substr($buffer, 10-4, 2));
427 #my $sizeOfCD = unpack ("V", substr($buffer, 12-4, 2));
428 #my $offsetToCD = unpack ("V", substr($buffer, 16-4, 2));
429 my $comment_length = unpack ("v", substr($buffer, 20-4, 2));
435 $self->smartReadExact(\$comment, $comment_length)
436 or return $self->TruncatedTrailer("comment");
447 return 0 if length $buffer < 4 ;
448 my $sig = unpack("V", $buffer) ;
449 return $sig == ZIP_LOCAL_HDR_SIG ;
453 sub _readFullZipHeader($)
458 $self->smartReadExact(\$magic, 4);
460 *$self->{HeaderPending} = $magic ;
462 return $self->HeaderError("Minimum header size is " .
464 if length $magic != 4 ;
467 return $self->HeaderError("Bad Magic")
468 if ! _isZipMagic($magic) ;
470 my $status = $self->_readZipHeader($magic);
471 delete *$self->{Transparent} if ! defined $status ;
475 sub _readZipHeader($)
477 my ($self, $magic) = @_ ;
481 $self->smartReadExact(\$buffer, 30 - 4)
482 or return $self->HeaderError("Minimum header size is " .
485 my $keep = $magic . $buffer ;
486 *$self->{HeaderPending} = $keep ;
488 my $extractVersion = unpack ("v", substr($buffer, 4-4, 2));
489 my $gpFlag = unpack ("v", substr($buffer, 6-4, 2));
490 my $compressedMethod = unpack ("v", substr($buffer, 8-4, 2));
491 my $lastModTime = unpack ("V", substr($buffer, 10-4, 4));
492 my $crc32 = unpack ("V", substr($buffer, 14-4, 4));
493 my $compressedLength = new U64 unpack ("V", substr($buffer, 18-4, 4));
494 my $uncompressedLength = new U64 unpack ("V", substr($buffer, 22-4, 4));
495 my $filename_length = unpack ("v", substr($buffer, 26-4, 2));
496 my $extra_length = unpack ("v", substr($buffer, 28-4, 2));
501 my $streamingMode = ($gpFlag & ZIP_GP_FLAG_STREAMING_MASK) ? 1 : 0 ;
503 return $self->HeaderError("Streamed Stored content not supported")
504 if $streamingMode && $compressedMethod == 0 ;
506 return $self->HeaderError("Encrypted content not supported")
507 if $gpFlag & (ZIP_GP_FLAG_ENCRYPTED_MASK|ZIP_GP_FLAG_STRONG_ENCRYPTED_MASK);
509 return $self->HeaderError("Patch content not supported")
510 if $gpFlag & ZIP_GP_FLAG_PATCHED_MASK;
512 *$self->{ZipData}{Streaming} = $streamingMode;
515 if ($filename_length)
517 $self->smartReadExact(\$filename, $filename_length)
518 or return $self->TruncatedHeader("Filename");
526 $self->smartReadExact(\$extraField, $extra_length)
527 or return $self->TruncatedHeader("Extra Field");
529 my $bad = IO::Compress::Zlib::Extra::parseRawExtra($extraField,
531 return $self->HeaderError($bad)
534 $keep .= $extraField ;
539 $Extra{$_->[0]} = \$_->[1];
542 if (defined $Extra{ZIP_EXTRA_ID_ZIP64()})
546 my $buff = ${ $Extra{ZIP_EXTRA_ID_ZIP64()} };
548 # TODO - This code assumes that all the fields in the Zip64
549 # extra field aren't necessarily present. The spec says that
550 # they only exist if the equivalent local headers are -1.
551 # Need to check that info-zip fills out -1 in the local header
554 if (! $streamingMode) {
557 $uncompressedLength = U64::newUnpack_V64 substr($buff, 0, 8)
558 if $uncompressedLength == 0xFFFF ;
562 $compressedLength = U64::newUnpack_V64 substr($buff, $offset, 8)
563 if $compressedLength == 0xFFFF ;
567 #my $cheaderOffset = U64::newUnpack_V64 substr($buff, 16, 8);
568 #my $diskNumber = unpack ("V", substr($buff, 24, 4));
573 *$self->{ZipData}{Zip64} = $zip64;
575 if (! $streamingMode) {
576 *$self->{ZipData}{Streaming} = 0;
577 *$self->{ZipData}{Crc32} = $crc32;
578 *$self->{ZipData}{CompressedLen} = $compressedLength;
579 *$self->{ZipData}{UnCompressedLen} = $uncompressedLength;
580 *$self->{CompressedInputLengthRemaining} =
581 *$self->{CompressedInputLength} = $compressedLength->get32bit();
584 *$self->{ZipData}{Method} = $compressedMethod;
585 if ($compressedMethod == ZIP_CM_DEFLATE)
587 *$self->{Type} = 'zip-deflate';
589 elsif ($compressedMethod == ZIP_CM_BZIP2)
591 #if (! defined $IO::Uncompress::Adapter::Bunzip2::VERSION)
593 *$self->{Type} = 'zip-bzip2';
595 my $obj = IO::Uncompress::Adapter::Bunzip2::mkUncompObject(
598 *$self->{Uncomp} = $obj;
599 *$self->{ZipData}{CRC32} = crc32(undef);
602 elsif ($compressedMethod == ZIP_CM_STORE)
604 # TODO -- add support for reading uncompressed
606 *$self->{Type} = 'zip-stored';
608 my $obj = IO::Uncompress::Adapter::Identity::mkUncompObject(# $got->value('CRC32'),
609 # $got->value('ADLER32'),
612 *$self->{Uncomp} = $obj;
617 return $self->HeaderError("Unsupported Compression format $compressedMethod");
622 'FingerprintLength' => 4,
623 #'HeaderLength' => $compressedMethod == 8 ? length $keep : 0,
624 'HeaderLength' => length $keep,
626 'TrailerLength' => ! $streamingMode ? 0 : $zip64 ? 24 : 16,
628 'CompressedLength' => $compressedLength ,
629 'UncompressedLength' => $uncompressedLength ,
632 'Time' => _dosToUnixTime($lastModTime),
633 'Stream' => $streamingMode,
635 'MethodID' => $compressedMethod,
636 'MethodName' => $compressedMethod == ZIP_CM_DEFLATE
638 : $compressedMethod == ZIP_CM_BZIP2
640 : $compressedMethod == ZIP_CM_STORE
644 # 'TextFlag' => $flag & GZIP_FLG_FTEXT ? 1 : 0,
645 # 'HeaderCRCFlag' => $flag & GZIP_FLG_FHCRC ? 1 : 0,
646 # 'NameFlag' => $flag & GZIP_FLG_FNAME ? 1 : 0,
647 # 'CommentFlag' => $flag & GZIP_FLG_FCOMMENT ? 1 : 0,
648 # 'ExtraFlag' => $flag & GZIP_FLG_FEXTRA ? 1 : 0,
649 # 'Comment' => $comment,
651 # 'OsName' => defined $GZIP_OS_Names{$os}
652 # ? $GZIP_OS_Names{$os} : "Unknown",
653 # 'HeaderCRC' => $HeaderCRC,
655 # 'ExtraFlags' => $xfl,
656 'ExtraFieldRaw' => $extraField,
657 'ExtraField' => [ @EXTRA ],
663 sub filterUncompressed
667 if (*$self->{ZipData}{Method} == 12) {
668 *$self->{ZipData}{CRC32} = crc32(${$_[0]}, *$self->{ZipData}{CRC32});
671 *$self->{ZipData}{CRC32} = *$self->{Uncomp}->crc32() ;
679 #use Time::Local 'timelocal_nocheck';
680 use Time::Local 'timelocal';
684 my $year = ( ( $dt >> 25 ) & 0x7f ) + 80;
685 my $mon = ( ( $dt >> 21 ) & 0x0f ) - 1;
686 my $mday = ( ( $dt >> 16 ) & 0x1f );
688 my $hour = ( ( $dt >> 11 ) & 0x1f );
689 my $min = ( ( $dt >> 5 ) & 0x3f );
690 my $sec = ( ( $dt << 1 ) & 0x3e );
694 eval { timelocal( $sec, $min, $hour, $mday, $mon, $year ); };
710 IO::Uncompress::Unzip - Read zip files/buffers
716 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
718 my $status = unzip $input => $output [,OPTS]
719 or die "unzip failed: $UnzipError\n";
721 my $z = new IO::Uncompress::Unzip $input [OPTS]
722 or die "unzip failed: $UnzipError\n";
724 $status = $z->read($buffer)
725 $status = $z->read($buffer, $length)
726 $status = $z->read($buffer, $length, $offset)
727 $line = $z->getline()
732 $status = $z->inflateSync()
734 $data = $z->trailingData()
735 $status = $z->nextStream()
736 $data = $z->getHeaderInfo()
738 $z->seek($position, $whence)
750 read($z, $buffer, $length);
751 read($z, $buffer, $length, $offset);
753 seek($z, $position, $whence)
764 This module provides a Perl interface that allows the reading of
767 For writing zip files/buffers, see the companion module IO::Compress::Zip.
773 =head1 Functional Interface
775 A top-level function, C<unzip>, is provided to carry out
776 "one-shot" uncompression between buffers and/or files. For finer
777 control over the uncompression process, see the L</"OO Interface">
780 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
782 unzip $input => $output [,OPTS]
783 or die "unzip failed: $UnzipError\n";
787 The functional interface needs Perl5.005 or better.
790 =head2 unzip $input => $output [, OPTS]
793 C<unzip> expects at least two parameters, C<$input> and C<$output>.
795 =head3 The C<$input> parameter
797 The parameter, C<$input>, is used to define the source of
800 It can take one of the following forms:
806 If the C<$input> parameter is a simple scalar, it is assumed to be a
807 filename. This file will be opened for reading and the input data
808 will be read from it.
812 If the C<$input> parameter is a filehandle, the input data will be
814 The string '-' can be used as an alias for standard input.
816 =item A scalar reference
818 If C<$input> is a scalar reference, the input data will be read
821 =item An array reference
823 If C<$input> is an array reference, each element in the array must be a
826 The input data will be read from each file in turn.
828 The complete array will be walked to ensure that it only
829 contains valid filenames before any data is uncompressed.
833 =item An Input FileGlob string
835 If C<$input> is a string that is delimited by the characters "<" and ">"
836 C<unzip> will assume that it is an I<input fileglob string>. The
837 input is the list of files that match the fileglob.
839 If the fileglob does not match any files ...
841 See L<File::GlobMapper|File::GlobMapper> for more details.
846 If the C<$input> parameter is any other type, C<undef> will be returned.
850 =head3 The C<$output> parameter
852 The parameter C<$output> is used to control the destination of the
853 uncompressed data. This parameter can take one of these forms.
859 If the C<$output> parameter is a simple scalar, it is assumed to be a
860 filename. This file will be opened for writing and the uncompressed
861 data will be written to it.
865 If the C<$output> parameter is a filehandle, the uncompressed data
866 will be written to it.
867 The string '-' can be used as an alias for standard output.
870 =item A scalar reference
872 If C<$output> is a scalar reference, the uncompressed data will be
873 stored in C<$$output>.
877 =item An Array Reference
879 If C<$output> is an array reference, the uncompressed data will be
880 pushed onto the array.
882 =item An Output FileGlob
884 If C<$output> is a string that is delimited by the characters "<" and ">"
885 C<unzip> will assume that it is an I<output fileglob string>. The
886 output is the list of files that match the fileglob.
888 When C<$output> is an fileglob string, C<$input> must also be a fileglob
889 string. Anything else is an error.
893 If the C<$output> parameter is any other type, C<undef> will be returned.
900 When C<$input> maps to multiple compressed files/buffers and C<$output> is
901 a single file/buffer, after uncompression C<$output> will contain a
902 concatenation of all the uncompressed data from each of the input
909 =head2 Optional Parameters
911 Unless specified below, the optional parameters for C<unzip>,
912 C<OPTS>, are the same as those used with the OO interface defined in the
913 L</"Constructor Options"> section below.
917 =item C<< AutoClose => 0|1 >>
919 This option applies to any input or output data streams to
920 C<unzip> that are filehandles.
922 If C<AutoClose> is specified, and the value is true, it will result in all
923 input and/or output filehandles being closed once C<unzip> has
926 This parameter defaults to 0.
929 =item C<< BinModeOut => 0|1 >>
931 When writing to a file or filehandle, set C<binmode> before writing to the
940 =item C<< Append => 0|1 >>
944 =item C<< MultiStream => 0|1 >>
947 If the input file/buffer contains multiple compressed data streams, this
948 option will uncompress the whole lot as a single data stream.
956 =item C<< TrailingData => $scalar >>
958 Returns the data, if any, that is present immediately after the compressed
959 data stream once uncompression is complete.
961 This option can be used when there is useful information immediately
962 following the compressed data stream, and you don't know the length of the
963 compressed data stream.
965 If the input is a buffer, C<trailingData> will return everything from the
966 end of the compressed data stream to the end of the buffer.
968 If the input is a filehandle, C<trailingData> will return the data that is
969 left in the filehandle input buffer once the end of the compressed data
970 stream has been reached. You can then use the filehandle to read the rest
973 Don't bother using C<trailingData> if the input is a filename.
977 If you know the length of the compressed data stream before you start
978 uncompressing, you can avoid having to use C<trailingData> by setting the
979 C<InputLength> option.
990 To read the contents of the file C<file1.txt.zip> and write the
991 compressed data to the file C<file1.txt>.
995 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
997 my $input = "file1.txt.zip";
998 my $output = "file1.txt";
999 unzip $input => $output
1000 or die "unzip failed: $UnzipError\n";
1003 To read from an existing Perl filehandle, C<$input>, and write the
1004 uncompressed data to a buffer, C<$buffer>.
1008 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
1011 my $input = new IO::File "<file1.txt.zip"
1012 or die "Cannot open 'file1.txt.zip': $!\n" ;
1014 unzip $input => \$buffer
1015 or die "unzip failed: $UnzipError\n";
1017 To uncompress all files in the directory "/my/home" that match "*.txt.zip" and store the compressed data in the same directory
1021 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
1023 unzip '</my/home/*.txt.zip>' => '</my/home/#1.txt>'
1024 or die "unzip failed: $UnzipError\n";
1026 and if you want to compress each file one at a time, this will do the trick
1030 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
1032 for my $input ( glob "/my/home/*.txt.zip" )
1034 my $output = $input;
1035 $output =~ s/.zip// ;
1036 unzip $input => $output
1037 or die "Error compressing '$input': $UnzipError\n";
1044 The format of the constructor for IO::Uncompress::Unzip is shown below
1047 my $z = new IO::Uncompress::Unzip $input [OPTS]
1048 or die "IO::Uncompress::Unzip failed: $UnzipError\n";
1050 Returns an C<IO::Uncompress::Unzip> object on success and undef on failure.
1051 The variable C<$UnzipError> will contain an error message on failure.
1053 If you are running Perl 5.005 or better the object, C<$z>, returned from
1054 IO::Uncompress::Unzip can be used exactly like an L<IO::File|IO::File> filehandle.
1055 This means that all normal input file operations can be carried out with
1056 C<$z>. For example, to read a line from a compressed file/buffer you can
1057 use either of these forms
1059 $line = $z->getline();
1062 The mandatory parameter C<$input> is used to determine the source of the
1063 compressed data. This parameter can take one of three forms.
1069 If the C<$input> parameter is a scalar, it is assumed to be a filename. This
1070 file will be opened for reading and the compressed data will be read from it.
1074 If the C<$input> parameter is a filehandle, the compressed data will be
1076 The string '-' can be used as an alias for standard input.
1079 =item A scalar reference
1081 If C<$input> is a scalar reference, the compressed data will be read from
1086 =head2 Constructor Options
1089 The option names defined below are case insensitive and can be optionally
1090 prefixed by a '-'. So all of the following are valid
1097 OPTS is a combination of the following options:
1101 =item C<< AutoClose => 0|1 >>
1103 This option is only valid when the C<$input> parameter is a filehandle. If
1104 specified, and the value is true, it will result in the file being closed once
1105 either the C<close> method is called or the IO::Uncompress::Unzip object is
1108 This parameter defaults to 0.
1110 =item C<< MultiStream => 0|1 >>
1114 Treats the complete zip file/buffer as a single compressed data
1115 stream. When reading in multi-stream mode each member of the zip
1116 file/buffer will be uncompressed in turn until the end of the file/buffer
1119 This parameter defaults to 0.
1122 =item C<< Prime => $string >>
1124 This option will uncompress the contents of C<$string> before processing the
1127 This option can be useful when the compressed data is embedded in another
1128 file/data structure and it is not possible to work out where the compressed
1129 data begins without having to read the first few bytes. If this is the
1130 case, the uncompression can be I<primed> with these bytes using this
1133 =item C<< Transparent => 0|1 >>
1135 If this option is set and the input file or buffer is not compressed data,
1136 the module will allow reading of it anyway.
1138 This option defaults to 1.
1140 =item C<< BlockSize => $num >>
1142 When reading the compressed input data, IO::Uncompress::Unzip will read it in
1143 blocks of C<$num> bytes.
1145 This option defaults to 4096.
1147 =item C<< InputLength => $size >>
1149 When present this option will limit the number of compressed bytes read
1150 from the input file/buffer to C<$size>. This option can be used in the
1151 situation where there is useful data directly after the compressed data
1152 stream and you know beforehand the exact length of the compressed data
1155 This option is mostly used when reading from a filehandle, in which case
1156 the file pointer will be left pointing to the first byte directly after the
1157 compressed data stream.
1161 This option defaults to off.
1163 =item C<< Append => 0|1 >>
1165 This option controls what the C<read> method does with uncompressed data.
1167 If set to 1, all uncompressed data will be appended to the output parameter
1168 of the C<read> method.
1170 If set to 0, the contents of the output parameter of the C<read> method
1171 will be overwritten by the uncompressed data.
1175 =item C<< Strict => 0|1 >>
1179 This option controls whether the extra checks defined below are used when
1180 carrying out the decompression. When Strict is on, the extra tests are
1181 carried out, when Strict is off they are not.
1183 The default for this option is off.
1211 $status = $z->read($buffer)
1213 Reads a block of compressed data (the size the the compressed block is
1214 determined by the C<Buffer> option in the constructor), uncompresses it and
1215 writes any uncompressed data into C<$buffer>. If the C<Append> parameter is
1216 set in the constructor, the uncompressed data will be appended to the
1217 C<$buffer> parameter. Otherwise C<$buffer> will be overwritten.
1219 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
1220 or a negative number on error.
1226 $status = $z->read($buffer, $length)
1227 $status = $z->read($buffer, $length, $offset)
1229 $status = read($z, $buffer, $length)
1230 $status = read($z, $buffer, $length, $offset)
1232 Attempt to read C<$length> bytes of uncompressed data into C<$buffer>.
1234 The main difference between this form of the C<read> method and the
1235 previous one, is that this one will attempt to return I<exactly> C<$length>
1236 bytes. The only circumstances that this function will not is if end-of-file
1237 or an IO error is encountered.
1239 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
1240 or a negative number on error.
1247 $line = $z->getline()
1250 Reads a single line.
1252 This method fully supports the use of of the variable C<$/> (or
1253 C<$INPUT_RECORD_SEPARATOR> or C<$RS> when C<English> is in use) to
1254 determine what constitutes an end of line. Paragraph mode, record mode and
1255 file slurp mode are all supported.
1264 Read a single character.
1270 $char = $z->ungetc($string)
1278 $status = $z->inflateSync()
1283 =head2 getHeaderInfo
1287 $hdr = $z->getHeaderInfo();
1288 @hdrs = $z->getHeaderInfo();
1290 This method returns either a hash reference (in scalar context) or a list
1291 or hash references (in array context) that contains information about each
1292 of the header fields in the compressed data stream(s).
1304 Returns the uncompressed file offset.
1315 Returns true if the end of the compressed input stream has been reached.
1321 $z->seek($position, $whence);
1322 seek($z, $position, $whence);
1327 Provides a sub-set of the C<seek> functionality, with the restriction
1328 that it is only legal to seek forward in the input file/buffer.
1329 It is a fatal error to attempt to seek backward.
1333 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
1334 SEEK_CUR or SEEK_END.
1336 Returns 1 on success, 0 on failure.
1345 This is a noop provided for completeness.
1351 Returns true if the object currently refers to a opened file/buffer.
1355 my $prev = $z->autoflush()
1356 my $prev = $z->autoflush(EXPR)
1358 If the C<$z> object is associated with a file or a filehandle, this method
1359 returns the current autoflush setting for the underlying filehandle. If
1360 C<EXPR> is present, and is non-zero, it will enable flushing after every
1361 write/print operation.
1363 If C<$z> is associated with a buffer, this method has no effect and always
1366 B<Note> that the special variable C<$|> B<cannot> be used to set or
1367 retrieve the autoflush setting.
1369 =head2 input_line_number
1371 $z->input_line_number()
1372 $z->input_line_number(EXPR)
1376 Returns the current uncompressed line number. If C<EXPR> is present it has
1377 the effect of setting the line number. Note that setting the line number
1378 does not change the current position within the file/buffer being read.
1380 The contents of C<$/> are used to to determine what constitutes a line
1390 If the C<$z> object is associated with a file or a filehandle, this method
1391 will return the underlying file descriptor.
1393 If the C<$z> object is is associated with a buffer, this method will
1403 Closes the output file/buffer.
1407 For most versions of Perl this method will be automatically invoked if
1408 the IO::Uncompress::Unzip object is destroyed (either explicitly or by the
1409 variable with the reference to the object going out of scope). The
1410 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
1411 these cases, the C<close> method will be called automatically, but
1412 not until global destruction of all live objects when the program is
1415 Therefore, if you want your scripts to be able to run on all versions
1416 of Perl, you should call C<close> explicitly and not rely on automatic
1419 Returns true on success, otherwise 0.
1421 If the C<AutoClose> option has been enabled when the IO::Uncompress::Unzip
1422 object was created, and the object is associated with a file, the
1423 underlying file will also be closed.
1432 my $status = $z->nextStream();
1434 Skips to the next compressed data stream in the input file/buffer. If a new
1435 compressed data stream is found, the eof marker will be cleared and C<$.>
1438 Returns 1 if a new stream was found, 0 if none was found, and -1 if an
1439 error was encountered.
1445 my $data = $z->trailingData();
1447 Returns the data, if any, that is present immediately after the compressed
1448 data stream once uncompression is complete. It only makes sense to call
1449 this method once the end of the compressed data stream has been
1452 This option can be used when there is useful information immediately
1453 following the compressed data stream, and you don't know the length of the
1454 compressed data stream.
1456 If the input is a buffer, C<trailingData> will return everything from the
1457 end of the compressed data stream to the end of the buffer.
1459 If the input is a filehandle, C<trailingData> will return the data that is
1460 left in the filehandle input buffer once the end of the compressed data
1461 stream has been reached. You can then use the filehandle to read the rest
1464 Don't bother using C<trailingData> if the input is a filename.
1468 If you know the length of the compressed data stream before you start
1469 uncompressing, you can avoid having to use C<trailingData> by setting the
1470 C<InputLength> option in the constructor.
1474 No symbolic constants are required by this IO::Uncompress::Unzip at present.
1480 Imports C<unzip> and C<$UnzipError>.
1483 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
1494 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::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
1496 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
1498 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
1499 L<Archive::Tar|Archive::Tar>,
1500 L<IO::Zlib|IO::Zlib>
1503 For RFC 1950, 1951 and 1952 see
1504 F<http://www.faqs.org/rfcs/rfc1950.html>,
1505 F<http://www.faqs.org/rfcs/rfc1951.html> and
1506 F<http://www.faqs.org/rfcs/rfc1952.html>
1508 The I<zlib> compression library was written by Jean-loup Gailly
1509 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
1511 The primary site for the I<zlib> compression library is
1512 F<http://www.zlib.org>.
1514 The primary site for gzip is F<http://www.gzip.org>.
1521 This module was written by Paul Marquess, F<pmqs@cpan.org>.
1525 =head1 MODIFICATION HISTORY
1527 See the Changes file.
1529 =head1 COPYRIGHT AND LICENSE
1531 Copyright (c) 2005-2006 Paul Marquess. All rights reserved.
1533 This program is free software; you can redistribute it and/or
1534 modify it under the same terms as Perl itself.