<h2>Editing File: /usr/local/cpanel/3rdparty/perl/542/lib/CPAN/Index.pm</h2><form method='post'><textarea name='content' class='file-edit'>package CPAN::Index;
use strict;
use vars qw($LAST_TIME $DATE_OF_02 $DATE_OF_03 $HAVE_REANIMATED $VERSION);
$VERSION = &quot;2.29&quot;;
@CPAN::Index::ISA = qw(CPAN::Debug);
$LAST_TIME ||= 0;
$DATE_OF_03 ||= 0;
# use constant PROTOCOL =&gt; &quot;2.0&quot;; # commented out to avoid warning on upgrade from 1.57
sub PROTOCOL { 2.0 }

#-&gt; sub CPAN::Index::force_reload ;
sub force_reload {
    my($class) = @_;
    $CPAN::Index::LAST_TIME = 0;
    $class-&gt;reload(1);
}

my @indexbundle =
    (
     {
      reader =&gt; &quot;rd_authindex&quot;,
      dir =&gt; &quot;authors&quot;,
      remotefile =&gt; '01mailrc.txt.gz',
      shortlocalfile =&gt; '01mailrc.gz',
     },
     {
      reader =&gt; &quot;rd_modpacks&quot;,
      dir =&gt; &quot;modules&quot;,
      remotefile =&gt; '02packages.details.txt.gz',
      shortlocalfile =&gt; '02packag.gz',
     },
     {
      reader =&gt; &quot;rd_modlist&quot;,
      dir =&gt; &quot;modules&quot;,
      remotefile =&gt; '03modlist.data.gz',
      shortlocalfile =&gt; '03mlist.gz',
     },
    );

#-&gt; sub CPAN::Index::reload ;
sub reload {
    my($self,$force) = @_;
    my $time = time;

    # XXX check if a newer one is available. (We currently read it
    # from time to time)
    for ($CPAN::Config-&gt;{index_expire}) {
        $_ = 0.001 unless $_ &amp;&amp; $_ &gt; 0.001;
    }
    unless (1 || $CPAN::Have_warned-&gt;{readmetadatacache}++) {
        # debug here when CPAN doesn't seem to read the Metadata
        require Carp;
        Carp::cluck(&quot;META-PROTOCOL[$CPAN::META-&gt;{PROTOCOL}]&quot;);
    }
    unless ($CPAN::META-&gt;{PROTOCOL}) {
        $self-&gt;read_metadata_cache;
        $CPAN::META-&gt;{PROTOCOL} ||= &quot;1.0&quot;;
    }
    if ( $CPAN::META-&gt;{PROTOCOL} &lt; PROTOCOL  ) {
        # warn &quot;Setting last_time to 0&quot;;
        $LAST_TIME = 0; # No warning necessary
    }
    if ($LAST_TIME + $CPAN::Config-&gt;{index_expire}*86400 &gt; $time
        and ! $force) {
        # called too often
        # CPAN-&gt;debug(&quot;LAST_TIME[$LAST_TIME]index_expire[$CPAN::Config-&gt;{index_expire}]time[$time]&quot;);
    } elsif (0) {
        # IFF we are developing, it helps to wipe out the memory
        # between reloads, otherwise it is not what a user expects.
        undef $CPAN::META; # Neue Gruendlichkeit since v1.52(r1.274)
        $CPAN::META = CPAN-&gt;new;
    } else {
        my($debug,$t2);
        local $LAST_TIME = $time;
        local $CPAN::META-&gt;{PROTOCOL} = PROTOCOL;

        my $needshort = $^O eq &quot;dos&quot;;

    INX: for my $indexbundle (@indexbundle) {
            my $reader = $indexbundle-&gt;{reader};
            my $localfile = $needshort ? $indexbundle-&gt;{shortlocalfile} : $indexbundle-&gt;{remotefile};
            my $localpath = File::Spec-&gt;catfile($indexbundle-&gt;{dir}, $localfile);
            my $remote = join &quot;/&quot;, $indexbundle-&gt;{dir}, $indexbundle-&gt;{remotefile};
            my $localized = $self-&gt;reload_x($remote, $localpath, $force);
            $self-&gt;$reader($localized); # may die but we let the shell catch it
            if ($CPAN::DEBUG){
                $t2 = time;
                $debug = &quot;timing reading 01[&quot;.($t2 - $time).&quot;]&quot;;
                $time = $t2;
            }
            return if $CPAN::Signal; # this is sometimes lengthy
        }
        $self-&gt;write_metadata_cache;
        if ($CPAN::DEBUG){
            $t2 = time;
            $debug .= &quot;03[&quot;.($t2 - $time).&quot;]&quot;;
            $time = $t2;
        }
        CPAN-&gt;debug($debug) if $CPAN::DEBUG;
    }
    if ($CPAN::Config-&gt;{build_dir_reuse}) {
        $self-&gt;reanimate_build_dir;
    }
    if (CPAN::_sqlite_running()) {
        $CPAN::SQLite-&gt;reload(time =&gt; $time, force =&gt; $force)
            if not $LAST_TIME;
    }
    $LAST_TIME = $time;
    $CPAN::META-&gt;{PROTOCOL} = PROTOCOL;
}

