IO::Compress::Gzip(3pm)

1IO::Compress::Gzip(3) User Contributed Perl DocumentationIO::Compress::Gzip(3)
2
3
4

NAME

6       IO::Compress::Gzip - Write RFC 1952 files/buffers
7

SYNOPSIS

9           use IO::Compress::Gzip qw(gzip $GzipError) ;
10
11           my $status = gzip $input => $output [,OPTS]
12               or die "gzip failed: $GzipError\n";
13
14           my $z = new IO::Compress::Gzip $output [,OPTS]
15               or die "gzip failed: $GzipError\n";
16
17           $z->print($string);
18           $z->printf($format, $string);
19           $z->write($string);
20           $z->syswrite($string [, $length, $offset]);
21           $z->flush();
22           $z->tell();
23           $z->eof();
24           $z->seek($position, $whence);
25           $z->binmode();
26           $z->fileno();
27           $z->opened();
28           $z->autoflush();
29           $z->input_line_number();
30           $z->newStream( [OPTS] );
31
32           $z->deflateParams();
33
34           $z->close() ;
35
36           $GzipError ;
37
38           # IO::File mode
39
40           print $z $string;
41           printf $z $format, $string;
42           tell $z
43           eof $z
44           seek $z, $position, $whence
45           binmode $z
46           fileno $z
47           close $z ;
48

DESCRIPTION

50       This module provides a Perl interface that allows writing compressed
51       data to files or buffer as defined in RFC 1952.
52
53       All the gzip headers defined in RFC 1952 can be created using this
54       module.
55
56       For reading RFC 1952 files/buffers, see the companion module
57       IO::Uncompress::Gunzip.
58

Functional Interface

