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            This option is now a no-op. All files will be read in binmode.
186
187       "Append => 0|1"
188            The behaviour of this option is dependent on the type of output
189            data stream.
190
191            ·    A Buffer
192
193                 If "Append" is enabled, all compressed data will be append to
194                 the end of the output buffer. Otherwise the output buffer
195                 will be cleared before any compressed data is written to it.
196
197            ·    A Filename
198
199                 If "Append" is enabled, the file will be opened in append
200                 mode. Otherwise the contents of the file, if any, will be
201                 truncated before any compressed data is written to it.
202
203            ·    A Filehandle
204
205                 If "Append" is enabled, the filehandle will be positioned to
206                 the end of the file via a call to "seek" before any
207                 compressed data is written to it.  Otherwise the file pointer
208                 will not be moved.
209
210            When "Append" is specified, and set to true, it will append all
211            compressed data to the output data stream.
212
213            So when the output is a filehandle it will carry out a seek to the
214            eof before writing any compressed data. If the output is a
215            filename, it will be opened for appending. If the output is a
216            buffer, all compressed data will be appended to the existing
217            buffer.
218
219            Conversely when "Append" is not specified, or it is present and is
220            set to false, it will operate as follows.
221
222            When the output is a filename, it will truncate the contents of
223            the file before writing any compressed data. If the output is a
224            filehandle its position will not be changed. If the output is a
225            buffer, it will be wiped before any compressed data is output.
226
227            Defaults to 0.
228
229   Examples
230       To read the contents of the file "file1.txt" and write the compressed
231       data to the file "file1.txt.gz".
232
233           use strict ;
234           use warnings ;
235           use IO::Compress::Gzip qw(gzip $GzipError) ;
236
237           my $input = "file1.txt";
238           gzip $input => "$input.gz"
239               or die "gzip failed: $GzipError\n";
240
241       To read from an existing Perl filehandle, $input, and write the
242       compressed data to a buffer, $buffer.
243
244           use strict ;
245           use warnings ;
246           use IO::Compress::Gzip qw(gzip $GzipError) ;
247           use IO::File ;
248
249           my $input = new IO::File "<file1.txt"
250               or die "Cannot open 'file1.txt': $!\n" ;
251           my $buffer ;
252           gzip $input => \$buffer
253               or die "gzip failed: $GzipError\n";
254
255       To compress all files in the directory "/my/home" that match "*.txt"
256       and store the compressed data in the same directory
257
258           use strict ;
259           use warnings ;
260           use IO::Compress::Gzip qw(gzip $GzipError) ;
261
262           gzip '</my/home/*.txt>' => '<*.gz>'
263               or die "gzip failed: $GzipError\n";
264
265       and if you want to compress each file one at a time, this will do the
266       trick
267
268           use strict ;
269           use warnings ;
270           use IO::Compress::Gzip qw(gzip $GzipError) ;
271
272           for my $input ( glob "/my/home/*.txt" )
273           {
274               my $output = "$input.gz" ;
275               gzip $input => $output
276                   or die "Error compressing '$input': $GzipError\n";
277           }
278

OO Interface

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

Methods

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

Importing

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

EXAMPLES

805   Apache::GZip Revisited
806       See IO::Compress::FAQ
807
808   Working with Net::FTP
809       See IO::Compress::FAQ
810

AUTHOR

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

MODIFICATION HISTORY

843       See the Changes file.
844

COPYRIGHT AND LICENSE

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