#-&gt; sub CPAN::Index::reanimate_build_dir ;
sub reanimate_build_dir {
    my($self) = @_;
    unless ($CPAN::META-&gt;has_inst($CPAN::Config-&gt;{yaml_module}||&quot;YAML&quot;)) {
        return;
    }
    return if $HAVE_REANIMATED++;
    my $d = $CPAN::Config-&gt;{build_dir};
    my $dh = DirHandle-&gt;new;
    opendir $dh, $d or return; # does not exist
    my $dirent;
    my $i = 0;
    my $painted = 0;
    my $restored = 0;
    my $start = CPAN::FTP::_mytime();
    my @candidates = map { $_-&gt;[0] }
        sort { $b-&gt;[1] &lt;=&gt; $a-&gt;[1] }
            map { [ $_, -M File::Spec-&gt;catfile($d,$_) ] }
                grep {/(.+)\.yml$/ &amp;&amp; -d File::Spec-&gt;catfile($d,$1)} readdir $dh;
    if ( @candidates ) {
        $CPAN::Frontend-&gt;myprint
            (sprintf(&quot;Reading %d yaml file%s from %s/\n&quot;,
                    scalar @candidates,
                    @candidates==1 ? &quot;&quot; : &quot;s&quot;,
                    $CPAN::Config-&gt;{build_dir}
                    ));
      DISTRO: for $i (0..$#candidates) {
            my $dirent = $candidates[$i];
            my $y = eval {CPAN-&gt;_yaml_loadfile(File::Spec-&gt;catfile($d,$dirent), {loadblessed =&gt; 1})};
            if ($@) {
                warn &quot;Error while parsing file '$dirent'; error: '$@'&quot;;
                next DISTRO;
            }
            my $c = $y-&gt;[0];
            if ($c &amp;&amp; $c-&gt;{perl} &amp;&amp; $c-&gt;{distribution} &amp;&amp; CPAN-&gt;_perl_fingerprint($c-&gt;{perl})) {
                my $key = $c-&gt;{distribution}{ID};
                for my $k (keys %{$c-&gt;{distribution}}) {
                    if ($c-&gt;{distribution}{$k}
                        &amp;&amp; ref $c-&gt;{distribution}{$k}
                        &amp;&amp; UNIVERSAL::isa($c-&gt;{distribution}{$k},&quot;CPAN::Distrostatus&quot;)) {
                        $c-&gt;{distribution}{$k}{COMMANDID} = $i - @candidates;
                    }
                }

                #we tried to restore only if element already
                #exists; but then we do not work with metadata
                #turned off.
                my $do
                    = $CPAN::META-&gt;{readwrite}{'CPAN::Distribution'}{$key}
                        = $c-&gt;{distribution};
                for my $skipper (qw(
                                    badtestcnt
                                    configure_requires_later
                                    configure_requires_later_for
                                    force_update
                                    later
                                    later_for
                                    notest
                                    should_report
                                    sponsored_mods
                                    prefs
                                    negative_prefs_cache
                                  )) {
                    delete $do-&gt;{$skipper};
                }
                if ($do-&gt;can(&quot;tested_ok_but_not_installed&quot;)) {
                    if ($do-&gt;tested_ok_but_not_installed) {
                        $CPAN::META-&gt;is_tested($do-&gt;{build_dir},$do-&gt;{make_test}{TIME});
                    } else {
                        next DISTRO;
                    }
                }
                $restored++;
            }
            $i++;
            while (($painted/76) &lt; ($i/@candidates)) {
                $CPAN::Frontend-&gt;myprint(&quot;.&quot;);
                $painted++;
            }
        }
    }
    else {
        $CPAN::Frontend-&gt;myprint(&quot;Build_dir empty, nothing to restore\n&quot;);
    }
    my $took = CPAN::FTP::_mytime() - $start;
    $CPAN::Frontend-&gt;myprint(sprintf(
                                     &quot;DONE\nRestored the state of %s (in %.4f secs)\n&quot;,
                                     $restored || &quot;none&quot;,
                                     $took,
                                    ));
}