60       A top-level function, "gzip", is provided to carry out "one-shot"
61       compression between buffers and/or files. For finer control over the
62       compression process, see the "OO Interface" section.
63
64           use IO::Compress::Gzip qw(gzip $GzipError) ;
65
66           gzip $input_filename_or_reference => $output_filename_or_reference [,OPTS]
67               or die "gzip failed: $GzipError\n";
68
69       The functional interface needs Perl5.005 or better.
70
71   gzip $input_filename_or_reference => $output_filename_or_reference [, OPTS]
72       "gzip" expects at least two parameters, $input_filename_or_reference
73       and $output_filename_or_reference.
74
75       The $input_filename_or_reference parameter
76
77       The parameter, $input_filename_or_reference, is used to define the
78       source of the uncompressed data.
79
80       It can take one of the following forms:
81
82       A filename
83            If the <$input_filename_or_reference> parameter is a simple
84            scalar, it is assumed to be a filename. This file will be opened
85            for reading and the input data will be read from it.
86
87       A filehandle
88            If the $input_filename_or_reference parameter is a filehandle, the
89            input data will be read from it.  The string '-' can be used as an
90            alias for standard input.
91
92       A scalar reference
93            If $input_filename_or_reference is a scalar reference, the input
94            data will be read from $$input_filename_or_reference.
95
96       An array reference
97            If $input_filename_or_reference is an array reference, each
98            element in the array must be a filename.
99
100            The input data will be read from each file in turn.
101
102            The complete array will be walked to ensure that it only contains
103            valid filenames before any data is compressed.
104
105       An Input FileGlob string
106            If $input_filename_or_reference is a string that is delimited by
107            the characters "<" and ">" "gzip" will assume that it is an input
108            fileglob string. The input is the list of files that match the
109            fileglob.
110
111            See File::GlobMapper for more details.
112
113       If the $input_filename_or_reference parameter is any other type,
114       "undef" will be returned.
115
116       In addition, if $input_filename_or_reference is a simple filename, the
117       default values for the "Name" and "Time" options will be sourced from
118       that file.
119
120       If you do not want to use these defaults they can be overridden by
121       explicitly setting the "Name" and "Time" options or by setting the
122       "Minimal" parameter.
123
124       The $output_filename_or_reference parameter
125
126       The parameter $output_filename_or_reference is used to control the
127       destination of the compressed data. This parameter can take one of
128       these forms.
129
130       A filename
131            If the $output_filename_or_reference parameter is a simple scalar,
132            it is assumed to be a filename.  This file will be opened for
133            writing and the compressed data will be written to it.
134
135       A filehandle
136            If the $output_filename_or_reference parameter is a filehandle,
137            the compressed data will be written to it.  The string '-' can be
138            used as an alias for standard output.
139
140       A scalar reference
141            If $output_filename_or_reference is a scalar reference, the
142            compressed data will be stored in $$output_filename_or_reference.
143
144       An Array Reference
145            If $output_filename_or_reference is an array reference, the
146            compressed data will be pushed onto the array.
147
148       An Output FileGlob
149            If $output_filename_or_reference is a string that is delimited by
150            the characters "<" and ">" "gzip" will assume that it is an output
151            fileglob string. The output is the list of files that match the
152            fileglob.
153
154            When $output_filename_or_reference is an fileglob string,
155            $input_filename_or_reference must also be a fileglob string.
156            Anything else is an error.
157
158            See File::GlobMapper for more details.
159
160       If the $output_filename_or_reference parameter is any other type,
161       "undef" will be returned.
162
163   Notes
164       When $input_filename_or_reference maps to multiple files/buffers and
165       $output_filename_or_reference is a single file/buffer the input
166       files/buffers will be stored in $output_filename_or_reference as a
167       concatenated series of compressed data streams.
168
169   Optional Parameters
170       Unless specified below, the optional parameters for "gzip", "OPTS", are
171       the same as those used with the OO interface defined in the
172       "Constructor Options" section below.
173
174       "AutoClose => 0|1"
175            This option applies to any input or output data streams to "gzip"
176            that are filehandles.
177
178            If "AutoClose" is specified, and the value is true, it will result
179            in all input and/or output filehandles being closed once "gzip"
180            has completed.
181
182            This parameter defaults to 0.
183
184       "BinModeIn => 0|1"
185            When reading from a file or filehandle, set "binmode" before
186            reading.
187
188            Defaults to 0.
189
190       "Append => 0|1"
191            The behaviour of this option is dependent on the type of output
192            data stream.
193
194            ·    A Buffer
195
196                 If "Append" is enabled, all compressed data will be append to
197                 the end of the output buffer. Otherwise the output buffer
198                 will be cleared before any compressed data is written to it.
199
200            ·    A Filename
201
202                 If "Append" is enabled, the file will be opened in append
203                 mode. Otherwise the contents of the file, if any, will be
204                 truncated before any compressed data is written to it.
205
206            ·    A Filehandle
207
208                 If "Append" is enabled, the filehandle will be positioned to
209                 the end of the file via a call to "seek" before any
210                 compressed data is written to it.  Otherwise the file pointer
211                 will not be moved.
212
213            When "Append" is specified, and set to true, it will append all
214            compressed data to the output data stream.
215
216            So when the output is a filehandle it will carry out a seek to the
217            eof before writing any compressed data. If the output is a
218            filename, it will be opened for appending. If the output is a
219            buffer, all compressed data will be appended to the existing
220            buffer.
221
222            Conversely when "Append" is not specified, or it is present and is
223            set to false, it will operate as follows.
224
225            When the output is a filename, it will truncate the contents of
226            the file before writing any compressed data. If the output is a
227            filehandle its position will not be changed. If the output is a
228            buffer, it will be wiped before any compressed data is output.
229
230            Defaults to 0.
231
232   Examples
233       To read the contents of the file "file1.txt" and write the compressed
234       data to the file "file1.txt.gz".
235
236           use strict ;
237           use warnings ;
238           use IO::Compress::Gzip qw(gzip $GzipError) ;
239
240           my $input = "file1.txt";
241           gzip $input => "$input.gz"
242               or die "gzip failed: $GzipError\n";
243
244       To read from an existing Perl filehandle, $input, and write the
245       compressed data to a buffer, $buffer.
246
247           use strict ;
248           use warnings ;
249           use IO::Compress::Gzip qw(gzip $GzipError) ;
250           use IO::File ;
251
252           my $input = new IO::File "<file1.txt"
253               or die "Cannot open 'file1.txt': $!\n" ;
254           my $buffer ;
255           gzip $input => \$buffer
256               or die "gzip failed: $GzipError\n";
257
258       To compress all files in the directory "/my/home" that match "*.txt"
259       and store the compressed data in the same directory
260
261           use strict ;
262           use warnings ;
263           use IO::Compress::Gzip qw(gzip $GzipError) ;
264
265           gzip '</my/home/*.txt>' => '<*.gz>'
266               or die "gzip failed: $GzipError\n";
267
268       and if you want to compress each file one at a time, this will do the
269       trick
270
271           use strict ;
272           use warnings ;
273           use IO::Compress::Gzip qw(gzip $GzipError) ;
274
275           for my $input ( glob "/my/home/*.txt" )
276           {
277               my $output = "$input.gz" ;
278               gzip $input => $output
279                   or die "Error compressing '$input': $GzipError\n";
280           }
281

