ext/Compress/IO/Zlib/lib/IO/Compress/Zip.pm

   1 package IO::Compress::Zip ;
   2
   3 use strict ;
   4 use warnings;
   5 use bytes;
   6
   7 use IO::Compress::Base::Common qw(:Status createSelfTiedObject);
   8 use IO::Compress::RawDeflate;
   9 use IO::Compress::Adapter::Deflate;
  10 use IO::Compress::Adapter::Identity;
  11 use IO::Compress::Zlib::Extra;
  12 use IO::Compress::Zip::Constants;
  13
  14
  15 use Compress::Raw::Zlib qw(crc32) ;
  16 BEGIN
  17 {
  18     eval { require IO::Compress::Adapter::Bzip2;
  19            import  IO::Compress::Adapter::Bzip2;
  20            require IO::Compress::Bzip2;
  21            import  IO::Compress::Bzip2;
  22          } ;
  23 }
  24
  25
  26 require Exporter ;
  27
  28 our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $ZipError);
  29
  30 $VERSION = '2.000_13';
  31 $ZipError = '';
  32
  33 @ISA = qw(Exporter IO::Compress::RawDeflate);
  34 @EXPORT_OK = qw( $ZipError zip ) ;
  35 %EXPORT_TAGS = %IO::Compress::RawDeflate::DEFLATE_CONSTANTS ;
  36 push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
  37
  38 $EXPORT_TAGS{zip_method} = [qw( ZIP_CM_STORE ZIP_CM_DEFLATE ZIP_CM_BZIP2 )];
  39 push @{ $EXPORT_TAGS{all} }, @{ $EXPORT_TAGS{zip_method} };
  40
  41 Exporter::export_ok_tags('all');
  42
  43 sub new
  44 {
  45     my $class = shift ;
  46
  47     my $obj = createSelfTiedObject($class, \$ZipError);
  48     $obj->_create(undef, @_);
  49 }
  50
  51 sub zip
  52 {
  53     my $obj = createSelfTiedObject(undef, \$ZipError);
  54     return $obj->_def(@_);
  55 }
  56
  57 sub mkComp
  58 {
  59     my $self = shift ;
  60     my $class = shift ;
  61     my $got = shift ;
  62
  63     my ($obj, $errstr, $errno) ;
  64
  65     if (*$self->{ZipData}{Method} == ZIP_CM_STORE) {
  66         ($obj, $errstr, $errno) = IO::Compress::Adapter::Identity::mkCompObject(
  67                                                  $got->value('Level'),
  68                                                  $got->value('Strategy')
  69                                                  );
  70     }
  71     elsif (*$self->{ZipData}{Method} == ZIP_CM_DEFLATE) {
  72         ($obj, $errstr, $errno) = IO::Compress::Adapter::Deflate::mkCompObject(
  73                                                  $got->value('CRC32'),
  74                                                  $got->value('Adler32'),
  75                                                  $got->value('Level'),
  76                                                  $got->value('Strategy')
  77                                                  );
  78     }
  79     elsif (*$self->{ZipData}{Method} == ZIP_CM_BZIP2) {
  80         ($obj, $errstr, $errno) = IO::Compress::Adapter::Bzip2::mkCompObject(
  81                                                 $got->value('BlockSize100K'),
  82                                                 $got->value('WorkFactor'),
  83                                                 $got->value('Verbosity')
  84                                                );
  85         *$self->{ZipData}{CRC32} = crc32(undef);
  86     }
  87
  88     return $self->saveErrorString(undef, $errstr, $errno)
  89        if ! defined $obj;
  90
  91     if (! defined *$self->{ZipData}{StartOffset}) {
  92         *$self->{ZipData}{StartOffset} = 0;
  93         *$self->{ZipData}{Offset} = new U64 ;
  94     }
  95
  96     return $obj;
  97 }
  98
  99 sub reset
 100 {
 101     my $self = shift ;
 102
 103     *$self->{Compress}->reset();
 104     *$self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32('');
 105
 106     return STATUS_OK;
 107 }
 108
 109 sub filterUncompressed
 110 {
 111     my $self = shift ;
 112
 113     if (*$self->{ZipData}{Method} == ZIP_CM_DEFLATE) {
 114         *$self->{ZipData}{CRC32} = *$self->{Compress}->crc32();
 115     }
 116     else {
 117         *$self->{ZipData}{CRC32} = crc32(${$_[0]}, *$self->{ZipData}{CRC32});
 118
 119     }
 120 }
 121
 122 sub mkHeader
 123 {
 124     my $self  = shift;
 125     my $param = shift ;
 126
 127     *$self->{ZipData}{StartOffset} = *$self->{ZipData}{Offset}->get32bit() ;
 128
 129     my $filename = '';
 130     $filename = $param->value('Name') || '';
 131
 132     my $comment = '';
 133     $comment = $param->value('Comment') || '';
 134
 135     my $hdr = '';
 136
 137     my $time = _unixToDosTime($param->value('Time'));
 138
 139     my $extra = '';
 140     my $ctlExtra = '';
 141     my $empty = 0;
 142
 143     if (*$self->{ZipData}{Zip64}) {
 144         $empty = 0xFFFF;
 145
 146         my $x = '';
 147         $x .= pack "V V", 0, 0 ; # uncompressedLength
 148         $x .= pack "V V", 0, 0 ; # compressedLength
 149         $x .= *$self->{ZipData}{Offset}->getPacked_V64() ; # offset to local hdr
 150         #$x .= pack "V  ", 0    ; # disk no
 151
 152         $x = IO::Compress::Zlib::Extra::mkSubField(ZIP_EXTRA_ID_ZIP64, $x);
 153         $extra .= $x;
 154         $ctlExtra .= $x;
 155     }
 156
 157     if (! $param->value('Minimal')) {
 158         if (defined $param->value('exTime'))
 159         {
 160             $extra .= mkExtendedTime($param->value('MTime'),
 161                                     $param->value('ATime'),
 162                                     $param->value('CTime'));
 163
 164             $ctlExtra .= mkExtendedTime($param->value('MTime'));
 165         }
 166
 167     #    if ( $param->value('UID'))
 168     #    {
 169     #        $extra    .= mkUnixExtra( $param->value('UID'), $param->value('GID'));
 170     #        $ctlExtra .= mkUnixExtra();
 171     #    }
 172
 173         $extra .= $param->value('ExtraFieldLocal')
 174             if defined $param->value('ExtraFieldLocal');
 175
 176         $ctlExtra .= $param->value('ExtraFieldCentral')
 177             if defined $param->value('ExtraFieldCentral');
 178     }
 179
 180
 181     my $extAttr = 0;
 182     $extAttr = $param->value('Mode') << 16
 183         if defined $param->value('Mode') ;
 184
 185     my $gpFlag = 0 ;
 186     $gpFlag |= ZIP_GP_FLAG_STREAMING_MASK
 187         if *$self->{ZipData}{Stream} ;
 188
 189     my $method = *$self->{ZipData}{Method} ;
 190
 191     my $version = $ZIP_CM_MIN_VERSIONS{$method};
 192     $version = ZIP64_MIN_VERSION
 193         if ZIP64_MIN_VERSION > $version && *$self->{ZipData}{Zip64};
 194     my $madeBy = ($param->value('OS_Code') << 8) + $version;
 195     my $extract = $version;
 196
 197     *$self->{ZipData}{Version} = $version;
 198     *$self->{ZipData}{MadeBy} = $madeBy;
 199
 200     my $ifa = 0;
 201     $ifa |= ZIP_IFA_TEXT_MASK
 202         if $param->value('TextFlag');
 203
 204     $hdr .= pack "V", ZIP_LOCAL_HDR_SIG ; # signature
 205     $hdr .= pack 'v', $extract   ; # extract Version & OS
 206     $hdr .= pack 'v', $gpFlag    ; # general purpose flag (set streaming mode)
 207     $hdr .= pack 'v', $method    ; # compression method (deflate)
 208     $hdr .= pack 'V', $time      ; # last mod date/time
 209     $hdr .= pack 'V', 0          ; # crc32               - 0 when streaming
 210     $hdr .= pack 'V', $empty     ; # compressed length   - 0 when streaming
 211     $hdr .= pack 'V', $empty     ; # uncompressed length - 0 when streaming
 212     $hdr .= pack 'v', length $filename ; # filename length
 213     $hdr .= pack 'v', length $extra ; # extra length
 214
 215     $hdr .= $filename ;
 216     $hdr .= $extra ;
 217
 218
 219     my $ctl = '';
 220
 221     $ctl .= pack "V", ZIP_CENTRAL_HDR_SIG ; # signature
 222     $ctl .= pack 'v', $madeBy    ; # version made by
 223     $ctl .= pack 'v', $extract   ; # extract Version
 224     $ctl .= pack 'v', $gpFlag    ; # general purpose flag (streaming mode)
 225     $ctl .= pack 'v', $method    ; # compression method (deflate)
 226     $ctl .= pack 'V', $time      ; # last mod date/time
 227     $ctl .= pack 'V', 0          ; # crc32
 228     $ctl .= pack 'V', $empty     ; # compressed length
 229     $ctl .= pack 'V', $empty     ; # uncompressed length
 230     $ctl .= pack 'v', length $filename ; # filename length
 231     $ctl .= pack 'v', length $ctlExtra ; # extra length
 232     $ctl .= pack 'v', length $comment ;  # file comment length
 233     $ctl .= pack 'v', 0          ; # disk number start
 234     $ctl .= pack 'v', $ifa       ; # internal file attributes
 235     $ctl .= pack 'V', $extAttr   ; # external file attributes
 236     if (! *$self->{ZipData}{Zip64}) {
 237         $ctl .= pack 'V', *$self->{ZipData}{Offset}->get32bit()  ; # offset to local header
 238     }
 239     else {
 240         $ctl .= pack 'V', $empty ; # offset to local header
 241     }
 242
 243     $ctl .= $filename ;
 244     *$self->{ZipData}{StartOffset64} = 4 + length $ctl;
 245     $ctl .= $ctlExtra ;
 246     $ctl .= $comment ;
 247
 248     *$self->{ZipData}{Offset}->add(length $hdr) ;
 249
 250     *$self->{ZipData}{CentralHeader} = $ctl;
 251
 252     return $hdr;
 253 }
 254
 255 sub mkTrailer
 256 {
 257     my $self = shift ;
 258
 259     my $crc32 ;
 260     if (*$self->{ZipData}{Method} == ZIP_CM_DEFLATE) {
 261         $crc32 = pack "V", *$self->{Compress}->crc32();
 262     }
 263     else {
 264         $crc32 = pack "V", *$self->{ZipData}{CRC32};
 265     }
 266
 267     my $ctl = *$self->{ZipData}{CentralHeader} ;
 268
 269     my $sizes ;
 270     if (! *$self->{ZipData}{Zip64}) {
 271         $sizes .= *$self->{CompSize}->getPacked_V32() ;   # Compressed size
 272         $sizes .= *$self->{UnCompSize}->getPacked_V32() ; # Uncompressed size
 273     }
 274     else {
 275         $sizes .= *$self->{CompSize}->getPacked_V64() ;   # Compressed size
 276         $sizes .= *$self->{UnCompSize}->getPacked_V64() ; # Uncompressed size
 277     }
 278
 279     my $data = $crc32 . $sizes ;
 280
 281
 282     my $hdr = '';
 283
 284     if (*$self->{ZipData}{Stream}) {
 285         $hdr  = pack "V", ZIP_DATA_HDR_SIG ;                       # signature
 286         $hdr .= $data ;
 287     }
 288     else {
 289         $self->writeAt(*$self->{ZipData}{StartOffset} + 14, $data)
 290             or return undef;
 291     }
 292
 293     if (! *$self->{ZipData}{Zip64})
 294       { substr($ctl, 16, length $data) = $data }
 295     else {
 296         substr($ctl, 16, length $crc32) = $crc32 ;
 297         my $s  = *$self->{UnCompSize}->getPacked_V64() ; # Uncompressed size
 298            $s .= *$self->{CompSize}->getPacked_V64() ;   # Compressed size
 299         substr($ctl, *$self->{ZipData}{StartOffset64}, length $s) = $s ;
 300     }
 301
 302     *$self->{ZipData}{Offset}->add(length($hdr));
 303     *$self->{ZipData}{Offset}->add( *$self->{CompSize} );
 304     push @{ *$self->{ZipData}{CentralDir} }, $ctl ;
 305
 306     return $hdr;
 307 }
 308
 309 sub mkFinalTrailer
 310 {
 311     my $self = shift ;
 312
 313     my $comment = '';
 314     $comment = *$self->{ZipData}{ZipComment} ;
 315
 316     my $cd_offset = *$self->{ZipData}{Offset}->get32bit() ; # offset to start central dir
 317
 318     my $entries = @{ *$self->{ZipData}{CentralDir} };
 319     my $cd = join '', @{ *$self->{ZipData}{CentralDir} };
 320     my $cd_len = length $cd ;
 321
 322     my $z64e = '';
 323
 324     if ( *$self->{ZipData}{Zip64} ) {
 325
 326         my $v  = *$self->{ZipData}{Version} ;
 327         my $mb = *$self->{ZipData}{MadeBy} ;
 328         $z64e .= pack 'v', $v             ; # Version made by
 329         $z64e .= pack 'v', $mb            ; # Version to extract
 330         $z64e .= pack 'V', 0              ; # number of disk
 331         $z64e .= pack 'V', 0              ; # number of disk with central dir
 332         $z64e .= U64::pack_V64 $entries   ; # entries in central dir on this disk
 333         $z64e .= U64::pack_V64 $entries   ; # entries in central dir
 334         $z64e .= U64::pack_V64 $cd_len    ; # size of central dir
 335         $z64e .= *$self->{ZipData}{Offset}->getPacked_V64() ; # offset to start central dir
 336
 337         $z64e  = pack("V", ZIP64_END_CENTRAL_REC_HDR_SIG) # signature
 338               .  U64::pack_V64(length $z64e)
 339               .  $z64e ;
 340
 341         *$self->{ZipData}{Offset}->add(length $cd) ;
 342
 343         $z64e .= pack "V", ZIP64_END_CENTRAL_LOC_HDR_SIG; # signature
 344         $z64e .= pack 'V', 0              ; # number of disk with central dir
 345         $z64e .= *$self->{ZipData}{Offset}->getPacked_V64() ; # offset to end zip64 central dir
 346         $z64e .= pack 'V', 1              ; # Total number of disks
 347
 348         # TODO - fix these when info-zip 3 is fixed.
 349         #$cd_len =
 350         #$cd_offset =
 351         $entries = 0xFFFF ;
 352     }
 353
 354     my $ecd = '';
 355     $ecd .= pack "V", ZIP_END_CENTRAL_HDR_SIG ; # signature
 356     $ecd .= pack 'v', 0          ; # number of disk
 357     $ecd .= pack 'v', 0          ; # number of disk with central dir
 358     $ecd .= pack 'v', $entries   ; # entries in central dir on this disk
 359     $ecd .= pack 'v', $entries   ; # entries in central dir
 360     $ecd .= pack 'V', $cd_len    ; # size of central dir
 361     $ecd .= pack 'V', $cd_offset ; # offset to start central dir
 362     $ecd .= pack 'v', length $comment ; # zipfile comment length
 363     $ecd .= $comment;
 364
 365     return $cd . $z64e . $ecd ;
 366 }
 367
 368 sub ckParams
 369 {
 370     my $self = shift ;
 371     my $got = shift;
 372
 373     $got->value('CRC32' => 1);
 374
 375     if (! $got->parsed('Time') ) {
 376         # Modification time defaults to now.
 377         $got->value('Time' => time) ;
 378     }
 379
 380     if (! $got->parsed('exTime') ) {
 381         my $timeRef = $got->value('exTime');
 382         if ( defined $timeRef) {
 383             return $self->saveErrorString(undef, "exTime not a 3-element array ref")
 384                 if ref $timeRef ne 'ARRAY' || @$timeRef != 3;
 385         }
 386
 387         $got->value("MTime", $timeRef->[1]);
 388         $got->value("ATime", $timeRef->[0]);
 389         $got->value("CTime", $timeRef->[2]);
 390     }
 391
 392     *$self->{ZipData}{Zip64} = $got->value('Zip64');
 393     *$self->{ZipData}{Stream} = $got->value('Stream');
 394
 395     return $self->saveErrorString(undef, "Zip64 only supported if Stream enabled")
 396         if  *$self->{ZipData}{Zip64} && ! *$self->{ZipData}{Stream} ;
 397
 398     my $method = $got->value('Method');
 399     return $self->saveErrorString(undef, "Unknown Method '$method'")
 400         if ! defined $ZIP_CM_MIN_VERSIONS{$method};
 401
 402     return $self->saveErrorString(undef, "Bzip2 not available")
 403         if $method == ZIP_CM_BZIP2 and
 404            ! defined $IO::Compress::Adapter::Bzip2::VERSION;
 405
 406     *$self->{ZipData}{Method} = $method;
 407
 408     *$self->{ZipData}{ZipComment} = $got->value('ZipComment') ;
 409
 410     for my $name (qw( ExtraFieldLocal ExtraFieldCentral ))
 411     {
 412         my $data = $got->value($name) ;
 413         if (defined $data) {
 414             my $bad = IO::Compress::Zlib::Extra::parseExtraField($data, 1, 0) ;
 415             return $self->saveErrorString(undef, "Error with $name Parameter: $bad")
 416                 if $bad ;
 417
 418             $got->value($name, $data) ;
 419         }
 420     }
 421
 422     return undef
 423         if defined $IO::Compress::Bzip2::VERSION
 424             and ! IO::Compress::Bzip2::ckParams($self, $got);
 425
 426     return 1 ;
 427 }
 428
 429 #sub newHeader
 430 #{
 431 #    my $self = shift ;
 432 #
 433 #    return $self->mkHeader(*$self->{Got});
 434 #}
 435
 436 sub getExtraParams
 437 {
 438     my $self = shift ;
 439
 440     use IO::Compress::Base::Common qw(:Parse);
 441     use Compress::Raw::Zlib qw(Z_DEFLATED Z_DEFAULT_COMPRESSION Z_DEFAULT_STRATEGY);
 442
 443     my @Bzip2 = ();
 444
 445     @Bzip2 = IO::Compress::Bzip2::getExtraParams($self)
 446         if defined $IO::Compress::Bzip2::VERSION;
 447
 448     return (
 449             # zlib behaviour
 450             $self->getZlibParams(),
 451
 452             'Stream'    => [1, 1, Parse_boolean,   1],
 453            #'Store'     => [0, 1, Parse_boolean,   0],
 454             'Method'    => [0, 1, Parse_unsigned,  ZIP_CM_DEFLATE],
 455
 456 #            # Zip header fields
 457             'Minimal'   => [0, 1, Parse_boolean,   0],
 458             'Zip64'     => [0, 1, Parse_boolean,   0],
 459             'Comment'   => [0, 1, Parse_any,       ''],
 460             'ZipComment'=> [0, 1, Parse_any,       ''],
 461             'Name'      => [0, 1, Parse_any,       ''],
 462             'Time'      => [0, 1, Parse_any,       undef],
 463             'exTime'    => [0, 1, Parse_any,       undef],
 464             'OS_Code'   => [0, 1, Parse_unsigned,  $Compress::Raw::Zlib::gzip_os_code],
 465
 466            'TextFlag'  => [0, 1, Parse_boolean,   0],
 467            'ExtraFieldLocal'  => [0, 1, Parse_any,    undef],
 468            'ExtraFieldCentral'=> [0, 1, Parse_any,    undef],
 469
 470             @Bzip2,
 471         );
 472 }
 473
 474 sub getInverseClass
 475 {
 476     return ('IO::Uncompress::Unzip',
 477                 \$IO::Uncompress::Unzip::UnzipError);
 478 }
 479
 480 sub getFileInfo
 481 {
 482     my $self = shift ;
 483     my $params = shift;
 484     my $filename = shift ;
 485
 486     my ($mode, $uid, $gid, $atime, $mtime, $ctime)
 487                 = (stat($filename))[2, 4,5, 8,9,10] ;
 488
 489     $params->value('Name' => $filename)
 490         if ! $params->parsed('Name') ;
 491
 492     $params->value('Time' => $mtime)
 493         if ! $params->parsed('Time') ;
 494
 495     if ( ! $params->parsed('exTime'))
 496     {
 497         $params->value('MTime' => $mtime) ;
 498         $params->value('ATime' => $atime) ;
 499         $params->value('CTime' => $ctime) ;
 500     }
 501
 502     $params->value('Mode' => $mode) ;
 503
 504     $params->value('UID' => $uid) ;
 505     $params->value('GID' => $gid) ;
 506
 507 }
 508
 509 sub mkExtendedTime
 510 {
 511     # order expected is m, a, c
 512
 513     my $times = '';
 514     my $bit = 1 ;
 515     my $flags = 0;
 516
 517     for my $time (@_)
 518     {
 519         if (defined $time)
 520         {
 521             $flags |= $bit;
 522             $times .= pack("V", $time);
 523         }
 524
 525         $bit <<= 1 ;
 526     }
 527
 528     #return "UT" . pack("v C", length($times) + 1, $flags) . $times;
 529     return IO::Compress::Zlib::Extra::mkSubField(ZIP_EXTRA_ID_EXT_TIMESTAMP,
 530                                                  pack("C", $flags) .  $times);
 531 }
 532
 533 sub mkUnixExtra
 534 {
 535     my $ids = '';
 536     for my $id (@_)
 537     {
 538         $ids .= pack("v", $id);
 539     }
 540
 541     #return "Ux" . pack("v", length $ids) . $ids;
 542     return IO::Compress::Zlib::Extra::mkSubField(ZIP_EXTRA_ID_INFO_ZIP_UNIX, $ids);
 543 }
 544
 545
 546 # from Archive::Zip
 547 sub _unixToDosTime    # Archive::Zip::Member
 548 {
 549         my $time_t = shift;
 550     # TODO - add something to cope with unix time < 1980
 551         my ( $sec, $min, $hour, $mday, $mon, $year ) = localtime($time_t);
 552         my $dt = 0;
 553         $dt += ( $sec >> 1 );
 554         $dt += ( $min << 5 );
 555         $dt += ( $hour << 11 );
 556         $dt += ( $mday << 16 );
 557         $dt += ( ( $mon + 1 ) << 21 );
 558         $dt += ( ( $year - 80 ) << 25 );
 559         return $dt;
 560 }
 561
 562 1;
 563
 564 __END__
 565
 566 =head1 NAME
 567
 568
 569
 570 IO::Compress::Zip - Write zip files/buffers
 571
 572
 573
 574 =head1 SYNOPSIS
 575
 576     use IO::Compress::Zip qw(zip $ZipError) ;
 577
 578
 579     my $status = zip $input => $output [,OPTS]
 580         or die "zip failed: $ZipError\n";
 581
 582     my $z = new IO::Compress::Zip $output [,OPTS]
 583         or die "zip failed: $ZipError\n";
 584
 585     $z->print($string);
 586     $z->printf($format, $string);
 587     $z->write($string);
 588     $z->syswrite($string [, $length, $offset]);
 589     $z->flush();
 590     $z->tell();
 591     $z->eof();
 592     $z->seek($position, $whence);
 593     $z->binmode();
 594     $z->fileno();
 595     $z->opened();
 596     $z->autoflush();
 597     $z->input_line_number();
 598     $z->newStream( [OPTS] );
 599
 600     $z->deflateParams();
 601
 602     $z->close() ;
 603
 604     $ZipError ;
 605
 606     # IO::File mode
 607
 608     print $z $string;
 609     printf $z $format, $string;
 610     tell $z
 611     eof $z
 612     seek $z, $position, $whence
 613     binmode $z
 614     fileno $z
 615     close $z ;
 616
 617
 618 =head1 DESCRIPTION
 619
 620
 621
 622 B<WARNING -- This is a Beta release>.
 623
 624 =over 5
 625
 626 =item * DO NOT use in production code.
 627
 628 =item * The documentation is incomplete in places.
 629
 630 =item * Parts of the interface defined here are tentative.
 631
 632 =item * Please report any problems you find.
 633
 634 =back
 635
 636
 637
 638
 639 This module provides a Perl interface that allows writing zip
 640 compressed data to files or buffer.
 641
 642
 643
 644
 645
 646
 647
 648 Note that IO::Compress::Zip is not intended to be a replacement for the module
 649 C<Archive::Zip>.
 650
 651 The primary aim of this module is not as an archiver, but to provide
 652 streaming write access to zip file files and buffers.
 653
 654
 655
 656 For reading zip files/buffers, see the companion module
 657 L<IO::Uncompress::Unzip|IO::Uncompress::Unzip>.
 658
 659
 660 =head1 Functional Interface
 661
 662 A top-level function, C<zip>, is provided to carry out
 663 "one-shot" compression between buffers and/or files. For finer
 664 control over the compression process, see the L</"OO Interface">
 665 section.
 666
 667     use IO::Compress::Zip qw(zip $ZipError) ;
 668
 669     zip $input => $output [,OPTS]
 670         or die "zip failed: $ZipError\n";
 671
 672
 673
 674 The functional interface needs Perl5.005 or better.
 675
 676
 677 =head2 zip $input => $output [, OPTS]
 678
 679
 680 C<zip> expects at least two parameters, C<$input> and C<$output>.
 681
 682 =head3 The C<$input> parameter
 683
 684 The parameter, C<$input>, is used to define the source of
 685 the uncompressed data.
 686
 687 It can take one of the following forms:
 688
 689 =over 5
 690
 691 =item A filename
 692
 693 If the C<$input> parameter is a simple scalar, it is assumed to be a
 694 filename. This file will be opened for reading and the input data
 695 will be read from it.
 696
 697 =item A filehandle
 698
 699 If the C<$input> parameter is a filehandle, the input data will be
 700 read from it.
 701 The string '-' can be used as an alias for standard input.
 702
 703 =item A scalar reference
 704
 705 If C<$input> is a scalar reference, the input data will be read
 706 from C<$$input>.
 707
 708 =item An array reference
 709
 710 If C<$input> is an array reference, each element in the array must be a
 711 filename.
 712
 713 The input data will be read from each file in turn.
 714
 715 The complete array will be walked to ensure that it only
 716 contains valid filenames before any data is compressed.
 717
 718
 719
 720 =item An Input FileGlob string
 721
 722 If C<$input> is a string that is delimited by the characters "<" and ">"
 723 C<zip> will assume that it is an I<input fileglob string>. The
 724 input is the list of files that match the fileglob.
 725
 726 If the fileglob does not match any files ...
 727
 728 See L<File::GlobMapper|File::GlobMapper> for more details.
 729
 730
 731 =back
 732
 733 If the C<$input> parameter is any other type, C<undef> will be returned.
 734
 735
 736 In addition, if C<$input> is a simple filename, the default values for
 737 the C<Name>, C<Time> and C<exTime> options will be sourced from that file.
 738
 739 If you do not want to use these defaults they can be overridden by
 740 explicitly setting the C<Name>, C<Time> and C<exTime> options or by setting the
 741 C<Minimal> parameter.
 742
 743
 744
 745 =head3 The C<$output> parameter
 746
 747 The parameter C<$output> is used to control the destination of the
 748 compressed data. This parameter can take one of these forms.
 749
 750 =over 5
 751
 752 =item A filename
 753
 754 If the C<$output> parameter is a simple scalar, it is assumed to be a
 755 filename.  This file will be opened for writing and the compressed
 756 data will be written to it.
 757
 758 =item A filehandle
 759
 760 If the C<$output> parameter is a filehandle, the compressed data
 761 will be written to it.
 762 The string '-' can be used as an alias for standard output.
 763
 764
 765 =item A scalar reference
 766
 767 If C<$output> is a scalar reference, the compressed data will be
 768 stored in C<$$output>.
 769
 770
 771
 772 =item An Array Reference
 773
 774 If C<$output> is an array reference, the compressed data will be
 775 pushed onto the array.
 776
 777 =item An Output FileGlob
 778
 779 If C<$output> is a string that is delimited by the characters "<" and ">"
 780 C<zip> will assume that it is an I<output fileglob string>. The
 781 output is the list of files that match the fileglob.
 782
 783 When C<$output> is an fileglob string, C<$input> must also be a fileglob
 784 string. Anything else is an error.
 785
 786 =back
 787
 788 If the C<$output> parameter is any other type, C<undef> will be returned.
 789
 790
 791
 792 =head2 Notes
 793
 794
 795
 796 When C<$input> maps to multiple files/buffers and C<$output> is a single
 797 file/buffer the input files/buffers will each be stored
 798 in C<$output> as a distinct entry.
 799
 800
 801
 802
 803
 804
 805 =head2 Optional Parameters
 806
 807 Unless specified below, the optional parameters for C<zip>,
 808 C<OPTS>, are the same as those used with the OO interface defined in the
 809 L</"Constructor Options"> section below.
 810
 811 =over 5
 812
 813 =item C<< AutoClose => 0|1 >>
 814
 815 This option applies to any input or output data streams to
 816 C<zip> that are filehandles.
 817
 818 If C<AutoClose> is specified, and the value is true, it will result in all
 819 input and/or output filehandles being closed once C<zip> has
 820 completed.
 821
 822 This parameter defaults to 0.
 823
 824
 825 =item C<< BinModeIn => 0|1 >>
 826
 827 When reading from a file or filehandle, set C<binmode> before reading.
 828
 829 Defaults to 0.
 830
 831
 832
 833
 834
 835 =item C<< Append => 0|1 >>
 836
 837 TODO
 838
 839
 840 =back
 841
 842
 843
 844 =head2 Examples
 845
 846 To read the contents of the file C<file1.txt> and write the compressed
 847 data to the file C<file1.txt.zip>.
 848
 849     use strict ;
 850     use warnings ;
 851     use IO::Compress::Zip qw(zip $ZipError) ;
 852
 853     my $input = "file1.txt";
 854     zip $input => "$input.zip"
 855         or die "zip failed: $ZipError\n";
 856
 857
 858 To read from an existing Perl filehandle, C<$input>, and write the
 859 compressed data to a buffer, C<$buffer>.
 860
 861     use strict ;
 862     use warnings ;
 863     use IO::Compress::Zip qw(zip $ZipError) ;
 864     use IO::File ;
 865
 866     my $input = new IO::File "<file1.txt"
 867         or die "Cannot open 'file1.txt': $!\n" ;
 868     my $buffer ;
 869     zip $input => \$buffer
 870         or die "zip failed: $ZipError\n";
 871
 872 To compress all files in the directory "/my/home" that match "*.txt"
 873 and store the compressed data in the same directory
 874
 875     use strict ;
 876     use warnings ;
 877     use IO::Compress::Zip qw(zip $ZipError) ;
 878
 879     zip '</my/home/*.txt>' => '<*.zip>'
 880         or die "zip failed: $ZipError\n";
 881
 882 and if you want to compress each file one at a time, this will do the trick
 883
 884     use strict ;
 885     use warnings ;
 886     use IO::Compress::Zip qw(zip $ZipError) ;
 887
 888     for my $input ( glob "/my/home/*.txt" )
 889     {
 890         my $output = "$input.zip" ;
 891         zip $input => $output
 892             or die "Error compressing '$input': $ZipError\n";
 893     }
 894
 895
 896 =head1 OO Interface
 897
 898 =head2 Constructor
 899
 900 The format of the constructor for C<IO::Compress::Zip> is shown below
 901
 902     my $z = new IO::Compress::Zip $output [,OPTS]
 903         or die "IO::Compress::Zip failed: $ZipError\n";
 904
 905 It returns an C<IO::Compress::Zip> object on success and undef on failure.
 906 The variable C<$ZipError> will contain an error message on failure.
 907
 908 If you are running Perl 5.005 or better the object, C<$z>, returned from
 909 IO::Compress::Zip can be used exactly like an L<IO::File|IO::File> filehandle.
 910 This means that all normal output file operations can be carried out
 911 with C<$z>.
 912 For example, to write to a compressed file/buffer you can use either of
 913 these forms
 914
 915     $z->print("hello world\n");
 916     print $z "hello world\n";
 917
 918 The mandatory parameter C<$output> is used to control the destination
 919 of the compressed data. This parameter can take one of these forms.
 920
 921 =over 5
 922
 923 =item A filename
 924
 925 If the C<$output> parameter is a simple scalar, it is assumed to be a
 926 filename. This file will be opened for writing and the compressed data
 927 will be written to it.
 928
 929 =item A filehandle
 930
 931 If the C<$output> parameter is a filehandle, the compressed data will be
 932 written to it.
 933 The string '-' can be used as an alias for standard output.
 934
 935
 936 =item A scalar reference
 937
 938 If C<$output> is a scalar reference, the compressed data will be stored
 939 in C<$$output>.
 940
 941 =back
 942
 943 If the C<$output> parameter is any other type, C<IO::Compress::Zip>::new will
 944 return undef.
 945
 946 =head2 Constructor Options
 947
 948 C<OPTS> is any combination of the following options:
 949
 950 =over 5
 951
 952 =item C<< AutoClose => 0|1 >>
 953
 954 This option is only valid when the C<$output> parameter is a filehandle. If
 955 specified, and the value is true, it will result in the C<$output> being
 956 closed once either the C<close> method is called or the C<IO::Compress::Zip>
 957 object is destroyed.
 958
 959 This parameter defaults to 0.
 960
 961 =item C<< Append => 0|1 >>
 962
 963 Opens C<$output> in append mode.
 964
 965 The behaviour of this option is dependent on the type of C<$output>.
 966
 967 =over 5
 968
 969 =item * A Buffer
 970
 971 If C<$output> is a buffer and C<Append> is enabled, all compressed data
 972 will be append to the end if C<$output>. Otherwise C<$output> will be
 973 cleared before any data is written to it.
 974
 975 =item * A Filename
 976
 977 If C<$output> is a filename and C<Append> is enabled, the file will be
 978 opened in append mode. Otherwise the contents of the file, if any, will be
 979 truncated before any compressed data is written to it.
 980
 981 =item * A Filehandle
 982
 983 If C<$output> is a filehandle, the file pointer will be positioned to the
 984 end of the file via a call to C<seek> before any compressed data is written
 985 to it.  Otherwise the file pointer will not be moved.
 986
 987 =back
 988
 989 This parameter defaults to 0.
 990
 991
 992
 993 =item C<< Name => $string >>
 994
 995 Stores the contents of C<$string> in the zip filename header field. If
 996 C<Name> is not specified, no zip filename field will be created.
 997
 998 =item C<< Time => $number >>
 999
