2 package IO::Uncompress::Gunzip ;
12 use IO::Uncompress::RawInflate ;
14 use Compress::Raw::Zlib qw( crc32 ) ;
15 use IO::Compress::Base::Common qw(:Status createSelfTiedObject);
16 use IO::Compress::Gzip::Constants;
20 our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $GunzipError);
22 @ISA = qw( Exporter IO::Uncompress::RawInflate );
23 @EXPORT_OK = qw( $GunzipError gunzip );
24 %EXPORT_TAGS = %IO::Uncompress::RawInflate::DEFLATE_CONSTANTS ;
25 push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
26 Exporter::export_ok_tags('all');
30 $VERSION = '2.000_08';
36 my $obj = createSelfTiedObject($class, \$GunzipError);
38 $obj->_create(undef, 0, @_);
43 my $obj = createSelfTiedObject(undef, \$GunzipError);
44 return $obj->_inf(@_) ;
49 use IO::Compress::Base::Common qw(:Parse);
50 return ( 'ParseExtra' => [1, 1, Parse_boolean, 0] ) ;
58 # gunzip always needs crc32
59 $got->value('CRC32' => 1);
69 $self->smartReadExact(\$magic, GZIP_ID_SIZE);
71 *$self->{HeaderPending} = $magic ;
73 return $self->HeaderError("Minimum header size is " .
74 GZIP_MIN_HEADER_SIZE . " bytes")
75 if length $magic != GZIP_ID_SIZE ;
77 return $self->HeaderError("Bad Magic")
78 if ! isGzipMagic($magic) ;
80 *$self->{Type} = 'rfc1952';
90 return $self->_readGzipHeader($magic);
99 my ($CRC32, $ISIZE) = unpack("V V", $trailer) ;
100 *$self->{Info}{CRC32} = $CRC32;
101 *$self->{Info}{ISIZE} = $ISIZE;
103 if (*$self->{Strict}) {
104 return $self->TrailerError("CRC mismatch")
105 if $CRC32 != *$self->{Uncomp}->crc32() ;
107 my $exp_isize = *$self->{Uncomp}->uncompressedBytes();
108 return $self->TrailerError("ISIZE mismatch. Got $ISIZE"
109 . ", expected $exp_isize")
110 if $ISIZE != $exp_isize ;
119 return 0 if length $buffer < GZIP_ID_SIZE ;
120 my ($id1, $id2) = unpack("C C", $buffer) ;
121 return $id1 == GZIP_ID1 && $id2 == GZIP_ID2 ;
124 sub _readFullGzipHeader($)
129 $self->smartReadExact(\$magic, GZIP_ID_SIZE);
131 *$self->{HeaderPending} = $magic ;
133 return $self->HeaderError("Minimum header size is " .
134 GZIP_MIN_HEADER_SIZE . " bytes")
135 if length $magic != GZIP_ID_SIZE ;
138 return $self->HeaderError("Bad Magic")
139 if ! isGzipMagic($magic) ;
141 my $status = $self->_readGzipHeader($magic);
142 delete *$self->{Transparent} if ! defined $status ;
146 sub _readGzipHeader($)
148 my ($self, $magic) = @_ ;
152 $self->smartReadExact(\$buffer, GZIP_MIN_HEADER_SIZE - GZIP_ID_SIZE)
153 or return $self->HeaderError("Minimum header size is " .
154 GZIP_MIN_HEADER_SIZE . " bytes") ;
156 my $keep = $magic . $buffer ;
157 *$self->{HeaderPending} = $keep ;
159 # now split out the various parts
160 my ($cm, $flag, $mtime, $xfl, $os) = unpack("C C V C C", $buffer) ;
162 $cm == GZIP_CM_DEFLATED
163 or return $self->HeaderError("Not Deflate (CM is $cm)") ;
165 # check for use of reserved bits
166 return $self->HeaderError("Use of Reserved Bits in FLG field.")
167 if $flag & GZIP_FLG_RESERVED ;
171 if ($flag & GZIP_FLG_FEXTRA) {
173 $self->smartReadExact(\$buffer, GZIP_FEXTRA_HEADER_SIZE)
174 or return $self->TruncatedHeader("FEXTRA Length") ;
176 my ($XLEN) = unpack("v", $buffer) ;
177 $self->smartReadExact(\$EXTRA, $XLEN)
178 or return $self->TruncatedHeader("FEXTRA Body");
179 $keep .= $buffer . $EXTRA ;
181 if ($XLEN && *$self->{'ParseExtra'}) {
183 while ($offset < $XLEN) {
185 return $self->TruncatedHeader("FEXTRA Body")
186 if $offset + GZIP_FEXTRA_SUBFIELD_HEADER_SIZE > $XLEN ;
188 my $id = substr($EXTRA, $offset, GZIP_FEXTRA_SUBFIELD_ID_SIZE);
189 $offset += GZIP_FEXTRA_SUBFIELD_ID_SIZE ;
191 return $self->HeaderError("SubField ID 2nd byte is 0x00")
192 if *$self->{Strict} && substr($id, 1, 1) eq "\x00" ;
194 my ($subLen) = unpack("v", substr($EXTRA, $offset,
195 GZIP_FEXTRA_SUBFIELD_LEN_SIZE)) ;
196 $offset += GZIP_FEXTRA_SUBFIELD_LEN_SIZE ;
198 return $self->TruncatedHeader("FEXTRA Body")
199 if $offset + $subLen > $XLEN ;
201 push @EXTRA, [$id => substr($EXTRA, $offset, $subLen)];
208 if ($flag & GZIP_FLG_FNAME) {
211 $self->smartReadExact(\$buffer, 1)
212 or return $self->TruncatedHeader("FNAME");
213 last if $buffer eq GZIP_NULL_BYTE ;
216 $keep .= $origname . GZIP_NULL_BYTE ;
218 return $self->HeaderError("Non ISO 8859-1 Character found in Name")
219 if *$self->{Strict} && $origname =~ /$GZIP_FNAME_INVALID_CHAR_RE/o ;
223 if ($flag & GZIP_FLG_FCOMMENT) {
226 $self->smartReadExact(\$buffer, 1)
227 or return $self->TruncatedHeader("FCOMMENT");
228 last if $buffer eq GZIP_NULL_BYTE ;
231 $keep .= $comment . GZIP_NULL_BYTE ;
233 return $self->HeaderError("Non ISO 8859-1 Character found in Comment")
234 if *$self->{Strict} && $comment =~ /$GZIP_FCOMMENT_INVALID_CHAR_RE/o ;
237 if ($flag & GZIP_FLG_FHCRC) {
238 $self->smartReadExact(\$buffer, GZIP_FHCRC_SIZE)
239 or return $self->TruncatedHeader("FHCRC");
241 $HeaderCRC = unpack("v", $buffer) ;
242 my $crc16 = crc32($keep) & 0xFF ;
244 return $self->HeaderError("CRC16 mismatch.")
245 if *$self->{Strict} && $crc16 != $HeaderCRC;
250 # Assume compression method is deflated for xfl tests
254 *$self->{Type} = 'rfc1952';
258 'FingerprintLength' => 2,
259 'HeaderLength' => length $keep,
260 'TrailerLength' => GZIP_TRAILER_SIZE,
262 'isMinimalHeader' => $keep eq GZIP_MINIMUM_HEADER ? 1 : 0,
265 'MethodName' => $cm == GZIP_CM_DEFLATED ? "Deflated" : "Unknown" ,
266 'TextFlag' => $flag & GZIP_FLG_FTEXT ? 1 : 0,
267 'HeaderCRCFlag' => $flag & GZIP_FLG_FHCRC ? 1 : 0,
268 'NameFlag' => $flag & GZIP_FLG_FNAME ? 1 : 0,
269 'CommentFlag' => $flag & GZIP_FLG_FCOMMENT ? 1 : 0,
270 'ExtraFlag' => $flag & GZIP_FLG_FEXTRA ? 1 : 0,
272 'Comment' => $comment,
275 'OsName' => defined $GZIP_OS_Names{$os}
276 ? $GZIP_OS_Names{$os} : "Unknown",
277 'HeaderCRC' => $HeaderCRC,
279 'ExtraFlags' => $xfl,
280 'ExtraFieldRaw' => $EXTRA,
281 'ExtraField' => [ @EXTRA ],
284 #'CompSize'=> $compsize,
286 #'OrigSize'=> $ISIZE,
299 IO::Uncompress::Gunzip - Perl interface to read RFC 1952 files/buffers
304 use IO::Uncompress::Gunzip qw(gunzip $GunzipError) ;
306 my $status = gunzip $input => $output [,OPTS]
307 or die "gunzip failed: $GunzipError\n";
309 my $z = new IO::Uncompress::Gunzip $input [OPTS]
310 or die "gunzip failed: $GunzipError\n";
312 $status = $z->read($buffer)
313 $status = $z->read($buffer, $length)
314 $status = $z->read($buffer, $length, $offset)
315 $line = $z->getline()
320 $status = $z->inflateSync()
323 $data = $z->getHeaderInfo()
325 $z->seek($position, $whence)
337 read($z, $buffer, $length);
338 read($z, $buffer, $length, $offset);
340 seek($z, $position, $whence)
351 B<WARNING -- This is a Beta release>.
355 =item * DO NOT use in production code.
357 =item * The documentation is incomplete in places.
359 =item * Parts of the interface defined here are tentative.
361 =item * Please report any problems you find.
369 This module provides a Perl interface that allows the reading of
370 files/buffers that conform to RFC 1952.
372 For writing RFC 1952 files/buffers, see the companion module IO::Compress::Gzip.
376 =head1 Functional Interface
378 A top-level function, C<gunzip>, is provided to carry out
379 "one-shot" uncompression between buffers and/or files. For finer
380 control over the uncompression process, see the L</"OO Interface">
383 use IO::Uncompress::Gunzip qw(gunzip $GunzipError) ;
385 gunzip $input => $output [,OPTS]
386 or die "gunzip failed: $GunzipError\n";
390 The functional interface needs Perl5.005 or better.
393 =head2 gunzip $input => $output [, OPTS]
396 C<gunzip> expects at least two parameters, C<$input> and C<$output>.
398 =head3 The C<$input> parameter
400 The parameter, C<$input>, is used to define the source of
403 It can take one of the following forms:
409 If the C<$input> parameter is a simple scalar, it is assumed to be a
410 filename. This file will be opened for reading and the input data
411 will be read from it.
415 If the C<$input> parameter is a filehandle, the input data will be
417 The string '-' can be used as an alias for standard input.
419 =item A scalar reference
421 If C<$input> is a scalar reference, the input data will be read
424 =item An array reference
426 If C<$input> is an array reference, each element in the array must be a
429 The input data will be read from each file in turn.
431 The complete array will be walked to ensure that it only
432 contains valid filenames before any data is uncompressed.
436 =item An Input FileGlob string
438 If C<$input> is a string that is delimited by the characters "<" and ">"
439 C<gunzip> will assume that it is an I<input fileglob string>. The
440 input is the list of files that match the fileglob.
442 If the fileglob does not match any files ...
444 See L<File::GlobMapper|File::GlobMapper> for more details.
449 If the C<$input> parameter is any other type, C<undef> will be returned.
453 =head3 The C<$output> parameter
455 The parameter C<$output> is used to control the destination of the
456 uncompressed data. This parameter can take one of these forms.
462 If the C<$output> parameter is a simple scalar, it is assumed to be a
463 filename. This file will be opened for writing and the uncompressed
464 data will be written to it.
468 If the C<$output> parameter is a filehandle, the uncompressed data
469 will be written to it.
470 The string '-' can be used as an alias for standard output.
473 =item A scalar reference
475 If C<$output> is a scalar reference, the uncompressed data will be
476 stored in C<$$output>.
480 =item An Array Reference
482 If C<$output> is an array reference, the uncompressed data will be
483 pushed onto the array.
485 =item An Output FileGlob
487 If C<$output> is a string that is delimited by the characters "<" and ">"
488 C<gunzip> will assume that it is an I<output fileglob string>. The
489 output is the list of files that match the fileglob.
491 When C<$output> is an fileglob string, C<$input> must also be a fileglob
492 string. Anything else is an error.
496 If the C<$output> parameter is any other type, C<undef> will be returned.
502 When C<$input> maps to multiple files/buffers and C<$output> is a single
503 file/buffer the uncompressed input files/buffers will all be stored
504 in C<$output> as a single uncompressed stream.
508 =head2 Optional Parameters
510 Unless specified below, the optional parameters for C<gunzip>,
511 C<OPTS>, are the same as those used with the OO interface defined in the
512 L</"Constructor Options"> section below.
516 =item AutoClose =E<gt> 0|1
518 This option applies to any input or output data streams to
519 C<gunzip> that are filehandles.
521 If C<AutoClose> is specified, and the value is true, it will result in all
522 input and/or output filehandles being closed once C<gunzip> has
525 This parameter defaults to 0.
529 =item BinModeOut =E<gt> 0|1
531 When writing to a file or filehandle, set C<binmode> before writing to the
540 =item -Append =E<gt> 0|1
544 =item -MultiStream =E<gt> 0|1
546 Creates a new stream after each file.
559 To read the contents of the file C<file1.txt.gz> and write the
560 compressed data to the file C<file1.txt>.
564 use IO::Uncompress::Gunzip qw(gunzip $GunzipError) ;
566 my $input = "file1.txt.gz";
567 my $output = "file1.txt";
568 gunzip $input => $output
569 or die "gunzip failed: $GunzipError\n";
572 To read from an existing Perl filehandle, C<$input>, and write the
573 uncompressed data to a buffer, C<$buffer>.
577 use IO::Uncompress::Gunzip qw(gunzip $GunzipError) ;
580 my $input = new IO::File "<file1.txt.gz"
581 or die "Cannot open 'file1.txt.gz': $!\n" ;
583 gunzip $input => \$buffer
584 or die "gunzip failed: $GunzipError\n";
586 To uncompress all files in the directory "/my/home" that match "*.txt.gz" and store the compressed data in the same directory
590 use IO::Uncompress::Gunzip qw(gunzip $GunzipError) ;
592 gunzip '</my/home/*.txt.gz>' => '</my/home/#1.txt>'
593 or die "gunzip failed: $GunzipError\n";
595 and if you want to compress each file one at a time, this will do the trick
599 use IO::Uncompress::Gunzip qw(gunzip $GunzipError) ;
601 for my $input ( glob "/my/home/*.txt.gz" )
605 gunzip $input => $output
606 or die "Error compressing '$input': $GunzipError\n";
613 The format of the constructor for IO::Uncompress::Gunzip is shown below
616 my $z = new IO::Uncompress::Gunzip $input [OPTS]
617 or die "IO::Uncompress::Gunzip failed: $GunzipError\n";
619 Returns an C<IO::Uncompress::Gunzip> object on success and undef on failure.
620 The variable C<$GunzipError> will contain an error message on failure.
622 If you are running Perl 5.005 or better the object, C<$z>, returned from
623 IO::Uncompress::Gunzip can be used exactly like an L<IO::File|IO::File> filehandle.
624 This means that all normal input file operations can be carried out with
625 C<$z>. For example, to read a line from a compressed file/buffer you can
626 use either of these forms
628 $line = $z->getline();
631 The mandatory parameter C<$input> is used to determine the source of the
632 compressed data. This parameter can take one of three forms.
638 If the C<$input> parameter is a scalar, it is assumed to be a filename. This
639 file will be opened for reading and the compressed data will be read from it.
643 If the C<$input> parameter is a filehandle, the compressed data will be
645 The string '-' can be used as an alias for standard input.
648 =item A scalar reference
650 If C<$input> is a scalar reference, the compressed data will be read from
655 =head2 Constructor Options
658 The option names defined below are case insensitive and can be optionally
659 prefixed by a '-'. So all of the following are valid
666 OPTS is a combination of the following options:
670 =item -AutoClose =E<gt> 0|1
672 This option is only valid when the C<$input> parameter is a filehandle. If
673 specified, and the value is true, it will result in the file being closed once
674 either the C<close> method is called or the IO::Uncompress::Gunzip object is
677 This parameter defaults to 0.
679 =item -MultiStream =E<gt> 0|1
683 Allows multiple concatenated compressed streams to be treated as a single
684 compressed stream. Decompression will stop once either the end of the
685 file/buffer is reached, an error is encountered (premature eof, corrupt
686 compressed data) or the end of a stream is not immediately followed by the
687 start of another stream.
689 This parameter defaults to 0.
693 =item -Prime =E<gt> $string
695 This option will uncompress the contents of C<$string> before processing the
698 This option can be useful when the compressed data is embedded in another
699 file/data structure and it is not possible to work out where the compressed
700 data begins without having to read the first few bytes. If this is the
701 case, the uncompression can be I<primed> with these bytes using this
704 =item -Transparent =E<gt> 0|1
706 If this option is set and the input file or buffer is not compressed data,
707 the module will allow reading of it anyway.
709 This option defaults to 1.
711 =item -BlockSize =E<gt> $num
713 When reading the compressed input data, IO::Uncompress::Gunzip will read it in
714 blocks of C<$num> bytes.
716 This option defaults to 4096.
718 =item -InputLength =E<gt> $size
720 When present this option will limit the number of compressed bytes read
721 from the input file/buffer to C<$size>. This option can be used in the
722 situation where there is useful data directly after the compressed data
723 stream and you know beforehand the exact length of the compressed data
726 This option is mostly used when reading from a filehandle, in which case
727 the file pointer will be left pointing to the first byte directly after the
728 compressed data stream.
732 This option defaults to off.
734 =item -Append =E<gt> 0|1
736 This option controls what the C<read> method does with uncompressed data.
738 If set to 1, all uncompressed data will be appended to the output parameter
739 of the C<read> method.
741 If set to 0, the contents of the output parameter of the C<read> method
742 will be overwritten by the uncompressed data.
746 =item -Strict =E<gt> 0|1
750 This option controls whether the extra checks defined below are used when
751 carrying out the decompression. When Strict is on, the extra tests are
752 carried out, when Strict is off they are not.
754 The default for this option is off.
768 If the FHCRC bit is set in the gzip FLG header byte, the CRC16 bytes in the
769 header must match the crc16 value of the gzip header actually read.
773 If the gzip header contains a name field (FNAME) it consists solely of ISO
778 If the gzip header contains a comment field (FCOMMENT) it consists solely
779 of ISO 8859-1 characters plus line-feed.
783 If the gzip FEXTRA header field is present it must conform to the sub-field
784 structure as defined in RFC 1952.
788 The CRC32 and ISIZE trailer fields must be present.
792 The value of the CRC32 field read must match the crc32 value of the
793 uncompressed data actually contained in the gzip file.
797 The value of the ISIZE fields read must match the length of the
798 uncompressed data actually read from the file.
807 =item -ParseExtra =E<gt> 0|1
809 If the gzip FEXTRA header field is present and this option is set, it will
810 force the module to check that it conforms to the sub-field structure as
813 If the C<Strict> is on it will automatically enable this option.
833 $status = $z->read($buffer)
835 Reads a block of compressed data (the size the the compressed block is
836 determined by the C<Buffer> option in the constructor), uncompresses it and
837 writes any uncompressed data into C<$buffer>. If the C<Append> parameter is
838 set in the constructor, the uncompressed data will be appended to the
839 C<$buffer> parameter. Otherwise C<$buffer> will be overwritten.
841 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
842 or a negative number on error.
848 $status = $z->read($buffer, $length)
849 $status = $z->read($buffer, $length, $offset)
851 $status = read($z, $buffer, $length)
852 $status = read($z, $buffer, $length, $offset)
854 Attempt to read C<$length> bytes of uncompressed data into C<$buffer>.
856 The main difference between this form of the C<read> method and the
857 previous one, is that this one will attempt to return I<exactly> C<$length>
858 bytes. The only circumstances that this function will not is if end-of-file
859 or an IO error is encountered.
861 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
862 or a negative number on error.
869 $line = $z->getline()
874 This method fully supports the use of of the variable C<$/>
875 (or C<$INPUT_RECORD_SEPARATOR> or C<$RS> when C<English> is in use) to
876 determine what constitutes an end of line. Both paragraph mode and file
877 slurp mode are supported.
886 Read a single character.
892 $char = $z->ungetc($string)
900 $status = $z->inflateSync()
909 $hdr = $z->getHeaderInfo();
910 @hdrs = $z->getHeaderInfo();
912 This method returns either a hash reference (in scalar context) or a list
913 or hash references (in array context) that contains information about each
914 of the header fields in the compressed data stream(s).
922 The contents of the Name header field, if present. If no name is
923 present, the value will be undef. Note this is different from a zero length
924 name, which will return an empty string.
928 The contents of the Comment header field, if present. If no comment is
929 present, the value will be undef. Note this is different from a zero length
930 comment, which will return an empty string.
944 Returns the uncompressed file offset.
955 Returns true if the end of the compressed input stream has been reached.
961 $z->seek($position, $whence);
962 seek($z, $position, $whence);
967 Provides a sub-set of the C<seek> functionality, with the restriction
968 that it is only legal to seek forward in the input file/buffer.
969 It is a fatal error to attempt to seek backward.
973 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
974 SEEK_CUR or SEEK_END.
976 Returns 1 on success, 0 on failure.
985 This is a noop provided for completeness.
991 Returns true if the object currently refers to a opened file/buffer.
995 my $prev = $z->autoflush()
996 my $prev = $z->autoflush(EXPR)
998 If the C<$z> object is associated with a file or a filehandle, this method
999 returns the current autoflush setting for the underlying filehandle. If
1000 C<EXPR> is present, and is non-zero, it will enable flushing after every
1001 write/print operation.
1003 If C<$z> is associated with a buffer, this method has no effect and always
1006 B<Note> that the special variable C<$|> B<cannot> be used to set or
1007 retrieve the autoflush setting.
1009 =head2 input_line_number
1011 $z->input_line_number()
1012 $z->input_line_number(EXPR)
1016 Returns the current uncompressed line number. If C<EXPR> is present it has
1017 the effect of setting the line number. Note that setting the line number
1018 does not change the current position within the file/buffer being read.
1020 The contents of C<$/> are used to to determine what constitutes a line
1030 If the C<$z> object is associated with a file or a filehandle, this method
1031 will return the underlying file descriptor.
1033 If the C<$z> object is is associated with a buffer, this method will
1043 Closes the output file/buffer.
1047 For most versions of Perl this method will be automatically invoked if
1048 the IO::Uncompress::Gunzip object is destroyed (either explicitly or by the
1049 variable with the reference to the object going out of scope). The
1050 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
1051 these cases, the C<close> method will be called automatically, but
1052 not until global destruction of all live objects when the program is
1055 Therefore, if you want your scripts to be able to run on all versions
1056 of Perl, you should call C<close> explicitly and not rely on automatic
1059 Returns true on success, otherwise 0.
1061 If the C<AutoClose> option has been enabled when the IO::Uncompress::Gunzip
1062 object was created, and the object is associated with a file, the
1063 underlying file will also be closed.
1070 No symbolic constants are required by this IO::Uncompress::Gunzip at present.
1076 Imports C<gunzip> and C<$GunzipError>.
1079 use IO::Uncompress::Gunzip qw(gunzip $GunzipError) ;
1090 L<Compress::Zlib>, L<IO::Compress::Gzip>, 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>
1092 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
1094 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
1095 L<Archive::Tar|Archive::Tar>,
1096 L<IO::Zlib|IO::Zlib>
1099 For RFC 1950, 1951 and 1952 see
1100 F<http://www.faqs.org/rfcs/rfc1950.html>,
1101 F<http://www.faqs.org/rfcs/rfc1951.html> and
1102 F<http://www.faqs.org/rfcs/rfc1952.html>
1104 The I<zlib> compression library was written by Jean-loup Gailly
1105 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
1107 The primary site for the I<zlib> compression library is
1108 F<http://www.zlib.org>.
1110 The primary site for gzip is F<http://www.gzip.org>.
1120 The I<IO::Uncompress::Gunzip> module was written by Paul Marquess,
1125 =head1 MODIFICATION HISTORY
1127 See the Changes file.
1129 =head1 COPYRIGHT AND LICENSE
1132 Copyright (c) 2005-2006 Paul Marquess. All rights reserved.
1134 This program is free software; you can redistribute it and/or
1135 modify it under the same terms as Perl itself.