OO Interface

283   Constructor
284       The format of the constructor for "IO::Compress::Gzip" is shown below
285
286           my $z = new IO::Compress::Gzip $output [,OPTS]
287               or die "IO::Compress::Gzip failed: $GzipError\n";
288
289       It returns an "IO::Compress::Gzip" object on success and undef on
290       failure.  The variable $GzipError will contain an error message on
291       failure.
292
293       If you are running Perl 5.005 or better the object, $z, returned from
294       IO::Compress::Gzip can be used exactly like an IO::File filehandle.
295       This means that all normal output file operations can be carried out
296       with $z.  For example, to write to a compressed file/buffer you can use
297       either of these forms
298
299           $z->print("hello world\n");
300           print $z "hello world\n";
301
302       The mandatory parameter $output is used to control the destination of
303       the compressed data. This parameter can take one of these forms.
304
305       A filename
306            If the $output parameter is a simple scalar, it is assumed to be a
307            filename. This file will be opened for writing and the compressed
308            data will be written to it.
309
310       A filehandle
311            If the $output parameter is a filehandle, the compressed data will
312            be written to it.  The string '-' can be used as an alias for
313            standard output.
314
315       A scalar reference
316            If $output is a scalar reference, the compressed data will be
317            stored in $$output.
318
319       If the $output parameter is any other type, "IO::Compress::Gzip"::new
320       will return undef.
321
322   Constructor Options
323       "OPTS" is any combination of the following options:
324
325       "AutoClose => 0|1"
326            This option is only valid when the $output parameter is a
327            filehandle. If specified, and the value is true, it will result in
328            the $output being closed once either the "close" method is called
329            or the "IO::Compress::Gzip" object is destroyed.
330
331            This parameter defaults to 0.
332
333       "Append => 0|1"
334            Opens $output in append mode.
335
336            The behaviour of this option is dependent on the type of $output.
337
338            ·    A Buffer
339
340                 If $output is a buffer and "Append" is enabled, all
341                 compressed data will be append to the end of $output.
342                 Otherwise $output will be cleared before any data is written
343                 to it.
344
345            ·    A Filename
346
347                 If $output is a filename and "Append" is enabled, the file
348                 will be opened in append mode. Otherwise the contents of the
349                 file, if any, will be truncated before any compressed data is
350                 written to it.
351
352            ·    A Filehandle
353
354                 If $output is a filehandle, the file pointer will be
355                 positioned to the end of the file via a call to "seek" before
356                 any compressed data is written to it.  Otherwise the file
357                 pointer will not be moved.
358
359            This parameter defaults to 0.
360
361       "Merge => 0|1"
362            This option is used to compress input data and append it to an
363            existing compressed data stream in $output. The end result is a
364            single compressed data stream stored in $output.
365
366            It is a fatal error to attempt to use this option when $output is
367            not an RFC 1952 data stream.
368
369            There are a number of other limitations with the "Merge" option:
370
371            1.   This module needs to have been built with zlib 1.2.1 or
372                 better to work. A fatal error will be thrown if "Merge" is
373                 used with an older version of zlib.
374
375            2.   If $output is a file or a filehandle, it must be seekable.
376
377            This parameter defaults to 0.
378
379       -Level
380            Defines the compression level used by zlib. The value should
381            either be a number between 0 and 9 (0 means no compression and 9
382            is maximum compression), or one of the symbolic constants defined
383            below.
384
385               Z_NO_COMPRESSION
386               Z_BEST_SPEED
387               Z_BEST_COMPRESSION
388               Z_DEFAULT_COMPRESSION
389
390            The default is Z_DEFAULT_COMPRESSION.
391
392            Note, these constants are not imported by "IO::Compress::Gzip" by
393            default.
394
395                use IO::Compress::Gzip qw(:strategy);
396                use IO::Compress::Gzip qw(:constants);
397                use IO::Compress::Gzip qw(:all);
398
399       -Strategy
400            Defines the strategy used to tune the compression. Use one of the
401            symbolic constants defined below.
402
403               Z_FILTERED
404               Z_HUFFMAN_ONLY
405               Z_RLE
406               Z_FIXED
407               Z_DEFAULT_STRATEGY
408
409            The default is Z_DEFAULT_STRATEGY.
410
411       "Minimal => 0|1"
412            If specified, this option will force the creation of the smallest
413            possible compliant gzip header (which is exactly 10 bytes long) as
414            defined in RFC 1952.
415
416            See the section titled "Compliance" in RFC 1952 for a definition
417            of the values used for the fields in the gzip header.
418
419            All other parameters that control the content of the gzip header
420            will be ignored if this parameter is set to 1.
421
422            This parameter defaults to 0.
423
424       "Comment => $comment"
425            Stores the contents of $comment in the COMMENT field in the gzip
426            header.  By default, no comment field is written to the gzip file.
427
428            If the "-Strict" option is enabled, the comment can only consist
429            of ISO 8859-1 characters plus line feed.
430
431            If the "-Strict" option is disabled, the comment field can contain
432            any character except NULL. If any null characters are present, the
433            field will be truncated at the first NULL.
434
435       "Name => $string"
436            Stores the contents of $string in the gzip NAME header field. If
437            "Name" is not specified, no gzip NAME field will be created.
438
439            If the "-Strict" option is enabled, $string can only consist of
440            ISO 8859-1 characters.
441
442            If "-Strict" is disabled, then $string can contain any character
443            except NULL. If any null characters are present, the field will be
444            truncated at the first NULL.
445
446       "Time => $number"
447            Sets the MTIME field in the gzip header to $number.
448
449            This field defaults to the time the "IO::Compress::Gzip" object
450            was created if this option is not specified.
451
452       "TextFlag => 0|1"
453            This parameter controls the setting of the FLG.FTEXT bit in the
454            gzip header. It is used to signal that the data stored in the gzip
455            file/buffer is probably text.
456
457            The default is 0.
458
459       "HeaderCRC => 0|1"
460            When true this parameter will set the FLG.FHCRC bit to 1 in the
461            gzip header and set the CRC16 header field to the CRC of the
462            complete gzip header except the CRC16 field itself.
463
464            Note that gzip files created with the "HeaderCRC" flag set to 1
465            cannot be read by most, if not all, of the standard gunzip
466            utilities, most notably gzip version 1.2.4. You should therefore
467            avoid using this option if you want to maximize the portability of
468            your gzip files.
469
470            This parameter defaults to 0.
471
472       "OS_Code => $value"
473            Stores $value in the gzip OS header field. A number between 0 and
474            255 is valid.
475
476            If not specified, this parameter defaults to the OS code of the
477            Operating System this module was built on. The value 3 is used as
478            a catch-all for all Unix variants and unknown Operating Systems.
479
480       "ExtraField => $data"
481            This parameter allows additional metadata to be stored in the
482            ExtraField in the gzip header. An RFC 1952 compliant ExtraField
483            consists of zero or more subfields. Each subfield consists of a
484            two byte header followed by the subfield data.
485
486            The list of subfields can be supplied in any of the following
487            formats
488
489                -ExtraField => [$id1, $data1,
490                                $id2, $data2,
491                                 ...
492                               ]
493                -ExtraField => [ [$id1 => $data1],
494                                 [$id2 => $data2],
495                                 ...
496                               ]
497                -ExtraField => { $id1 => $data1,
498                                 $id2 => $data2,
499                                 ...
500                               }
501
502            Where $id1, $id2 are two byte subfield ID's. The second byte of
503            the ID cannot be 0, unless the "Strict" option has been disabled.
504
505            If you use the hash syntax, you have no control over the order in
506            which the ExtraSubFields are stored, plus you cannot have
507            SubFields with duplicate ID.
508
509            Alternatively the list of subfields can by supplied as a scalar,
510            thus
511
512                -ExtraField => $rawdata
513
514            If you use the raw format, and the "Strict" option is enabled,
515            "IO::Compress::Gzip" will check that $rawdata consists of zero or
516            more conformant sub-fields. When "Strict" is disabled, $rawdata
517            can consist of any arbitrary byte stream.
518
519            The maximum size of the Extra Field 65535 bytes.
520
521       "ExtraFlags => $value"
522            Sets the XFL byte in the gzip header to $value.
523
524            If this option is not present, the value stored in XFL field will
525            be determined by the setting of the "Level" option.
526
527            If "Level => Z_BEST_SPEED" has been specified then XFL is set to
528            2.  If "Level => Z_BEST_COMPRESSION" has been specified then XFL
529            is set to 4.  Otherwise XFL is set to 0.
530
531       "Strict => 0|1"
532            "Strict" will optionally police the values supplied with other
533            options to ensure they are compliant with RFC1952.
534
535            This option is enabled by default.
536
537            If "Strict" is enabled the following behaviour will be policed:
538
539            ·    The value supplied with the "Name" option can only contain
540                 ISO 8859-1 characters.
541
542            ·    The value supplied with the "Comment" option can only contain
543                 ISO 8859-1 characters plus line-feed.
544
545            ·    The values supplied with the "-Name" and "-Comment" options
546                 cannot contain multiple embedded nulls.
547
548            ·    If an "ExtraField" option is specified and it is a simple
549                 scalar, it must conform to the sub-field structure as defined
550                 in RFC 1952.
551
552            ·    If an "ExtraField" option is specified the second byte of the
553                 ID will be checked in each subfield to ensure that it does
554                 not contain the reserved value 0x00.
555
556            When "Strict" is disabled the following behaviour will be policed:
557
558            ·    The value supplied with "-Name" option can contain any
559                 character except NULL.
560
561            ·    The value supplied with "-Comment" option can contain any
562                 character except NULL.
563
564            ·    The values supplied with the "-Name" and "-Comment" options
565                 can contain multiple embedded nulls. The string written to
566                 the gzip header will consist of the characters up to, but not
567                 including, the first embedded NULL.
568
569            ·    If an "ExtraField" option is specified and it is a simple
570                 scalar, the structure will not be checked. The only error is
571                 if the length is too big.
572
573            ·    The ID header in an "ExtraField" sub-field can consist of any
574                 two bytes.
575
576   Examples
577       TODO
578

