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