ext/Compress/IO/Zlib/lib/IO/Uncompress/Inflate.pm

   1 package IO::Uncompress::Inflate ;
   2 # for RFC1950
   3
   4 use strict ;
   5 use warnings;
   6 use bytes;
   7
   8 use IO::Compress::Base::Common qw(:Status createSelfTiedObject);
   9 use IO::Compress::Zlib::Constants;
  10
  11 use IO::Uncompress::RawInflate ;
  12
  13 require Exporter ;
  14 our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $InflateError);
  15
  16 $VERSION = '2.000_12';
  17 $InflateError = '';
  18
  19 @ISA    = qw( Exporter IO::Uncompress::RawInflate );
  20 @EXPORT_OK = qw( $InflateError inflate ) ;
  21 %EXPORT_TAGS = %IO::Uncompress::RawInflate::DEFLATE_CONSTANTS ;
  22 push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
  23 Exporter::export_ok_tags('all');
  24
  25
  26 sub new
  27 {
  28     my $class = shift ;
  29     my $obj = createSelfTiedObject($class, \$InflateError);
  30
  31     $obj->_create(undef, 0, @_);
  32 }
  33
  34 sub inflate
  35 {
  36     my $obj = createSelfTiedObject(undef, \$InflateError);
  37     return $obj->_inf(@_);
  38 }
  39
  40 sub getExtraParams
  41 {
  42     return ();
  43 }
  44
  45 sub ckParams
  46 {
  47     my $self = shift ;
  48     my $got = shift ;
  49
  50     # gunzip always needs adler32
  51     $got->value('ADLER32' => 1);
  52
  53     return 1;
  54 }
  55
  56 sub ckMagic
  57 {
  58     my $self = shift;
  59
  60     my $magic ;
  61     $self->smartReadExact(\$magic, ZLIB_HEADER_SIZE);
  62
  63     *$self->{HeaderPending} = $magic ;
  64
  65     return $self->HeaderError("Header size is " .
  66                                         ZLIB_HEADER_SIZE . " bytes")
  67         if length $magic != ZLIB_HEADER_SIZE;
  68
  69     return $self->HeaderError("CRC mismatch.")
  70         if ! isZlibMagic($magic) ;
  71
  72     *$self->{Type} = 'rfc1950';
  73     return $magic;
  74 }
  75
  76 sub readHeader
  77 {
  78     my $self = shift;
  79     my $magic = shift ;
  80
  81     return $self->_readDeflateHeader($magic) ;
  82 }
  83
  84 sub chkTrailer
  85 {
  86     my $self = shift;
  87     my $trailer = shift;
  88
  89     my $ADLER32 = unpack("N", $trailer) ;
  90     *$self->{Info}{ADLER32} = $ADLER32;
  91     return $self->TrailerError("CRC mismatch")
  92         if *$self->{Strict} && $ADLER32 != *$self->{Uncomp}->adler32() ;
  93
  94     return STATUS_OK;
  95 }
  96
  97
  98
  99 sub isZlibMagic
 100 {
 101     my $buffer = shift ;
 102     return 0 if length $buffer < ZLIB_HEADER_SIZE ;
 103     my $hdr = unpack("n", $buffer) ;
 104     return $hdr % 31 == 0 ;
 105 }
 106
 107 sub bits
 108 {
 109     my $data   = shift ;
 110     my $offset = shift ;
 111     my $mask  = shift ;
 112
 113     ($data >> $offset ) & $mask & 0xFF ;
 114 }
 115
 116
 117 sub _readDeflateHeader
 118 {
 119     my ($self, $buffer) = @_ ;
 120
 121 #    if (! $buffer) {
 122 #        $self->smartReadExact(\$buffer, ZLIB_HEADER_SIZE);
 123 #
 124 #        *$self->{HeaderPending} = $buffer ;
 125 #
 126 #        return $self->HeaderError("Header size is " .
 127 #                                            ZLIB_HEADER_SIZE . " bytes")
 128 #            if length $buffer != ZLIB_HEADER_SIZE;
 129 #
 130 #        return $self->HeaderError("CRC mismatch.")
 131 #            if ! isZlibMagic($buffer) ;
 132 #    }
 133
 134     my ($CMF, $FLG) = unpack "C C", $buffer;
 135     my $FDICT = bits($FLG, ZLIB_FLG_FDICT_OFFSET,  ZLIB_FLG_FDICT_BITS ),
 136
 137     my $cm = bits($CMF, ZLIB_CMF_CM_OFFSET, ZLIB_CMF_CM_BITS) ;
 138     $cm == ZLIB_CMF_CM_DEFLATED
 139         or return $self->HeaderError("Not Deflate (CM is $cm)") ;
 140
 141     my $DICTID;
 142     if ($FDICT) {
 143         $self->smartReadExact(\$buffer, ZLIB_FDICT_SIZE)
 144             or return $self->TruncatedHeader("FDICT");
 145
 146         $DICTID = unpack("N", $buffer) ;
 147     }
 148
 149     *$self->{Type} = 'rfc1950';
 150
 151     return {
 152         'Type'          => 'rfc1950',
 153         'FingerprintLength'  => ZLIB_HEADER_SIZE,
 154         'HeaderLength'  => ZLIB_HEADER_SIZE,
 155         'TrailerLength' => ZLIB_TRAILER_SIZE,
 156         'Header'        => $buffer,
 157
 158         CMF     =>      $CMF                                               ,
 159         CM      => bits($CMF, ZLIB_CMF_CM_OFFSET,     ZLIB_CMF_CM_BITS    ),
 160         CINFO   => bits($CMF, ZLIB_CMF_CINFO_OFFSET,  ZLIB_CMF_CINFO_BITS ),
 161         FLG     =>      $FLG                                               ,
 162         FCHECK  => bits($FLG, ZLIB_FLG_FCHECK_OFFSET, ZLIB_FLG_FCHECK_BITS),
 163         FDICT   => bits($FLG, ZLIB_FLG_FDICT_OFFSET,  ZLIB_FLG_FDICT_BITS ),
 164         FLEVEL  => bits($FLG, ZLIB_FLG_LEVEL_OFFSET,  ZLIB_FLG_LEVEL_BITS ),
 165         DICTID  =>      $DICTID                                            ,
 166
 167     };
 168 }
 169
 170
 171
 172
 173 1 ;
 174
 175 __END__
 176
 177
 178 =head1 NAME
 179
 180
 181
 182 IO::Uncompress::Inflate - Read RFC 1950 files/buffers
 183
 184
 185
 186 =head1 SYNOPSIS
 187
 188     use IO::Uncompress::Inflate qw(inflate $InflateError) ;
 189
 190     my $status = inflate $input => $output [,OPTS]
 191         or die "inflate failed: $InflateError\n";
 192
 193     my $z = new IO::Uncompress::Inflate $input [OPTS]
 194         or die "inflate failed: $InflateError\n";
 195
 196     $status = $z->read($buffer)
 197     $status = $z->read($buffer, $length)
 198     $status = $z->read($buffer, $length, $offset)
 199     $line = $z->getline()
 200     $char = $z->getc()
 201     $char = $z->ungetc()
 202     $char = $z->opened()
 203
 204     $status = $z->inflateSync()
 205
 206     $z->trailingData()
 207     $data = $z->getHeaderInfo()
 208     $z->tell()
 209     $z->seek($position, $whence)
 210     $z->binmode()
 211     $z->fileno()
 212     $z->eof()
 213     $z->close()
 214
 215     $InflateError ;
 216
 217     # IO::File mode
 218
 219     <$z>
 220     read($z, $buffer);
 221     read($z, $buffer, $length);
 222     read($z, $buffer, $length, $offset);
 223     tell($z)
 224     seek($z, $position, $whence)
 225     binmode($z)
 226     fileno($z)
 227     eof($z)
 228     close($z)
 229
 230
 231 =head1 DESCRIPTION
 232
 233
 234
 235 B<WARNING -- This is a Beta release>.
 236
 237 =over 5
 238
 239 =item * DO NOT use in production code.
 240
 241 =item * The documentation is incomplete in places.
 242
 243 =item * Parts of the interface defined here are tentative.
 244
 245 =item * Please report any problems you find.
 246
 247 =back
 248
 249
 250
 251
 252
 253 This module provides a Perl interface that allows the reading of
 254 files/buffers that conform to RFC 1950.
 255
 256 For writing RFC 1950 files/buffers, see the companion module IO::Compress::Deflate.
 257
 258
 259
 260
 261
 262
 263 =head1 Functional Interface
 264
 265 A top-level function, C<inflate>, is provided to carry out
 266 "one-shot" uncompression between buffers and/or files. For finer
 267 control over the uncompression process, see the L</"OO Interface">
 268 section.
 269
 270     use IO::Uncompress::Inflate qw(inflate $InflateError) ;
 271
 272     inflate $input => $output [,OPTS]
 273         or die "inflate failed: $InflateError\n";
 274
 275
 276
 277 The functional interface needs Perl5.005 or better.
 278
 279
 280 =head2 inflate $input => $output [, OPTS]
 281
 282
 283 C<inflate> expects at least two parameters, C<$input> and C<$output>.
 284
 285 =head3 The C<$input> parameter
 286
 287 The parameter, C<$input>, is used to define the source of
 288 the compressed data.
 289
 290 It can take one of the following forms:
 291
 292 =over 5
 293
 294 =item A filename
 295
 296 If the C<$input> parameter is a simple scalar, it is assumed to be a
 297 filename. This file will be opened for reading and the input data
 298 will be read from it.
 299
 300 =item A filehandle
 301
 302 If the C<$input> parameter is a filehandle, the input data will be
 303 read from it.
 304 The string '-' can be used as an alias for standard input.
 305
 306 =item A scalar reference
 307
 308 If C<$input> is a scalar reference, the input data will be read
 309 from C<$$input>.
 310
 311 =item An array reference
 312
 313 If C<$input> is an array reference, each element in the array must be a
 314 filename.
 315
 316 The input data will be read from each file in turn.
 317
 318 The complete array will be walked to ensure that it only
 319 contains valid filenames before any data is uncompressed.
 320
 321
 322
 323 =item An Input FileGlob string
 324
 325 If C<$input> is a string that is delimited by the characters "<" and ">"
 326 C<inflate> will assume that it is an I<input fileglob string>. The
 327 input is the list of files that match the fileglob.
 328
 329 If the fileglob does not match any files ...
 330
 331 See L<File::GlobMapper|File::GlobMapper> for more details.
 332
 333
 334 =back
 335
 336 If the C<$input> parameter is any other type, C<undef> will be returned.
 337
 338
 339
 340 =head3 The C<$output> parameter
 341
 342 The parameter C<$output> is used to control the destination of the
 343 uncompressed data. This parameter can take one of these forms.
 344
 345 =over 5
 346
 347 =item A filename
 348
 349 If the C<$output> parameter is a simple scalar, it is assumed to be a
 350 filename.  This file will be opened for writing and the uncompressed
 351 data will be written to it.
 352
 353 =item A filehandle
 354
 355 If the C<$output> parameter is a filehandle, the uncompressed data
 356 will be written to it.
 357 The string '-' can be used as an alias for standard output.
 358
 359
 360 =item A scalar reference
 361
 362 If C<$output> is a scalar reference, the uncompressed data will be
 363 stored in C<$$output>.
 364
 365
 366
 367 =item An Array Reference
 368
 369 If C<$output> is an array reference, the uncompressed data will be
 370 pushed onto the array.
 371
 372 =item An Output FileGlob
 373
 374 If C<$output> is a string that is delimited by the characters "<" and ">"
 375 C<inflate> will assume that it is an I<output fileglob string>. The
 376 output is the list of files that match the fileglob.
 377
 378 When C<$output> is an fileglob string, C<$input> must also be a fileglob
 379 string. Anything else is an error.
 380
 381 =back
 382
 383 If the C<$output> parameter is any other type, C<undef> will be returned.
 384
 385
 386
 387 =head2 Notes
 388
 389
 390 When C<$input> maps to multiple compressed files/buffers and C<$output> is
 391 a single file/buffer, after uncompression C<$output> will contain a
 392 concatenation of all the uncompressed data from each of the input
 393 files/buffers.
 394
 395
 396
 397
 398
 399 =head2 Optional Parameters
 400
 401 Unless specified below, the optional parameters for C<inflate>,
 402 C<OPTS>, are the same as those used with the OO interface defined in the
 403 L</"Constructor Options"> section below.
 404
 405 =over 5
 406
 407 =item AutoClose =E<gt> 0|1
 408
 409 This option applies to any input or output data streams to
 410 C<inflate> that are filehandles.
 411
 412 If C<AutoClose> is specified, and the value is true, it will result in all
 413 input and/or output filehandles being closed once C<inflate> has
 414 completed.
 415
 416 This parameter defaults to 0.
 417
 418
 419
 420 =item BinModeOut =E<gt> 0|1
 421
 422 When writing to a file or filehandle, set C<binmode> before writing to the
 423 file.
 424
 425 Defaults to 0.
 426
 427
 428
 429
 430
 431 =item -Append =E<gt> 0|1
 432
 433 TODO
 434
 435 =item -MultiStream =E<gt> 0|1
 436
 437 Creates a new stream after each file.
 438
 439 Defaults to 1.
 440
 441
 442
 443 =back
 444
 445
 446
 447
 448 =head2 Examples
 449
 450 To read the contents of the file C<file1.txt.1950> and write the
 451 compressed data to the file C<file1.txt>.
 452
 453     use strict ;
 454     use warnings ;
 455     use IO::Uncompress::Inflate qw(inflate $InflateError) ;
 456
 457     my $input = "file1.txt.1950";
 458     my $output = "file1.txt";
 459     inflate $input => $output
 460         or die "inflate failed: $InflateError\n";
 461
 462
 463 To read from an existing Perl filehandle, C<$input>, and write the
 464 uncompressed data to a buffer, C<$buffer>.
 465
 466     use strict ;
 467     use warnings ;
 468     use IO::Uncompress::Inflate qw(inflate $InflateError) ;
 469     use IO::File ;
 470
 471     my $input = new IO::File "<file1.txt.1950"
 472         or die "Cannot open 'file1.txt.1950': $!\n" ;
 473     my $buffer ;
 474     inflate $input => \$buffer
 475         or die "inflate failed: $InflateError\n";
 476
 477 To uncompress all files in the directory "/my/home" that match "*.txt.1950" and store the compressed data in the same directory
 478
 479     use strict ;
 480     use warnings ;
 481     use IO::Uncompress::Inflate qw(inflate $InflateError) ;
 482
 483     inflate '</my/home/*.txt.1950>' => '</my/home/#1.txt>'
 484         or die "inflate failed: $InflateError\n";
 485
 486 and if you want to compress each file one at a time, this will do the trick
 487
 488     use strict ;
 489     use warnings ;
 490     use IO::Uncompress::Inflate qw(inflate $InflateError) ;
 491
 492     for my $input ( glob "/my/home/*.txt.1950" )
 493     {
 494         my $output = $input;
 495         $output =~ s/.1950// ;
 496         inflate $input => $output
 497             or die "Error compressing '$input': $InflateError\n";
 498     }
 499
 500 =head1 OO Interface
 501
 502 =head2 Constructor
 503
 504 The format of the constructor for IO::Uncompress::Inflate is shown below
 505
 506
 507     my $z = new IO::Uncompress::Inflate $input [OPTS]
 508         or die "IO::Uncompress::Inflate failed: $InflateError\n";
 509
 510 Returns an C<IO::Uncompress::Inflate> object on success and undef on failure.
 511 The variable C<$InflateError> will contain an error message on failure.
 512
 513 If you are running Perl 5.005 or better the object, C<$z>, returned from
 514 IO::Uncompress::Inflate can be used exactly like an L<IO::File|IO::File> filehandle.
 515 This means that all normal input file operations can be carried out with
 516 C<$z>.  For example, to read a line from a compressed file/buffer you can
 517 use either of these forms
 518
 519     $line = $z->getline();
 520     $line = <$z>;
 521
 522 The mandatory parameter C<$input> is used to determine the source of the
 523 compressed data. This parameter can take one of three forms.
 524
 525 =over 5
 526
 527 =item A filename
 528
 529 If the C<$input> parameter is a scalar, it is assumed to be a filename. This
 530 file will be opened for reading and the compressed data will be read from it.
 531
 532 =item A filehandle
 533
 534 If the C<$input> parameter is a filehandle, the compressed data will be
 535 read from it.
 536 The string '-' can be used as an alias for standard input.
 537
 538
 539 =item A scalar reference
 540
 541 If C<$input> is a scalar reference, the compressed data will be read from
 542 C<$$output>.
 543
 544 =back
 545
 546 =head2 Constructor Options
 547
 548
 549 The option names defined below are case insensitive and can be optionally
 550 prefixed by a '-'.  So all of the following are valid
 551
 552     -AutoClose
 553     -autoclose
 554     AUTOCLOSE
 555     autoclose
 556
 557 OPTS is a combination of the following options:
 558
 559 =over 5
 560
 561 =item -AutoClose =E<gt> 0|1
 562
 563 This option is only valid when the C<$input> parameter is a filehandle. If
 564 specified, and the value is true, it will result in the file being closed once
 565 either the C<close> method is called or the IO::Uncompress::Inflate object is
 566 destroyed.
 567
 568 This parameter defaults to 0.
 569
 570 =item -MultiStream =E<gt> 0|1
 571
 572
 573
 574 Allows multiple concatenated compressed streams to be treated as a single
 575 compressed stream. Decompression will stop once either the end of the
 576 file/buffer is reached, an error is encountered (premature eof, corrupt
 577 compressed data) or the end of a stream is not immediately followed by the
 578 start of another stream.
 579
 580 This parameter defaults to 0.
 581
 582
 583
 584 =item -Prime =E<gt> $string
 585
 586 This option will uncompress the contents of C<$string> before processing the
 587 input file/buffer.
 588
 589 This option can be useful when the compressed data is embedded in another
 590 file/data structure and it is not possible to work out where the compressed
 591 data begins without having to read the first few bytes. If this is the
 592 case, the uncompression can be I<primed> with these bytes using this
 593 option.
 594
 595 =item -Transparent =E<gt> 0|1
 596
 597 If this option is set and the input file or buffer is not compressed data,
 598 the module will allow reading of it anyway.
 599
 600 This option defaults to 1.
 601
 602 =item -BlockSize =E<gt> $num
 603
 604 When reading the compressed input data, IO::Uncompress::Inflate will read it in
 605 blocks of C<$num> bytes.
 606
 607 This option defaults to 4096.
 608
 609 =item -InputLength =E<gt> $size
 610
 611 When present this option will limit the number of compressed bytes read
 612 from the input file/buffer to C<$size>. This option can be used in the
 613 situation where there is useful data directly after the compressed data
 614 stream and you know beforehand the exact length of the compressed data
 615 stream.
 616
 617 This option is mostly used when reading from a filehandle, in which case
 618 the file pointer will be left pointing to the first byte directly after the
 619 compressed data stream.
 620
 621
 622
 623 This option defaults to off.
 624
 625 =item -Append =E<gt> 0|1
 626
 627 This option controls what the C<read> method does with uncompressed data.
 628
 629 If set to 1, all uncompressed data will be appended to the output parameter
 630 of the C<read> method.
 631
 632 If set to 0, the contents of the output parameter of the C<read> method
 633 will be overwritten by the uncompressed data.
 634
 635 Defaults to 0.
 636
 637 =item -Strict =E<gt> 0|1
 638
 639
 640
 641 This option controls whether the extra checks defined below are used when
 642 carrying out the decompression. When Strict is on, the extra tests are
 643 carried out, when Strict is off they are not.
 644
 645 The default for this option is off.
 646
 647
 648
 649
 650
 651 =over 5
 652
 653 =item 1
 654
 655 The ADLER32 checksum field must be present.
 656
 657 =item 2
 658
 659 The value of the ADLER32 field read must match the adler32 value of the
 660 uncompressed data actually contained in the file.
 661
 662 =back
 663
 664
 665
 666
 667
 668
 669
 670
 671
 672
 673
 674 =back
 675
 676 =head2 Examples
 677
 678 TODO
 679
 680 =head1 Methods
 681
 682 =head2 read
 683
 684 Usage is
 685
 686     $status = $z->read($buffer)
 687
 688 Reads a block of compressed data (the size the the compressed block is
 689 determined by the C<Buffer> option in the constructor), uncompresses it and
 690 writes any uncompressed data into C<$buffer>. If the C<Append> parameter is
 691 set in the constructor, the uncompressed data will be appended to the
 692 C<$buffer> parameter. Otherwise C<$buffer> will be overwritten.
 693
 694 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
 695 or a negative number on error.
 696
 697 =head2 read
 698
 699 Usage is
 700
 701     $status = $z->read($buffer, $length)
 702     $status = $z->read($buffer, $length, $offset)
 703
 704     $status = read($z, $buffer, $length)
 705     $status = read($z, $buffer, $length, $offset)
 706
 707 Attempt to read C<$length> bytes of uncompressed data into C<$buffer>.
 708
 709 The main difference between this form of the C<read> method and the
 710 previous one, is that this one will attempt to return I<exactly> C<$length>
 711 bytes. The only circumstances that this function will not is if end-of-file
 712 or an IO error is encountered.
 713
 714 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
 715 or a negative number on error.
 716
 717
 718 =head2 getline
 719
 720 Usage is
 721
 722     $line = $z->getline()
 723     $line = <$z>
 724
 725 Reads a single line.
 726
 727 This method fully supports the use of of the variable C<$/>
 728 (or C<$INPUT_RECORD_SEPARATOR> or C<$RS> when C<English> is in use) to
 729 determine what constitutes an end of line. Both paragraph mode and file
 730 slurp mode are supported.
 731
 732
 733 =head2 getc
 734
 735 Usage is
 736
 737     $char = $z->getc()
 738
 739 Read a single character.
 740
 741 =head2 ungetc
 742
 743 Usage is
 744
 745     $char = $z->ungetc($string)
 746
 747
 748
 749 =head2 inflateSync
 750
 751 Usage is
 752
 753     $status = $z->inflateSync()
 754
 755 TODO
 756
 757
 758 =head2 getHeaderInfo
 759
 760 Usage is
 761
 762     $hdr  = $z->getHeaderInfo();
 763     @hdrs = $z->getHeaderInfo();
 764
 765 This method returns either a hash reference (in scalar context) or a list
 766 or hash references (in array context) that contains information about each
 767 of the header fields in the compressed data stream(s).
 768
 769
 770
 771
 772 =head2 tell
 773
 774 Usage is
 775
 776     $z->tell()
 777     tell $z
 778
 779 Returns the uncompressed file offset.
 780
 781 =head2 eof
 782
 783 Usage is
 784
 785     $z->eof();
 786     eof($z);
 787
 788
 789
 790 Returns true if the end of the compressed input stream has been reached.
 791
 792
 793
 794 =head2 seek
 795
 796     $z->seek($position, $whence);
 797     seek($z, $position, $whence);
 798
 799
 800
 801
 802 Provides a sub-set of the C<seek> functionality, with the restriction
 803 that it is only legal to seek forward in the input file/buffer.
 804 It is a fatal error to attempt to seek backward.
 805
 806
 807
 808 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
 809 SEEK_CUR or SEEK_END.
 810
 811 Returns 1 on success, 0 on failure.
 812
 813 =head2 binmode
 814
 815 Usage is
 816
 817     $z->binmode
 818     binmode $z ;
 819
 820 This is a noop provided for completeness.
 821
 822 =head2 opened
 823
 824     $z->opened()
 825
 826 Returns true if the object currently refers to a opened file/buffer.
 827
 828 =head2 autoflush
 829
 830     my $prev = $z->autoflush()
 831     my $prev = $z->autoflush(EXPR)
 832
 833 If the C<$z> object is associated with a file or a filehandle, this method
 834 returns the current autoflush setting for the underlying filehandle. If
 835 C<EXPR> is present, and is non-zero, it will enable flushing after every
 836 write/print operation.
 837
 838 If C<$z> is associated with a buffer, this method has no effect and always
 839 returns C<undef>.
 840
 841 B<Note> that the special variable C<$|> B<cannot> be used to set or
 842 retrieve the autoflush setting.
 843
 844 =head2 input_line_number
 845
 846     $z->input_line_number()
 847     $z->input_line_number(EXPR)
 848
 849
 850
 851 Returns the current uncompressed line number. If C<EXPR> is present it has
 852 the effect of setting the line number. Note that setting the line number
 853 does not change the current position within the file/buffer being read.
 854
 855 The contents of C<$/> are used to to determine what constitutes a line
 856 terminator.
 857
 858
 859
 860 =head2 fileno
 861
 862     $z->fileno()
 863     fileno($z)
 864
 865 If the C<$z> object is associated with a file or a filehandle, this method
 866 will return the underlying file descriptor.
 867
 868 If the C<$z> object is is associated with a buffer, this method will
 869 return undef.
 870
 871 =head2 close
 872
 873     $z->close() ;
 874     close $z ;
 875
 876
 877
 878 Closes the output file/buffer.
 879
 880
 881
 882 For most versions of Perl this method will be automatically invoked if
 883 the IO::Uncompress::Inflate object is destroyed (either explicitly or by the
 884 variable with the reference to the object going out of scope). The
 885 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
 886 these cases, the C<close> method will be called automatically, but
 887 not until global destruction of all live objects when the program is
 888 terminating.
 889
 890 Therefore, if you want your scripts to be able to run on all versions
 891 of Perl, you should call C<close> explicitly and not rely on automatic
 892 closing.
 893
 894 Returns true on success, otherwise 0.
 895
 896 If the C<AutoClose> option has been enabled when the IO::Uncompress::Inflate
 897 object was created, and the object is associated with a file, the
 898 underlying file will also be closed.
 899
 900
 901
 902
 903 =head1 Importing
 904
 905 No symbolic constants are required by this IO::Uncompress::Inflate at present.
 906
 907 =over 5
 908
 909 =item :all
 910
 911 Imports C<inflate> and C<$InflateError>.
 912 Same as doing this
 913
 914     use IO::Uncompress::Inflate qw(inflate $InflateError) ;
 915
 916 =back
 917
 918 =head1 EXAMPLES
 919
 920
 921
 922
 923 =head1 SEE ALSO
 924
 925 L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, 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>
 926
 927 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
 928
 929 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
 930 L<Archive::Tar|Archive::Tar>,
 931 L<IO::Zlib|IO::Zlib>
 932
 933
 934 For RFC 1950, 1951 and 1952 see
 935 F<http://www.faqs.org/rfcs/rfc1950.html>,
 936 F<http://www.faqs.org/rfcs/rfc1951.html> and
 937 F<http://www.faqs.org/rfcs/rfc1952.html>
 938
 939 The I<zlib> compression library was written by Jean-loup Gailly
 940 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
 941
 942 The primary site for the I<zlib> compression library is
 943 F<http://www.zlib.org>.
 944
 945 The primary site for gzip is F<http://www.gzip.org>.
 946
 947
 948
 949
 950 =head1 AUTHOR
 951
 952 This module was written by Paul Marquess, F<pmqs@cpan.org>.
 953
 954
 955
 956 =head1 MODIFICATION HISTORY
 957
 958 See the Changes file.
 959
 960 =head1 COPYRIGHT AND LICENSE
 961
 962 Copyright (c) 2005-2006 Paul Marquess. All rights reserved.
 963
 964 This program is free software; you can redistribute it and/or
 965 modify it under the same terms as Perl itself.
 966