Methods

580   print
581       Usage is
582
583           $z->print($data)
584           print $z $data
585
586       Compresses and outputs the contents of the $data parameter. This has
587       the same behaviour as the "print" built-in.
588
589       Returns true if successful.
590
591   printf
592       Usage is
593
594           $z->printf($format, $data)
595           printf $z $format, $data
596
597       Compresses and outputs the contents of the $data parameter.
598
599       Returns true if successful.
600
601   syswrite
602       Usage is
603
604           $z->syswrite $data
605           $z->syswrite $data, $length
606           $z->syswrite $data, $length, $offset
607
608       Compresses and outputs the contents of the $data parameter.
609
610       Returns the number of uncompressed bytes written, or "undef" if
611       unsuccessful.
612
613   write
614       Usage is
615
616           $z->write $data
617           $z->write $data, $length
618           $z->write $data, $length, $offset
619
620       Compresses and outputs the contents of the $data parameter.
621
622       Returns the number of uncompressed bytes written, or "undef" if
623       unsuccessful.
624
625   flush
626       Usage is
627
628           $z->flush;
629           $z->flush($flush_type);
630
631       Flushes any pending compressed data to the output file/buffer.
632
633       This method takes an optional parameter, $flush_type, that controls how
634       the flushing will be carried out. By default the $flush_type used is
635       "Z_FINISH". Other valid values for $flush_type are "Z_NO_FLUSH",
636       "Z_SYNC_FLUSH", "Z_FULL_FLUSH" and "Z_BLOCK". It is strongly
637       recommended that you only set the "flush_type" parameter if you fully
638       understand the implications of what it does - overuse of "flush" can
639       seriously degrade the level of compression achieved. See the "zlib"
640       documentation for details.
641
642       Returns true on success.
643
644   tell
645       Usage is
646
647           $z->tell()
648           tell $z
649
650       Returns the uncompressed file offset.
651
652   eof
653       Usage is
654
655           $z->eof();
656           eof($z);
657
658       Returns true if the "close" method has been called.
659
660   seek
661           $z->seek($position, $whence);
662           seek($z, $position, $whence);
663
664       Provides a sub-set of the "seek" functionality, with the restriction
665       that it is only legal to seek forward in the output file/buffer.  It is
666       a fatal error to attempt to seek backward.
667
668       Empty parts of the file/buffer will have NULL (0x00) bytes written to
669       them.
670
671       The $whence parameter takes one the usual values, namely SEEK_SET,
672       SEEK_CUR or SEEK_END.
673
674       Returns 1 on success, 0 on failure.
675
676   binmode
677       Usage is
678
679           $z->binmode
680           binmode $z ;
681
682       This is a noop provided for completeness.
683
684   opened
685           $z->opened()
686
687       Returns true if the object currently refers to a opened file/buffer.
688
689   autoflush
690           my $prev = $z->autoflush()
691           my $prev = $z->autoflush(EXPR)
692
693       If the $z object is associated with a file or a filehandle, this method
694       returns the current autoflush setting for the underlying filehandle. If
695       "EXPR" is present, and is non-zero, it will enable flushing after every
696       write/print operation.
697
698       If $z is associated with a buffer, this method has no effect and always
699       returns "undef".
700
701       Note that the special variable $| cannot be used to set or retrieve the
702       autoflush setting.
703
704   input_line_number
705           $z->input_line_number()
706           $z->input_line_number(EXPR)
707
708       This method always returns "undef" when compressing.
709
710   fileno
711           $z->fileno()
712           fileno($z)
713
714       If the $z object is associated with a file or a filehandle, "fileno"
715       will return the underlying file descriptor. Once the "close" method is
716       called "fileno" will return "undef".
717
718       If the $z object is associated with a buffer, this method will return
719       "undef".
720
721   close
722           $z->close() ;
723           close $z ;
724
725       Flushes any pending compressed data and then closes the output
726       file/buffer.
727
728       For most versions of Perl this method will be automatically invoked if
729       the IO::Compress::Gzip object is destroyed (either explicitly or by the
730       variable with the reference to the object going out of scope). The
731       exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In these
732       cases, the "close" method will be called automatically, but not until
733       global destruction of all live objects when the program is terminating.
734
735       Therefore, if you want your scripts to be able to run on all versions
736       of Perl, you should call "close" explicitly and not rely on automatic
737       closing.
738
739       Returns true on success, otherwise 0.
740
741       If the "AutoClose" option has been enabled when the IO::Compress::Gzip
742       object was created, and the object is associated with a file, the
743       underlying file will also be closed.
744
745   newStream([OPTS])
746       Usage is
747
748           $z->newStream( [OPTS] )
749
750       Closes the current compressed data stream and starts a new one.
751
752       OPTS consists of any of the options that are available when creating
753       the $z object.
754
755       See the "Constructor Options" section for more details.
756
757   deflateParams
758       Usage is
759
760           $z->deflateParams
761
762       TODO
763