1000 Sets the last modified time field in the zip header to $number.
1001
1002 This field defaults to the time the C<IO::Compress::Zip> object was created
1003 if this option is not specified.
1004
1005 =item C<< exTime => [$atime, $mtime, $ctime] >>
1006
1007 This option expects an array reference with exactly three elements:
1008 C<$atime>, C<mtime> and C<$ctime>. These correspond to the last access
1009 time, last modification time and creation time respectively.
1010
1011 It uses these values to set the extended timestamp field in the local zip
1012 header to the three values, $atime, $mtime, $ctime and sets the extended
1013 timestamp field in the central zip header to C<$mtime>.
1014
1015 If the C<Minimal> option is set to true, this option will be ignored.
1016
1017 By default no extended time field is created.
1018
1019 =item C<< Comment => $comment >>
1020
1021 Stores the contents of C<$comment> in the Central File Header of
1022 the zip file.
1023
1024 By default, no comment field is written to the zip file.
1025
1026 =item C<< ZipComment => $comment >>
1027
1028 Stores the contents of C<$comment> in the End of Central Directory record
1029 of the zip file.
1030
1031 By default, no comment field is written to the zip file.
1032
1033 =item C<< Method => $method >>
1034
1035 Controls which compression method is used. At present three compression
1036 methods are supported, namely Store (no compression at all), Deflate and
1037 Bzip2.
1038
1039 The symbols, ZIP_CM_STORE, ZIP_CM_DEFLATE and ZIP_CM_BZIP2 are used to
1040 select the compression method.
1041
1042 These constants are not imported by C<IO::Compress::Zip> by default.
1043
1044     use IO::Compress::Zip qw(:zip_method);
1045     use IO::Compress::Zip qw(:constants);
1046     use IO::Compress::Zip qw(:all);
1047
1048 Note that to create Bzip2 content, the module C<IO::Compress::Bzip2> must
1049 be installed. A fatal error will be thrown if you attempt to create Bzip2
1050 content when C<IO::Compress::Bzip2> is not available.
1051
1052 The default method is ZIP_CM_DEFLATE.
1053
1054 =item C<< Stream => 0|1 >>
1055
1056 This option controls whether the zip file/buffer output is created in
1057 streaming mode.
1058
1059 Note that when outputting to a file with streaming mode disabled (C<Stream>
1060 is 0), the output file must be seekable.
1061
1062 The default is 1.
1063
1064 =item C<< TextFlag => 0|1 >>
1065
1066 This parameter controls the setting of a bit in the zip central header. It
1067 is used to signal that the data stored in the zip file/buffer is probably
1068 text.
1069
1070 The default is 0.
1071
1072 =item C<< ExtraFieldLocal => $data >>
1073 =item C<< ExtraFieldCentral => $data >>
1074
1075 These options allows additional metadata to be stored in the local and
1076 central headers in the zip file/buffer.
1077
1078 An extra field consists of zero or more subfields. Each subfield consists
1079 of a two byte header followed by the subfield data.
1080
1081 The list of subfields can be supplied in any of the following formats
1082
1083     ExtraFieldLocal => [$id1, $data1,
1084                         $id2, $data2,
1085                          ...
1086                        ]
1087
1088     ExtraFieldLocal => [ [$id1 => $data1],
1089                          [$id2 => $data2],
1090                          ...
1091                        ]
1092
1093     ExtraFieldLocal => { $id1 => $data1,
1094                          $id2 => $data2,
1095                          ...
1096                        }
1097
1098 Where C<$id1>, C<$id2> are two byte subfield ID's.
1099
1100 If you use the hash syntax, you have no control over the order in which
1101 the ExtraSubFields are stored, plus you cannot have SubFields with
1102 duplicate ID.
1103
1104 Alternatively the list of subfields can by supplied as a scalar, thus
1105
1106     ExtraField => $rawdata
1107
1108
1109
1110 If the C<Minimal> option is set to true, this option will be ignored.
1111
1112 The maximum size of an extra field 65535 bytes.
1113
1114 =item C<< Minimal => 1|0 >>
1115
1116 If specified, this option will disable the creation of all extended fields
1117 in the zip local and central headers.
1118
1119 This parameter defaults to 0.
1120
1121 =item C<< BlockSize100K => number >>
1122
1123 Specify the number of 100K blocks bzip2 uses during compression.
1124
1125 Valid values are from 1 to 9, where 9 is best compression.
1126
1127 This option is only valid if the C<Method> is ZIP_CM_BZIP2. It is ignored
1128 otherwise.
1129
1130 The default is 1.
1131
1132 =item C<< WorkFactor => number >>
1133
1134 Specifies how much effort bzip2 should take before resorting to a slower
1135 fallback compression algorithm.
1136
1137 Valid values range from 0 to 250, where 0 means use the default value 30.
1138
1139 This option is only valid if the C<Method> is ZIP_CM_BZIP2. It is ignored
1140 otherwise.
1141
1142 The default is 0.
1143
1144
1145
1146
1147 =item -Level
1148
1149 Defines the compression level used by zlib. The value should either be
1150 a number between 0 and 9 (0 means no compression and 9 is maximum
1151 compression), or one of the symbolic constants defined below.
1152
1153    Z_NO_COMPRESSION
1154    Z_BEST_SPEED
1155    Z_BEST_COMPRESSION
1156    Z_DEFAULT_COMPRESSION
1157
1158 The default is Z_DEFAULT_COMPRESSION.
1159
1160 Note, these constants are not imported by C<IO::Compress::Zip> by default.
1161
1162     use IO::Compress::Zip qw(:strategy);
1163     use IO::Compress::Zip qw(:constants);
1164     use IO::Compress::Zip qw(:all);
1165
1166 =item -Strategy
1167
1168 Defines the strategy used to tune the compression. Use one of the symbolic
1169 constants defined below.
1170
1171    Z_FILTERED
1172    Z_HUFFMAN_ONLY
1173    Z_RLE
1174    Z_FIXED
1175    Z_DEFAULT_STRATEGY
1176
1177 The default is Z_DEFAULT_STRATEGY.
1178
1179
1180
1181
1182
1183
1184 =item C<< Strict => 0|1 >>
1185
1186
1187
1188 This is a placeholder option.
1189
1190
1191
1192 =back
1193
1194 =head2 Examples
1195
1196 TODO
1197
1198 =head1 Methods
1199
1200 =head2 print
1201
1202 Usage is
1203
1204     $z->print($data)
1205     print $z $data
1206
1207 Compresses and outputs the contents of the C<$data> parameter. This
1208 has the same behaviour as the C<print> built-in.
1209
1210 Returns true if successful.
1211
1212 =head2 printf
1213
1214 Usage is
1215
1216     $z->printf($format, $data)
1217     printf $z $format, $data
1218
1219 Compresses and outputs the contents of the C<$data> parameter.
1220
1221 Returns true if successful.
1222
1223 =head2 syswrite
1224
1225 Usage is
1226
1227     $z->syswrite $data
1228     $z->syswrite $data, $length
1229     $z->syswrite $data, $length, $offset
1230
1231 Compresses and outputs the contents of the C<$data> parameter.
1232
1233 Returns the number of uncompressed bytes written, or C<undef> if
1234 unsuccessful.
1235
1236 =head2 write
1237
1238 Usage is
1239
1240     $z->write $data
1241     $z->write $data, $length
1242     $z->write $data, $length, $offset
1243
1244 Compresses and outputs the contents of the C<$data> parameter.
1245
1246 Returns the number of uncompressed bytes written, or C<undef> if
1247 unsuccessful.
1248
1249 =head2 flush
1250
1251 Usage is
1252
1253
1254     $z->flush;
1255     $z->flush($flush_type);
1256
1257
1258 Flushes any pending compressed data to the output file/buffer.
1259
1260
1261 This method takes an optional parameter, C<$flush_type>, that controls
1262 how the flushing will be carried out. By default the C<$flush_type>
1263 used is C<Z_FINISH>. Other valid values for C<$flush_type> are
1264 C<Z_NO_FLUSH>, C<Z_SYNC_FLUSH>, C<Z_FULL_FLUSH> and C<Z_BLOCK>. It is
1265 strongly recommended that you only set the C<flush_type> parameter if
1266 you fully understand the implications of what it does - overuse of C<flush>
1267 can seriously degrade the level of compression achieved. See the C<zlib>
1268 documentation for details.
1269
1270
1271 Returns true on success.
1272
1273
1274 =head2 tell
1275
1276 Usage is
1277
1278     $z->tell()
1279     tell $z
1280
1281 Returns the uncompressed file offset.
1282
1283 =head2 eof
1284
1285 Usage is
1286
1287     $z->eof();
1288     eof($z);
1289
1290
1291
1292 Returns true if the C<close> method has been called.
1293
1294
1295
1296 =head2 seek
1297
1298     $z->seek($position, $whence);
1299     seek($z, $position, $whence);
1300
1301
1302
1303
1304 Provides a sub-set of the C<seek> functionality, with the restriction
1305 that it is only legal to seek forward in the output file/buffer.
1306 It is a fatal error to attempt to seek backward.
1307
1308 Empty parts of the file/buffer will have NULL (0x00) bytes written to them.
1309
1310
1311
1312 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
1313 SEEK_CUR or SEEK_END.
1314
1315 Returns 1 on success, 0 on failure.
1316
1317 =head2 binmode
1318
1319 Usage is
1320
1321     $z->binmode
1322     binmode $z ;
1323
1324 This is a noop provided for completeness.
1325
1326 =head2 opened
1327
1328     $z->opened()
1329
1330 Returns true if the object currently refers to a opened file/buffer.
1331
1332 =head2 autoflush
1333
1334     my $prev = $z->autoflush()
1335     my $prev = $z->autoflush(EXPR)
1336
1337 If the C<$z> object is associated with a file or a filehandle, this method
1338 returns the current autoflush setting for the underlying filehandle. If
1339 C<EXPR> is present, and is non-zero, it will enable flushing after every
1340 write/print operation.
1341
1342 If C<$z> is associated with a buffer, this method has no effect and always
1343 returns C<undef>.
1344
1345 B<Note> that the special variable C<$|> B<cannot> be used to set or
1346 retrieve the autoflush setting.
1347
1348 =head2 input_line_number
1349
1350     $z->input_line_number()
1351     $z->input_line_number(EXPR)
1352
1353
1354 This method always returns C<undef> when compressing.
1355
1356
1357
1358 =head2 fileno
1359
1360     $z->fileno()
1361     fileno($z)
1362
1363 If the C<$z> object is associated with a file or a filehandle, this method
1364 will return the underlying file descriptor.
1365
1366 If the C<$z> object is is associated with a buffer, this method will
1367 return undef.
1368
1369 =head2 close
1370
1371     $z->close() ;
1372     close $z ;
1373
1374
1375
1376 Flushes any pending compressed data and then closes the output file/buffer.
1377
1378
1379
1380 For most versions of Perl this method will be automatically invoked if
1381 the IO::Compress::Zip object is destroyed (either explicitly or by the
1382 variable with the reference to the object going out of scope). The
1383 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
1384 these cases, the C<close> method will be called automatically, but
1385 not until global destruction of all live objects when the program is
1386 terminating.
1387
1388 Therefore, if you want your scripts to be able to run on all versions
1389 of Perl, you should call C<close> explicitly and not rely on automatic
1390 closing.
1391
1392 Returns true on success, otherwise 0.
1393
1394 If the C<AutoClose> option has been enabled when the IO::Compress::Zip
1395 object was created, and the object is associated with a file, the
1396 underlying file will also be closed.
1397
1398
1399
1400
1401 =head2 newStream([OPTS])
1402
1403 Usage is
1404
1405     $z->newStream( [OPTS] )
1406
1407 Closes the current compressed data stream and starts a new one.
1408
1409 OPTS consists of any of the the options that are available when creating
1410 the C<$z> object.
1411
1412 See the L</"Constructor Options"> section for more details.
1413
1414
1415 =head2 deflateParams
1416
1417 Usage is
1418
1419     $z->deflateParams
1420
1421 TODO
1422
1423
1424 =head1 Importing
1425
1426
1427 A number of symbolic constants are required by some methods in
1428 C<IO::Compress::Zip>. None are imported by default.
1429
1430
1431
1432 =over 5
1433
1434 =item :all
1435
1436
1437 Imports C<zip>, C<$ZipError> and all symbolic
1438 constants that can be used by C<IO::Compress::Zip>. Same as doing this
1439
1440     use IO::Compress::Zip qw(zip $ZipError :constants) ;
1441
1442 =item :constants
1443
1444 Import all symbolic constants. Same as doing this
1445
1446
1447     use IO::Compress::Zip qw(:flush :level :strategy :zip_method) ;
1448
1449
1450 =item :flush
1451
1452 These symbolic constants are used by the C<flush> method.
1453
1454     Z_NO_FLUSH
1455     Z_PARTIAL_FLUSH
1456     Z_SYNC_FLUSH
1457     Z_FULL_FLUSH
1458     Z_FINISH
1459     Z_BLOCK
1460
1461 =item :level
1462
1463 These symbolic constants are used by the C<Level> option in the constructor.
1464
1465     Z_NO_COMPRESSION
1466     Z_BEST_SPEED
1467     Z_BEST_COMPRESSION
1468     Z_DEFAULT_COMPRESSION
1469
1470
1471 =item :strategy
1472
1473 These symbolic constants are used by the C<Strategy> option in the constructor.
1474
1475     Z_FILTERED
1476     Z_HUFFMAN_ONLY
1477     Z_RLE
1478     Z_FIXED
1479     Z_DEFAULT_STRATEGY
1480
1481
1482 =item :zip_method
1483
1484 These symbolic constants are used by the C<Method> option in the
1485 constructor.
1486
1487     ZIP_CM_STORE
1488     ZIP_CM_DEFLATE
1489     ZIP_CM_BZIP2
1490
1491
1492
1493
1494 =back
1495
1496 For
1497
1498 =head1 EXAMPLES
1499
1500 TODO
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512 =head1 SEE ALSO
1513
1514 L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
1515
1516 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
1517
1518 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
1519 L<Archive::Tar|Archive::Tar>,
1520 L<IO::Zlib|IO::Zlib>
1521
1522
1523 For RFC 1950, 1951 and 1952 see
1524 F<http://www.faqs.org/rfcs/rfc1950.html>,
1525 F<http://www.faqs.org/rfcs/rfc1951.html> and
1526 F<http://www.faqs.org/rfcs/rfc1952.html>
1527
1528 The I<zlib> compression library was written by Jean-loup Gailly
1529 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
1530
1531 The primary site for the I<zlib> compression library is
1532 F<http://www.zlib.org>.
1533
1534 The primary site for gzip is F<http://www.gzip.org>.
1535
1536
1537
1538
1539 =head1 AUTHOR
1540
1541 This module was written by Paul Marquess, F<pmqs@cpan.org>.
1542
1543
1544
1545 =head1 MODIFICATION HISTORY
1546
1547 See the Changes file.
1548
1549 =head1 COPYRIGHT AND LICENSE
1550
1551 Copyright (c) 2005-2006 Paul Marquess. All rights reserved.
1552
1553 This program is free software; you can redistribute it and/or
1554 modify it under the same terms as Perl itself.
1555
1556