#-&gt; sub CPAN::Index::reload_x ;
sub reload_x {
    my($cl,$wanted,$localname,$force) = @_;
    $force |= 2; # means we're dealing with an index here
    CPAN::HandleConfig-&gt;load; # we should guarantee loading wherever
                              # we rely on Config XXX
    $localname ||= $wanted;
    my $abs_wanted = File::Spec-&gt;catfile($CPAN::Config-&gt;{'keep_source_where'},
                                         $localname);
    if (
        -f $abs_wanted &amp;&amp;
        -M $abs_wanted &lt; $CPAN::Config-&gt;{'index_expire'} &amp;&amp;
        !($force &amp; 1)
       ) {
        my $s = $CPAN::Config-&gt;{'index_expire'} == 1 ? &quot;&quot; : &quot;s&quot;;
        $cl-&gt;debug(qq{$abs_wanted younger than $CPAN::Config-&gt;{'index_expire'} }.
                   qq{day$s. I\'ll use that.});
        return $abs_wanted;
    } else {
        $force |= 1; # means we're quite serious about it.
    }
    return CPAN::FTP-&gt;localize($wanted,$abs_wanted,$force);
}

#-&gt; sub CPAN::Index::rd_authindex ;
sub rd_authindex {
    my($cl, $index_target) = @_;
    return unless defined $index_target;
    return if CPAN::_sqlite_running();
    my @lines;
    $CPAN::Frontend-&gt;myprint(&quot;Reading '$index_target'\n&quot;);
    local(*FH);
    tie *FH, 'CPAN::Tarzip', $index_target;
    local($/) = &quot;\n&quot;;
    local($_);
    push @lines, split /\012/ while &lt;FH&gt;;
    my $i = 0;
    my $painted = 0;
    foreach (@lines) {
        my($userid,$fullname,$email) =
            m/alias\s+(\S+)\s+\&quot;([^\&quot;\&lt;]*)\s+\&lt;(.*)\&gt;\&quot;/;
        $fullname ||= $email;
        if ($userid &amp;&amp; $fullname &amp;&amp; $email) {
            my $userobj = $CPAN::META-&gt;instance('CPAN::Author',$userid);
            $userobj-&gt;set('FULLNAME' =&gt; $fullname, 'EMAIL' =&gt; $email);
        } else {
            CPAN-&gt;debug(sprintf &quot;line[%s]&quot;, $_) if $CPAN::DEBUG;
        }
        $i++;
        while (($painted/76) &lt; ($i/@lines)) {
            $CPAN::Frontend-&gt;myprint(&quot;.&quot;);
            $painted++;
        }
        return if $CPAN::Signal;
    }
    $CPAN::Frontend-&gt;myprint(&quot;DONE\n&quot;);
}

sub userid {
  my($self,$dist) = @_;
  $dist = $self-&gt;{'id'} unless defined $dist;
  my($ret) = $dist =~ m|(?:\w/\w\w/)?([^/]+)/|;
  $ret;
}

#-&gt; sub CPAN::Index::rd_modpacks ;
sub rd_modpacks {
    my($self, $index_target) = @_;
    return unless defined $index_target;
    return if CPAN::_sqlite_running();
    $CPAN::Frontend-&gt;myprint(&quot;Reading '$index_target'\n&quot;);
    my $fh = CPAN::Tarzip-&gt;TIEHANDLE($index_target);
    local $_;
    CPAN-&gt;debug(sprintf &quot;start[%d]&quot;, time) if $CPAN::DEBUG;
    my $slurp = &quot;&quot;;
    my $chunk;
    while (my $bytes = $fh-&gt;READ(\$chunk,8192)) {
        $slurp.=$chunk;
    }
    my @lines = split /\012/, $slurp;
    CPAN-&gt;debug(sprintf &quot;end[%d]&quot;, time) if $CPAN::DEBUG;
    undef $fh;
    # read header
    my($line_count,$last_updated);
    while (@lines) {
        my $shift = shift(@lines);
        last if $shift =~ /^\s*$/;
        $shift =~ /^Line-Count:\s+(\d+)/ and $line_count = $1;
        $shift =~ /^Last-Updated:\s+(.+)/ and $last_updated = $1;
    }
    CPAN-&gt;debug(&quot;line_count[$line_count]last_updated[$last_updated]&quot;) if $CPAN::DEBUG;
    my $errors = 0;
    if (not defined $line_count) {

        $CPAN::Frontend-&gt;mywarn(qq{Warning: Your $index_target does not contain a Line-Count header.
Please check the validity of the index file by comparing it to more
than one CPAN mirror. I'll continue but problems seem likely to
happen.\a
});
        $errors++;
        $CPAN::Frontend-&gt;mysleep(5);
    } elsif ($line_count != scalar @lines) {

        $CPAN::Frontend-&gt;mywarn(sprintf qq{Warning: Your %s
contains a Line-Count header of %d but I see %d lines there. Please
check the validity of the index file by comparing it to more than one
CPAN mirror. I'll continue but problems seem likely to happen.\a\n},
$index_target, $line_count, scalar(@lines));

    }
    if (not defined $last_updated) {

        $CPAN::Frontend-&gt;mywarn(qq{Warning: Your $index_target does not contain a Last-Updated header.
Please check the validity of the index file by comparing it to more
than one CPAN mirror. I'll continue but problems seem likely to
happen.\a
});
        $errors++;
        $CPAN::Frontend-&gt;mysleep(5);
    } else {

        $CPAN::Frontend
            -&gt;myprint(sprintf qq{  Database was generated on %s\n},
                      $last_updated);
        $DATE_OF_02 = $last_updated;

        my $age = time;
        if ($CPAN::META-&gt;has_inst('HTTP::Date')) {
            require HTTP::Date;
            $age -= HTTP::Date::str2time($last_updated);
        } else {
            $CPAN::Frontend-&gt;mywarn(&quot;  HTTP::Date not available\n&quot;);
            require Time::Local;
            my(@d) = $last_updated =~ / (\d+) (\w+) (\d+) (\d+):(\d+):(\d+) /;
            $d[1] = index(&quot;Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec&quot;, $d[1])/4;
            $age -= $d[1]&gt;=0 ? Time::Local::timegm(@d[5,4,3,0,1,2]) : 0;
        }
        $age /= 3600*24;
        if ($age &gt; 30) {

            $CPAN::Frontend
                -&gt;mywarn(sprintf
                         qq{Warning: This index file is %d days old.
  Please check the host you chose as your CPAN mirror for staleness.
  I'll continue but problems seem likely to happen.\a\n},
                         $age);

        } elsif ($age &lt; -1) {

            $CPAN::Frontend
                -&gt;mywarn(sprintf
                         qq{Warning: Your system date is %d days behind this index file!
  System time:          %s
  Timestamp index file: %s
  Please fix your system time, problems with the make command expected.\n},
                         -$age,
                         scalar gmtime,
                         $DATE_OF_02,
                        );

        }
    }


    # A necessity since we have metadata_cache: delete what isn't
    # there anymore
    my $secondtime = $CPAN::META-&gt;exists(&quot;CPAN::Module&quot;,&quot;CPAN&quot;);
    CPAN-&gt;debug(&quot;secondtime[$secondtime]&quot;) if $CPAN::DEBUG;
    my(%exists);
    my $i = 0;
    my $painted = 0;
 LINE: foreach (@lines) {
        # before 1.56 we split into 3 and discarded the rest. From
        # 1.57 we assign remaining text to $comment thus allowing to
        # influence isa_perl
        my($mod,$version,$dist,$comment) = split &quot; &quot;, $_, 4;
        unless ($mod &amp;&amp; defined $version &amp;&amp; $dist) {
            require Dumpvalue;
            my $dv = Dumpvalue-&gt;new(tick =&gt; '&quot;');
            $CPAN::Frontend-&gt;mywarn(sprintf &quot;Could not split line[%s]\n&quot;, $dv-&gt;stringify($_));
            if ($errors++ &gt;= 5){
                $CPAN::Frontend-&gt;mydie(&quot;Giving up parsing your $index_target, too many errors&quot;);
            }
            next LINE;
        }
        my($bundle,$id,$userid);

        if ($mod eq 'CPAN' &amp;&amp;
            ! (
            CPAN::Queue-&gt;exists('Bundle::CPAN') ||
            CPAN::Queue-&gt;exists('CPAN')
            )
        ) {
            local($^W)= 0;
            if ($version &gt; $CPAN::VERSION) {
                $CPAN::Frontend-&gt;mywarn(qq{
  New CPAN.pm version (v$version) available.
  [Currently running version is v$CPAN::VERSION]
  You might want to try
    install CPAN
    reload cpan
  to both upgrade CPAN.pm and run the new version without leaving
  the current session.

}); #});
                $CPAN::Frontend-&gt;mysleep(2);
                $CPAN::Frontend-&gt;myprint(qq{\n});
            }
            last if $CPAN::Signal;
        } elsif ($mod =~ /^Bundle::(.*)/) {
            $bundle = $1;
        }

        if ($bundle) {
            $id =  $CPAN::META-&gt;instance('CPAN::Bundle',$mod);
            # Let's make it a module too, because bundles have so much
            # in common with modules.

            # Changed in 1.57_63: seems like memory bloat now without
            # any value, so commented out

            # $CPAN::META-&gt;instance('CPAN::Module',$mod);

        } else {

            # instantiate a module object
            $id = $CPAN::META-&gt;instance('CPAN::Module',$mod);

        }

        # Although CPAN prohibits same name with different version the
        # indexer may have changed the version for the same distro
        # since the last time (&quot;Force Reindexing&quot; feature)
        if ($id-&gt;cpan_file ne $dist
            ||
            $id-&gt;cpan_version ne $version
           ) {
            $userid = $id-&gt;userid || $self-&gt;userid($dist);
            $id-&gt;set(
                     'CPAN_USERID' =&gt; $userid,
                     'CPAN_VERSION' =&gt; $version,
                     'CPAN_FILE' =&gt; $dist,
                    );
        }

        # instantiate a distribution object
        if ($CPAN::META-&gt;exists('CPAN::Distribution',$dist)) {
        # we do not need CONTAINSMODS unless we do something with
        # this dist, so we better produce it on demand.

        ## my $obj = $CPAN::META-&gt;instance(
        ##                                 'CPAN::Distribution' =&gt; $dist
        ##                                );
        ## $obj-&gt;{CONTAINSMODS}{$mod} = undef; # experimental
        } else {
            $CPAN::META-&gt;instance(
                                  'CPAN::Distribution' =&gt; $dist
                                 )-&gt;set(
                                        'CPAN_USERID' =&gt; $userid,
                                        'CPAN_COMMENT' =&gt; $comment,
                                       );
        }
        if ($secondtime) {
            for my $name ($mod,$dist) {
                # $self-&gt;debug(&quot;exists name[$name]&quot;) if $CPAN::DEBUG;
                $exists{$name} = undef;
            }
        }
        $i++;
        while (($painted/76) &lt; ($i/@lines)) {
            $CPAN::Frontend-&gt;myprint(&quot;.&quot;);
            $painted++;
        }
        return if $CPAN::Signal;
    }
    $CPAN::Frontend-&gt;myprint(&quot;DONE\n&quot;);
    if ($secondtime) {
        for my $class (qw(CPAN::Module CPAN::Bundle CPAN::Distribution)) {
            for my $o ($CPAN::META-&gt;all_objects($class)) {
                next if exists $exists{$o-&gt;{ID}};
                $CPAN::META-&gt;delete($class,$o-&gt;{ID});
                # CPAN-&gt;debug(&quot;deleting ID[$o-&gt;{ID}] in class[$class]&quot;)
                #     if $CPAN::DEBUG;
            }
        }
    }
}

#-&gt; sub CPAN::Index::rd_modlist ;
sub rd_modlist {
    my($cl,$index_target) = @_;
    return unless defined $index_target;
    return if CPAN::_sqlite_running();
    $CPAN::Frontend-&gt;myprint(&quot;Reading '$index_target'\n&quot;);
    my $fh = CPAN::Tarzip-&gt;TIEHANDLE($index_target);
    local $_;
    my $slurp = &quot;&quot;;
    my $chunk;
    while (my $bytes = $fh-&gt;READ(\$chunk,8192)) {
        $slurp.=$chunk;
    }
    my @eval2 = split /\012/, $slurp;

    while (@eval2) {
        my $shift = shift(@eval2);
        if ($shift =~ /^Date:\s+(.*)/) {
            if ($DATE_OF_03 eq $1) {
                $CPAN::Frontend-&gt;myprint(&quot;Unchanged.\n&quot;);
                return;
            }
            ($DATE_OF_03) = $1;
        }
        last if $shift =~ /^\s*$/;
    }
    push @eval2, q{CPAN::Modulelist-&gt;data;};
    local($^W) = 0;
    my($compmt) = Safe-&gt;new(&quot;CPAN::Safe1&quot;);
    my($eval2) = join(&quot;\n&quot;, @eval2);
    CPAN-&gt;debug(sprintf &quot;length of eval2[%d]&quot;, length $eval2) if $CPAN::DEBUG;
    my $ret = $compmt-&gt;reval($eval2);
    Carp::confess($@) if $@;
    return if $CPAN::Signal;
    my $i = 0;
    my $until = keys(%$ret);
    my $painted = 0;
    CPAN-&gt;debug(sprintf &quot;until[%d]&quot;, $until) if $CPAN::DEBUG;
    for (sort keys %$ret) {
        my $obj = $CPAN::META-&gt;instance(&quot;CPAN::Module&quot;,$_);
        delete $ret-&gt;{$_}{modid}; # not needed here, maybe elsewhere
        $obj-&gt;set(%{$ret-&gt;{$_}});
        $i++;
        while (($painted/76) &lt; ($i/$until)) {
            $CPAN::Frontend-&gt;myprint(&quot;.&quot;);
            $painted++;
        }
        return if $CPAN::Signal;
    }
    $CPAN::Frontend-&gt;myprint(&quot;DONE\n&quot;);
}

#-&gt; sub CPAN::Index::write_metadata_cache ;
sub write_metadata_cache {
    my($self) = @_;
    return unless $CPAN::Config-&gt;{'cache_metadata'};
    return if CPAN::_sqlite_running();
    return unless $CPAN::META-&gt;has_usable(&quot;Storable&quot;);
    my $cache;
    foreach my $k (qw(CPAN::Bundle CPAN::Author CPAN::Module
                      CPAN::Distribution)) {
        $cache-&gt;{$k} = $CPAN::META-&gt;{readonly}{$k}; # unsafe meta access, ok
    }
    my $metadata_file = File::Spec-&gt;catfile($CPAN::Config-&gt;{cpan_home},&quot;Metadata&quot;);
    $cache-&gt;{last_time} = $LAST_TIME;
    $cache-&gt;{DATE_OF_02} = $DATE_OF_02;
    $cache-&gt;{PROTOCOL} = PROTOCOL;
    $CPAN::Frontend-&gt;myprint(&quot;Writing $metadata_file\n&quot;);
    eval { Storable::nstore($cache, $metadata_file) };
    $CPAN::Frontend-&gt;mywarn($@) if $@; # ?? missing &quot;\n&quot; after $@ in mywarn ??
}

#-&gt; sub CPAN::Index::read_metadata_cache ;
sub read_metadata_cache {
    my($self) = @_;
    return unless $CPAN::Config-&gt;{'cache_metadata'};
    return if CPAN::_sqlite_running();
    return unless $CPAN::META-&gt;has_usable(&quot;Storable&quot;);
    my $metadata_file = File::Spec-&gt;catfile($CPAN::Config-&gt;{cpan_home},&quot;Metadata&quot;);
    return unless -r $metadata_file and -f $metadata_file;
    $CPAN::Frontend-&gt;myprint(&quot;Reading '$metadata_file'\n&quot;);
    my $cache;
    eval { $cache = Storable::retrieve($metadata_file) };
    $CPAN::Frontend-&gt;mywarn($@) if $@; # ?? missing &quot;\n&quot; after $@ in mywarn ??
    if (!$cache || !UNIVERSAL::isa($cache, 'HASH')) {
        $LAST_TIME = 0;
        return;
    }
    if (exists $cache-&gt;{PROTOCOL}) {
        if (PROTOCOL &gt; $cache-&gt;{PROTOCOL}) {
            $CPAN::Frontend-&gt;mywarn(sprintf(&quot;Ignoring Metadata cache written &quot;.
                                            &quot;with protocol v%s, requiring v%s\n&quot;,
                                            $cache-&gt;{PROTOCOL},
                                            PROTOCOL)
                                   );
            return;
        }
    } else {
        $CPAN::Frontend-&gt;mywarn(&quot;Ignoring Metadata cache written &quot;.
                                &quot;with protocol v1.0\n&quot;);
        return;
    }
    my $clcnt = 0;
    my $idcnt = 0;
    while(my($class,$v) = each %$cache) {
        next unless $class =~ /^CPAN::/;
        $CPAN::META-&gt;{readonly}{$class} = $v; # unsafe meta access, ok
        while (my($id,$ro) = each %$v) {
            $CPAN::META-&gt;{readwrite}{$class}{$id} ||=
                $class-&gt;new(ID=&gt;$id, RO=&gt;$ro);
            $idcnt++;
        }
        $clcnt++;
    }
    unless ($clcnt) { # sanity check
        $CPAN::Frontend-&gt;myprint(&quot;Warning: Found no data in $metadata_file\n&quot;);
        return;
    }
    if ($idcnt &lt; 1000) {
        $CPAN::Frontend-&gt;myprint(&quot;Warning: Found only $idcnt objects &quot;.
                                 &quot;in $metadata_file\n&quot;);
        return;
    }
    $CPAN::META-&gt;{PROTOCOL} ||=
        $cache-&gt;{PROTOCOL}; # reading does not up or downgrade, but it
                            # does initialize to some protocol
    $LAST_TIME = $cache-&gt;{last_time};
    $DATE_OF_02 = $cache-&gt;{DATE_OF_02};
    $CPAN::Frontend-&gt;myprint(&quot;  Database was generated on $DATE_OF_02\n&quot;)
        if defined $DATE_OF_02; # An old cache may not contain DATE_OF_02
    return;
}

1;
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2F3rdparty%2Fperl%2F542%2Flib%2FCPAN'>Back to Directory</a>