1 package IO::Uncompress::Unzip;
11 use IO::Uncompress::RawInflate 2.003 ;
12 use IO::Compress::Base::Common 2.003 qw(:Status createSelfTiedObject);
13 use IO::Uncompress::Adapter::Identity 2.003 ;
14 use IO::Compress::Zlib::Extra 2.003 ;
15 use IO::Compress::Zip::Constants 2.003 ;
17 use Compress::Raw::Zlib 2.003 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 2.003 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/buffer is not compressed data,
1136 the module will allow reading of it anyway.
1138 In addition, if the input file/buffer does contain compressed data and
1139 there is non-compressed data immediately following it, setting this option
1140 will make this module treat the whole file/bufffer as a single data stream.
1142 This option defaults to 1.
1144 =item C<< BlockSize => $num >>
1146 When reading the compressed input data, IO::Uncompress::Unzip will read it in
1147 blocks of C<$num> bytes.
1149 This option defaults to 4096.
1151 =item C<< InputLength => $size >>
1153 When present this option will limit the number of compressed bytes read
1154 from the input file/buffer to C<$size>. This option can be used in the
1155 situation where there is useful data directly after the compressed data
1156 stream and you know beforehand the exact length of the compressed data
1159 This option is mostly used when reading from a filehandle, in which case
1160 the file pointer will be left pointing to the first byte directly after the
1161 compressed data stream.
1165 This option defaults to off.
1167 =item C<< Append => 0|1 >>
1169 This option controls what the C<read> method does with uncompressed data.
1171 If set to 1, all uncompressed data will be appended to the output parameter
1172 of the C<read> method.
1174 If set to 0, the contents of the output parameter of the C<read> method
1175 will be overwritten by the uncompressed data.
1179 =item C<< Strict => 0|1 >>
1183 This option controls whether the extra checks defined below are used when
1184 carrying out the decompression. When Strict is on, the extra tests are
1185 carried out, when Strict is off they are not.
1187 The default for this option is off.
1215 $status = $z->read($buffer)
1217 Reads a block of compressed data (the size the the compressed block is
1218 determined by the C<Buffer> option in the constructor), uncompresses it and
1219 writes any uncompressed data into C<$buffer>. If the C<Append> parameter is
1220 set in the constructor, the uncompressed data will be appended to the
1221 C<$buffer> parameter. Otherwise C<$buffer> will be overwritten.
1223 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
1224 or a negative number on error.
1230 $status = $z->read($buffer, $length)
1231 $status = $z->read($buffer, $length, $offset)
1233 $status = read($z, $buffer, $length)
1234 $status = read($z, $buffer, $length, $offset)
1236 Attempt to read C<$length> bytes of uncompressed data into C<$buffer>.
1238 The main difference between this form of the C<read> method and the
1239 previous one, is that this one will attempt to return I<exactly> C<$length>
1240 bytes. The only circumstances that this function will not is if end-of-file
1241 or an IO error is encountered.
1243 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
1244 or a negative number on error.
1251 $line = $z->getline()
1254 Reads a single line.
1256 This method fully supports the use of of the variable C<$/> (or
1257 C<$INPUT_RECORD_SEPARATOR> or C<$RS> when C<English> is in use) to
1258 determine what constitutes an end of line. Paragraph mode, record mode and
1259 file slurp mode are all supported.
1268 Read a single character.
1274 $char = $z->ungetc($string)
1282 $status = $z->inflateSync()
1287 =head2 getHeaderInfo
1291 $hdr = $z->getHeaderInfo();
1292 @hdrs = $z->getHeaderInfo();
1294 This method returns either a hash reference (in scalar context) or a list
1295 or hash references (in array context) that contains information about each
1296 of the header fields in the compressed data stream(s).
1308 Returns the uncompressed file offset.
1319 Returns true if the end of the compressed input stream has been reached.
1325 $z->seek($position, $whence);
1326 seek($z, $position, $whence);
1331 Provides a sub-set of the C<seek> functionality, with the restriction
1332 that it is only legal to seek forward in the input file/buffer.
1333 It is a fatal error to attempt to seek backward.
1337 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
1338 SEEK_CUR or SEEK_END.
1340 Returns 1 on success, 0 on failure.
1349 This is a noop provided for completeness.
1355 Returns true if the object currently refers to a opened file/buffer.
1359 my $prev = $z->autoflush()
1360 my $prev = $z->autoflush(EXPR)
1362 If the C<$z> object is associated with a file or a filehandle, this method
1363 returns the current autoflush setting for the underlying filehandle. If
1364 C<EXPR> is present, and is non-zero, it will enable flushing after every
1365 write/print operation.
1367 If C<$z> is associated with a buffer, this method has no effect and always
1370 B<Note> that the special variable C<$|> B<cannot> be used to set or
1371 retrieve the autoflush setting.
1373 =head2 input_line_number
1375 $z->input_line_number()
1376 $z->input_line_number(EXPR)
1380 Returns the current uncompressed line number. If C<EXPR> is present it has
1381 the effect of setting the line number. Note that setting the line number
1382 does not change the current position within the file/buffer being read.
1384 The contents of C<$/> are used to to determine what constitutes a line
1394 If the C<$z> object is associated with a file or a filehandle, this method
1395 will return the underlying file descriptor.
1397 If the C<$z> object is is associated with a buffer, this method will
1407 Closes the output file/buffer.
1411 For most versions of Perl this method will be automatically invoked if
1412 the IO::Uncompress::Unzip object is destroyed (either explicitly or by the
1413 variable with the reference to the object going out of scope). The
1414 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
1415 these cases, the C<close> method will be called automatically, but
1416 not until global destruction of all live objects when the program is
1419 Therefore, if you want your scripts to be able to run on all versions
1420 of Perl, you should call C<close> explicitly and not rely on automatic
1423 Returns true on success, otherwise 0.
1425 If the C<AutoClose> option has been enabled when the IO::Uncompress::Unzip
1426 object was created, and the object is associated with a file, the
1427 underlying file will also be closed.
1436 my $status = $z->nextStream();
1438 Skips to the next compressed data stream in the input file/buffer. If a new
1439 compressed data stream is found, the eof marker will be cleared and C<$.>
1442 Returns 1 if a new stream was found, 0 if none was found, and -1 if an
1443 error was encountered.
1449 my $data = $z->trailingData();
1451 Returns the data, if any, that is present immediately after the compressed
1452 data stream once uncompression is complete. It only makes sense to call
1453 this method once the end of the compressed data stream has been
1456 This option can be used when there is useful information immediately
1457 following the compressed data stream, and you don't know the length of the
1458 compressed data stream.
1460 If the input is a buffer, C<trailingData> will return everything from the
1461 end of the compressed data stream to the end of the buffer.
1463 If the input is a filehandle, C<trailingData> will return the data that is
1464 left in the filehandle input buffer once the end of the compressed data
1465 stream has been reached. You can then use the filehandle to read the rest
1468 Don't bother using C<trailingData> if the input is a filename.
1472 If you know the length of the compressed data stream before you start
1473 uncompressing, you can avoid having to use C<trailingData> by setting the
1474 C<InputLength> option in the constructor.
1478 No symbolic constants are required by this IO::Uncompress::Unzip at present.
1484 Imports C<unzip> and C<$UnzipError>.
1487 use IO::Uncompress::Unzip qw(unzip $UnzipError) ;
1498 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>
1500 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
1502 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
1503 L<Archive::Tar|Archive::Tar>,
1504 L<IO::Zlib|IO::Zlib>
1507 For RFC 1950, 1951 and 1952 see
1508 F<http://www.faqs.org/rfcs/rfc1950.html>,
1509 F<http://www.faqs.org/rfcs/rfc1951.html> and
1510 F<http://www.faqs.org/rfcs/rfc1952.html>
1512 The I<zlib> compression library was written by Jean-loup Gailly
1513 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
1515 The primary site for the I<zlib> compression library is
1516 F<http://www.zlib.org>.
1518 The primary site for gzip is F<http://www.gzip.org>.
1525 This module was written by Paul Marquess, F<pmqs@cpan.org>.
1529 =head1 MODIFICATION HISTORY
1531 See the Changes file.
1533 =head1 COPYRIGHT AND LICENSE
1535 Copyright (c) 2005-2007 Paul Marquess. All rights reserved.
1537 This program is free software; you can redistribute it and/or
1538 modify it under the same terms as Perl itself.