1 package IO::Uncompress::RawInflate ;
8 use Compress::Raw::Zlib 2.023 ;
9 use IO::Compress::Base::Common 2.023 qw(:Status createSelfTiedObject);
11 use IO::Uncompress::Base 2.023 ;
12 use IO::Uncompress::Adapter::Inflate 2.023 ;
15 our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, %DEFLATE_CONSTANTS, $RawInflateError);
18 $RawInflateError = '';
20 @ISA = qw( Exporter IO::Uncompress::Base );
21 @EXPORT_OK = qw( $RawInflateError rawinflate ) ;
22 %DEFLATE_CONSTANTS = ();
23 %EXPORT_TAGS = %IO::Uncompress::Base::EXPORT_TAGS ;
24 push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
25 Exporter::export_ok_tags('all');
28 # # Execute at runtime
30 # for my $module (qw(Compress::Raw::Zlib IO::Compress::Base::Common IO::Uncompress::Base IO::Uncompress::Adapter::Inflate))
32 # my $ver = ${ $module . "::VERSION"} ;
34 # $bad{$module} = $ver
35 # if $ver ne $VERSION;
40 # my $string = join "\n", map { "$_ $bad{$_}" } keys %bad;
41 # die caller(0)[0] . "needs version $VERSION mismatch\n$string\n";
48 my $obj = createSelfTiedObject($class, \$RawInflateError);
49 $obj->_create(undef, 0, @_);
54 my $obj = createSelfTiedObject(undef, \$RawInflateError);
55 return $obj->_inf(@_);
76 my ($obj, $errstr, $errno) = IO::Uncompress::Adapter::Inflate::mkUncompObject(
78 $got->value('ADLER32'),
82 return $self->saveErrorString(undef, $errstr, $errno)
85 *$self->{Uncomp} = $obj;
87 my $magic = $self->ckMagic()
90 *$self->{Info} = $self->readHeader($magic)
102 return $self->_isRaw() ;
112 'FingerprintLength' => 0,
114 'TrailerLength' => 0,
128 my $got = $self->_isRawx(@_);
131 *$self->{Pending} = *$self->{HeaderPending} ;
134 $self->pushBack(*$self->{HeaderPending});
135 *$self->{Uncomp}->reset();
137 *$self->{HeaderPending} = '';
147 $magic = '' unless defined $magic ;
151 $self->smartRead(\$buffer, *$self->{BlockSize}) >= 0
152 or return $self->saveErrorString(undef, "No data to read");
154 my $temp_buf = $magic . $buffer ;
155 *$self->{HeaderPending} = $temp_buf ;
157 my $status = *$self->{Uncomp}->uncompr(\$temp_buf, \$buffer, $self->smartEof()) ;
159 return $self->saveErrorString(undef, *$self->{Uncomp}{Error}, STATUS_ERROR)
160 if $status == STATUS_ERROR;
162 $self->pushBack($temp_buf) ;
164 return $self->saveErrorString(undef, "unexpected end of file", STATUS_ERROR)
165 if $self->smartEof() && $status != STATUS_ENDSTREAM;
167 #my $buf_len = *$self->{Uncomp}->uncompressedBytes();
168 my $buf_len = length $buffer;
170 if ($status == STATUS_ENDSTREAM) {
171 if (*$self->{MultiStream}
172 && (length $temp_buf || ! $self->smartEof())){
173 *$self->{NewStream} = 1 ;
174 *$self->{EndStream} = 0 ;
177 *$self->{EndStream} = 1 ;
180 *$self->{HeaderPending} = $buffer ;
181 *$self->{InflatedBytesRead} = $buf_len ;
182 *$self->{TotalInflatedBytesRead} += $buf_len ;
183 *$self->{Type} = 'rfc1951';
185 $self->saveStatus(STATUS_OK);
190 'TrailerLength' => 0,
200 # inflateSync is a no-op in Plain mode
204 return 0 if *$self->{Closed} ;
205 #return G_EOF if !length *$self->{Pending} && *$self->{EndStream} ;
206 return 0 if ! length *$self->{Pending} && *$self->{EndStream} ;
209 *$self->{Strict} = 0 ;
216 if (length *$self->{Pending} )
218 $temp_buf = *$self->{Pending} ;
219 *$self->{Pending} = '';
223 $status = $self->smartRead(\$temp_buf, *$self->{BlockSize}) ;
224 return $self->saveErrorString(0, "Error Reading Data")
228 *$self->{EndStream} = 1 ;
229 return $self->saveErrorString(0, "unexpected end of file", STATUS_ERROR);
233 $status = *$self->{Uncomp}->sync($temp_buf) ;
235 if ($status == STATUS_OK)
237 *$self->{Pending} .= $temp_buf ;
241 last unless $status == STATUS_ERROR ;
252 # my $end_offset = 0;
254 # $status = $self->scan()
255 # #or return $self->saveErrorString(undef, "Error Scanning: $$error_ref", $self->errorNo) ;
256 # or return $self->saveErrorString(G_ERR, "Error Scanning: $status")
258 # $status = $self->zap($end_offset)
259 # or return $self->saveErrorString(G_ERR, "Error Zapping: $status");
260 # #or return $self->saveErrorString(undef, "Error Zapping: $$error_ref", $self->errorNo) ;
262 # #(*$obj->{Deflate}, $status) = $inf->createDeflate();
264 ## *$obj->{Header} = *$inf->{Info}{Header};
265 ## *$obj->{UnCompSize_32bit} =
266 ## *$obj->{BytesWritten} = *$inf->{UnCompSize_32bit} ;
267 ## *$obj->{CompSize_32bit} = *$inf->{CompSize_32bit} ;
270 ## if ( $outType eq 'buffer')
271 ## { substr( ${ *$self->{Buffer} }, $end_offset) = '' }
272 ## elsif ($outType eq 'handle' || $outType eq 'filename') {
273 ## *$self->{FH} = *$inf->{FH} ;
274 ## delete *$inf->{FH};
275 ## *$obj->{FH}->flush() ;
276 ## *$obj->{Handle} = 1 if $outType eq 'handle';
278 ## #seek(*$obj->{FH}, $end_offset, SEEK_SET)
279 ## *$obj->{FH}->seek($end_offset, SEEK_SET)
280 ## or return $obj->saveErrorString(undef, $!, $!) ;
289 return 1 if *$self->{Closed} ;
290 return 1 if !length *$self->{Pending} && *$self->{EndStream} ;
295 $len = $self->_raw_read(\$buffer, 1)
296 while ! *$self->{EndStream} && $len >= 0 ;
298 #return $len if $len < 0 ? $len : 0 ;
299 return $len < 0 ? 0 : 1 ;
306 my $headerLength = *$self->{Info}{HeaderLength};
307 my $block_offset = $headerLength + *$self->{Uncomp}->getLastBlockOffset();
308 $_[0] = $headerLength + *$self->{Uncomp}->getEndOffset();
309 #printf "# End $_[0], headerlen $headerLength \n";;
310 #printf "# block_offset $block_offset %x\n", $block_offset;
312 ( $self->smartSeek($block_offset) &&
313 $self->smartRead(\$byte, 1) )
314 or return $self->saveErrorString(0, $!, $!);
316 #printf "#byte is %x\n", unpack('C*',$byte);
317 *$self->{Uncomp}->resetLastBlockByte($byte);
318 #printf "#to byte is %x\n", unpack('C*',$byte);
320 ( $self->smartSeek($block_offset) &&
321 $self->smartWrite($byte) )
322 or return $self->saveErrorString(0, $!, $!);
324 #$self->smartSeek($end_offset, 1);
332 my ($def, $status) = *$self->{Uncomp}->createDeflateStream(
334 -WindowBits => - MAX_WBITS,
335 -CRC32 => *$self->{Params}->value('CRC32'),
336 -ADLER32 => *$self->{Params}->value('ADLER32'),
339 return wantarray ? ($status, $def) : $def ;
350 IO::Uncompress::RawInflate - Read RFC 1951 files/buffers
354 use IO::Uncompress::RawInflate qw(rawinflate $RawInflateError) ;
356 my $status = rawinflate $input => $output [,OPTS]
357 or die "rawinflate failed: $RawInflateError\n";
359 my $z = new IO::Uncompress::RawInflate $input [OPTS]
360 or die "rawinflate failed: $RawInflateError\n";
362 $status = $z->read($buffer)
363 $status = $z->read($buffer, $length)
364 $status = $z->read($buffer, $length, $offset)
365 $line = $z->getline()
370 $status = $z->inflateSync()
372 $data = $z->trailingData()
373 $status = $z->nextStream()
374 $data = $z->getHeaderInfo()
376 $z->seek($position, $whence)
388 read($z, $buffer, $length);
389 read($z, $buffer, $length, $offset);
391 seek($z, $position, $whence)
399 This module provides a Perl interface that allows the reading of
400 files/buffers that conform to RFC 1951.
402 For writing RFC 1951 files/buffers, see the companion module IO::Compress::RawDeflate.
404 =head1 Functional Interface
406 A top-level function, C<rawinflate>, is provided to carry out
407 "one-shot" uncompression between buffers and/or files. For finer
408 control over the uncompression process, see the L</"OO Interface">
411 use IO::Uncompress::RawInflate qw(rawinflate $RawInflateError) ;
413 rawinflate $input => $output [,OPTS]
414 or die "rawinflate failed: $RawInflateError\n";
416 The functional interface needs Perl5.005 or better.
418 =head2 rawinflate $input => $output [, OPTS]
420 C<rawinflate> expects at least two parameters, C<$input> and C<$output>.
422 =head3 The C<$input> parameter
424 The parameter, C<$input>, is used to define the source of
427 It can take one of the following forms:
433 If the C<$input> parameter is a simple scalar, it is assumed to be a
434 filename. This file will be opened for reading and the input data
435 will be read from it.
439 If the C<$input> parameter is a filehandle, the input data will be
441 The string '-' can be used as an alias for standard input.
443 =item A scalar reference
445 If C<$input> is a scalar reference, the input data will be read
448 =item An array reference
450 If C<$input> is an array reference, each element in the array must be a
453 The input data will be read from each file in turn.
455 The complete array will be walked to ensure that it only
456 contains valid filenames before any data is uncompressed.
458 =item An Input FileGlob string
460 If C<$input> is a string that is delimited by the characters "<" and ">"
461 C<rawinflate> will assume that it is an I<input fileglob string>. The
462 input is the list of files that match the fileglob.
464 If the fileglob does not match any files ...
466 See L<File::GlobMapper|File::GlobMapper> for more details.
470 If the C<$input> parameter is any other type, C<undef> will be returned.
472 =head3 The C<$output> parameter
474 The parameter C<$output> is used to control the destination of the
475 uncompressed data. This parameter can take one of these forms.
481 If the C<$output> parameter is a simple scalar, it is assumed to be a
482 filename. This file will be opened for writing and the uncompressed
483 data will be written to it.
487 If the C<$output> parameter is a filehandle, the uncompressed data
488 will be written to it.
489 The string '-' can be used as an alias for standard output.
491 =item A scalar reference
493 If C<$output> is a scalar reference, the uncompressed data will be
494 stored in C<$$output>.
496 =item An Array Reference
498 If C<$output> is an array reference, the uncompressed data will be
499 pushed onto the array.
501 =item An Output FileGlob
503 If C<$output> is a string that is delimited by the characters "<" and ">"
504 C<rawinflate> will assume that it is an I<output fileglob string>. The
505 output is the list of files that match the fileglob.
507 When C<$output> is an fileglob string, C<$input> must also be a fileglob
508 string. Anything else is an error.
512 If the C<$output> parameter is any other type, C<undef> will be returned.
516 When C<$input> maps to multiple compressed files/buffers and C<$output> is
517 a single file/buffer, after uncompression C<$output> will contain a
518 concatenation of all the uncompressed data from each of the input
521 =head2 Optional Parameters
523 Unless specified below, the optional parameters for C<rawinflate>,
524 C<OPTS>, are the same as those used with the OO interface defined in the
525 L</"Constructor Options"> section below.
529 =item C<< AutoClose => 0|1 >>
531 This option applies to any input or output data streams to
532 C<rawinflate> that are filehandles.
534 If C<AutoClose> is specified, and the value is true, it will result in all
535 input and/or output filehandles being closed once C<rawinflate> has
538 This parameter defaults to 0.
540 =item C<< BinModeOut => 0|1 >>
542 When writing to a file or filehandle, set C<binmode> before writing to the
547 =item C<< Append => 0|1 >>
549 The behaviour of this option is dependent on the type of output data
556 If C<Append> is enabled, all uncompressed data will be append to the end of
557 the output buffer. Otherwise the output buffer will be cleared before any
558 uncompressed data is written to it.
562 If C<Append> is enabled, the file will be opened in append mode. Otherwise
563 the contents of the file, if any, will be truncated before any uncompressed
564 data is written to it.
568 If C<Append> is enabled, the filehandle will be positioned to the end of
569 the file via a call to C<seek> before any uncompressed data is
570 written to it. Otherwise the file pointer will not be moved.
574 When C<Append> is specified, and set to true, it will I<append> all uncompressed
575 data to the output data stream.
577 So when the output is a filehandle it will carry out a seek to the eof
578 before writing any uncompressed data. If the output is a filename, it will be opened for
579 appending. If the output is a buffer, all uncompressed data will be appened to
582 Conversely when C<Append> is not specified, or it is present and is set to
583 false, it will operate as follows.
585 When the output is a filename, it will truncate the contents of the file
586 before writing any uncompressed data. If the output is a filehandle
587 its position will not be changed. If the output is a buffer, it will be
588 wiped before any uncompressed data is output.
592 =item C<< MultiStream => 0|1 >>
594 This option is a no-op.
596 =item C<< TrailingData => $scalar >>
598 Returns the data, if any, that is present immediately after the compressed
599 data stream once uncompression is complete.
601 This option can be used when there is useful information immediately
602 following the compressed data stream, and you don't know the length of the
603 compressed data stream.
605 If the input is a buffer, C<trailingData> will return everything from the
606 end of the compressed data stream to the end of the buffer.
608 If the input is a filehandle, C<trailingData> will return the data that is
609 left in the filehandle input buffer once the end of the compressed data
610 stream has been reached. You can then use the filehandle to read the rest
613 Don't bother using C<trailingData> if the input is a filename.
615 If you know the length of the compressed data stream before you start
616 uncompressing, you can avoid having to use C<trailingData> by setting the
617 C<InputLength> option.
623 To read the contents of the file C<file1.txt.1951> and write the
624 uncompressed data to the file C<file1.txt>.
628 use IO::Uncompress::RawInflate qw(rawinflate $RawInflateError) ;
630 my $input = "file1.txt.1951";
631 my $output = "file1.txt";
632 rawinflate $input => $output
633 or die "rawinflate failed: $RawInflateError\n";
635 To read from an existing Perl filehandle, C<$input>, and write the
636 uncompressed data to a buffer, C<$buffer>.
640 use IO::Uncompress::RawInflate qw(rawinflate $RawInflateError) ;
643 my $input = new IO::File "<file1.txt.1951"
644 or die "Cannot open 'file1.txt.1951': $!\n" ;
646 rawinflate $input => \$buffer
647 or die "rawinflate failed: $RawInflateError\n";
649 To uncompress all files in the directory "/my/home" that match "*.txt.1951" and store the compressed data in the same directory
653 use IO::Uncompress::RawInflate qw(rawinflate $RawInflateError) ;
655 rawinflate '</my/home/*.txt.1951>' => '</my/home/#1.txt>'
656 or die "rawinflate failed: $RawInflateError\n";
658 and if you want to compress each file one at a time, this will do the trick
662 use IO::Uncompress::RawInflate qw(rawinflate $RawInflateError) ;
664 for my $input ( glob "/my/home/*.txt.1951" )
667 $output =~ s/.1951// ;
668 rawinflate $input => $output
669 or die "Error compressing '$input': $RawInflateError\n";
676 The format of the constructor for IO::Uncompress::RawInflate is shown below
678 my $z = new IO::Uncompress::RawInflate $input [OPTS]
679 or die "IO::Uncompress::RawInflate failed: $RawInflateError\n";
681 Returns an C<IO::Uncompress::RawInflate> object on success and undef on failure.
682 The variable C<$RawInflateError> will contain an error message on failure.
684 If you are running Perl 5.005 or better the object, C<$z>, returned from
685 IO::Uncompress::RawInflate can be used exactly like an L<IO::File|IO::File> filehandle.
686 This means that all normal input file operations can be carried out with
687 C<$z>. For example, to read a line from a compressed file/buffer you can
688 use either of these forms
690 $line = $z->getline();
693 The mandatory parameter C<$input> is used to determine the source of the
694 compressed data. This parameter can take one of three forms.
700 If the C<$input> parameter is a scalar, it is assumed to be a filename. This
701 file will be opened for reading and the compressed data will be read from it.
705 If the C<$input> parameter is a filehandle, the compressed data will be
707 The string '-' can be used as an alias for standard input.
709 =item A scalar reference
711 If C<$input> is a scalar reference, the compressed data will be read from
716 =head2 Constructor Options
718 The option names defined below are case insensitive and can be optionally
719 prefixed by a '-'. So all of the following are valid
726 OPTS is a combination of the following options:
730 =item C<< AutoClose => 0|1 >>
732 This option is only valid when the C<$input> parameter is a filehandle. If
733 specified, and the value is true, it will result in the file being closed once
734 either the C<close> method is called or the IO::Uncompress::RawInflate object is
737 This parameter defaults to 0.
739 =item C<< MultiStream => 0|1 >>
741 Allows multiple concatenated compressed streams to be treated as a single
742 compressed stream. Decompression will stop once either the end of the
743 file/buffer is reached, an error is encountered (premature eof, corrupt
744 compressed data) or the end of a stream is not immediately followed by the
745 start of another stream.
747 This parameter defaults to 0.
749 =item C<< Prime => $string >>
751 This option will uncompress the contents of C<$string> before processing the
754 This option can be useful when the compressed data is embedded in another
755 file/data structure and it is not possible to work out where the compressed
756 data begins without having to read the first few bytes. If this is the
757 case, the uncompression can be I<primed> with these bytes using this
760 =item C<< Transparent => 0|1 >>
762 If this option is set and the input file/buffer is not compressed data,
763 the module will allow reading of it anyway.
765 In addition, if the input file/buffer does contain compressed data and
766 there is non-compressed data immediately following it, setting this option
767 will make this module treat the whole file/bufffer as a single data stream.
769 This option defaults to 1.
771 =item C<< BlockSize => $num >>
773 When reading the compressed input data, IO::Uncompress::RawInflate will read it in
774 blocks of C<$num> bytes.
776 This option defaults to 4096.
778 =item C<< InputLength => $size >>
780 When present this option will limit the number of compressed bytes read
781 from the input file/buffer to C<$size>. This option can be used in the
782 situation where there is useful data directly after the compressed data
783 stream and you know beforehand the exact length of the compressed data
786 This option is mostly used when reading from a filehandle, in which case
787 the file pointer will be left pointing to the first byte directly after the
788 compressed data stream.
790 This option defaults to off.
792 =item C<< Append => 0|1 >>
794 This option controls what the C<read> method does with uncompressed data.
796 If set to 1, all uncompressed data will be appended to the output parameter
797 of the C<read> method.
799 If set to 0, the contents of the output parameter of the C<read> method
800 will be overwritten by the uncompressed data.
804 =item C<< Strict => 0|1 >>
806 This option is a no-op.
820 $status = $z->read($buffer)
822 Reads a block of compressed data (the size the the compressed block is
823 determined by the C<Buffer> option in the constructor), uncompresses it and
824 writes any uncompressed data into C<$buffer>. If the C<Append> parameter is
825 set in the constructor, the uncompressed data will be appended to the
826 C<$buffer> parameter. Otherwise C<$buffer> will be overwritten.
828 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
829 or a negative number on error.
835 $status = $z->read($buffer, $length)
836 $status = $z->read($buffer, $length, $offset)
838 $status = read($z, $buffer, $length)
839 $status = read($z, $buffer, $length, $offset)
841 Attempt to read C<$length> bytes of uncompressed data into C<$buffer>.
843 The main difference between this form of the C<read> method and the
844 previous one, is that this one will attempt to return I<exactly> C<$length>
845 bytes. The only circumstances that this function will not is if end-of-file
846 or an IO error is encountered.
848 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
849 or a negative number on error.
855 $line = $z->getline()
860 This method fully supports the use of of the variable C<$/> (or
861 C<$INPUT_RECORD_SEPARATOR> or C<$RS> when C<English> is in use) to
862 determine what constitutes an end of line. Paragraph mode, record mode and
863 file slurp mode are all supported.
871 Read a single character.
877 $char = $z->ungetc($string)
883 $status = $z->inflateSync()
891 $hdr = $z->getHeaderInfo();
892 @hdrs = $z->getHeaderInfo();
894 This method returns either a hash reference (in scalar context) or a list
895 or hash references (in array context) that contains information about each
896 of the header fields in the compressed data stream(s).
905 Returns the uncompressed file offset.
914 Returns true if the end of the compressed input stream has been reached.
918 $z->seek($position, $whence);
919 seek($z, $position, $whence);
921 Provides a sub-set of the C<seek> functionality, with the restriction
922 that it is only legal to seek forward in the input file/buffer.
923 It is a fatal error to attempt to seek backward.
925 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
926 SEEK_CUR or SEEK_END.
928 Returns 1 on success, 0 on failure.
937 This is a noop provided for completeness.
943 Returns true if the object currently refers to a opened file/buffer.
947 my $prev = $z->autoflush()
948 my $prev = $z->autoflush(EXPR)
950 If the C<$z> object is associated with a file or a filehandle, this method
951 returns the current autoflush setting for the underlying filehandle. If
952 C<EXPR> is present, and is non-zero, it will enable flushing after every
953 write/print operation.
955 If C<$z> is associated with a buffer, this method has no effect and always
958 B<Note> that the special variable C<$|> B<cannot> be used to set or
959 retrieve the autoflush setting.
961 =head2 input_line_number
963 $z->input_line_number()
964 $z->input_line_number(EXPR)
966 Returns the current uncompressed line number. If C<EXPR> is present it has
967 the effect of setting the line number. Note that setting the line number
968 does not change the current position within the file/buffer being read.
970 The contents of C<$/> are used to to determine what constitutes a line
978 If the C<$z> object is associated with a file or a filehandle, C<fileno>
979 will return the underlying file descriptor. Once the C<close> method is
980 called C<fileno> will return C<undef>.
982 If the C<$z> object is is associated with a buffer, this method will return
990 Closes the output file/buffer.
992 For most versions of Perl this method will be automatically invoked if
993 the IO::Uncompress::RawInflate object is destroyed (either explicitly or by the
994 variable with the reference to the object going out of scope). The
995 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
996 these cases, the C<close> method will be called automatically, but
997 not until global destruction of all live objects when the program is
1000 Therefore, if you want your scripts to be able to run on all versions
1001 of Perl, you should call C<close> explicitly and not rely on automatic
1004 Returns true on success, otherwise 0.
1006 If the C<AutoClose> option has been enabled when the IO::Uncompress::RawInflate
1007 object was created, and the object is associated with a file, the
1008 underlying file will also be closed.
1014 my $status = $z->nextStream();
1016 Skips to the next compressed data stream in the input file/buffer. If a new
1017 compressed data stream is found, the eof marker will be cleared and C<$.>
1020 Returns 1 if a new stream was found, 0 if none was found, and -1 if an
1021 error was encountered.
1027 my $data = $z->trailingData();
1029 Returns the data, if any, that is present immediately after the compressed
1030 data stream once uncompression is complete. It only makes sense to call
1031 this method once the end of the compressed data stream has been
1034 This option can be used when there is useful information immediately
1035 following the compressed data stream, and you don't know the length of the
1036 compressed data stream.
1038 If the input is a buffer, C<trailingData> will return everything from the
1039 end of the compressed data stream to the end of the buffer.
1041 If the input is a filehandle, C<trailingData> will return the data that is
1042 left in the filehandle input buffer once the end of the compressed data
1043 stream has been reached. You can then use the filehandle to read the rest
1046 Don't bother using C<trailingData> if the input is a filename.
1048 If you know the length of the compressed data stream before you start
1049 uncompressing, you can avoid having to use C<trailingData> by setting the
1050 C<InputLength> option in the constructor.
1054 No symbolic constants are required by this IO::Uncompress::RawInflate at present.
1060 Imports C<rawinflate> and C<$RawInflateError>.
1063 use IO::Uncompress::RawInflate qw(rawinflate $RawInflateError) ;
1069 =head2 Working with Net::FTP
1071 See L<IO::Uncompress::RawInflate::FAQ|IO::Uncompress::RawInflate::FAQ/"Compressed files and Net::FTP">
1075 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::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzma>, L<IO::Uncompress::UnLzma>, L<IO::Compress::Xz>, L<IO::Uncompress::UnXz>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
1077 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
1079 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
1080 L<Archive::Tar|Archive::Tar>,
1081 L<IO::Zlib|IO::Zlib>
1083 For RFC 1950, 1951 and 1952 see
1084 F<http://www.faqs.org/rfcs/rfc1950.html>,
1085 F<http://www.faqs.org/rfcs/rfc1951.html> and
1086 F<http://www.faqs.org/rfcs/rfc1952.html>
1088 The I<zlib> compression library was written by Jean-loup Gailly
1089 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
1091 The primary site for the I<zlib> compression library is
1092 F<http://www.zlib.org>.
1094 The primary site for gzip is F<http://www.gzip.org>.
1098 This module was written by Paul Marquess, F<pmqs@cpan.org>.
1100 =head1 MODIFICATION HISTORY
1102 See the Changes file.
1104 =head1 COPYRIGHT AND LICENSE
1106 Copyright (c) 2005-2009 Paul Marquess. All rights reserved.
1108 This program is free software; you can redistribute it and/or
1109 modify it under the same terms as Perl itself.