Importing

765       A number of symbolic constants are required by some methods in
766       "IO::Compress::Gzip". None are imported by default.
767
768       :all Imports "gzip", $GzipError and all symbolic constants that can be
769            used by "IO::Compress::Gzip". Same as doing this
770
771                use IO::Compress::Gzip qw(gzip $GzipError :constants) ;
772
773       :constants
774            Import all symbolic constants. Same as doing this
775
776                use IO::Compress::Gzip qw(:flush :level :strategy) ;
777
778       :flush
779            These symbolic constants are used by the "flush" method.
780
781                Z_NO_FLUSH
782                Z_PARTIAL_FLUSH
783                Z_SYNC_FLUSH
784                Z_FULL_FLUSH
785                Z_FINISH
786                Z_BLOCK
787
788       :level
789            These symbolic constants are used by the "Level" option in the
790            constructor.
791
792                Z_NO_COMPRESSION
793                Z_BEST_SPEED
794                Z_BEST_COMPRESSION
795                Z_DEFAULT_COMPRESSION
796
797       :strategy
798            These symbolic constants are used by the "Strategy" option in the
799            constructor.
800
801                Z_FILTERED
802                Z_HUFFMAN_ONLY
803                Z_RLE
804                Z_FIXED
805                Z_DEFAULT_STRATEGY
806

EXAMPLES

808   Apache::GZip Revisited
809       See IO::Compress::FAQ
810
811   Working with Net::FTP
812       See IO::Compress::FAQ
813

AUTHOR

841       This module was written by Paul Marquess, "pmqs@cpan.org".
842

MODIFICATION HISTORY

844       See the Changes file.
845

COPYRIGHT AND LICENSE

847       Copyright (c) 2005-2018 Paul Marquess. All rights reserved.
848
849       This program is free software; you can redistribute it and/or modify it
850       under the same terms as Perl itself.
851
852
853
854perl v5.26.3                      2018-04-05             IO::Compress::Gzip(3)