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