<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fetc%2F'>etc</a>/</p><hr><h3>✏️ Editing: exim.pl.local</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>
=encoding utf-8

=head1 NAME

/etc/exim.pl.local - Perl functions for exim that are loaded by /etc/exim.pl

=cut

my $VALIASES_DIR       = &#039;/etc/valiases&#039;;
my $VDOMAINALIASES_DIR = &#039;/etc/vdomainaliases&#039;;

my $outgoing_mail_suspended_message;
my $outgoing_sender;
my $outgoing_sender_domain;
my $outgoing_sender_counted_domain;
my $outgoing_sender_sysuser;
my $outgoing_sender_is_mailman;
my $outgoing_sender_archive_directory = &#039;outgoing&#039;;
my $mail_gid;
my $nobody_uid;
my $nobody_gid;
my $mailtrap_gid;
my $check_mail_permissions_domain     = &#039;&#039;;
my $check_mail_permissions_sender     = &#039;&#039;;
my $check_mail_permissions_msgid      = &#039;&#039;;
my $check_mail_permissions_data       = &#039;&#039;;
my $check_mail_permissions_is_mailman = 0;
my $enforce_mail_permissions_data     = &#039;&#039;;
my $primary_hostname;
my %uid_cache  = ( 0      =&gt; &#039;root&#039;, 47         =&gt; &#039;mailnull&#039;, 99       =&gt; &#039;nobody&#039; );
my %user_cache = ( &#039;root&#039; =&gt; 0,      &#039;mailnull&#039; =&gt; 47,         &#039;nobody&#039; =&gt; 99 );
my $reattempt_message = &#039;Message will be reattempted later&#039;;
my $sender_lookup;
my $sender_lookup_method;

# TEST VARIABLES
my $check_mail_permissions_result;

my %file_exists_cache;

sub file_exists {
    return $file_exists_cache{ $_[0] } if exists $file_exists_cache{ $_[0] };
    $file_exists_cache{ $_[0] } = -e $_[0] ? 1 : 0;
    return $file_exists_cache{ $_[0] };
}

sub checkbx_autowhitelist {
    my $address = shift;
    my $phost   = Exim::expand_string(&#039;$primary_hostname&#039;);
    my $rp      = Exim::expand_string(&#039;$received_protocol&#039;);
    if ( $rp eq &#039;local&#039; || $rp !~ /^e?smtps?a$/i || !$address || $address eq &#039;&#039; ) { return &#039;no&#039;; }
    my ( $localpart, $domain ) = split( /\@/, $address );

    if ( ( !$domain || $domain eq &#039;&#039; || $domain eq $phost ) ) {
        my $homedir = gethomedir($localpart);
        unless ( $homedir ne &#039;&#039; ) {
            return &#039;no&#039;;
        }

        if ( -e $homedir . &#039;/etc/.boxtrapperenable&#039; &amp;&amp; !-e $homedir . &#039;/etc/.boxtrapperautowhitelistdisable&#039; ) {
            return &#039;yes&#039;;
        }
        else {
            return &#039;no&#039;;
        }
    }
    else {
        my $owner   = getdomainowner($domain);
        my $homedir = gethomedir($owner);
        unless ( $homedir ne &#039;&#039; ) {
            return &#039;no&#039;;
        }
        my $passwd = &quot;${homedir}/etc/${domain}/passwd&quot;;
        my $addressexists = user_exists_in_db( $localpart, $passwd );
        if ( $addressexists &amp;&amp; ( -e $homedir . &quot;/etc/${domain}/${localpart}/.boxtrapperenable&quot; &amp;&amp; !-e $homedir . &quot;/etc/${domain}/${localpart}/.boxtrapperautowhitelistdisable&quot; ) ) {
            return &#039;yes&#039;;
        }
        else {
            return &#039;no&#039;;
        }
    }
}

sub getemailuser {
    my ( $address, $received_protocol, $sender_ident ) = @_;

    my $primary_hostname = Exim::expand_string(&#039;$primary_hostname&#039;);
    my ( $local_part, $domain ) = split( m/[\@\+\%\:]/, ( $address || ( $received_protocol &amp;&amp; $received_protocol eq &#039;local&#039; ? $sender_ident : &#039;&#039; ) ) );

    if ( !$domain || $domain eq &#039;&#039; || $domain eq $primary_hostname ) {
        return $local_part;
    }
    else {
        my $user = getdomainowner($domain);
        if ($user) { return $user; }
    }

    return &#039;nobody&#039;;
}
#DO NOT REMOVE THIS COMMENT AS IT TELLS CPANEL TO ENABLE SERVICE AUTH CHECKING
#exim:serviceauth=1
#
# Checkpass not used since auth is passed to dovecot SASL

{
    no warnings &#039;redefine&#039;;
    sub checkuserpass { 0; }

    sub checkpass { 0; }
}
sub checkspam {

    # This is an old code block that should never be reached unless there is a serious
    # problem installing their exim configuration
    Exim::log_write(&quot;Something went very wrong during the exim configuration update.  Please try reinstalling your exim configuration.&quot;);
    1;
}

sub convert_address_directory_to_dovecot_lda_destination_username {
    my $local_part = Exim::expand_string(&#039;$local_part&#039;);
    my $domain     = Exim::expand_string(&#039;$domain&#039;);
    $primary_hostname ||= Exim::expand_string(&#039;$primary_hostname&#039;);
    my $address_file = Exim::expand_string(&#039;$address_file&#039;);

    if ( $address_file !~ m{mail/\Q$domain\E} ) {
        return ( getpwuid($&gt;) )[0];
    }
    else {
        return $local_part . &#039;@&#039; . $domain;
    }

}

sub convert_address_directory_to_dovecot_lda_mailbox {
    my $address_file = Exim::expand_string(&#039;$address_file&#039;);

    my ($mailbox) = $address_file =~ m{/\.([^\/]+)};
    if ($mailbox) {
        return &quot;INBOX.$mailbox&quot;;
    }

    return &#039;INBOX&#039;;

}

sub call_cpwrap {
    my ( $function, @ARGS ) = @_;

    my @JSON_ENCODED_ARGS = map { aggressive_json_safe_encode($_) } @ARGS;
    my $data = join( &#039; &#039;, @JSON_ENCODED_ARGS );
    my $json_template = qq[{&quot;function&quot;:&quot;$function&quot;,&quot;namespace&quot;:&quot;Cpanel&quot;,&quot;version&quot;:2,&quot;action&quot;:&quot;run&quot;,&quot;data&quot;:&quot;$data&quot;,&quot;send_data_only&quot;:1,&quot;module&quot;:&quot;exim&quot;}\r\n\r\n];
    require Cpanel::Encoder::Exim;
    return eval { Exim::expand_string( &#039;${readsocket{/usr/local/cpanel/var/cpwrapd.sock}{&#039; . Cpanel::Encoder::Exim::unquoted_encode_string_literal($json_template) . &#039;}{10s}}&#039; ); };
}

sub aggressive_json_safe_encode {
    my ($arg) = @_;
    $arg =~ tr/^a-zA-Z0-9!#\$\-=?^_{}~:.//cd;
    return $arg;
}

my $archived_at_domain_level = 0;
my $archived_outgoing        = 0;
my $archived_mailman         = 0;

sub should_archive_incoming_domain_message {
    return ( $archived_at_domain_level = !_message_has_been_seen() );
}

sub _message_has_been_seen {

    #ARCHIVE ONLY IF
    #
    #$parent_domain = &quot;&quot;
    #
    #OR
    #
    #$parent_domain != $domain

    # Delivery was not a result of an expansion
    my $parent_domain = Exim::expand_string(&#039;$parent_domain&#039;);
    if ( !length $parent_domain ) {
        return 0;
    }

    # Delivery was the result of an expansion / alias.  Since its a diffrent domain we don&#039;t
    # know if it was archived so we need to archive if enabled
    my $domain = Exim::expand_string(&#039;$domain&#039;);
    if ( $domain ne $parent_domain ) {
        return 0;
    }

    my $parent_local_part = Exim::expand_string(&#039;$parent_local_part&#039;);
    my $local_part        = Exim::expand_string(&#039;$local_part&#039;);

    # case 60975: If any deliveries happened, parent_domain and parent_local_part
    # will get set to match domain and local_part. Since we need to
    # still archive outgoing if it to our same domain or a local
    # user we need to accept when they all match
    if ( $parent_domain eq $domain &amp;&amp; $local_part &amp;&amp; $parent_local_part ) {
        return 0;
    }

    # parent_local_part ne local_part and
    # parent_domain == domain so it already got archived if we have it on

    return 1;
}

sub archive_headers {
    my ($router) = @_;

    if ( $router eq &#039;archive_incoming_email_domain_method&#039; ) {
        return &quot;X-Archive-Type: incoming\nX-Archive-Recipient: &quot; . Exim::expand_string(&#039;$local_part&#039;) . &#039;@&#039; . Exim::expand_string(&#039;$domain&#039;);
    }
    elsif ( $router eq &#039;archive_incoming_email_local_user_method&#039; ) {
        return &quot;X-Archive-Type: incoming\nX-Archive-Recipient: &quot; . Exim::expand_string(&#039;$local_part&#039;);
    }
    elsif ( $router eq &#039;archive_outgoing_email&#039; ) {
        return &quot;X-Archive-Type: &quot; . $outgoing_sender_archive_directory . &quot;\nX-Archive-Sender: $outgoing_sender&quot;;
    }

}

sub should_archive_incoming_localuser_message {

    # case 60999: Do not archive a message at the localuser level
    # if we have already archived it at the domain level (avoid two copies)
    return 0 if $archived_at_domain_level;

    my $local_part      = Exim::expand_string(&#039;$local_part&#039;);
    my $incoming_domain = getusersdomain($local_part);
    if ($incoming_domain) {
        my $home = gethomedir($local_part);
        if ( file_exists(&quot;$home/etc/$incoming_domain/archive/incoming&quot;) ) {
            return 1;
        }
    }
    return 0;
}

sub get_incoming_domain {
    return getusersdomain( Exim::expand_string(&#039;$local_part&#039;) );
}

sub should_archive_outgoing_message {
    return 0 if _message_has_been_seen();

    return determine_sender_and_check_if_archive_needed();
}

sub determine_sender_and_check_if_archive_needed {
    my $uid = int( Exim::expand_string(&#039;$originator_uid&#039;) );
    my $gid = int( Exim::expand_string(&#039;$originator_gid&#039;) );

    # outgoing_sender_domain is the domain of the actual sender
    # outgoing_sender_counted_domain is the domain we actually count the message against

    # Currently these are always the same except domain may be
    # rewritten if we are coming from a mailman list in order
    # to count against the owner of the list instead of the mailman
    # user assuming /var/cpanel/email_send_limits/count_mailman exists
    ( $outgoing_sender, $outgoing_sender_domain, $outgoing_sender_counted_domain, $outgoing_sender_is_mailman ) = get_message_sender( $uid, $gid );

    if ( $outgoing_sender_domain &amp;&amp; $outgoing_sender_domain ne &#039;-system-&#039; ) {
        $outgoing_sender_sysuser = getdomainowner($outgoing_sender_domain);

        my $home = gethomedir($outgoing_sender_sysuser);

        if ( $outgoing_sender_is_mailman &amp;&amp; file_exists(&quot;$home/etc/$outgoing_sender_domain/archive/mailman&quot;) ) {
            $outgoing_sender_archive_directory = &#039;mailman&#039;;
            return 0 if $archived_mailman;    # already archived
            return ( $archived_mailman = 1 );
        }
        elsif ( file_exists(&quot;$home/etc/$outgoing_sender_domain/archive/outgoing&quot;) ) {
            $outgoing_sender_archive_directory = &#039;outgoing&#039;;
            return 0 if $archived_outgoing;    # already archived
            return ( $archived_outgoing = 1 );
        }
    }
    return 0;

}

sub pack_archive_address_data {
    my ($router) = @_;
    return join( &#039; &#039;,
                 &#039;router=&#039; . Cpanel::Encoder::Exim::encode_string_literal($router),
                 &#039;sender=&#039; . Cpanel::Encoder::Exim::encode_string_literal($outgoing_sender),
                 &#039;sender_domain=&#039; . Cpanel::Encoder::Exim::encode_string_literal($outgoing_sender_domain),
                 &#039;sender_sysuser=&#039; . Cpanel::Encoder::Exim::encode_string_literal($outgoing_sender_sysuser),
                 &#039;sender_archive_directory=&#039; . Cpanel::Encoder::Exim::encode_string_literal($outgoing_sender_archive_directory)
                 );
}

sub get_outgoing_sender {
    return ( $outgoing_sender // Exim::expand_string(&#039;${extract{sender}{$address_data}}&#039;));
}

sub get_outgoing_sender_domain {
    return ( $outgoing_sender_domain // Exim::expand_string(&#039;${extract{sender_domain}{$address_data}}&#039;));
}

sub get_outgoing_sender_sysuser {
    return ( $outgoing_sender_sysuser // Exim::expand_string(&#039;${extract{sender_sysuser}{$address_data}}&#039;));
}

sub get_outgoing_archive_directory {
    return ( $outgoing_sender_archive_directory // Exim::expand_string(&#039;${extract{sender_archive_directory}{$address_data}}&#039;));
}

sub YYYYMMDDGMT {
    my ( $sec, $min, $hour, $mday, $mon, $year ) = gmtime( $_[0] || time() );
    return sprintf( &#039;%04d-%02d-%02d&#039;, $year + 1900, $mon + 1, $mday );
}
our $DEFAULT_EMAIL_SEND_LIMITS_DEFER_CUTOFF_PERCENTAGE = 125;

sub getmaxemailsperhour {
    my $domain = shift;

    return 0 if $domain eq &#039;-system-&#039;;

    $domain =~ s/\///g;    #jic

    my $maxemails = 0;     # Defaults to &quot;unlimited&quot;

    my $master_email_send_limits_mtime = ( stat(&#039;/etc/email_send_limits&#039;) )[9];
    my $max_fh;

    if ( open( $max_fh, &#039;&lt;&#039;, &#039;/var/cpanel/email_send_limits/cache/&#039; . $domain ) &amp;&amp; ( stat($max_fh) )[9] &gt; $master_email_send_limits_mtime ) {    # This is the user&#039;s main domain. All user&#039;s domains are aggregated here
        $maxemails = readline $max_fh;
        close $max_fh;
        return 0 if !$maxemails || $maxemails eq &#039;unlimited&#039;;
        return ( $maxemails ? int($maxemails) : 0 );
    }

    my $search_regex          = qr/^\Q$domain\E:/;
    my $search_wildcard_regex = qr/^\Q*\E:/;

    _check_cache_dir();

    my $old_umask = umask();
    umask(0027);

    #format DOMAIN: MAX_EMAIL_PER_HOUR,MAX_DEFER_FAIL_PERCENTAGE,MIN_DEFER_FAIL_TO_TRIGGER_PROTECTION
    if ( open( my $max_fh, &#039;&gt;&#039;, &#039;/var/cpanel/email_send_limits/cache/.&#039; . $domain ) ) {
        umask($old_umask);
        if ( open( my $email_limits_fh, &#039;&lt;&#039;, &#039;/etc/email_send_limits&#039; ) ) {
            while ( readline($email_limits_fh) ) {
                if ( $_ =~ $search_regex ) {
                    $maxemails = ( split( /\,/, ( split( /:\s+/, $_ ) )[1] ) )[0];
                    last if $maxemails || $maxemails eq &#039;0&#039;;    # case 51568: if there is no value we use the wildcard
                }
                elsif ( $_ =~ $search_wildcard_regex ) {
                    $maxemails = ( split( /\,/, ( split( /:\s+/, $_ ) )[1] ) )[0];
                    last;
                }
            }
        }
        chomp $maxemails;
        print {$max_fh} $maxemails;
        close($max_fh);
        rename( &#039;/var/cpanel/email_send_limits/cache/.&#039; . $domain, &#039;/var/cpanel/email_send_limits/cache/&#039; . $domain );    #rename is atomic and will overwrite the file
        return int $maxemails;                                                                                            # case 51568: must transform &#039;unlimited&#039; to 0
    }
    else {
        umask($old_umask);
    }
    return 0;
}

sub increment_max_emails_per_hour {
    my ( $domain, $time, $msgid ) = @_;
    $domain =~ s/\///g;                                                                                                   #jic

    _check_tracker_dir($domain);

    $time ||= time();

    Exim::log_write( &quot;SMTP connection outbound $time $msgid $domain &quot; . Exim::expand_string(&#039;$local_part&#039;) . &#039;@&#039; . Exim::expand_string(&#039;$domain&#039;) );

    if ( open( my $emailt_fh, &#039;&gt;&gt;&#039;, &quot;/var/cpanel/email_send_limits/track/$domain/&quot; . join( &#039;.&#039;, ( gmtime($time) )[ 2, 3, 4, 5 ] ) ) ) {

        print {$emailt_fh} &#039;1&#039;;
        close($emailt_fh);
    }

    # !DEBUG!
    #   if ( open( my $emailt_fh, &#039;&gt;&gt;&#039;, &quot;/var/cpanel/email_send_limits/track/$domain/msgids_&quot; . join( &#039;.&#039;, ( gmtime( $time ) )[ 2, 3, 4, 5 ] ) ) ) {
    #
    #       print {$emailt_fh} $msgid . &quot;\n&quot;;
    #       close($emailt_fh);
    #  }

}

sub _check_cache_dir {
    mkdir( &#039;/var/cpanel/email_send_limits/cache&#039;, 0750 ) if !-e &#039;/var/cpanel/email_send_limits/cache&#039;;
}

sub _check_tracker_dir {
    my $domain = shift;
    $domain =~ s/\///g;    #jic

    if ( !-e &#039;/var/cpanel/email_send_limits/track/&#039; . $domain ) {
        mkdir( &#039;/var/cpanel/email_send_limits&#039;,                  0751 );
        mkdir( &#039;/var/cpanel/email_send_limits/track&#039;,            0750 );
        mkdir( &#039;/var/cpanel/email_send_limits/track/&#039; . $domain, 0750 );
    }
}

sub get_current_emails_per_hour {
    ( ( stat( &quot;/var/cpanel/email_send_limits/track/$_[0]/&quot; . join( &#039;.&#039;, ( gmtime( $_[1] || time() ) )[ 2, 3, 4, 5 ] ) ) )[7] || 0 );
}

sub get_current_emails_per_day {
    my $domain = shift;
    $domain =~ s/\///g;    #jic

    return 0 if ( !-e &#039;/var/cpanel/email_send_limits/track/&#039; . $domain );
    my $total_size = 0;
    if ( opendir( my $domain_track_fh, &#039;/var/cpanel/email_send_limits/track/&#039; . $domain ) ) {
        while ( my $domaintime = readdir($domain_track_fh) ) {
            next if ( $domaintime =~ /^\.\.?$/ );
            my $tracker_file_size = ( stat(&quot;/var/cpanel/email_send_limits/track/$domain/$domaintime&quot;) )[7];
            $total_size += $tracker_file_size;
        }
    }
    return $total_size;
}

sub reached_max_emails_per_hour {
    my $domain = shift;
    $domain =~ s/\///g;    #jic
    my $max_allowed = int( shift || 0 );
    my $time = shift || time();

    if ($max_allowed) {

        # AKA number_of_emails_sent &gt;= $max_allowed
        if ( get_current_emails_per_hour( $domain, $time ) &gt;= $max_allowed ) {
            return 1;
        }
        else {
            return 0;
        }
    }
    return 0;
}

#
# This converse function for reference only
#
#sub set_email_send_limits_defer_cutoff {
#	my $percentage = int shift ;
#
#	# The value is the size of the file so we can avoid the open/close overhead (just a stat)
#	if ( open(my $cut_off_percentage_fh,&#039;&gt;&#039;,&#039;/var/cpanel/email_send_limits/defer_cutoff&#039;) ) {
#		print {$cut_off_percentage_fh} &#039;x&#039; x $percentage;
#		return 1;
#	}
#
#	return 0;
# }

sub get_email_send_limits_defer_cutoff {

    # The value is the size of the file so we can avoid the open/close overhead (just a stat)

    my $cut_off_percentage = ( stat(&#039;/var/cpanel/email_send_limits/defer_cutoff&#039;) )[7];
    if ( !defined $cut_off_percentage ) { $cut_off_percentage = $DEFAULT_EMAIL_SEND_LIMITS_DEFER_CUTOFF_PERCENTAGE; }
    return $cut_off_percentage;
}

#
# This converse function for reference only
#
# sub set_email_daily_limit_notify {
#	my $limit = int shift ;
#       if ( $limit == 0 ) {
#           unlink &#039;/var/cpanel/email_send_limits/daily_limit_notify&#039;;
#           return 1;
#       }
#	# The value is the size of the file so we can avoid the open/close overhead (just a stat)
#	if ( open(my $daily_limit_fh,&#039;&gt;&#039;,&#039;/var/cpanel/email_send_limits/daily_limit_notify&#039;) ) {
#		print {$daily_limit_fh} &#039;x&#039; x $limit;
#		return 1;
#	}
#	return 0;
# }

sub get_email_daily_limit_notify {

    # The value is the size of the file so we can avoid the open/close overhead (just a stat)
    my $limit = ( stat(&#039;/var/cpanel/email_send_limits/daily_limit_notify&#039;) )[7];
    if ( !defined $limit ) { $limit = 0; }
    return $limit;
}

sub create_daily_notify_touchfile {

    my $domain = shift;
    $domain =~ s/\///g;    #jic
    mkdir( &#039;/var/cpanel/email_send_limits/daily_notify&#039;, 0750 ) if !-e &#039;/var/cpanel/email_send_limits/daily_notify&#039;;
    if ( open( my $daily_limit_fh, &#039;&gt;&#039;, &#039;/var/cpanel/email_send_limits/daily_notify/&#039; . $domain ) ) {
        close $daily_limit_fh;
    }
    return undef;
}
BEGIN {
    unshift @INC, &#039;/usr/local/cpanel&#039;;
}

#DO NOT USE lib here
# use Cpanel::Encoder::Exim (); -- no loaded with require or preload
sub gethomedir {
    my $user = shift;
    require Cpanel::Encoder::Exim;
    return Exim::expand_string( &#039;${extract{5}{:}{${lookup passwd{&#039; . Cpanel::Encoder::Exim::unquoted_encode_string_literal($user) . &#039;}{$value}}}}&#039; ) || &#039;&#039;;
}

sub getuid {
    my $user = shift;
    require Cpanel::Encoder::Exim;
    my $uid = Exim::expand_string( &#039;${extract{2}{:}{${lookup passwd{&#039; . Cpanel::Encoder::Exim::unquoted_encode_string_literal($user) . &#039;}{$value}}}}&#039; );
    return defined $uid ? $uid : &#039;&#039;;
}

sub getdomainowner {
    my $domain = shift;
    require Cpanel::Encoder::Exim;
    substr($domain,0,4,&#039;&#039;) if index($domain,&#039;www.&#039;) == 0;
    return Exim::expand_string( &#039;${lookup{&#039; . Cpanel::Encoder::Exim::unquoted_encode_string_literal($domain) . &#039;}lsearch{/etc/userdomains}{$value}}&#039; ) || &#039;&#039;;
}

my %domain_to_user_cache;

# This must be cached because we call getusersdomain as root in the archive_incoming_email_local_user_method router
# and then we need to read the user out of the memory cache in archiver_incoming_local_user_method since
# we no longer have access to read /etc/domainusers at that point.   Note, we need to be able to cache multiple
# users in case they send a message to multiple system users
sub getusersdomain {
    return &#039;&#039; if !$_[0] || $_[0] eq &#039;root&#039; || $_[0] =~ tr{/}{} || !-e &quot;/var/cpanel/users/$_[0]&quot;;
    return ( $domain_to_user_cache{ $_[0] } || ( $domain_to_user_cache{ $_[0] } = lookup_key_in_file( &#039;/etc/domainusers&#039;, $_[0] ) ) );
}

sub lookup_key_in_file {
    my ( $file, $key ) = @_;
    require Cpanel::Encoder::Exim;
    return Exim::expand_string( &#039;${lookup{&#039; . Cpanel::Encoder::Exim::unquoted_encode_string_literal($key) . &#039;}lsearch{&#039; . $file . &#039;}{$value}}&#039; ) || &#039;&#039;;
}

sub isdemo {
    my $user = shift;
    return if ( !$user );
    return 0 if $user eq &#039;0&#039; || $user eq &#039;8&#039; || $user eq &#039;mail&#039; || $user eq &#039;mailnull&#039; || $user eq &#039;root&#039;;
    if ( $user =~ /^\d+$/ ) {
        return user_exists_in_db( $user, &#039;/etc/demouids&#039; );
    }
    return user_exists_in_db( $user, &#039;/etc/demousers&#039; );
}

sub user_exists_in_db {
    my ( $user, $db ) = @_;

    # If the user is empty, &#039;0&#039; or only whitespace
    # we should return 0 as $lookup will always return
    # 1 even if it does not exist
    return 0 if !$user || $user !~ tr{ \t}{}c;

    require Cpanel::Encoder::Exim;
    return Exim::expand_string( &#039;${lookup{&#039; . Cpanel::Encoder::Exim::unquoted_encode_string_literal($user) . &#039;}lsearch{&#039; . $db . &#039;}{1}{0}}&#039; ) || &#039;0&#039;;
}
my %sender_recent_authed_mail_ips_address_cache;
my $get_recent_authed_mail_ips_lookup_method;

sub get_recent_authed_mail_ips_text_entry {
    my ( $sender, $domain ) = get_recent_authed_mail_ips_entry(@_);
    return join( &#039;|&#039;, ( $sender || &#039;&#039; ), $domain );
}

sub popbeforesmtpwarn {
    if ( my @possible_users = _get_possible_users_from_recent_authed_mail_ips_users() ) {
        return ( &quot;X-PopBeforeSMTPSenders: &quot; . join( &quot;,&quot;, @possible_users ) );
    }
    return &#039;&#039;;
}

sub get_recent_authed_mail_ips_entry {
    my $log = shift;

    # SENDING OVER POP B4 SMTP or NOAUTH
    # case 43151, case 43150
    $get_recent_authed_mail_ips_lookup_method = &#039;&#039;;

    my $sender_host_address = Exim::expand_string(&#039;$sender_host_address&#039;);

    # Exim::log_write(&quot;!DEBUG! get_recent_authed_mail_ips_entry sender_host_address=[$sender_host_address] log=[$log]&quot;);
    my ( $sender, $domain );

    if ( exists $sender_recent_authed_mail_ips_address_cache{$sender_host_address} ) {

        # Exim::log_write(&quot;!DEBUG! get_recent_authed_mail_ips_entry sender_host_address=[$sender_host_address] USING CACHE&quot;);
        ( $sender, $domain, $get_recent_authed_mail_ips_lookup_method ) = @{ $sender_recent_authed_mail_ips_address_cache{$sender_host_address} };
        $get_recent_authed_mail_ips_lookup_method = &quot;cached: &quot; . $get_recent_authed_mail_ips_lookup_method;
        $log                                      = 0;
    }
    else {
        my $recent_authed_mail_ips_users_is_up_to_date = ( stat(&#039;/etc/recent_authed_mail_ips_users&#039;) )[9] + 7200 &gt; time() ? 1 : 0;
        my $sender_address_domain;

        # Exim::log_write(&quot;!DEBUG! get_recent_authed_mail_ips_entry sender_host_address=[$sender_host_address] recent_authed_mail_ips_users_is_up_to_date= $recent_authed_mail_ips_users_is_up_to_date&quot;);

        # If we have a recent_authed_mail_ips_users file that is up to date, we can verify the ip matches
        if ($recent_authed_mail_ips_users_is_up_to_date) {

            # This is what the user has claimed as the sender
            my $sender_address   = Exim::expand_string(&#039;$sender_address&#039;);
            my $from_h_domain    = Exim::expand_string(&#039;${domain:$h_from:}&#039;);
            my $from_h_localpart = Exim::expand_string(&#039;${local_part:$h_from:}&#039;);
            my $from_h           = &quot;$from_h_localpart\@$from_h_domain&quot;;

            # First we try to find the address in the recent_authed_mail_ips_users file (with a cached exim lookup)
            if ( my @possible_users = _get_possible_users_from_recent_authed_mail_ips_users() ) {

                if ( grep { tr/@// ? $from_h eq $_ : $from_h eq $_ . &#039;@&#039; . $primary_hostname } @possible_users ) {
                    $sender                                   = $from_h;
                    $domain                                   = getdomainfromaddress($from_h);
                    $get_recent_authed_mail_ips_lookup_method = &quot;full match of from_h in recent_authed_mail_ips_users&quot;;
                }
                elsif ( grep { tr/@// ? $sender_address eq $_ : $sender_address eq $_ . &#039;@&#039; . $primary_hostname } @possible_users ) {
                    $sender                                   = $sender_address;
                    $domain                                   = getdomainfromaddress($sender_address);
                    $get_recent_authed_mail_ips_lookup_method = &quot;full match of sender_address in recent_authed_mail_ips_users&quot;;
                }
                elsif ( ( $sender_address_domain = ( split( m/\@/, $sender_address ) )[1] ) &amp;&amp; grep( m/\@\Q$sender_address_domain\E$/, @possible_users ) ) {
                    $domain                                   = $sender_address_domain;
                    $sender                                   = &#039;-unknown-@&#039; . $domain;
                    $get_recent_authed_mail_ips_lookup_method = &quot;match of sender_address_domain in recent_authed_mail_ips_users&quot;;
                }
                elsif ( grep { tr/@// ? ( $from_h eq $_ ) : ( $from_h_localpart eq $_ &amp;&amp; ( !length $from_h_domain || $from_h_domain eq $primary_hostname ) ) } @possible_users ) {
                    $sender                                   = $from_h;
                    $domain                                   = $from_h_domain;
                    $get_recent_authed_mail_ips_lookup_method = &quot;full match of from_h in recent_authed_mail_ips_users&quot;;
                }
                elsif ( grep( m/\@\Q$from_h_domain\E$/, @possible_users ) ) {
                    $domain                                   = $from_h_domain;
                    $sender                                   = &#039;-unknown-@&#039; . $from_h_domain;
                    $get_recent_authed_mail_ips_lookup_method = &quot;match of from_h_domain in recent_authed_mail_ips_users&quot;;
                }
                elsif ( $possible_users[0] &amp;&amp; $possible_users[0] eq &#039;-alwaysrelay-&#039; ) {
                    if ($from_h_domain) {
                        Exim::log_write(&quot;$sender_host_address in /etc/alwaysrelay trusting from_h_domain of: $from_h_domain and from_h_localpart: $from_h_localpart&quot;);
                        $domain                                   = $from_h_domain;
                        $sender                                   = $from_h;
                        $get_recent_authed_mail_ips_lookup_method = &quot;in alwaysrelay trusted from_h&quot;;
                    }
                    else {
                        Exim::log_write(&quot;$sender_host_address in /etc/alwaysrelay trusting sender_address_domain of: $sender_address_domain&quot;);
                        $domain                                   = $sender_address_domain;
                        $sender                                   = $sender_address;
                        $get_recent_authed_mail_ips_lookup_method = &quot;in alwaysrelay trusted sender_address&quot;;
                    }
                }
                else {

                    # If none of them matched, we have to assume they authenticated in some we so we go with the first one
                    $domain                                   = getdomainfromaddress( $possible_users[0] );
                    $sender                                   = $possible_users[0];
                    $get_recent_authed_mail_ips_lookup_method = &quot;in recent_authed_mail_ips_users using first address&quot;;
                }
                if ( $sender =~ m/^\*/ ) {
                    $sender =~ s/^\*/-unknown-/;
                }
                $sender_recent_authed_mail_ips_address_cache{$sender_host_address} = [ $sender, $domain, $get_recent_authed_mail_ips_lookup_method ];
            }
        }

        # we need to check alwaysrelay since we don&#039;t require recentauthedmailiptracker to be enabled
        if ( !$domain &amp;&amp; -e &#039;/etc/alwaysrelay&#039; ) {
            my $alwaysrelay_result = Exim::expand_string(&#039;${lookup{$sender_host_address}iplsearch{/etc/alwaysrelay}{$sender_host_address $value}}&#039;);
            if ($alwaysrelay_result) {
                my ( $alwaysrelay_ip, $alwaysrelay_user ) = split( /\s+/, $alwaysrelay_result );
                if ($alwaysrelay_user) {
                    $domain                                   = getdomainfromaddress($alwaysrelay_user);
                    $sender                                   = $alwaysrelay_user;
                    $get_recent_authed_mail_ips_lookup_method = &quot;full match in alwaysrelay with recentauthedmailiptracker disabled&quot;;
                    Exim::log_write(&quot;$sender_host_address in /etc/alwaysrelay using domain $domain from lookup of $alwaysrelay_user&quot;);
                }
                if ( !$domain ) {
                    $domain = $sender_address_domain = ( split( /\@/, Exim::expand_string(&#039;$sender_address&#039;) ) )[1];
                    $sender = &quot;-unknown-\@$domain&quot;;
                    $get_recent_authed_mail_ips_lookup_method = &quot;in alwaysrelay with recentauthedmailiptracker disabled&quot;;
                    Exim::log_write(&quot;$sender_host_address in /etc/alwaysrelay trusting sender_address_domain of: $sender_address_domain&quot;);
                }
            }

            # no need to check /etc/alwaysrelay as they are automaticlly built into recent_authed_mail_ips_users
        }
    }
    if ($domain) {
        if ($log) {
            my $message_exim_id                   = Exim::expand_string(&#039;$message_exim_id&#039;);
            my $sender_host_name                  = Exim::expand_string(&#039;${if match_ip{$sender_host_address}{+loopback}{localhost}{$sender_host_name}}&#039;);
            my $sender_host_port                  = Exim::expand_string(&#039;$sender_host_port&#039;);
            my $recent_authed_mail_ips_local_user = getdomainowner($domain);
            my $recent_authed_mail_ips_local_uid  = user2uid($recent_authed_mail_ips_local_user);
            Exim::log_write(&quot;SMTP connection identification H=$sender_host_name A=$sender_host_address P=$sender_host_port U=$recent_authed_mail_ips_local_user ID=$recent_authed_mail_ips_local_uid S=$sender B=get_recent_authed_mail_ips_entry&quot;);
        }
        return ( $sender, $domain, $get_recent_authed_mail_ips_lookup_method );
    }

    return ( &#039;&#039;, &#039;&#039;, &#039;&#039; );
}

sub _get_possible_users_from_recent_authed_mail_ips_users {
    my $recent_authed_mail_ips_users_result = Exim::expand_string(&#039;${lookup{$sender_host_address}lsearch{/etc/recent_authed_mail_ips_users}{$value}}&#039;);
    return map {
        s/\/.*$//g if tr/\///;
        tr/+%:/@/;
        $_;
    } split( m/\s*\,\s*/, $recent_authed_mail_ips_users_result );
}
my $local_connection_uid;
my $local_connection_user;
my %sender_host_address_cache;

sub get_identified_local_connection_uid {
    $local_connection_uid;
}

sub get_identified_local_connection_user {
    $local_connection_user;
}

sub identify_local_connection {

    # passes but not for production
    # use strict;
    # On Linux we can identify users by reading /proc/net/tcp*
    # Since this requires access kernel memory on bsd and we don&#039;t have a way
    # do that under exim users MUST authenticate to send messages from localhost

    my ( $sender_host_address, $sender_host_port, $received_ip_address, $received_port, $log ) = @_;

    undef $local_connection_uid;
    undef $local_connection_user;

    my $uid;

    if ( exists $sender_host_address_cache{ $sender_host_address . &#039;__&#039; . $sender_host_port } ) {
        $uid = $sender_host_address_cache{ $sender_host_address . &#039;__&#039; . $sender_host_port };
        $log = 0;
    }
    else {
        local @INC = ( &#039;/usr/local/cpanel&#039;, @INC ) if !grep { &#039;/usr/local/cpanel&#039; } @INC;
        require Cpanel::Ident;
        $uid = Cpanel::Ident::identify_local_connection( $sender_host_address, $sender_host_port, $received_ip_address, $received_port );
        if ( !defined $uid ) {
            $uid = identify_local_connection_wrapped( $sender_host_address, $sender_host_port, $received_ip_address, $received_port );
        }
    }

    if ( defined $uid ) {
        $local_connection_uid = $uid;
        $sender_host_address_cache{ $sender_host_address . &#039;__&#039; . $sender_host_port } = $local_connection_uid;

        if ( $uid == -1 ) {
            Exim::log_write(&quot;Could not identify the local connection from $sender_host_address on port $sender_host_port.  Please authenticate&quot;) if $log;
            return 0;
        }

        $local_connection_user = uid2user($uid);

        # Log this for tailwatchd
        Exim::log_write(&quot;SMTP connection identification H=localhost A=$sender_host_address P=$sender_host_port U=$local_connection_user ID=$local_connection_uid S=$local_connection_user B=identify_local_connection&quot;) if $log;
        return 1;
    }
    else {
        $sender_host_address_cache{ $sender_host_address . &#039;__&#039; . $sender_host_port } = undef;

        Exim::log_write(&quot;could not identify the local connection from $sender_host_address on port $sender_host_port.  Please authenticate&quot;) if $log;
        return 0;
    }
}

sub identify_local_connection_wrapped {
    my ( $address, $port, $localaddress, $localport ) = @_;

    my $uidline = call_cpwrap( &#039;IDENTIFYLOCALCONNECTION&#039;, $address, $port, $localaddress, $localport );

    chomp($uidline) if defined $uidline;

    my ( $uidkey, $uid ) = split( /:/, $uidline, 2 );
    $uid = undef if $uid eq &#039;&#039;;

    Exim::log_write(&quot;/usr/local/cpanel/bin/eximwrap IDENTIFYLOCALCONNECTION $address $port $localaddress $localport failed to return the uid key.&quot;) if ( !defined $uidkey || $uidkey ne &#039;uid&#039; );

    return $uid;
}

my $headers_rewrite_notice = &#039;&#039;;
my $new_from_header;

use constant {
    _ENOENT =&gt; 2,
    _EEXIST =&gt; 17,

    _SENDER_SYSTEM =&gt; &#039;-system-&#039;,
};

sub spamd_is_available {
    require Cpanel::Services::Enabled::Spamd;
    return eval { Cpanel::Services::Enabled::Spamd::is_enabled() } // do {
        warn;
        1;    # this defaults to on for historical reasons
    };
}

sub get_dkim_domain {
    my $msg_sender_domain = get_message_sender_domain();

    if ($msg_sender_domain eq _SENDER_SYSTEM) {
        $msg_sender_domain = Exim::expand_string(&#039;$sender_address_domain&#039;);
    }

    return $msg_sender_domain =~ tr&lt;A-Z&gt;&lt;a-z&gt;r;
}

sub sender_domain_can_dkim_sign {
    require Cpanel::DKIM::ValidityCache;

    my $sender_domain = get_dkim_domain();

    local $@;
    return eval { Cpanel::DKIM::ValidityCache-&gt;get($sender_domain) } // do {
        warn;
        q&lt;&gt;;
    };
}

sub discover_sender_information {

    # If $sender_lookup_method and $check_mail_permissions_sender is already set
    # we have already discovered the sender
    if ( !$sender_lookup_method || !$check_mail_permissions_sender ) {
        my $uid = int( Exim::expand_string(&#039;$originator_uid&#039;) );
        my $gid = int( Exim::expand_string(&#039;$originator_gid&#039;) );

        #Exim::log_write(&quot;discover_sender_information calling get_message_sender&quot;);
        my ( $sender, $real_domain, $domain, $is_mailman ) = get_message_sender( $uid, $gid, 1 );
        $check_mail_permissions_sender     = $sender if $sender;
        $check_mail_permissions_is_mailman = $is_mailman;
    }

    #Exim::log_write(&quot;discover_sender_information calling discover_sender_information&quot;);
    $new_from_header = get_from_header_rewrite_target();

    return 0;
}

sub get_headers_rewrite {
    return $new_from_header if $new_from_header;

    my ($from_h_sender) = _get_from_h_sender();

    Exim::log_write(&quot;discover_sender_information failed to set the from header rewrite for $from_h_sender&quot;);

    return $from_h_sender;
}

sub get_from_header_rewrite_target {
    $headers_rewrite_notice = &#039;&#039;;

    my ( $from_h_sender, $from_h_localpart, $from_h_domain ) = _get_from_h_sender();

    if ( $sender_lookup_method &amp;&amp; $check_mail_permissions_sender ) {
        my $actual_sender = _get_login_from_check_mail_permissions_sender($check_mail_permissions_sender);

        #Exim::log_write(&quot;!DEBUG! get_from_header_rewrite_target() actual_sender=[$actual_sender] from_h_sender=[$from_h_sender]&quot;);
        my $qualified_actual_sender = _qualify_as_email_address($actual_sender);

        my ( $status, $statusmsg );
        if ( $sender_lookup_method =~ m{^redirect/forwarder} ) {
            $headers_rewrite_notice = &#039;unmodified, forwarded message&#039;;
            return $from_h_sender;
        }
        elsif ($check_mail_permissions_is_mailman) {
            $headers_rewrite_notice = &#039;unmodified, sender is mailman&#039;;
            return $from_h_sender;
        }
        elsif ( $from_h_sender eq $actual_sender ) {
            $headers_rewrite_notice = &#039;unmodified, already matched&#039;;
            return $from_h_sender;
        }
        else {

            if ( $actual_sender eq &#039;mailnull&#039; ) {    # handle Mailer-Daemon messages
                $headers_rewrite_notice = &#039;unmodified, actual sender is mailnull&#039;;
                return $from_h_sender;
            }

            my $from_h_sender_domainowner = getdomainowner($from_h_domain);

            # Actual Sender is a system user.
            if ( $from_h_sender_domainowner &amp;&amp; $from_h_sender_domainowner eq $actual_sender ) {
                $headers_rewrite_notice = &#039;unmodified, actual sender is system user that owns from domain in the from header&#039;;
                return $from_h_sender;
            }
            elsif ( $from_h_sender eq $qualified_actual_sender ) {
                $headers_rewrite_notice = &#039;unmodified, actual sender is the system user&#039;;
                return $from_h_sender;
            }
            elsif ( $actual_sender eq &#039;root&#039; ) {

                $headers_rewrite_notice = &#039;unmodified, actual sender is root&#039;;
                return $from_h_sender;
            }
            elsif ( $actual_sender eq &#039;mailman&#039; ) {

                $headers_rewrite_notice = &#039;unmodified, actual sender is mailman&#039;;
                return $from_h_sender;
            }
            elsif ( $actual_sender !~ tr/\@// &amp;&amp; _is_trusted_user($actual_sender) ) {
                $headers_rewrite_notice = &#039;unmodified, actual sender is a trusted user&#039;;
                return $from_h_sender;
            }
            elsif ( ( ( $status, $statusmsg ) = _has_valias_pointing_to_actual_sender( $from_h_sender, $actual_sender ) )[0] ) {
                if ( $statusmsg eq &#039;valias_exact_match&#039; ) {
                    $headers_rewrite_notice = &#039;unmodified, there is a forwarder that points to the actual sender.&#039;;
                }
                elsif ( $statusmsg eq &#039;valias_domainowner_match&#039; ) {
                    $headers_rewrite_notice = &#039;unmodified, there is a forwarder that points to a user owned by actual sender.&#039;;
                }
                elsif ( $statusmsg eq &#039;vdomainaliases_match&#039; ) {
                    $headers_rewrite_notice = &#039;unmodified, there is a domain forwarder that maps to the actual sender.&#039;;
                }

                return $from_h_sender;
            }
            else {
                if ( $actual_sender !~ tr/\@// ) {
                    $headers_rewrite_notice = &#039;rewritten was: [&#039; . $from_h_sender . &#039;], actual sender is not the same system user&#039;;
                }
                else {
                    $headers_rewrite_notice = &#039;rewritten was: [&#039; . $from_h_sender . &#039;], actual sender does not match&#039;;
                }
                Exim::log_write(&quot;From: header ($headers_rewrite_notice) original=[$from_h_sender] actual_sender=[$qualified_actual_sender]&quot;);
                return $qualified_actual_sender;
            }
        }

    }

    # We have no sender set so we leave it unmodified
    # AKA unable to determine sender would get here
    $headers_rewrite_notice = &#039;unmodified, no actual sender determined from check mail permissions&#039;;
    return $from_h_sender;
}

sub get_headers_rewritten_notice {
    if ($headers_rewrite_notice) {
        return &quot;X-From-Rewrite: $headers_rewrite_notice&quot;;
    }
    return &#039;&#039;;
}

#
#  This converts an unqualified address which is just a system
#  account IE local_part.  Into local_part@primary_hostname.
#
#  If the address is already qualified ie has @, it returns returns the
#  address.
#
sub _qualify_as_email_address {
    my ($address) = @_;

    return $address if $address =~ tr/@//;

    $primary_hostname ||= Exim::expand_string(&#039;$primary_hostname&#039;);

    return $address . &#039;@&#039; . $primary_hostname;
}

#
#  Convert the $check_mail_permissions_sender variable
#  into the real login that the user has authenticated as
#  in most cases this is already their email address, however it may
#  be USER@PRIMARY_HOSTNAME, in which case we want to strip PRIMARY_HOSTNAME
#
sub _get_login_from_check_mail_permissions_sender {
    my ($sender) = @_;

    $primary_hostname ||= Exim::expand_string(&#039;$primary_hostname&#039;);

    $sender =~ s/\@\Q$primary_hostname\E$//;

    return $sender;
}

#  _has_valias_pointing_to_target lets us know if there
#  if a forwarder for the address pointing at the target.
#
#  For example  ORIGIN bob@cpanel.net
#  might point to a user account DEST &#039;bob&#039;
#
sub _has_valias_pointing_to_actual_sender {
    my ( $origin, $actual_sender ) = @_;

    #Exim::log_write(&quot;!DEBUG! _has_valias_pointing_to_actual_sender() actual_sender=[$actual_sender] origin=[$origin]&quot;);
    my $qualified_origin        = _qualify_as_email_address($origin);
    my $qualified_actual_sender = _qualify_as_email_address($actual_sender);

    my ( $origin_local_part,        $origin_domain )        = split( m{@}, $qualified_origin,        2 );
    my ( $actual_sender_local_part, $actual_sender_domain ) = split( m{@}, $qualified_actual_sender, 2 );

    my $actual_sender_domainowner;

    require Cpanel::Encoder::Exim;

    return ( 0, &#039;invalid_origin_domain&#039; ) if $origin_domain =~ m{/};

    if ( file_exists(&quot;$VALIASES_DIR/$origin_domain&quot;) ) {

        if ( my $valiases_alias_line = Exim::expand_string( &#039;${lookup{&#039; . Cpanel::Encoder::Exim::unquoted_encode_string_literal($origin) . &#039;}lsearch*{&#039; . $VALIASES_DIR . &#039;/&#039; . $origin_domain . &#039;}{$value}}&#039; ) ) {
            if ( my @forwarders = _get_forwarders_from_string($valiases_alias_line) ) {
                foreach my $forwarder_destination (@forwarders) {
                    #
                    # Handle exact matches
                    # IE bob@cpanel.net is forwarded to the actual sender
                    #
                    if ( _qualify_as_email_address($forwarder_destination) eq $qualified_actual_sender ) {
                        return ( 1, &#039;valias_exact_match&#039; );
                    }

                    # $VALIASES_DIR/dog.com: nick@dog.org: me@samsdomain.org
                    # I send email From: nick@dog.org and I am authenticated as &#039;sam&#039; it should likely be allowed
                    if ( $actual_sender !~ tr/\@// &amp;&amp; $forwarder_destination =~ tr/\@// ) {
                        my ( $forwarder_destination_local_part, $forwarder_destination_domain ) = split( m{@}, $forwarder_destination, 2 );
                        my $forwarder_destination_domainowner = getdomainowner($forwarder_destination_domain);

                        if ( $actual_sender eq $forwarder_destination_domainowner ) {
                            return ( 1, &#039;valias_domainowner_match&#039; );
                        }
                    }
                }
            }
        }
    }

    if ( file_exists(&quot;$VDOMAINALIASES_DIR/$origin_domain&quot;) ) {
        if ( my $vdomainaliases_alias_line = Exim::expand_string( &#039;${lookup{&#039; . Cpanel::Encoder::Exim::unquoted_encode_string_literal($origin_domain) . &#039;}lsearch{&#039; . $VDOMAINALIASES_DIR . &#039;/&#039; . $origin_domain . &#039;}{$value}}&#039; ) ) {
            my $vdomainaliases_domain = _ws_trim($vdomainaliases_alias_line);
            if ( ( $origin_local_part . &#039;@&#039; . $vdomainaliases_domain ) eq $qualified_actual_sender ) {
                return ( 1, &#039;vdomainaliases_match&#039; );
            }
        }
    }

    return ( 0, &#039;no_match&#039; );

}

sub _is_trusted_user {
    my ($user) = @_;

    return 0 if !file_exists(&#039;/etc/trusted_mail_users&#039;);

    local $/;
    open my $trusted_mail_users_fh, &#039;&lt;&#039;, &#039;/etc/trusted_mail_users&#039; or return 0;
    my @trusted_mail_users = split( qq{\n}, &lt;$trusted_mail_users_fh&gt; );
    close $trusted_mail_users_fh;

    return scalar grep { $_ eq $user } @trusted_mail_users;
}

#
# From Cpanel::StringFunc::Trim
#
sub _ws_trim {
    my ($this) = @_;
    my $fix = ref $this eq &#039;SCALAR&#039; ? $this : \$this;
    ${$fix} =~ s/^\s+//;
    ${$fix} =~ s/\s+$//;
    return ${$fix};
}

#
# From Cpanel::API::Email
#
sub _get_forwarders_from_string {
    my ($forwarder_csv) = @_;

    # to leave \, as \, uncomment this:
    # $forwarder_csv =~ s{\\,}{\\\\,}g;
    my @forwarders =
      $forwarder_csv =~ /^[\s&quot;]*\:(fail|defer|blackhole|include)\:/
      ? ($forwarder_csv)
      : split( /(?&lt;![\\]),/, $forwarder_csv );

    my @parsed_forwarders;

    for my $forward (@forwarders) {
        $forward = _ws_trim($forward);
        next if ( $forward =~ m{^&quot;} );
        push @parsed_forwarders, $forward;

    }

    return wantarray ? @parsed_forwarders : \@parsed_forwarders;
}

sub check_mail_permissions_results {
    return $check_mail_permissions_data;
}

sub enforce_mail_permissions_results {
    $enforce_mail_permissions_data;
}

sub uid2user {
    my $uid = shift;
    return exists $uid_cache{$uid} ? $uid_cache{$uid} : ( $uid_cache{$uid} = ( getpwuid($uid) )[0] );
}

sub user2uid {
    my $user = shift;
    return exists $user_cache{$user} ? $user_cache{$user} : ( $user_cache{$user} = getuid($user) );
}

sub get_sender_from_uid {
    my $uid  = int( Exim::expand_string(&#039;$originator_uid&#039;) );
    my $user = uid2user($uid);
    return getdomainfromaddress($user);
}

sub mailtrapheaders {
    $primary_hostname ||= Exim::expand_string(&#039;$primary_hostname&#039;);
    my $original_domain       = Exim::expand_string(&#039;$original_domain&#039;);
    my $sender_address_domain = Exim::expand_string(&#039;$sender_address_domain&#039;);
    my $originator_uid        = Exim::expand_string(&#039;$originator_uid&#039;);
    my $originator_gid        = Exim::expand_string(&#039;$originator_gid&#039;);
    my $caller_uid            = Exim::expand_string(&#039;$caller_uid&#039;);
    my $caller_gid            = Exim::expand_string(&#039;$caller_gid&#039;);
    my $headers =
        &quot;X-AntiAbuse: This header was added to track abuse, please include it with any abuse report\n&quot;
      . &quot;X-AntiAbuse: Primary Hostname - $primary_hostname\n&quot;
      . &quot;X-AntiAbuse: Original Domain - $original_domain\n&quot;
      . &quot;X-AntiAbuse: Originator/Caller UID/GID - [$originator_uid $originator_gid] / [$caller_uid $caller_gid]\n&quot;
      . &quot;X-AntiAbuse: Sender Address Domain - $sender_address_domain\n&quot;
      . check_mail_permissions_headers() . &quot;\n&quot;;

    if ( file_exists(&#039;/etc/eximmailtrap&#039;) ) {
        my $xsource     = $ENV{&#039;X-SOURCE&#039;};
        my $xsourceargs = $ENV{&#039;X-SOURCE-ARGS&#039;};
        my $xsourcedir  = maskdir( $ENV{&#039;X-SOURCE-DIR&#039;} );

        $headers .= &quot;X-Source: ${xsource}\n&quot; . &quot;X-Source-Args: ${xsourceargs}\n&quot; . &quot;X-Source-Dir: ${xsourcedir}&quot;;
    }
    return ($headers);

}

sub getdomainfromaddress {
    my $address = shift;
    $address =~ s/\/.*$//g if $address =~ tr/\///;    # remove /spam
    if ( $address =~ tr/@+%:// ) {
        unless ( $address =~ tr/@// ) {

            # This matches exactly how authentication occurs
            $address =~ s/[+:%]/@/;
        }
        $primary_hostname ||= Exim::expand_string(&#039;$primary_hostname&#039;);
        if ( $address =~ m/[@]\Q$primary_hostname\E$/ ) {
            return getusersdomain( ( split( m/[@]/, $address, 2 ) )[0] ) || _SENDER_SYSTEM;    #from MailAuth.pm
        }
        else {
            return ( split( m/[@]/, $address, 2 ) )[1];                                    #from MailAuth.pm
        }
    }
    else {
        return getusersdomain($address) || _SENDER_SYSTEM;
    }
}

sub get_message_sender_domain {
    my ( $uid, $gid, $log ) = @_;
    $uid = int( Exim::expand_string(&#039;$originator_uid&#039;) ) if !defined $uid;
    $gid = int( Exim::expand_string(&#039;$originator_gid&#039;) ) if !defined $gid;
    return ( ( get_message_sender( $uid, $gid, $log ) )[1] ) || &#039;&#039;;
}

sub get_sender_lookup_method {
    return $sender_lookup_method || &#039;none&#039;;
}

sub get_sender_lookup {
    return $sender_lookup || &#039;&#039;;
}

sub check_mail_permissions_headers {
    return &quot;X-Get-Message-Sender-Via: &quot; . ( $primary_hostname ||= Exim::expand_string(&#039;$primary_hostname&#039;) ) . &quot;: &quot; . get_sender_lookup_method() . &quot;\n&quot; . &quot;X-Authenticated-Sender: &quot; . ( $primary_hostname ||= Exim::expand_string(&#039;$primary_hostname&#039;) ) . &quot;: &quot; . get_sender_lookup();
}

# This must match the logic extactly for Cpanel::TailWatch::EximStats ($direction eq &#039;&lt;=&#039;)
sub get_message_sender {

    #passes but not for production
    #use strict;

    my ( $uid, $gid, $log ) = @_;
    my ( $authenticated_local_user, $authenticated_id, $recent_authed_mail_ips_text_entry, $domain, $counted_domain, $sender, $is_mailman, $username );

    $sender_lookup_method = &#039;&#039;;

    my ( $acl_c_vhost_owner, $acl_c_vhost_owner_url ) = split( m{:}, Exim::expand_string(&#039;$acl_c_vhost_owner&#039;) || &#039;&#039;, 2 );
    my $message_exim_id = Exim::expand_string(&#039;$message_exim_id&#039;);

    # SMTP AUTH
    if ( $authenticated_id = Exim::expand_string(&#039;$authenticated_id&#039;) ) {
        $authenticated_id =~ s/[\r\n\f]//g;
        if ( $authenticated_id eq &#039;nobody&#039; ) {
            if ($acl_c_vhost_owner) {
                $authenticated_id = uid2user($acl_c_vhost_owner);
            }
            $sender_lookup_method = &#039;uid via acl_c_vhost_owner from authenticated_id: &#039; . $authenticated_id . &#039; from &#039; . $acl_c_vhost_owner_url;
        }
        else {
            $sender_lookup_method = &#039;authenticated_id: &#039; . $authenticated_id;
        }
        $sender = $authenticated_id;
        $domain = getdomainfromaddress($authenticated_id);

        # If the sender owns the domain they are sending
        # from we can trust it
        if ( length $sender &amp;&amp; $sender !~ tr/\@// ) {
            ( $sender, $domain, $sender_lookup_method ) = resolve_authenticated_sender( $sender, $domain, $sender_lookup_method );
        }

        #Exim::log_write(&quot;!DEBUG! get_message_sender() got domain $domain from authenticated_id ($authenticated_id)&quot;);
    }

    # FROM A CONNECTION TO LOCALHOST (linux only)
    elsif ( $authenticated_local_user = Exim::expand_string(&#039;${if match_ip{$sender_host_address}{+loopback}{$acl_c_authenticated_local_user}{}}&#039;) ) {
        my $authenticated_local_uid = user2uid($authenticated_local_user);
        my $sender_host_address     = Exim::expand_string(&#039;$sender_host_address&#039;);
        my $sender_host_name        = Exim::expand_string(&#039;${if match_ip{$sender_host_address}{+loopback}{localhost}{$sender_host_name}}&#039;);
        my $sender_host_port        = Exim::expand_string(&#039;$sender_host_port&#039;);

        $domain               = getusersdomain($authenticated_local_user) || _SENDER_SYSTEM;
        $sender               = $authenticated_local_user;
        $sender_lookup_method = &#039;acl_c_authenticated_local_user: &#039; . $authenticated_local_user;
        if ($log) { Exim::log_write(&quot;SMTP connection identification H=$sender_host_name A=$sender_host_address P=$sender_host_port M=$message_exim_id U=$authenticated_local_user ID=$authenticated_local_uid S=$sender B=authenticated_local_user&quot;); }    #replay for tailwatchd

        #Exim::log_write(&quot;!DEBUG! get_message_sender() got domain $domain from acl_c_authenticated_local_user&quot;);
    }

    # RELAY HOSTS
    elsif ( ( $recent_authed_mail_ips_text_entry = Exim::expand_string(&#039;$acl_m_recent_authed_mail_ips_text_entry&#039;) ) &amp;&amp; _entry_covers_this_recipient() ) {

        #FIXME: need to get sender
        ( $sender, $domain ) = split( /\|/, $recent_authed_mail_ips_text_entry );
        my $sender_host_address = Exim::expand_string(&#039;$sender_host_address&#039;);
        my $sender_host_name    = Exim::expand_string(&#039;${if match_ip{$sender_host_address}{+loopback}{localhost}{$sender_host_name}}&#039;);
        my $sender_host_port    = Exim::expand_string(&#039;$sender_host_port&#039;);

        my $recent_authed_mail_ips_local_user = getdomainowner($domain);
        my $recent_authed_mail_ips_local_uid  = user2uid($recent_authed_mail_ips_local_user);

        $sender_lookup_method = &#039;acl_m_recent_authed_mail_ips_text_entry: &#039; . $recent_authed_mail_ips_text_entry;
        if ($log) { Exim::log_write(&quot;SMTP connection identification H=$sender_host_name A=$sender_host_address P=$sender_host_port M=$message_exim_id U=$recent_authed_mail_ips_local_user ID=$recent_authed_mail_ips_local_uid S=$sender B=recent_authed_mail_ips_domain&quot;) }

        #Exim::log_write(&quot;!DEBUG! get_message_sender() got domain $domain from acl_m_recent_authed_mail_ips_text_entry&quot;);
    }
    elsif ( Exim::expand_string(&#039;$received_protocol&#039;) eq &#039;local&#039; ) {
        my $sender_ident = Exim::expand_string(&#039;$sender_ident&#039;);
        $sender_ident =~ s/[\r\n\f]//g;

        my $used_vhost_owner_lookup = 0;
        if ( $sender_ident eq &#039;nobody&#039; ) {
            if ($acl_c_vhost_owner) {
                $used_vhost_owner_lookup = 1;
                $sender_ident            = uid2user($acl_c_vhost_owner);
            }
        }

        $sender               = $sender_ident;
        $domain               = getusersdomain($sender_ident) || _SENDER_SYSTEM;
        $sender_lookup_method = &#039;sender_ident via received_protocol == local: &#039; . $sender_ident . ( $used_vhost_owner_lookup ? &#039; : used vhost owner lookup from: &#039; . $acl_c_vhost_owner_url : &#039;&#039; );

        # If the sender owns the domain they are sending
        # from we can trust it
        if ( length $sender &amp;&amp; $sender !~ tr/\@// ) {
            ( $sender, $domain, $sender_lookup_method ) = resolve_authenticated_sender( $sender, $domain, $sender_lookup_method );
        }

        #Exim::log_write(&quot;!DEBUG! get_message_sender() got domain $domain from local user ($sender_ident)&quot;);
    }
    else {
        $mail_gid ||= int( ( getgrnam(&#039;mail&#039;) )[2] );

        #Exim::log_write(&quot;!DEBUG! mailgid=$mail_gid == gid=$gid (uid=$uid)&quot;);
        if ( $gid == $mail_gid ) {
            my ( $recent_authed_mail_ips_sender, $recent_authed_mail_ips_domain, $recent_authed_mail_ips_lookup_method );
            if ( _recent_authed_mail_ips_may_identify_sender() ) {
                ( $recent_authed_mail_ips_sender, $recent_authed_mail_ips_domain, $recent_authed_mail_ips_lookup_method ) = get_recent_authed_mail_ips_entry();
            }
            else {
                $recent_authed_mail_ips_lookup_method = &#039;skipped as the remote sender is not authenticated&#039;;
            }
            if ($recent_authed_mail_ips_domain) {
                $sender = $recent_authed_mail_ips_sender;
                $sender =~ s/[\r\n\f]//g;
                $domain               = $recent_authed_mail_ips_domain;
                $sender_lookup_method = &#039;mailgid via get_recent_authed_mail_ips_entry: &#039; . $sender . &quot;/$recent_authed_mail_ips_lookup_method&quot;;

                #Exim::log_write(&quot;!DEBUG! get_message_sender() got domain $domain from get_recent_authed_mail_ips_entry() or sender_address_domain&quot;);
            }
            $primary_hostname ||= Exim::expand_string(&#039;$primary_hostname&#039;);
            if ( $domain &amp;&amp; $domain eq $primary_hostname ) {
                $username             = Exim::expand_string(&#039;$sender_address_local_part&#039;);
                $sender               = $username;
                $domain               = getusersdomain($username) || _SENDER_SYSTEM;
                $sender_lookup_method = &#039;mailgid via primary_hostname&#039; . &quot;/$recent_authed_mail_ips_lookup_method&quot;;
            }
            if ( !$domain ) {

                # If we cannot find the sender and it is not _SENDER_SYSTEM it is a redirected/forwarded message
                my $parent_domain     = Exim::expand_string(&#039;$parent_domain&#039;);
                my $parent_local_part = Exim::expand_string(&#039;$parent_local_part&#039;);
                my $local_part        = Exim::expand_string(&#039;$local_part&#039;);
                my $delivery_domain   = Exim::expand_string(&#039;$domain&#039;);

                $parent_domain     =~ s/[^\w\.\-\/]//g;
                $parent_local_part =~ s/[^\w\.\-\/]//g;
                $local_part        =~ s/[^\w\.\-\/]//g;
                $delivery_domain   =~ s/[^\w\.\-\/]//g;

                # If we have a parent_domain its probably a redirect
                if ( $parent_domain &amp;&amp; ( $parent_domain ne $delivery_domain || $parent_local_part ne $local_part ) ) {

                    # If the parent_domain is the primary_hostname its a localuser redirect
                    if ( my $local_user = $parent_domain eq $primary_hostname ? $parent_local_part : getdomainowner($parent_domain) ) {
                        my $local_uid         = user2uid($local_user);
                        my $redirected_domain = $parent_domain eq $primary_hostname ? getusersdomain($parent_local_part) : $parent_domain;
                        if ($log) { Exim::log_write(&quot;SMTP connection identification D=$redirected_domain O=$parent_local_part\@$parent_domain E=$local_part\@$delivery_domain M=$message_exim_id U=$local_user ID=$local_uid B=redirect_resolver&quot;) }
                        ;    #replay for tailwatchd

                        $domain               = $redirected_domain;
                        $sender               = $parent_domain eq $primary_hostname ? $local_user : &quot;$parent_local_part\@$parent_domain&quot;;
                        $sender_lookup_method = &quot;redirect/forwarder owner $parent_local_part\@$parent_domain -&gt; $local_part\@$delivery_domain&quot;;
                    }
                }
            }
            if ( !$domain ) {
                $sender_lookup_method = &#039;mailgid &#039; . ( $recent_authed_mail_ips_lookup_method || &#039;no entry from get_recent_authed_mail_ips_entry&#039; );

                #Exim::log_write(&quot;!DEBUG! get_message_sender() failed to get the domain.  However the sender domain claims to be $sender_address_domain&quot;);
            }
        }
        else {

            # FROM A SHELL OR CGI
            $username = uid2user($uid);

            if ($username) {
                if ( $username eq &#039;nobody&#039; ) {
                    if ($acl_c_vhost_owner) {
                        $username = uid2user($acl_c_vhost_owner);
                    }
                    $sender_lookup_method = &#039;uid via acl_c_vhost_owner from shell cgi: &#039; . $username . &#039; from: &#039; . $acl_c_vhost_owner_url;
                }
                else {
                    $sender_lookup_method = &#039;uid via shell cgi: &#039; . $username;
                }
                $domain = getusersdomain($username) || _SENDER_SYSTEM;
                $sender = $username;
            }

            # If the sender owns the domain they are sending
            # from we can trust it
            if ( length $sender &amp;&amp; $sender !~ tr/\@// ) {
                ( $sender, $domain, $sender_lookup_method ) = resolve_authenticated_sender( $sender, $domain, $sender_lookup_method );
            }

            #Exim::log_write(&quot;!DEBUG! get_message_sender() got domain $domain from UID&quot;);
        }
    }

    if ($domain) {
        $domain =~ s/[^\w\.\-\/]//g;
        $domain         = lc $domain;
        $counted_domain = $domain;
        if ($sender) {
            $sender =~ tr/+%:/@/;
            $sender =~ s/[^\w\.\-\/\@]//g;

            if ( $sender eq &#039;mailman&#039; ) {
                $is_mailman = 1;
                $domain     = lc Exim::expand_string(&#039;$sender_address_domain&#039;);
                $sender_lookup_method .= &#039;/mailman&#039;;
                $sender         = &#039;mailman@&#039; . $domain;
                $counted_domain = $domain if ( file_exists(&#039;/var/cpanel/email_send_limits/count_mailman&#039;) );
            }
        }
    }
    $sender_lookup = $sender;

    if ( $log &amp;&amp; $message_exim_id ) {
        $username ||= ( ( length($sender) &amp;&amp; $sender =~ tr{@}{} ) ? getdomainowner( ( split( m{@}, $sender ) )[1] ) : $sender );

        if ($username) {

            # Will log as 2017-05-26 13:42:22 1dEKBq-0007HB-6R Sender identification S=nick
            Exim::log_write(&quot;Sender identification U=$username D=$domain S=$sender&quot;);    #replay for tailwatchd
        }
    }

    return ( $sender, $domain, $counted_domain, $is_mailman );
}

#
#  The recent authenticated mail IP tracker records the address of every
#  connection that logs in to POP3 or IMAP.  A login does not by itself
#  authorize that address to send mail, so a message which merely arrives from
#  an address that recently checked its mail is unauthenticated inbound SMTP,
#  and the tracker must not be used to name its sender.  Doing so lets any
#  remote host sharing the address, a NAT gateway for instance, forge a local
#  sender, which the from header rewrite then stamps onto the message.
#
#  A login does authorize the address to relay while POP before SMTP is
#  enabled, but that is not decided here.  ACL_IDENTIFY_SENDER_BLOCK records
#  $acl_c_recent_authed_mail_ips_text_entry for precisely the recipients it
#  authorizes, and get_message_sender() uses that entry one branch earlier, so
#  reading /etc/popbeforesmtp here would only widen the ACL&#039;s decision: mail
#  inbound to a local domain needs no authorization at all, which is why the
#  ACL records no entry for it, and why POP before SMTP being enabled server
#  wide says nothing about the message in hand.
#
#  /etc/alwaysrelay is an explicit list of addresses the administrator trusts
#  to relay, so it still names a sender when the ACL recorded no entry, for
#  instance when an earlier ACL accepted the recipient before this block ran.
#
#  Messages that were not received from a remote host (local submission and
#  connections from the loopback address, which are identified by
#  $acl_c_authenticated_local_user) are not affected.
#
#
#  ACL_IDENTIFY_SENDER_BLOCK records the tracker entry for a POP before SMTP
#  host under &quot;domains = ! +local_domains&quot;, because a login authorizes that
#  address to relay and nothing more.  The entry is still recorded once per
#  message rather than once per recipient, so a transaction that offers a remote
#  recipient and a local one would otherwise carry the identity it earned for
#  the first into the delivery of the second, which the ACL never authorized.
#  Hold the entry to the same recipient scope it was recorded under.
#
#  The /etc/alwaysrelay accept records the entry with no recipient scope at all
#  and flags itself, so an address the administrator trusts is unaffected.
#
sub _entry_covers_this_recipient {

    return 1 if length Exim::expand_string(&#039;$acl_c_alwaysrelay&#039;);

    return !_recipient_is_local_domain();
}

#
#  Mirrors +local_domains, which cPanel builds as
#  &quot;$primary_hostname : lsearch;/etc/localdomains&quot;, so that this reads the same
#  list exim itself matched the recipient against.  /etc/userdomains is not the
#  same list: a domain served by a remote mail exchanger appears there but is
#  not local to exim.
#
sub _recipient_is_local_domain {
    my $domain = Exim::expand_string(&#039;$domain&#039;);

    return 0 if !length $domain;

    $primary_hostname ||= Exim::expand_string(&#039;$primary_hostname&#039;);
    return 1 if $domain eq $primary_hostname;

    require Cpanel::Encoder::Exim;

    return Exim::expand_string( &#039;${lookup{&#039; . Cpanel::Encoder::Exim::unquoted_encode_string_literal($domain) . &#039;}lsearch{/etc/localdomains}{1}}&#039; ) ? 1 : 0;
}

sub _recent_authed_mail_ips_may_identify_sender {
    my $sender_host_address = Exim::expand_string(&#039;$sender_host_address&#039;);

    return 1 if !length $sender_host_address;

    require Cpanel::IP::Loopback;
    return 1 if Cpanel::IP::Loopback::is_loopback($sender_host_address);

    return 1 if length Exim::expand_string(&#039;$acl_c_alwaysrelay&#039;);

    if ( file_exists(&#039;/etc/alwaysrelay&#039;) ) {
        return 1 if length Exim::expand_string(&#039;${lookup{$sender_host_address}iplsearch{/etc/alwaysrelay}{1}}&#039;);
    }

    return 0;
}

sub get_message_sender_address {
    return ( get_message_sender(@_) )[0];
}

sub enforce_mail_permissions {
    $enforce_mail_permissions_data ? 1 : 0;
}

sub check_mail_permissions {
    $check_mail_permissions_domain = undef;

    #Exim::log_write(&quot;!DEBUG! running check_mail_permissions&quot;);

    my $uid = int( Exim::expand_string(&#039;$originator_uid&#039;) );

    $enforce_mail_permissions_data     = &#039;:fail: check_mail_permissions failed to complete or set a status&#039;;
    $check_mail_permissions_result     = &#039;&#039;;
    $check_mail_permissions_data       = &#039;:unknown:&#039;;
    $check_mail_permissions_domain     = &#039;&#039;;
    $check_mail_permissions_sender     = &#039;&#039;;
    $check_mail_permissions_is_mailman = 0;
    $nobody_uid ||= user2uid(&#039;nobody&#039;);

    my $acl_c_vhost_owner = ( split( m{:}, Exim::expand_string(&#039;$acl_c_vhost_owner&#039;) || &#039;&#039; ) )[0];
    my $acl_c_vhost_owner_known_user = ( $acl_c_vhost_owner &amp;&amp; $acl_c_vhost_owner != $nobody_uid ) ? 1 : 0;

    if ( $uid == $nobody_uid &amp;&amp; !$acl_c_vhost_owner_known_user &amp;&amp; file_exists(&#039;/etc/webspam&#039;) ) {
        $enforce_mail_permissions_data = &#039;:fail: Mail sent by user nobody being discarded due to sender restrictions in WHM-&gt;Tweak Settings&#039;;
        $check_mail_permissions_result = &quot;uid ($uid) is the nobody_uid ($nobody_uid) and /etc/webspam exists&quot;;                                  # for tests (only set when enforce_mail_permissions_data is empty)

        return &#039;no&#039;;
    }

    my $gid = int( Exim::expand_string(&#039;$originator_gid&#039;) );

    #MAILTRAP
    if ( file_exists(&#039;/etc/eximmailtrap&#039;) ) {
        $mailtrap_gid ||= int( ( getgrnam(&#039;mailtrap&#039;) )[2] );
        $nobody_gid   ||= int( ( getgrnam(&#039;nobody&#039;) )[2] );
        if ( $uid &gt;= $nobody_uid &amp;&amp; $gid &gt;= $nobody_gid &amp;&amp; $gid != $mailtrap_gid ) {
            $enforce_mail_permissions_data = &quot;:fail: Gid $gid is not permitted to relay mail, or has directly called /usr/sbin/exim instead of /usr/sbin/sendmail.&quot;;
            return &#039;no&#039;;
        }
    }

    #MAILTRAP

    if ( Exim::expand_string(&#039;$received_protocol&#039;) eq &#039;local&#039; &amp;&amp; isdemo($uid) ) {
        $enforce_mail_permissions_data = &quot;:fail: User with uid $uid is a demo user.  You cannot send mail if your account is in demo mode.&quot;;
        return &#039;no&#039;;
    }

    my $message_exim_id = Exim::expand_string(&#039;$message_exim_id&#039;);
    if ( !$message_exim_id &amp;&amp; !Exim::expand_string(&#039;$sender_address&#039;) ) {
        $enforce_mail_permissions_data = &#039;&#039;;                                                                          # permit normal acction
                                                                                                                      #Exim::log_write(&quot;!DEBUG! check_mail_permissions called without sender_address set from $sender_host_address (rcount: $recipients_count)&quot;);
        $check_mail_permissions_result = &quot;webspam check, mailtrap check, demo check passed and no sender_address&quot;;    # for tests (only set when enforce_mail_permissions_data is empty)

        return &#039;no&#039;;
    }

    # real_domain is the domain of the actual sender
    # domain is the domain we actually count the message against

    # Currently these are always the same except domain may be
    # rewritten if we are coming from a mailman list in order
    # to count against the owner of the list instead of the mailman
    # user assuming /var/cpanel/email_send_limits/count_mailman exists
    my ( $sender, $real_domain, $domain, $is_mailman ) = get_message_sender( $uid, $gid, 1 );

    if ( $sender =~ m/^_archive\@/ ) {
        $enforce_mail_permissions_data = &quot;:fail: Archive Users are not permitted to send email.  Message discarded.&quot;;
        $check_mail_permissions_result = &quot;get_message_sender returned an archive user&quot;;
        return &#039;no&#039;;
    }

    if ( !Cpanel::Server::Type::Role::MailRelay-&gt;is_enabled() ) {
        $enforce_mail_permissions_data = &quot;:fail: This server does not relay mail.&quot;;
        $check_mail_permissions_result = &quot;This server does not relay mail.&quot;;
        return &#039;no&#039;;
    }

    if ( !$domain || $domain eq &#039;&#039; ) {
        my $sender_host_address = Exim::expand_string(&#039;$received_protocol&#039;) eq &#039;local&#039; ? &#039;localhost&#039; : Exim::expand_string(&#039;$sender_host_address&#039;);
        my $recipients_count    = Exim::expand_string(&#039;$recipients_count&#039;);
        my $routed_domain       = Exim::expand_string(&#039;$domain&#039;);
        if ( $sender eq &#039;nobody&#039; &amp;&amp; file_exists(&#039;/etc/webspam&#039;) ) {
            Exim::log_write(&quot;check_mail_permissions could not determine the sender domain for a nobody message [routed_domain=$routed_domain message_exim_id=$message_exim_id sender_host_address=$sender_host_address recipients_count=$recipients_count]&quot;) if $recipients_count &amp;&amp; !getdomainowner($routed_domain);
            $enforce_mail_permissions_data = &#039;:fail: Mail sent by user nobody that cannot be linked to a user is being discarded due to sender restrictions in WHM-&gt;Tweak Settings&#039;;
            $check_mail_permissions_result = &quot;The sender of the message nobody and /etc/webspam exists&quot;;                                                                               # for tests (only set when enforce_mail_permissions_data is empty)

        }
        else {
            Exim::log_write(&quot;check_mail_permissions could not determine the sender domain [routed_domain=$routed_domain message_exim_id=$message_exim_id sender_host_address=$sender_host_address recipients_count=$recipients_count]&quot;) if $recipients_count &amp;&amp; !getdomainowner($routed_domain);

            # If delivery is to a userdomain that its expected that we cannot get the sender domain
            $enforce_mail_permissions_data = &#039;&#039;;                                                                                                                                       # permit normal acction
            $check_mail_permissions_result = &quot;get_message_sender returned no domain&quot;;                                                                                                  # for tests (only set when enforce_mail_permissions_data is empty)

        }

        return &#039;no&#039;;
    }
    else {
        if ( !$message_exim_id ) {

            #Exim::log_write(&quot;check_mail_permissions !DEBUG! got the domain ($domain) of a message before the message id!&quot;);
        }
    }

    #Exim::log_write(&quot;check_mail_permissions !DEBUG! found sender domain of message: $message_exim_id to be $domain with sender [$sender]&quot;);
    $check_mail_permissions_msgid  = $message_exim_id if $message_exim_id;
    $check_mail_permissions_domain = $domain          if $domain;
    $check_mail_permissions_sender = $sender          if $sender;
    $check_mail_permissions_is_mailman = $is_mailman;

    if ( $domain &amp;&amp; $domain ne _SENDER_SYSTEM ) {
        my $now;

        # Just before we check to see if we&#039;ve exceeded the allowable mail counts for this domain,
        # check to see if we need to notify the admin about someone exceeding the warning level
        my $mail_count       = get_current_emails_per_day($domain) + 1;    # +1 for the one we&#039;re *about* to send, but haven&#039;t yet!
        my $emails_to_notify = get_email_daily_limit_notify();
        if ( ( $emails_to_notify &gt; 0 ) &amp;&amp; ( $mail_count &gt; $emails_to_notify ) ) {
            if ( !file_exists( &#039;/var/cpanel/email_send_limits/daily_notify/&#039; . $domain ) ) {
                create_daily_notify_touchfile($domain);
                Exim::log_write(&quot;check_mail_permissions Hit daily email notify limit for domain $domain&quot;);
            }
        }

        if ( file_exists( &#039;/var/cpanel/email_send_limits/max_deferfail_&#039; . $domain ) ) {
            local $/;
            my $limit_data;
            if ( open( my $email_fh, &#039;&lt;&#039;, &#039;/var/cpanel/email_send_limits/max_deferfail_&#039; . $domain ) ) {
                $limit_data = readline($email_fh);
                close($email_fh);
            }
            my ( $currentmail, $maxmails, $percentage ) = $limit_data =~ /([0-9]+)\/([0-9]+)\s+\(([0-9]+)/;

            $currentmail ||= &#039;unknown&#039;;
            $maxmails    ||= &#039;unknown&#039;;
            $percentage  ||= 100;

            $enforce_mail_permissions_data = &quot;:fail: Domain $domain has exceeded the max defers and failures per hour ($currentmail/$maxmails ($percentage\%)) allowed. Message discarded.&quot;;
            return &#039;no&#039;;
        }
        elsif ( my $maxmails = getmaxemailsperhour($domain) ) {
            my $currentmail = get_current_emails_per_hour( $domain, ( $now ||= time() ) );
            if ( $currentmail &gt;= $maxmails ) {
                my $cutoff_percentage = get_email_send_limits_defer_cutoff();
                my $percentage        = int( ( $currentmail / $maxmails ) * 100 );

                if ( $percentage &gt;= $cutoff_percentage ) {
                    $enforce_mail_permissions_data = &quot;:fail: Domain $domain has exceeded the max emails per hour ($currentmail/$maxmails ($percentage\%)) allowed.  Message discarded.&quot;;
                    return &#039;no&#039;;
                }
                else {
                    increment_max_emails_per_hour( $domain, ( $now ||= time() ), $message_exim_id );    # need to count it because we will try it later
                                                                                                        # this will result in percentages above 100% which may be confusing however correct
                                                                                                        # this is how we decide to defer or fail the message
                    return _check_mail_permission_defer_with_message(&quot;Domain $domain has exceeded the max emails per hour ($currentmail/$maxmails ($percentage\%)) allowed.  $reattempt_message&quot;);
                }
            }
        }
        if ( domain_has_outgoing_mail_suspended($domain) ) {

            # We already check this in the ACL, however if the sender domain
            # is forged we have to check it again here to ensure that
            # we are checking against the actual sender and not the
            # domain in the from: field
            $enforce_mail_permissions_data = &quot;:fail: Domain $domain has an outgoing mail suspension.  Message discarded.&quot;;
            return &#039;no&#039;;
        }
        elsif ( domain_has_outgoing_mail_hold($domain) ) {
            track_held_message($domain);
            return _check_mail_permission_defer_with_message(&quot;Domain $domain has an outgoing mail hold.  $reattempt_message&quot;);
        }
        elsif ($sender) {
            if ( user_has_outgoing_mail_suspended($sender) ) {

                # We already check this in the ACL, however if the sender domain
                # is forged we have to check it again here to ensure that
                # we are checking against the actual sender and not the
                # domain in the from: field
                $enforce_mail_permissions_data = &quot;:fail: Sender $sender has an outgoing mail suspension.  Message discarded.&quot;;
                return &#039;no&#039;;
            }
            elsif ( user_has_outgoing_mail_hold($sender) ) {
                track_held_message($sender);
                return _check_mail_permission_defer_with_message(&quot;Sender $sender has an outgoing mail hold.  $reattempt_message&quot;);
            }
        }
    }

    $enforce_mail_permissions_data = &#039;&#039;;                                         # permit normal action
    $check_mail_permissions_result = &quot;reached end of check_mail_permissions&quot;;    # for tests (only set when enforce_mail_permissions_data is empty)

    return &#039;no&#039;;
}

sub _check_mail_permission_defer_with_message {
    my ($message)           = @_;
    my $message_body        = Exim::expand_string(&#039;$message_body&#039;);
    my $message_body_size   = Exim::expand_string(&#039;$message_body_size&#039;);
    my $message_body_length = length($message_body);

    $check_mail_permissions_data =
        qq{# Exim filter\n\nunseen mail }
      . ( $check_mail_permissions_sender ? qq{to } . Cpanel::Encoder::Exim::unquoted_encode_string_literal($check_mail_permissions_sender) . qq{\n} : &#039;&#039; )
      . q{subject &quot;Mail delivery deferred: returning message to sender&quot; }
      . q{from &quot;Mail Delivery System &lt;Mailer-Daemon@$primary_hostname&gt;&quot; }
      . q{text &quot;This message was created automatically by mail delivery software.\n} . q{\n}
      . q{A message that you sent could not be delivered to one or more of its\n}
      . q{recipients. This is a temporary error. The following address(es) deferred:\n} . q{\n}
      . q{  $local_part@$domain\n}
      . qq{    $message} . q{\n\n}
      . q{------- This is a copy of the message, including all the headers. ------\n}
      . ( ( $message_body_length &lt; $message_body_size ) ? ( q{------ The body of the message is $message_body_size characters long; only the first\n} . q{------ } . $message_body_length . q{ or so are included here.\n} ) : () )
      . q{$message_headers\n\n}
      . q{$message_body&quot;}
      . qq{\nfinish};
    $enforce_mail_permissions_data = &quot;:defer: \&quot;$message\&quot;&quot;;
    return &#039;yes&#039;;
}

sub domain_has_outgoing_mail_hold {
    my ($domain) = @_;
    my $user = getdomainowner($domain);
    if ( $user &amp;&amp; user_has_outgoing_mail_hold($user) ) {
        return 1;
    }
    return 0;
}

sub domain_has_outgoing_mail_suspended {
    my ($domain) = @_;
    my $user = getdomainowner($domain);
    if ( $user &amp;&amp; user_has_outgoing_mail_suspended($user) ) {
        return 1;
    }
    return 0;
}

sub user_has_outgoing_mail_suspended {
    my ($user) = @_;
    if ( -e &#039;/etc/outgoing_mail_suspended_users&#039; ) {
        return user_exists_in_db( $user, &#039;/etc/outgoing_mail_suspended_users&#039; );
    }
    return 0;
}

sub user_has_outgoing_mail_hold {
    my ($user) = @_;
    if ( -e &#039;/etc/outgoing_mail_hold_users&#039; ) {
        return user_exists_in_db( $user, &#039;/etc/outgoing_mail_hold_users&#039; );
    }
    return 0;
}

sub check_outgoing_mail_suspended {
    if ( !Cpanel::Server::Type::Role::MailSend-&gt;is_enabled() &amp;&amp; Exim::expand_string(&#039;$sender_host_address&#039;) ) {
        $outgoing_mail_suspended_message = &quot;This server does not relay mail.&quot;;
        return 1;
    }

    my $uid = int( Exim::expand_string(&#039;$originator_uid&#039;) );
    my $gid = int( Exim::expand_string(&#039;$originator_gid&#039;) );
    my ( $sender, $real_domain, $domain, $is_mailman ) = get_message_sender( $uid, $gid, 0 );
    if ( $real_domain &amp;&amp; $real_domain ne _SENDER_SYSTEM &amp;&amp; domain_has_outgoing_mail_suspended($real_domain) ) {
        $outgoing_mail_suspended_message = &quot;Outgoing mail from \&quot;$real_domain\&quot; has been suspended.&quot;;
        return 1;
    }
    elsif ( $sender &amp;&amp; user_has_outgoing_mail_suspended($sender) ) {
        $outgoing_mail_suspended_message = &quot;Outgoing mail from \&quot;$sender\&quot; has been suspended.&quot;;
        return 1;
    }
    return 0;
}

sub get_outgoing_mail_suspended_message {
    return $outgoing_mail_suspended_message;
}

sub increment_max_emails_per_hour_if_needed {

    # Exim::log_write(&quot;!DEBUG! increment_max_emails_per_hour_if_needed entered&quot;);

    if ( $check_mail_permissions_domain &amp;&amp; $check_mail_permissions_domain ne _SENDER_SYSTEM ) {
        if ( Exim::expand_string(&#039;${if first_delivery{1}{0}}&#039;) || ( $check_mail_permissions_msgid &amp;&amp; _get_last_delivery_message($check_mail_permissions_msgid) =~ m/$reattempt_message/o ) ) {

            # if FIRST_DELIVERY or last line of msglog is our $reattempt_message
            # example == f@kos.net R=check_mail_permissions defer (-1): Domain pigdog.org has exceeded the max emails per hour (12/10 (120%)) allowed.  Message will be reattempted later
            # we need to tell the next function to charge us for the message since it was deferred before and we did not get here
            # Exim::log_write(&quot;!DEBUG! increment_max_emails_per_hour=$check_mail_permissions_domain msgid=$check_mail_permissions_msgid&quot;);
            increment_max_emails_per_hour( $check_mail_permissions_domain, time(), $check_mail_permissions_msgid );
        }
    }

    return &#039;no&#039;;
}

sub store_spam {
    my $sender_host_address = shift;
    my $spam_score          = shift;
    my $now                 = time();
    open( my $spam_fh, &#039;&gt;&gt;&#039;, &#039;/var/cpanel/spamstore&#039; );

    #uncomment to deploy
    #    syswrite($spam_fh, $now . &#039;:&#039; . $sender_host_address . &#039;:&#039; . $spam_score . &quot;:.\n&quot;);
    close($spam_fh);
}

sub _get_last_delivery_message {
    my $message_exim_id = shift;
    my ( $last_message, $msglog_file, $msglog_size );
    my $spool_directory       = Exim::expand_string(&#039;$spool_directory&#039;);
    my $spool_split_directory = substr( ( split( /-/, $message_exim_id ) )[0], -1, 1 );

    if ( file_exists(&quot;$spool_directory/msglog/$spool_split_directory/$message_exim_id&quot;) ) {    #split spool
        $msglog_size = ( stat(_) )[7];
        $msglog_file = &quot;$spool_directory/msglog/$spool_split_directory/$message_exim_id&quot;;
    }
    elsif ( file_exists(&quot;$spool_directory/msglog/$message_exim_id&quot;) ) {                        #not split
        $msglog_size = ( stat(_) )[7];
        $msglog_file = &quot;$spool_directory/msglog/$message_exim_id&quot;;
    }
    if ( $msglog_file &amp;&amp; open( my $msg_log_fh, &#039;&lt;&#039;, $msglog_file ) ) {
        seek( $msg_log_fh, $msglog_size - 4096, 0 ) if $msglog_size &gt; 8192;
        local $/;
        $last_message = ( split( /\n/, readline($msg_log_fh) ) )[-1];
    }

    # Exim::log_write(&quot;!DEBUG! _get_last_delivery_message for [$message_exim_id] is $last_message&quot;);

    return $last_message || &#039;&#039;;
}

sub resolve_authenticated_sender {
    my ( $sender, $domain, $sender_lookup_method ) = @_;

    my $sender_address        = Exim::expand_string(&#039;$sender_address&#039;);
    my $sender_address_domain = Exim::expand_string(&#039;$sender_address_domain&#039;);

    # We only want to use the sender in the from header if they have already
    # authenticated with at least the permissions of the account
    my ( $from_h_sender, $from_h_localpart, $from_h_domain ) = _get_from_h_sender();
    $primary_hostname ||= Exim::expand_string(&#039;$primary_hostname&#039;);

    # The user expects to be able to just set the From: headers
    # we try to accomodate that first if they have permissions on the account
    if ( $from_h_domain eq $primary_hostname ) {
        $sender_lookup_method .= &quot;/primary_hostname/system user&quot;;
    }
    elsif ( $sender eq getdomainowner($from_h_domain) ) {
        $sender = $from_h_localpart . &#039;@&#039; . $from_h_domain;
        $domain = $from_h_domain;
        $sender_lookup_method .= &quot;/from_h&quot;;
    }

    # otherwise we fallback to the sender_address_domain
    elsif ( $sender eq getdomainowner($sender_address_domain) ) {
        $sender = $sender_address;
        $domain = $sender_address_domain;
        $sender_lookup_method .= &quot;/sender_address_domain&quot;;
    }
    else {

        # finally we accept that we don&#039;t know who sent it besdies the
        # authenticated user
        $sender_lookup_method .= &quot;/only user confirmed/virtual account not confirmed&quot;;
    }

    return ( $sender, $domain, $sender_lookup_method );
}

sub resolve_vhost_owner {

    if ( file_exists(&#039;/var/cpanel/config/email/trust_x_php_script&#039;) ) {

        if ( my $x_php_script = Exim::expand_string(&#039;$h_x-php-script:&#039;) ) {

            #X-PHP-Script: &lt;servername&gt;&lt;php-self&gt; for &lt;remote-addr&gt;
            #X-PHP-Script: www.example.com/~user/testapp/send-mail.php for 10.0.0.1
            my ( $servername, $uri ) = split( m{/}, $x_php_script, 2 );
            if ( $uri =~ m/^\/?\~([^\/\s]+)/ ) {
                my $http_user = $1;
                my $uid       = user2uid($http_user);

                Exim::log_write(&quot;nobody send identification H=localhost A=127.0.0.1 U=$http_user ID=$uid B=acl_c_vhost_owner M=trust_x_php_script&quot;);
                return $uid . &#039;:&#039; . &#039;//&#039; . $servername . &#039;/&#039; . $uri . &#039; &#039;;
            }
            elsif ( my $http_user = getdomainowner($servername) ) {
                my $uid = user2uid($http_user);

                Exim::log_write(&quot;nobody send identification H=localhost A=127.0.0.1 U=$http_user ID=$uid B=acl_c_vhost_owner M=trust_x_php_script&quot;);
                return $uid . &#039;:&#039; . &#039;//&#039; . $servername . &#039;/&#039; . $uri . &#039; &#039;;
            }
        }
    }

    if ( file_exists(&#039;/var/cpanel/config/email/query_apache_for_nobody_senders&#039;) ) {

        # Lets lookup the real uid by querying apache
        require Cpanel::ProcessInfo;
        require Cpanel::ApacheServerStatus;
        my $server_status = Cpanel::ApacheServerStatus-&gt;new();

        my $httpd_pid;
        my $http_status_data;
        my $current_pid = $$;
        while ( ( $current_pid = Cpanel::ProcessInfo::get_parent_pid($current_pid) ) &amp;&amp; $current_pid != 1 ) {
            if ( my $status_data = $server_status-&gt;get_status_by_pid($current_pid) ) {
                $httpd_pid        = $current_pid;
                $http_status_data = $status_data;
                last;
            }
        }

        if ($http_status_data) {
            my $uri = ( split( /\s+/, $http_status_data-&gt;{&#039;request&#039;} ) )[1];
            if ( $uri =~ m/^\/?\~([^\/\s]+)/ ) {
                my $http_user = $1;
                my $uid       = user2uid($http_user);

                Exim::log_write(&quot;nobody send identification H=localhost A=127.0.0.1 U=$http_user ID=$uid B=acl_c_vhost_owner M=query_apache_for_nobody_senders&quot;);
                return $uid . &#039;:&#039; . &#039;//&#039; . $http_status_data-&gt;{&#039;vhost&#039;} . $uri . &#039; &#039;;
            }
            elsif ( my $http_user = getdomainowner( $http_status_data-&gt;{&#039;vhost&#039;} ) ) {
                my $uid = user2uid($http_user);

                Exim::log_write(&quot;nobody send identification H=localhost A=127.0.0.1 U=$http_user ID=$uid B=acl_c_vhost_owner M=query_apache_for_nobody_senders&quot;);
                return $uid . &#039;:&#039; . &#039;//&#039; . $http_status_data-&gt;{&#039;vhost&#039;} . $uri . &#039; &#039;;
            }
        }

    }

    return;
}

# Obtain the from header from the message
# We fallback to the envelope sender if there
# is no from header set (ie sendmail -bt or missing From header)
sub _get_from_h_sender {
    my $from_h_domain     = Exim::expand_string(&#039;${domain:$h_from:}&#039;);
    my $from_h_local_part = Exim::expand_string(&#039;${local_part:$h_from:}&#039;);

    if ( length $from_h_local_part ) {
        if ( length $from_h_domain ) {
            return ( $from_h_local_part . &#039;@&#039; . $from_h_domain, $from_h_local_part, $from_h_domain );
        }
        else {
            $primary_hostname ||= Exim::expand_string(&#039;$primary_hostname&#039;);
            return ( $from_h_local_part . &#039;@&#039; . $primary_hostname, $from_h_local_part, $primary_hostname );
        }
    }
    else {
        # Handle fallback to sender_address when message is missing a from header
        my $sender_address_domain     = Exim::expand_string(&#039;$sender_address_domain&#039;);
        my $sender_address_local_part = Exim::expand_string(&#039;$sender_address_local_part&#039;);
        return ( $sender_address_local_part . &#039;@&#039; . $sender_address_domain, $sender_address_local_part, $sender_address_domain );
    }
}

my $email_holds_dir = &#039;/var/cpanel/email_holds&#039;;

sub track_held_message {
    my ($holder) = @_;

    if ( -1 != index( $holder, &#039;/&#039; ) ) {
        warn &quot;Holder “$holder” should not have “/” in it!&quot;;
        $holder =~ s/\///g;    #jic
    }

    my $message_exim_id = Exim::expand_string(&#039;$message_exim_id&#039;);
    _check_hold_dir($holder);

    my $path = &quot;$email_holds_dir/track/$holder/$message_exim_id&quot;;

    if ( !-e $path ) {
        if ( $! == _ENOENT() ) {
            open( my $fh, &#039;&gt;&gt;&#039;, $path ) or do {
                warn &quot;open(&gt;&gt;, $path): $!&quot;;
            };
        }
        else {
            warn &quot;stat($path): $!&quot;;
        }
    }

    return 1;
}

sub _mkdir_if_not_exists_or_warn {
    my ( $path, $mode ) = @_;

    mkdir( $path, $mode ) or do {
        if ( $! != _EEXIST() ) {
            warn &quot;mkdir($path, $mode): $!&quot;;
        }

        return undef;
    };

    return 1;
}

sub _check_hold_dir {
    my ($holder) = @_;

    if ( !-e &quot;$email_holds_dir/track/$holder&quot; ) {
        if ( $! == _ENOENT() ) {
            _mkdir_if_not_exists_or_warn( $email_holds_dir,                 0751 );
            _mkdir_if_not_exists_or_warn( &quot;$email_holds_dir/track&quot;,         0750 );
            _mkdir_if_not_exists_or_warn( &quot;$email_holds_dir/track/$holder&quot;, 0750 );
        }
        else {
            warn &quot;stat($email_holds_dir/track/$holder): $!&quot;;
        }
    }

    return;
}


=head2 maskdir($dir)

This function converts a path on the system to a path relative to the users home directory that it contains.   The relative path is prefixed with the user&#039;s primary domain in the below format:

   domain.tld:/public_html/cgi-bin/xyz.cgi

If the path is not contained within a user&#039;s home directory, the path is returned without modification.

=cut

sub maskdir {
    my ($dir) = @_;

    # Try the user first
    my $maskeddir = $dir;
    my ($likely_user) = ( split( m{/}, $dir ) )[2];
    if ( my $likely_homedir = gethomedir($likely_user) ) {
        chop $likely_homedir if substr( $likely_homedir, -1 ) eq &#039;/&#039;;
        if ( rindex( $dir, &quot;$likely_homedir/&quot;, 0 ) == 0 ) {
            substr( $maskeddir, 0, length($likely_homedir), getusersdomain($likely_user) . &quot;:&quot; );
            return $maskeddir;
        }
    }

    # Next try all users in /etc/passwd
    if ( open my $passwd_fh, &#039;&lt;&#039;, &quot;/etc/passwd&quot; ) {
        while ( readline($passwd_fh) ) {
            my ( $homedir, $uid, $user ) = ( split( /:/, $_ ) )[ 0, 2, 5 ];
            next if $uid &lt; 100 || length $homedir &lt; 3;
            chop $homedir if substr( $homedir, -1 ) eq &#039;/&#039;;
            if ( rindex( $dir, &quot;$homedir/&quot;, 0 ) == 0 ) {
                substr( $maskeddir, 0, length($homedir), getusersdomain($user) . &quot;:&quot; );
                return $maskeddir;
            }
        }
    }
    else {
        warn &quot;open(/etc/passwd): $!&quot;;
    }

    return $dir;

}

sub extract_hosts_from_route_list_item {
    my $item = shift;
    my (undef, $hosts, undef) = Exim::parse_route_item($item);
    return $hosts;
}

sub convert_to_hostlist_item {
    my ($item, $separator) = @_;

    $separator //= &#039;\n&#039;;
    $item =~ s/^\s+//;
    $item =~ s/\s+$//;

    # Ignore group separator:
    if ($item eq &#039;+&#039;) {
        $item = &#039;&#039;;
    }

    # Extract bracketed IP address:
    elsif ( $item !~ s/^\[(\S*)\]:\d+$/$1/ ) {

        # If nothing subbed, what&#039;s left is an unbracketed IPv4 or a hostname.
        # Remove port if present:
        $item =~ s/:\d+$//;

        # Finally, if the hostname specified /mx, do a lookup of its MX records and sub in the entire list:
        if ($item =~ s{^(\S+)/mx$}{$1}i) {
            $item = Exim::expand_string(&#039;${lookup dnsdb{&gt;&#039; . $separator . &#039; mxh=&#039; . $item . &#039;}{$value}}&#039;);
        }
    }

    return $item;
}
sub get_suspended_shell {
    my ($user) = @_;
    my $passwd_file_shell = Exim::expand_string( &#039;${extract{6}{:}{${lookup passwd{&#039; . Cpanel::Encoder::Exim::unquoted_encode_string_literal($user) . &#039;}}}}&#039; );
    if ( !length($passwd_file_shell) ) {
        return &#039;&#039;;
    }
    if ( $passwd_file_shell ne &#039;/bin/false&#039; ) {
        return $passwd_file_shell;
    }
    if ( open my $fh, &#039;&lt;&#039;, &quot;/var/cpanel/suspendinfo/${user}&quot; ) {
        while ( my $ln = readline($fh) ) {
            if ( $ln =~ m{\Ashell=\s*(\S+)} ) {
                close $fh;
                return $1;
            }
        }
        close $fh;
    }
    return &#039;/usr/local/cpanel/bin/noshell&#039;;
}
sub is_temp_domain {
    my ($domain) = @_;
    if ( length $domain ) {
        require Cpanel::IP::AutoDomain::TemporaryDomain::Check;
        return 1 if Cpanel::IP::AutoDomain::TemporaryDomain::Check::domain_is_temporary_subdomain($domain);
    }
    return 0;
}

# Untaint a string for exim. This is not a perl untaint
sub untaint {
    return $_[0];
}
require Cpanel::Encoder::Exim;
require Cpanel::Server::Type::Role::MailRelay;
require Cpanel::Server::Type::Role::MailSend;

1;
BEGIN { # Suppress load of all of these at earliest point.
    $INC{&#039;cPstrict.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Encoder/Exim.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/ExceptionMessage.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Locale/Utils/Fallback.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/ExceptionMessage/Raw.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/LoadModule/Utils.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/ScalarUtil.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Exception/CORE.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Pack.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Pack/Template.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Validate/IP/v4.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Validate/IP.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Validate/IP/Expand.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/IP/Expand.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Linux/Netlink.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Linux/Proc/Net/Tcp.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Ident.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Autodie.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Autodie/CORE/exists.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Autodie/CORE/exists_nofollow.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Autodie/More/Lite.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Services/Enabled/Spamd.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/FileUtils/Dir.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/DKIM/ValidityCache.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/IP/Loopback.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Context.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/ProcessInfo.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Fcntl/Constants.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Socket/Constants.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Hulk/Constants.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Fcntl.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Time/Local.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/FileUtils/Open.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Parser/Vars.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Encoder/Tiny/Rare.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Encoder/Tiny.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Regex.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Carp.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Set.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/TimeHiRes.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/SafeFileLock.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/FHUtils/Tiny.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Hash.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/SafeFile/LockInfoCache.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/SafeFile/LockWatcher.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Syscall.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Inotify.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/SafeFile.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/LoadModule.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Linux/Constants.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Validate/FilesystemNodeName.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Notify.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Server/Utils.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Logger.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Debug.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/NSCD/Constants.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Socket/UNIX/Micro.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/NSCD/Check.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/PwCache/Helpers.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/PwCache/Cache.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/LoadFile/ReadFast.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/PwCache/Find.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/JSON/Unicode.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Encoder/ASCII.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/UTF8/Strict.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/JSON.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/JSON/FailOK.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Destruct.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Finally.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Readlink.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/FileUtils/Write.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/FileUtils/Write/JSON/Lazy.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/PwCache/Build.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/PwCache.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/SV.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/SafetyBits/Chown.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/LoadFile.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Slurper.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/ApacheServerStatus.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Sys/Uname.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Sys/Hostname/Fallback.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Sys/Hostname.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Hostname.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/ProductConfig.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/NAT/Object.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/NAT.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Struct/Common/Time.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Struct/timespec.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/NanoStat.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/NanoUtime.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/HiRes.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Path/Normalize.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Hash/Stringify.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/AdminBin/Serializer.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/AdminBin/Serializer/FailOK.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Umask.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Config/LoadConfig.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Config/LoadWwwAcctConf.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/StatCache.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/SafeDir/MK.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/CachedCommand/Utils.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/FindBin.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/CachedCommand/Valid.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/CachedCommand/Save.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/LocaleString.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Errno.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Config/Constants/Perl.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/ChildErrorStringifier.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Env.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/FHUtils/Autoflush.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/FHUtils/OS.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/FHUtils/Blocking.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/IO/Flush.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/ReadMultipleFH.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/ForkAsync.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/SafeRun/Object.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/SafeRun/Env.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/CachedCommand.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/GlobalCache.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/IP/NonlocalBind/Cache.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/FileUtils/TouchFile.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Linux/NetlinkConstants.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Linux/RtNetlink.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/IP/Configured.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/IP/Bound.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/DIp/MainIP.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/StringFunc/Trim.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Encoder/Punycode.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Validate/Domain/Tiny.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Validate/Domain/Normalize.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/IP/AutoDomain/Base.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Version/Tiny.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Version/Full.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Version/Compare.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Version.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/IP/AutoDomain.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/IP/AutoDomain/TemporaryDomain/Constants.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/YAML/Syck.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/YAML.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Transaction/File/Read/YAML.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Transaction/File/BaseReader.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Transaction/File/YAMLReader.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Transaction/File/Read/JSON.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Transaction/File/JSONReader.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/IP/AutoDomain/TemporaryDomain/Check.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Server/Type.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Server/Type/Profile/Constants.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Validate/AnyAllMatcher.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Server/Type/Profile.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Server/Type/Role/EnabledCache.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Server/Type/Role.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Server/Type/Role/TouchFileRole.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Server/Type/Role/MailRelay.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
    $INC{&#039;Cpanel/Server/Type/Role/MailSend.pm&#039;} = &#039;/usr/local/cpanel/tmp/exim.local.build.pl.static&#039;;
}

{ # --- BEGIN cPstrict
package cPstrict;

#                                      Copyright 2024 WebPros International, LLC
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited.

use strict;
use warnings;

=pod

This is importing the following to your namespace

    use strict;
    use warnings;
    use v5.30;

    use feature &#039;signatures&#039;;
    no warnings &#039;experimental::signatures&#039;;

=cut

sub import {
    if ( $] &lt; 5.030 ) {
        require Carp;
        Carp::confess(&quot;cPstrict is being loaded from an unsupported perl ($^X)&quot;);
    }

    # auto import strict and warnings to our caller

    warnings-&gt;import();
    strict-&gt;import();

    require feature;
    feature-&gt;import( &#039;:5.30&#039;, &#039;signatures&#039; );
    warnings-&gt;unimport(&#039;experimental::signatures&#039;);

    return;
}

1;

} # --- END cPstrict


{ # --- BEGIN Cpanel/Encoder/Exim.pm
package Cpanel::Encoder::Exim;


my %encodes = (
    q{\\}  =&gt; q{\\\\\\\\},    #\ -&gt; \\\\
    q{&quot;}   =&gt; q{\\&quot;},         #&quot; -&gt; \&quot;
    q{$}   =&gt; q{\\\\$},       #$ -&gt; \\$
    &quot;\x0a&quot; =&gt; q{\\n},         #newline -&gt; \n
    &quot;\x0d&quot; =&gt; q{\\r},         #carriage return -&gt; \r
    &quot;\x09&quot; =&gt; q{\\t},         #tab =&gt; \t
);

sub encode_string_literal {
    return if !defined $_[0];

    return q{&quot;} . join( q{}, map { $encodes{$_} || $_ } split( m{}, $_[0] ) ) . q{&quot;};
}

sub unquoted_encode_string_literal {
    my $string = shift;
    return if !defined $string;

    $string =~ s/\\N/\\N\\\\N\\N/g;    # Only use / here for perl compat
    return &quot;\\N$string\\N&quot;;
}

1;

} # --- END Cpanel/Encoder/Exim.pm


{ # --- BEGIN Cpanel/ExceptionMessage.pm
package Cpanel::ExceptionMessage;


use strict;
# use Cpanel::Exception (); # perlpkg line 211

*load_perl_module = \&amp;Cpanel::Exception::load_perl_module;

1;

} # --- END Cpanel/ExceptionMessage.pm


{ # --- BEGIN Cpanel/Locale/Utils/Fallback.pm
package Cpanel::Locale::Utils::Fallback;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub interpolate_variables {
    my ( $str, @maketext_opts ) = @_;

    my $c = 1;
    my %h = map { $c++, $_ } @maketext_opts;
    $str =~ s{(\[(?:[^_]+,)?_([0-9])+\])}{$h{$2}}g;
    return $str;
}

1;

} # --- END Cpanel/Locale/Utils/Fallback.pm


{ # --- BEGIN Cpanel/ExceptionMessage/Raw.pm
package Cpanel::ExceptionMessage::Raw;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use base Cpanel::ExceptionMessage (); # perlpkg line 238
our @ISA;
BEGIN { push @ISA, qw(Cpanel::ExceptionMessage); }

# use Cpanel::Locale::Utils::Fallback (); # perlpkg line 211

sub new {
    my ( $class, $str ) = @_;

    my $str_copy = $str;

    return bless( \$str_copy, $class );
}

sub to_string {
    my ($self) = @_;

    return $$self;
}

sub get_language_tag {
    return &#039;en&#039;;
}

BEGIN {
    *Cpanel::ExceptionMessage::Raw::convert_localized_to_raw = *Cpanel::Locale::Utils::Fallback::interpolate_variables;
    *Cpanel::ExceptionMessage::Raw::to_locale_string         = *Cpanel::ExceptionMessage::Raw::to_string;
    *Cpanel::ExceptionMessage::Raw::to_en_string             = *Cpanel::ExceptionMessage::Raw::to_string;
}
1;

} # --- END Cpanel/ExceptionMessage/Raw.pm


{ # --- BEGIN Cpanel/LoadModule/Utils.pm
package Cpanel::LoadModule::Utils;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub module_is_loaded {
    my $p = module_path( $_[0] );
    return 0 unless defined $p;

    return defined $INC{$p} ? 1 : 0;
}

sub module_path {
    my ($module_name) = @_;

    if ( defined $module_name &amp;&amp; length($module_name) ) {
        substr( $module_name, index( $module_name, &#039;::&#039; ), 2, &#039;/&#039; ) while index( $module_name, &#039;::&#039; ) &gt; -1;
        $module_name .= &#039;.pm&#039; unless substr( $module_name, -3 ) eq &#039;.pm&#039;;
    }

    return $module_name;
}

sub is_valid_module_name {
    return $_[0] =~ m/\A[A-Za-z_]\w*(?:(?:&#039;|::)\w+)*\z/ ? 1 : 0;
}

1;

} # --- END Cpanel/LoadModule/Utils.pm


{ # --- BEGIN Cpanel/ScalarUtil.pm
package Cpanel::ScalarUtil;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub blessed {
    return ref( $_[0] ) &amp;&amp; UNIVERSAL::isa( $_[0], &#039;UNIVERSAL&#039; ) || undef;
}

1;

} # --- END Cpanel/ScalarUtil.pm


{ # --- BEGIN Cpanel/Exception/CORE.pm
package Cpanel::Exception::CORE;


1;

package Cpanel::Exception;

use strict;


BEGIN {
    $INC{&#039;Cpanel/Exception.pm&#039;} = &#039;__BYPASSED__&#039;;
}

our $_SUPPRESS_STACK_TRACES = 0;

our $_EXCEPTION_MODULE_PREFIX = &#039;Cpanel::Exception&#039;;
our $IN_EXCEPTION_CREATION    = 0;

our $_suppressed_msg = &#039;__STACK_TRACE_SUPPRESSED__YOU_SHOULD_NEVER_SEE_THIS_MESSAGE__&#039;;

my $PACKAGE = &#039;Cpanel::Exception&#039;;
my $locale;

my @ID_CHARS = qw( a b c d e f g h j k m n p q r s t u v w x y z 2 3 4 5 6 7 8 9 );

my $ID_LENGTH = 6;


# use Cpanel::ExceptionMessage::Raw (); # perlpkg line 211
# use Cpanel::LoadModule::Utils     (); # perlpkg line 211

use constant _TRUE =&gt; 1;

use overload (
    &#039;&quot;&quot;&#039;     =&gt; \&amp;__spew,
    bool     =&gt; \&amp;_TRUE,
    fallback =&gt; 1,
);

BEGIN {
    die &quot;Cannot compile Cpanel::Exception::CORE&quot; if $INC{&#039;B/C.pm&#039;} &amp;&amp; $0 !~ m{cpkeyclt|cpsrvd\.so|t/large};
}

sub _init { return 1 }    # legacy


sub create {
    my ( $exception_type, @args ) = @_;

    _init();

    if ($IN_EXCEPTION_CREATION) {
        _load_cpanel_carp();
        die &#039;Cpanel::Carp&#039;-&gt;can(&#039;safe_longmess&#039;)-&gt;(&quot;Attempted to create a “$exception_type” exception with arguments “@args” while creating exception “$IN_EXCEPTION_CREATION-&gt;[0]” with arguments “@{$IN_EXCEPTION_CREATION-&gt;[1]}”.&quot;);
    }
    local $IN_EXCEPTION_CREATION = [ $exception_type, \@args ];

    if ( $exception_type !~ m/\A[A-Za-z0-9_]+(?:\:\:[A-Za-z0-9_]+)*\z/ ) {
        die &quot;Invalid exception type: $exception_type&quot;;
    }

    my $perl_class;
    if ( $exception_type eq __PACKAGE__ ) {
        $perl_class = $exception_type;
    }
    else {
        $perl_class = &quot;${_EXCEPTION_MODULE_PREFIX}::$exception_type&quot;;
    }

    _load_perl_module($perl_class) unless $perl_class-&gt;can(&#039;new&#039;);

    if ( $args[0] &amp;&amp; ref $args[0] eq &#039;ARRAY&#039; &amp;&amp; scalar @{ $args[0] } &gt; 1 ) {
        $args[0] = { @{ $args[0] } };
    }

    return $perl_class-&gt;new(@args);
}


sub create_raw {
    my ( $class, $msg, @extra_args ) = @_;

    _init();

    my $msg_obj = &#039;Cpanel::ExceptionMessage::Raw&#039;-&gt;new($msg);

    if ( $class =~ m&lt;\A(?:\Q${_EXCEPTION_MODULE_PREFIX}::\E)?Collection\z&gt; ) {
        die &quot;Use create(&#039;Collection&#039;, ..) to create a Cpanel::Exception::Collection object.&quot;;
    }

    return create( $class, $msg_obj, @extra_args );
}

sub _load_perl_module {
    my ($module) = @_;

    local ( $!, $@ );

    if ( !defined $module ) {
        die __PACKAGE__-&gt;new( &#039;Cpanel::ExceptionMessage::Raw&#039;-&gt;new(&quot;load_perl_module requires a module name.&quot;) );
    }

    return 1 if Cpanel::LoadModule::Utils::module_is_loaded($module);

    my $module_name = $module;
    $module_name =~ s{\.pm$}{};

    if ( !Cpanel::LoadModule::Utils::is_valid_module_name($module_name) ) {
        die __PACKAGE__-&gt;new( &#039;Cpanel::ExceptionMessage::Raw&#039;-&gt;new(&quot;load_perl_module requires a valid module name: &#039;$module_name&#039;.&quot;) );
    }

    {
        eval qq{use $module (); 1 }
          or die __PACKAGE__-&gt;new( &#039;Cpanel::ExceptionMessage::Raw&#039;-&gt;new(&quot;load_perl_module cannot load &#039;$module_name&#039;: $@&quot;) )
    }

    return 1;
}

sub new {
    my ( $class, @args ) = @_;

    @args = grep { defined } @args;

    my $self = {};

    bless $self, $class;

    if ( ref $args[-1] eq &#039;HASH&#039; ) {
        $self-&gt;{&#039;_metadata&#039;} = pop @args;
    }

    if ( defined $self-&gt;{&#039;_metadata&#039;}-&gt;{&#039;longmess&#039;} ) {
        $self-&gt;{&#039;_longmess&#039;} = &amp;{ $self-&gt;{&#039;_metadata&#039;}-&gt;{&#039;longmess&#039;} }($self)
          if $self-&gt;{&#039;_metadata&#039;}-&gt;{&#039;longmess&#039;};
    }
    elsif ($_SUPPRESS_STACK_TRACES) {
        $self-&gt;{&#039;_longmess&#039;} = $_suppressed_msg;
    }
    else {
        if ( !$INC{&#039;Carp.pm&#039;} ) { _load_carp(); }
        $self-&gt;{&#039;_longmess&#039;} = scalar do {

            local $Carp::CarpInternal{&#039;Cpanel::Exception&#039;} = 1;
            local $Carp::CarpInternal{$class} = 1;

            &#039;Carp&#039;-&gt;can(&#039;longmess&#039;)-&gt;();
        };
    }

    _init();

    $self-&gt;{&#039;_auxiliaries&#039;} = [];

    if ( UNIVERSAL::isa( $args[0], &#039;Cpanel::ExceptionMessage&#039; ) ) {
        $self-&gt;{&#039;_message&#039;} = shift @args;
    }
    else {
        my @mt_args;

        if ( @args &amp;&amp; !ref $args[0] ) {
            @mt_args = ( shift @args );

            if ( ref $args[0] eq &#039;ARRAY&#039; ) {
                push @mt_args, @{ $args[0] };
            }
        }
        else {

            $self-&gt;{&#039;_orig_mt_args&#039;} = $args[0];

            my $phrase = $self-&gt;_default_phrase( $args[0] );

            if ($phrase) {

                if ( ref $phrase ) {
                    @mt_args = $phrase-&gt;to_list();
                }

                else {
                    $self-&gt;{&#039;_message&#039;} = Cpanel::ExceptionMessage::Raw-&gt;new($phrase);
                    return $self;
                }
            }
        }

        if ( my @extras = grep { !ref } @args ) {
            die __PACKAGE__-&gt;new( &#039;Cpanel::ExceptionMessage::Raw&#039;-&gt;new(&quot;Extra scalar(s) passed to $PACKAGE! (@extras)&quot;) );
        }

        if ( !length $mt_args[0] ) {
            die __PACKAGE__-&gt;new( &#039;Cpanel::ExceptionMessage::Raw&#039;-&gt;new(&quot;No args passed to $PACKAGE constructor!&quot;) );
        }

        $self-&gt;{&#039;_mt_args&#039;} = \@mt_args;
    }

    return $self;
}


sub get_string {
    my ( $exc, $no_id_yn ) = @_;

    return get_string_no_id($exc) if $no_id_yn;

    return _get_string( $exc, &#039;to_string&#039; );
}


sub get_string_no_id {
    my ($exc) = @_;

    return _get_string( $exc, &#039;to_string_no_id&#039; );
}

sub _get_string {
    my ( $exc, $cp_exc_stringifier_name ) = @_;

    return $exc if !ref $exc;

    {
        local $@;
        my $ret = eval { $exc-&gt;$cp_exc_stringifier_name() };
        return $ret if defined $ret &amp;&amp; !$@ &amp;&amp; !ref $ret;
    }

    if ( ref $exc eq &#039;HASH&#039; &amp;&amp; $exc-&gt;{&#039;message&#039;} ) {
        return $exc-&gt;{&#039;message&#039;};
    }

    if ( $INC{&#039;Cpanel/YAML.pm&#039;} ) {
        local $@;
        my $ret = eval { &#039;Cpanel::YAML&#039;-&gt;can(&#039;Dump&#039;)-&gt;($exc); };
        return $ret if defined $ret &amp;&amp; !$@;
    }

    if ( $INC{&#039;Cpanel/JSON.pm&#039;} ) {
        local $@;
        my $ret = eval { &#039;Cpanel::JSON&#039;-&gt;can(&#039;Dump&#039;)-&gt;($exc); };
        return $ret if defined $ret &amp;&amp; !$@;
    }

    return $exc;
}


sub _create_id {

    srand();

    return join(
        q&lt;&gt;,
        map { $ID_CHARS[ int rand( 0 + @ID_CHARS ) ]; } ( 1 .. $ID_LENGTH ),
    );
}

sub get_stack_trace_suppressor {
    return Cpanel::Exception::_StackTraceSuppression-&gt;new();
}


sub set_id {
    my ( $self, $new_id ) = @_;
    $self-&gt;{&#039;_id&#039;} = $new_id;
    return $self;
}


sub id {
    my ($self) = @_;

    return $self-&gt;{&#039;_id&#039;} ||= _create_id();
}


sub set {
    my ( $self, $key ) = @_;

    $self-&gt;{&#039;_metadata&#039;}{$key} = $_[2];

    if ( exists $self-&gt;{&#039;_orig_mt_args&#039;} ) {
        my $phrase = $self-&gt;_default_phrase( $self-&gt;{&#039;_orig_mt_args&#039;} );

        if ($phrase) {
            if ( ref $phrase ) {
                $self-&gt;{&#039;_mt_args&#039;} = [ $phrase-&gt;to_list() ];
                undef $self-&gt;{&#039;_message&#039;};
            }
            else {
                $self-&gt;{&#039;_message&#039;} = Cpanel::ExceptionMessage::Raw-&gt;new($phrase);
            }
        }
    }

    return $self;
}


sub get {
    my ( $self, $key ) = @_;

    my $v = $self-&gt;{&#039;_metadata&#039;}{$key};

    if ( my $reftype = ref $v ) {
        local $@;
        if ( $reftype eq &#039;HASH&#039; ) {
            $v = { %{$v} };    # shallow copy
        }
        elsif ( $reftype eq &#039;ARRAY&#039; ) {
            $v = [ @{$v} ];    # shallow copy
        }
        elsif ( $reftype eq &#039;SCALAR&#039; ) {
            $v = \${$v};       # shallow copy
        }
        else {
            local ( $@, $! );
            require Cpanel::ScalarUtil;

            if ( $reftype ne &#039;GLOB&#039; &amp;&amp; !Cpanel::ScalarUtil::blessed($v) ) {

                warn if !eval {
                    _load_perl_module(&#039;Clone&#039;) if !$INC{&#039;Clone.pm&#039;};
                    $v = &#039;Clone&#039;-&gt;can(&#039;clone&#039;)-&gt;($v);
                };
            }
        }
    }

    return $v;
}


sub get_all_metadata {
    my $self = shift;
    my %metadata_copy;
    for my $key ( keys %{ $self-&gt;{&#039;_metadata&#039;} } ) {
        $metadata_copy{$key} = $self-&gt;get($key);
    }
    return \%metadata_copy;
}

my $loaded_LocaleString;

sub _require_LocaleString {
    return $loaded_LocaleString ||= do {
        local $@;
        eval &#039;require Cpanel::LocaleString; 1;&#039; or die $@;    ## no critic qw(BuiltinFunctions::ProhibitStringyEval) -  # PPI NO PARSE - load on demand
        1;
    };
}

my $loaded_ExceptionMessage_Locale;

sub _require_ExceptionMessage_Locale {
    return $loaded_ExceptionMessage_Locale ||= do {
        local $@;
        eval &#039;require Cpanel::ExceptionMessage::Locale; 1;&#039; or die $@;    ## no critic qw(BuiltinFunctions::ProhibitStringyEval) - # PPI NO PARSE - load on demand
        1;
    };
}

sub _default_phrase {
    _require_LocaleString();
    return &#039;Cpanel::LocaleString&#039;-&gt;new( &#039;An unknown error in the “[_1]” package has occurred.&#039;, scalar ref $_[0] );    # PPI NO PARSE - loaded above
}


sub longmess {
    my ($self) = @_;

    return &#039;&#039;           if $self-&gt;{&#039;_longmess&#039;} eq $_suppressed_msg;
    _load_cpanel_carp() if !$INC{&#039;Cpanel/Carp.pm&#039;};
    return Cpanel::Carp::sanitize_longmess( $self-&gt;{&#039;_longmess&#039;} );
}


sub to_string {
    my ($self) = @_;

    return _apply_id_prefix( $self-&gt;id(), $self-&gt;to_string_no_id() );
}

sub to_string_no_id {
    my ($self) = @_;

    my $string = $self-&gt;to_locale_string_no_id();

    if ( $self-&gt;_message()-&gt;get_language_tag() ne &#039;en&#039; ) {
        my $en_string = $self-&gt;to_en_string_no_id();
        $string .= &quot;\n$en_string&quot; if ( $en_string ne $string );
    }

    return $string;
}

sub _apply_id_prefix {
    my ( $id, $msg ) = @_;

    return sprintf &quot;(XID %s) %s&quot;, $id, $msg;
}


sub to_en_string {
    my ($self) = @_;

    return _apply_id_prefix( $self-&gt;id(), $self-&gt;to_en_string_no_id() );
}

sub to_en_string_no_id {
    my ($self) = @_;

    return $self-&gt;_message()-&gt;to_en_string() . $self-&gt;_stringify_auxiliaries(&#039;to_en_string&#039;);
}


sub to_locale_string {
    my ($self) = @_;

    return _apply_id_prefix( $self-&gt;id(), $self-&gt;to_locale_string_no_id() );
}

sub to_locale_string_no_id {
    my ($self) = @_;

    return $self-&gt;_message()-&gt;to_locale_string() . $self-&gt;_stringify_auxiliaries(&#039;to_locale_string&#039;);
}


sub add_auxiliary_exception {
    my ( $self, $aux ) = @_;

    return push @{ $self-&gt;{&#039;_auxiliaries&#039;} }, $aux;
}


sub get_auxiliary_exceptions {
    my ($self) = @_;

    die &#039;List context only!&#039; if !wantarray;    #Can’t use Cpanel::Context

    return @{ $self-&gt;{&#039;_auxiliaries&#039;} };
}

sub __spew {
    my ($self) = @_;

    return $self-&gt;_spew();
}

sub _spew {
    my ($self) = @_;

    return ref($self) . &#039;/&#039; . join &quot;\n&quot;, $self-&gt;to_string() || &#039;&lt;no message&gt;&#039;, $self-&gt;longmess() || ();
}

sub _stringify_auxiliaries {
    my ( $self, $method ) = @_;

    my @lines;

    if ( @{ $self-&gt;{&#039;_auxiliaries&#039;} } ) {

        local $@;

        _require_LocaleString();

        my $intro = &#039;Cpanel::LocaleString&#039;-&gt;new( &#039;The following additional [numerate,_1,error,errors] occurred:&#039;, 0 + @{ $self-&gt;{&#039;_auxiliaries&#039;} } );    # PPI NO PARSE - required above

        if ( $method eq &#039;to_locale_string&#039; ) {
            push @lines, _locale()-&gt;makevar( $intro-&gt;to_list() );
        }
        elsif ( $method eq &#039;to_en_string&#039; ) {
            push @lines, _locale()-&gt;makethis_base( $intro-&gt;to_list() );
        }
        else {
            die &quot;Invalid method: $method&quot;;
        }

        push @lines, map { UNIVERSAL::isa( $_, __PACKAGE__ ) ? $_-&gt;$method() : $_ } @{ $self-&gt;{&#039;_auxiliaries&#039;} };
    }

    return join q&lt;&gt;, map { &quot;\n$_&quot; } @lines;
}

*TO_JSON = \&amp;to_string;

sub _locale {
    return $locale ||= do {

        local $@;

        eval &#039;require Cpanel::Locale; 1;&#039; or die $@;

        &#039;Cpanel::Locale&#039;-&gt;get_handle();    # hide from perlcc
    };
}

sub _reset_locale {
    return undef $locale;
}

sub _load_carp {
    if ( !$INC{&#039;Carp.pm&#039;} ) {

        local $@;
        eval &#039;require Carp; 1;&#039; or die $@;    ## no critic qw(BuiltinFunctions::ProhibitStringyEval) -- hide from perlcc
    }

    return;
}

sub _load_cpanel_carp {
    if ( !$INC{&#039;Cpanel/Carp.pm&#039;} ) {

        local $@;
        eval &#039;require Cpanel::Carp; 1;&#039; or die $@;    ## no critic qw(BuiltinFunctions::ProhibitStringyEval) -- hide from perlcc
    }

    return;
}

sub _message {
    my ($self) = @_;

    return $self-&gt;{&#039;_message&#039;} if $self-&gt;{&#039;_message&#039;};

    local $!;
    if ($Cpanel::Exception::LOCALIZE_STRINGS) {    # the default
        _require_ExceptionMessage_Locale();
        return ( $self-&gt;{&#039;_message&#039;} ||= &#039;Cpanel::ExceptionMessage::Locale&#039;-&gt;new( @{ $self-&gt;{&#039;_mt_args&#039;} } ) );    # PPI NO PARSE - required above
    }

    return ( $self-&gt;{&#039;_message&#039;} ||= Cpanel::ExceptionMessage::Raw-&gt;new( Cpanel::ExceptionMessage::Raw::convert_localized_to_raw( @{ $self-&gt;{&#039;_mt_args&#039;} } ) ) );
}


package Cpanel::Exception::_StackTraceSuppression;

sub new {
    my ($class) = @_;

    $Cpanel::Exception::_SUPPRESS_STACK_TRACES++;

    return bless [], $class;
}

sub DESTROY {
    $Cpanel::Exception::_SUPPRESS_STACK_TRACES--;
    return;
}

1;

} # --- END Cpanel/Exception/CORE.pm


{ # --- BEGIN Cpanel/Pack.pm
package Cpanel::Pack;


use strict;

sub new {
    my ( $class, $template_ar ) = @_;

    if ( @$template_ar % 2 ) {
        die &quot;Cpanel::Pack::new detected an odd number of elements in hash assignment!&quot;;
    }

    my $self = bless {
        &#039;template_str&#039; =&gt; &#039;&#039;,
        &#039;keys&#039;         =&gt; [],
    }, $class;

    my $ti = 0;
    while ( $ti &lt; $#$template_ar ) {
        push @{ $self-&gt;{&#039;keys&#039;} }, $template_ar-&gt;[$ti];
        $self-&gt;{&#039;template_str&#039;} .= $template_ar-&gt;[ 1 + $ti ];
        $ti += 2;
    }

    return $self;
}

sub unpack_to_hashref {    ## no critic (RequireArgUnpacking)
    my %result;
    @result{ @{ $_[0]-&gt;{&#039;keys&#039;} } } = unpack( $_[0]-&gt;{&#039;template_str&#039;}, $_[1] );
    return \%result;
}

sub pack_from_hashref {
    my ( $self, $opts_ref ) = @_;
    no warnings &#039;uninitialized&#039;;
    return pack( $self-&gt;{&#039;template_str&#039;}, @{$opts_ref}{ @{ $self-&gt;{&#039;keys&#039;} } } );
}

sub sizeof {
    my ($self) = @_;
    return ( $self-&gt;{&#039;sizeof&#039;} ||= length pack( $self-&gt;{&#039;template_str&#039;}, () ) );
}

sub malloc {
    my ($self) = @_;

    return pack( $self-&gt;{&#039;template_str&#039;} );
}

1;

} # --- END Cpanel/Pack.pm


{ # --- BEGIN Cpanel/Pack/Template.pm
package Cpanel::Pack::Template;


use strict;
use warnings;
no warnings &#039;once&#039;;


use constant PACK_TEMPLATE_INT           =&gt; &#039;i&#039;;
use constant PACK_TEMPLATE_UNSIGNED_INT  =&gt; &#039;i!&#039;;
use constant PACK_TEMPLATE_UNSIGNED_LONG =&gt; &#039;L!&#039;;
use constant PACK_TEMPLATE_U32           =&gt; &#039;L&#039;;
use constant U32_BYTES_LENGTH            =&gt; 4;
use constant PACK_TEMPLATE_U16           =&gt; &#039;S&#039;;
use constant U16_BYTES_LENGTH            =&gt; 2;
use constant PACK_TEMPLATE_U8            =&gt; &#039;C&#039;;
use constant U8_BYTES_LENGTH             =&gt; 1;
use constant PACK_TEMPLATE_BE16          =&gt; &#039;n&#039;;
use constant PACK_TEMPLATE_BE32          =&gt; &#039;N&#039;;

1;

} # --- END Cpanel/Pack/Template.pm


{ # --- BEGIN Cpanel/Validate/IP/v4.pm
package Cpanel::Validate::IP::v4;


use strict;
use warnings;
no warnings &#039;once&#039;;

sub is_valid_ipv4 {
    my ($ip) = @_;
    return unless $ip;    # False scalars are never an _[0].

    my @segments = split /\./, $ip, -1;
    return unless scalar @segments == 4;

    my $octet_index;
    for my $octet_value (@segments) {
        return if !_valid_octet( $octet_value, ++$octet_index );
    }

    return 1;
}

sub is_valid_cidr4 {
    my ($ip) = @_;

    return unless defined $ip &amp;&amp; $ip;
    my ( $ip4, $mask ) = split /\//, $ip;
    return if !defined $mask || !length $mask || $mask =~ tr/0-9//c;

    return is_valid_ipv4($ip4) &amp;&amp; 0 &lt; $mask &amp;&amp; $mask &lt;= 32;
}

sub _valid_octet {
    my ( $octet_value, $octet_index ) = @_;
    return (
        !length $octet_value                                                ||    #
          $octet_value =~ tr/0-9//c                                         ||    #
          $octet_value &gt; 255                                                ||    #
          ( substr( $octet_value, 0, 1 ) == 0 &amp;&amp; length($octet_value) &gt; 1 ) ||    # Only dec values are permitted
          $octet_index == 1 &amp;&amp; length($octet_value) &amp;&amp; !$octet_value              # First oct can&#039;t be zero.
    ) ? 0 : 1;
}

1;

} # --- END Cpanel/Validate/IP/v4.pm


{ # --- BEGIN Cpanel/Validate/IP.pm
package Cpanel::Validate::IP;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Validate::IP::v4 (); # perlpkg line 211

sub is_valid_ipv6 {
    my ($ip) = @_;
    return unless defined $ip &amp;&amp; $ip;

    if (   ( substr( $ip, 0, 1 ) eq &#039;:&#039; &amp;&amp; substr( $ip, 1, 1 ) ne &#039;:&#039; )
        || ( substr( $ip, -1, 1 ) eq &#039;:&#039; &amp;&amp; substr( $ip, -2, 1 ) ne &#039;:&#039; ) ) {
        return;    # Can&#039;t have single : on front or back
    }

    my @seg = split /:/, $ip, -1;    # -1 to keep trailing empty fields

    shift @seg if $seg[0] eq &#039;&#039;;
    pop @seg   if $seg[-1] eq &#039;&#039;;

    my $max = 8;
    if ( index( $seg[-1], &#039;.&#039; ) &gt; -1 ) {
        return unless Cpanel::Validate::IP::v4::is_valid_ipv4( pop @seg );
        $max -= 2;
    }

    my $cmp;
    for my $seg (@seg) {
        if ( !defined $seg || $seg eq &#039;&#039; ) {

            return if $cmp;
            ++$cmp;
            next;
        }
        return if $seg =~ tr/0-9a-fA-F//c || length $seg == 0 || length $seg &gt; 4;
    }
    if ($cmp) {

        return ( @seg &amp;&amp; @seg &lt;= $max ) ? 1 : ();
    }

    return $max == @seg ? 1 : ();
}

sub is_valid_ipv6_prefix {
    my ($ip) = @_;
    return unless $ip;
    my ( $ip6, $mask ) = split /\//, $ip;
    return unless defined $mask;
    return if !length $mask || $mask =~ tr/0-9//c;
    return is_valid_ipv6($ip6) &amp;&amp; 0 &lt; $mask &amp;&amp; $mask &lt;= 128;
}

sub is_valid_ip {
    return !defined $_[0] ? undef : index( $_[0], &#039;:&#039; ) &gt; -1 ? is_valid_ipv6(@_) : Cpanel::Validate::IP::v4::is_valid_ipv4(@_);
}

sub ip_version {
    return 4 if Cpanel::Validate::IP::v4::is_valid_ipv4(@_);
    return 6 if is_valid_ipv6(@_);
    return;
}

sub is_valid_ip_cidr_or_prefix {
    return unless defined $_[0];
    if ( $_[0] =~ tr/:// ) {
        return $_[0] =~ tr{/}{} ? is_valid_ipv6_prefix(@_) : is_valid_ipv6(@_);
    }
    return $_[0] =~ tr{/}{} ? Cpanel::Validate::IP::v4::is_valid_cidr4(@_) : Cpanel::Validate::IP::v4::is_valid_ipv4(@_);
}

sub is_valid_ip_range_cidr_or_prefix {
    my $str = shift;
    return 0 if !$str;
    return 1 if is_valid_ip_cidr_or_prefix($str);

    my ( $from, $to ) = split /-/, $str, 2;
    return 0 if !length $from || !length $to;

    if ( Cpanel::Validate::IP::v4::is_valid_ipv4($from) ) {
        return _is_ipv4_fragment($to) ? 1 : 0;
    }
    if ( Cpanel::Validate::IP::v4::is_valid_ipv4($to) ) {
        return _is_ipv4_fragment($from) ? 1 : 0;
    }

    return is_valid_ipv6($from) &amp;&amp; is_valid_ipv6($to) ? 1 : 0;
}

sub _is_ipv4_fragment {
    my ($value) = @_;

    my @octets = split m{\.}, $value, -1;
    return 0 if !@octets || @octets &gt; 4;

    return Cpanel::Validate::IP::v4::is_valid_ipv4($value) ? 1 : 0 if @octets == 4;

    return 0 if grep { !length || tr/0-9//c || $_ &gt; 255 } @octets;
    return 0 if grep { length &gt; 1 &amp;&amp; substr( $_, 0, 1 ) eq &#039;0&#039; } @octets;

    return 1;
}

1;

} # --- END Cpanel/Validate/IP.pm


{ # --- BEGIN Cpanel/Validate/IP/Expand.pm
package Cpanel::Validate::IP::Expand;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Validate::IP     (); # perlpkg line 211
# use Cpanel::Validate::IP::v4 (); # perlpkg line 211

sub normalize_ipv4 {
    return unless Cpanel::Validate::IP::v4::is_valid_ipv4( $_[0] );
    return join &#039;.&#039;, map { $_ + 0 } split /\./, $_[0];
}

sub expand_ipv6 {
    my $ip = shift;

    return unless Cpanel::Validate::IP::is_valid_ipv6($ip);

    return $ip if length $ip == 39;    # already expanded

    my @seg = split /:/, $ip, -1;

    $seg[0]  = &#039;0000&#039; if !length $seg[0];
    $seg[-1] = &#039;0000&#039; if !length $seg[-1];

    if ( $seg[-1] =~ tr{.}{} &amp;&amp; Cpanel::Validate::IP::v4::is_valid_ipv4( $seg[-1] ) ) {
        my @ipv4 = split /\./, normalize_ipv4( pop @seg );
        push @seg, sprintf( &#039;%04x&#039;, ( $ipv4[0] &lt;&lt; 8 ) + $ipv4[1] ), sprintf( &#039;%04x&#039;, ( $ipv4[2] &lt;&lt; 8 ) + $ipv4[3] );
    }
    my @exp;
    for my $seg (@seg) {
        if ( !length $seg ) {
            my $count = scalar(@seg) - scalar(@exp);
            while ( $count + scalar(@exp) &lt;= 8 ) {
                push @exp, &#039;0000&#039;;
            }
        }
        else {
            push @exp, sprintf( &#039;%04x&#039;, hex $seg );
        }
    }
    return join &#039;:&#039;, @exp;
}

sub normalize_ipv6 {
    my $ip = shift;

    return unless $ip = expand_ipv6($ip);

    $ip = lc($ip);

    $ip =~ s/:(0+:){2,}/::/;         # flatten multiple groups of 0&#039;s to :: #
    $ip =~ s/(:0+){2,}$/::/;         # flatten multiple groups of 0&#039;s to :: #
    $ip =~ s/^0+([1-9a-f])/$1/;      # flatten the first segment&#039;s leading 0&#039;s to a single 0 #
    $ip =~ s/:0+([1-9a-f])/:$1/g;    # flatten each segment, after the first, leading 0&#039;s to a single 0 #
    $ip =~ s/:0+(:)/:0$1/g;          # flatten any segments that are just 0&#039;s to a single 0 #
    $ip =~ s/:0+$/:0/g;              # flatten the end segment if it&#039;s just 0&#039;s to a single 0 #
    $ip =~ s/^0+::/::/;              # remove single 0 at the beginning #
    $ip =~ s/::0+$/::/;              # remote single 0 at the end #

    return $ip;

}

sub normalize_ip {
    return !defined $_[0] ? undef : index( $_[0], &#039;:&#039; ) &gt; -1 ? normalize_ipv6( $_[0] ) : normalize_ipv4( $_[0] );
}

sub expand_ip {
    return !defined $_[0] ? undef : index( $_[0], &#039;:&#039; ) &gt; -1 ? expand_ipv6( $_[0] ) : normalize_ipv4( $_[0] );
}

1;

} # --- END Cpanel/Validate/IP/Expand.pm


{ # --- BEGIN Cpanel/IP/Expand.pm
package Cpanel::IP::Expand;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Validate::IP::v4     (); # perlpkg line 211
# use Cpanel::Validate::IP::Expand (); # perlpkg line 211

sub expand_ip {
    my ( $ip, $version ) = @_;

    $ip =~ tr{ \r\n\t}{}d if defined $ip;

    if ( defined $version &amp;&amp; $version eq 6 &amp;&amp; Cpanel::Validate::IP::v4::is_valid_ipv4($ip) ) {
        my @ipv4 = map { $_ + 0 } split /\./, $ip;
        return &quot;0000:0000:0000:0000:0000:ffff:&quot; . sprintf( &#039;%04x&#039;, ( $ipv4[0] &lt;&lt; 8 ) + $ipv4[1] ) . &#039;:&#039; . sprintf( &#039;%04x&#039;, ( $ipv4[2] &lt;&lt; 8 ) + $ipv4[3] );
    }

    my $expanded = Cpanel::Validate::IP::Expand::expand_ip($ip);

    return $expanded if $expanded;

    if ( defined $version &amp;&amp; $version eq 6 || $ip =~ m/:/ ) {
        return &#039;0000:0000:0000:0000:0000:0000:0000:0000&#039;;
    }
    return &#039;0.0.0.0&#039;;
}

sub ip2binary_string {
    my $ip = shift || &#039;&#039;;

    if ( $ip =~ tr/:// ) {
        $ip = expand_ip( $ip, 6 );
        $ip =~ tr&lt;:&gt;&lt;&gt;d;
        return unpack( &#039;B128&#039;, pack( &#039;H32&#039;, $ip ) );
    }

    return unpack( &#039;B32&#039;, pack( &#039;C4C4C4C4&#039;, split( /\./, $ip ) ) );
}

sub first_last_ip_in_range {
    my ($range) = @_;

    my ( $range_firstip, $mask ) = split( m{/}, $range );

    if ( !length $mask ) {
        die &quot;Invalid input ($range) -- must be CIDR!&quot;;
    }

    my $mask_offset = 0;

    if ( $range_firstip !~ tr/:// ) {    # match as if it were an embedded ipv4 in ipv6
        $range_firstip = expand_ip( $range_firstip, 6 );
        $mask_offset   = ( 128 - 32 );                     # If we convert the range from ipv4 to ipv6 we need to move the mask
    }

    my $size = 128;

    my $range_firstip_binary_string = ip2binary_string($range_firstip);
    my $range_lastip_binary_string  = substr( $range_firstip_binary_string, 0, $mask + $mask_offset ) . &#039;1&#039; x ( $size - $mask - $mask_offset );

    return ( $range_firstip_binary_string, $range_lastip_binary_string );
}

1;

} # --- END Cpanel/IP/Expand.pm


{ # --- BEGIN Cpanel/Linux/Netlink.pm
package Cpanel::Linux::Netlink;


use strict;
use warnings;
no warnings &#039;once&#039;;

use constant DEBUG =&gt; 0;

# use Cpanel::Exception      (); # perlpkg line 211
# use Cpanel::Pack           (); # perlpkg line 211
# use Cpanel::Pack::Template (); # perlpkg line 211

my $NETLINK_READ_SIZE = 262144;    # Maximum size of netlink message

use constant PAGE_SIZE =&gt; 0x400;
use constant READ_SIZE =&gt; 8 * PAGE_SIZE;

our $PF_NETLINK = 16;
our $AF_INET    = 2;
our $AF_INET6   = 10;

our $NLMSG_NOOP    = 0x1;
our $NLMSG_ERROR   = 0x2;
our $NLMSG_DONE    = 0x3;
our $NLMSG_OVERRUN = 0x4;

our $NETLINK_INET_DIAG_26_KERNEL = 0;

our $NETLINK_INET_DIAG = 4;
our $NLM_F_REQUEST     = 1;
our $NLM_F_MULTI       = 2;        # /* Multipart message, terminated by NLMSG_DONE */
our $NLM_F_ROOT        = 0x100;
our $NLM_F_MATCH       = 0x200;    # in queries, return all matches
our $NLM_F_EXCL        = 0x200;    # in commands, don&#039;t alter if it exists
our $NLM_F_CREATE      = 0x400;    # in commands, create if it does not exist

our $NLM_F_ACK          = 4;
our $SOCK_DGRAM         = 2;
our $TCPDIAG_GETSOCK    = 18;
our $INET_DIAG_NOCOOKIE = 0xFFFFFFFF;

use constant {
    PACK_TEMPLATE_U16 =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U16,
    U16_BYTES_LENGTH  =&gt; Cpanel::Pack::Template::U16_BYTES_LENGTH,
    PACK_TEMPLATE_U32 =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,
    U32_BYTES_LENGTH  =&gt; Cpanel::Pack::Template::U32_BYTES_LENGTH,
};

my $NLMSG_HEADER_PACK_OBJ;
my $NLMSG_HEADER_PACK_OBJ_SIZE;

our @NLMSG_HEADER_TEMPLATE;

BEGIN {

    @NLMSG_HEADER_TEMPLATE = (

        &#039;nlmsg_length&#039; =&gt; PACK_TEMPLATE_U32(),    #__u32 nlmsg_len;    /* Length of message including header. */
        &#039;nlmsg_type&#039;   =&gt; PACK_TEMPLATE_U16(),    #__u16 nlmsg_type;   /* Type of message content. */
        &#039;nlmsg_flags&#039;  =&gt; PACK_TEMPLATE_U16(),    #__u16 nlmsg_flags;  /* Additional flags. */
        &#039;nlmsg_seq&#039;    =&gt; PACK_TEMPLATE_U32(),    #__u32 nlmsg_seq;    /* Sequence number. */
        &#039;nlmsg_pid&#039;    =&gt; PACK_TEMPLATE_U32(),    #__u32 nlmsg_pid;    /* Sender port ID. */

    );
}


my @NETLINK_XACTION_REQUIRED = (
    &#039;message&#039;,          #hashref, to be sent via “send_pack_obj”
    &#039;send_pack_obj&#039;,    #Cpanel::Pack instance
    &#039;recv_pack_obj&#039;,    #Cpanel::Pack instance
    &#039;sock&#039;,             #Perl socket
);

my %_u16_cache;
my %_u32_cache;

sub netlink_transaction {
    my (%OPTS) = @_;

    foreach (@NETLINK_XACTION_REQUIRED) {

        die &quot;$_ is required for netlink_transaction&quot; if !$OPTS{$_};
    }
    my ( $message_ref, $send_pack_obj, $recv_pack_obj, $sock, $parser, $payload_parser, $header_parms_ar ) = @OPTS{ @NETLINK_XACTION_REQUIRED, &#039;parser&#039;, &#039;payload_parser&#039;, &#039;header&#039; };

    my $packed_nlmsg = _pack_nlmsg_with_header( $send_pack_obj, $message_ref, $header_parms_ar );

    if (DEBUG) {
        require Data::Dumper;
        print STDERR &quot;[request]:&quot; . Data::Dumper::Dumper($message_ref);
    }

    printf STDERR &quot;Send %v02x\n&quot;, $packed_nlmsg if DEBUG;

    send( $sock, $packed_nlmsg, 0 ) or die &quot;send: $!&quot;;

    my $message_hr;
    my $packed_response = &#039;&#039;;

    my $header_pack_size = $NLMSG_HEADER_PACK_OBJ-&gt;sizeof();
    my $recv_pack_size   = $recv_pack_obj-&gt;sizeof();

    my $msgcount = 0;
    my ( $msg, $u32, $u16, $nlmsg_length, $nlmsg_type, $nlmsg_flags );
  READ_LOOP:
    while ( !_nlmsg_type_indicates_finished_reading($message_hr) ) {
        sysread( $sock, $packed_response, $NETLINK_READ_SIZE, length $packed_response ) or die &quot;sysread: $!&quot;;

      PARSE_LOOP:
        while (1) {

            $msg          = substr( $packed_response, 0, $header_pack_size, q&lt;&gt; );
            $u32          = substr( $msg,             0, U32_BYTES_LENGTH,  &#039;&#039; );
            $nlmsg_length = $_u32_cache{$u32} //= unpack( PACK_TEMPLATE_U32, $u32 );
            $u16          = substr( $msg, 0, U16_BYTES_LENGTH, &#039;&#039; );
            $nlmsg_type   = $_u16_cache{$u16} //= unpack( PACK_TEMPLATE_U16, $u16 );
            $u16          = substr( $msg, 0, U16_BYTES_LENGTH );
            $nlmsg_flags  = $_u16_cache{$u16} //= unpack( PACK_TEMPLATE_U16, $u16 );

            last PARSE_LOOP if !$nlmsg_length || length $packed_response &lt; $nlmsg_length - $NLMSG_HEADER_PACK_OBJ_SIZE;

            print STDERR &quot;Received message, total size: [$nlmsg_length]\n&quot; if DEBUG;

            if ( $nlmsg_type == $NLMSG_ERROR ) {
                require Data::Dumper;

                my ( $errno, $msg ) = unpack &#039;i a*&#039;, $packed_response;

                die Cpanel::Exception::create( &#039;Netlink&#039;, [ error =&gt; do { local $! = -$errno }, message =&gt; $msg ] );
            }

            if ( $recv_pack_size &lt;= length $packed_response ) {

                my $main_msg = substr( $packed_response, 0, $recv_pack_size, &#039;&#039; );

                $message_hr = $recv_pack_obj-&gt;unpack_to_hashref($main_msg);

                if (DEBUG) {
                    require Data::Dumper;
                    printf STDERR &quot;Received %v02x\n&quot;, $main_msg;
                    print STDERR &quot;[response]:&quot; . Data::Dumper::Dumper($message_hr);
                }

                my $payload = substr(
                    $packed_response,
                    0,
                    $nlmsg_length - $NLMSG_HEADER_PACK_OBJ_SIZE - $recv_pack_size,
                    q&lt;&gt;,
                );

                if ( $payload_parser &amp;&amp; length $payload ) {
                    printf STDERR &quot;payload: Received [%v02x]\n&quot;, $payload if DEBUG;
                    $payload_parser-&gt;( $msgcount, $message_hr, $payload );
                }
            }

            last READ_LOOP if _nlmsg_type_flags_indicates_finished_reading( $nlmsg_type, $nlmsg_flags );

            $msgcount++;
        }

    }

    $parser-&gt;( $msgcount, $message_hr ) if $parser &amp;&amp; $nlmsg_type;

    return 1;
}


our @INET_DIAG_SOCKID_TEMPLATE = (
    &#039;idiag_sport&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_BE16,    #__be16  idiag_sport;
    &#039;idiag_dport&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_BE16,    #__be16  idiag_dport;
    &#039;idiag_src_0&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_BE32,    #__be32  idiag_src[0];
    &#039;idiag_src_1&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_BE32,    #__be32  idiag_src[1];
    &#039;idiag_src_2&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_BE32,    #__be32  idiag_src[2];
    &#039;idiag_src_3&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_BE32,    #__be32  idiag_src[3];
    &#039;idiag_dst_0&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_BE32,    #__be32  idiag_dst[0];
    &#039;idiag_dst_1&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_BE32,    #__be32  idiag_dst[1];
    &#039;idiag_dst_2&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_BE32,    #__be32  idiag_dst[2];
    &#039;idiag_dst_3&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_BE32,    #__be32  idiag_dst[3];
    &#039;idiag_if&#039;       =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,     #__u32  idiag_if;
    &#039;idiag_cookie_0&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,     #__u32  idiag_cookie[0];
    &#039;idiag_cookie_1&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,     #__u32  idiag_cookie[1];
);

my $INET_DIAG_MSG_PACK_OBJ;
our @INET_DIAG_MSG_TEMPLATE = (
    &#039;idiag_family&#039;  =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,       # __u8    idiag_family;           /* Family of addresses. */
    &#039;idiag_state&#039;   =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,       # __u8    idiag_state;
    &#039;idiag_timer&#039;   =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,       # __u8    idiag_timer;
    &#039;idiag_retrans&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,       # __u8    idiag_retrans;
    @INET_DIAG_SOCKID_TEMPLATE,                                        # inet_diag_sockid
    &#039;idiag_expires&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,      #__u32   idiag_expires;
    &#039;idiag_rqueue&#039;  =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,      #__u32   idiag_rqueue;
    &#039;idiag_wqueue&#039;  =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,      #__u32   idiag_wqueue;
    &#039;idiag_uid&#039;     =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,      #__u32   idiag_uid;
    &#039;idiag_inode&#039;   =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32       #__u32   idiag_inode;
);

my $INET_DIAG_REQ_PACK_OBJ;
our @INET_DIAG_REQ_TEMPLATE = (
    &#039;idiag_family&#039;  =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,       # __u8    idiag_family;           /* Family of addresses. */
    &#039;idiag_src_len&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,       # __u8    idiag_src_len;
    &#039;idiag_dst_len&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,       # __u8    idiag_dst_len;
    &#039;idiag_ext&#039;     =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,       # __u8    idiag_ext;              /* Query extended information */
    @INET_DIAG_SOCKID_TEMPLATE,                                        #inet_diag_sockid
    &#039;idiag_states&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,       #__u32   idiag_states;           /* States to dump */
    &#039;idiag_dbs&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32        #__u32   idiag_dbs;           /* Tables to dump (NI) */
);

sub connection_lookup {
    my ( $source_address, $source_port, $dest_address, $dest_port ) = @_;

    die &quot;A source port is required.&quot;      if !defined $source_port;
    die &quot;A destination port is required.&quot; if !defined $dest_port;

    my ( $idiag_dst_0, $idiag_dst_1, $idiag_dst_2, $idiag_dst_3 );
    my ( $idiag_src_0, $idiag_src_1, $idiag_src_2, $idiag_src_3 );
    my ($idiag_family);

    if ( $dest_address =~ tr/:// ) {
        require Cpanel::IP::Expand;    # hide from exim but not perlcc - not eval quoted

        ( $idiag_dst_0, $idiag_dst_1, $idiag_dst_2, $idiag_dst_3 ) = unpack( &#039;N4&#039;, pack( &#039;n8&#039;, split /:/, Cpanel::IP::Expand::expand_ip($dest_address) ) );
        ( $idiag_src_0, $idiag_src_1, $idiag_src_2, $idiag_src_3 ) = unpack( &#039;N4&#039;, pack( &#039;n8&#039;, split /:/, Cpanel::IP::Expand::expand_ip($source_address) ) );
        $idiag_family = $AF_INET6;
    }
    else {
        my $u32_dest_address   = unpack( &#039;N&#039;, pack( &#039;C4&#039;, split( /\D/, $dest_address,   4 ) ) );
        my $u32_source_address = unpack( &#039;N&#039;, pack( &#039;C4&#039;, split( /\D/, $source_address, 4 ) ) );
        $idiag_src_0  = $u32_source_address;
        $idiag_dst_0  = $u32_dest_address;
        $idiag_family = $AF_INET;
    }

    my $sock;
    socket( $sock, $PF_NETLINK, $SOCK_DGRAM, $NETLINK_INET_DIAG ) or die &quot;socket: $!&quot;;

    $INET_DIAG_REQ_PACK_OBJ ||= Cpanel::Pack-&gt;new( \@INET_DIAG_REQ_TEMPLATE );
    $INET_DIAG_MSG_PACK_OBJ ||= Cpanel::Pack-&gt;new( \@INET_DIAG_MSG_TEMPLATE );

    my %RESPONSE;
    netlink_transaction(
        &#039;message&#039; =&gt; {
            &#039;idiag_family&#039;   =&gt; $idiag_family,
            &#039;idiag_dst_0&#039;    =&gt; $idiag_dst_0,
            &#039;idiag_dst_1&#039;    =&gt; $idiag_dst_1,
            &#039;idiag_dst_2&#039;    =&gt; $idiag_dst_2,
            &#039;idiag_dst_3&#039;    =&gt; $idiag_dst_3,
            &#039;idiag_dport&#039;    =&gt; $dest_port,
            &#039;idiag_src_0&#039;    =&gt; $idiag_src_0,
            &#039;idiag_src_1&#039;    =&gt; $idiag_src_1,
            &#039;idiag_src_2&#039;    =&gt; $idiag_src_2,
            &#039;idiag_src_3&#039;    =&gt; $idiag_src_3,
            &#039;idiag_sport&#039;    =&gt; $source_port,
            &#039;idiag_cookie_0&#039; =&gt; $INET_DIAG_NOCOOKIE,
            &#039;idiag_cookie_1&#039; =&gt; $INET_DIAG_NOCOOKIE,
        },
        &#039;sock&#039;          =&gt; $sock,
        &#039;send_pack_obj&#039; =&gt; $INET_DIAG_REQ_PACK_OBJ,
        &#039;recv_pack_obj&#039; =&gt; $INET_DIAG_MSG_PACK_OBJ,
        &#039;parser&#039;        =&gt; sub {
            my ( undef, $response_ref ) = @_;
            %RESPONSE = %$response_ref if ( $response_ref &amp;&amp; &#039;HASH&#039; eq ref $response_ref );
        }
    );

    return \%RESPONSE;
}


my @NETLINK_SEND_HEADER = (
    &#039;nlmsg_length&#039; =&gt; undef,              #gets put in place
    &#039;nlmsg_type&#039;   =&gt; $TCPDIAG_GETSOCK,
    &#039;nlmsg_flags&#039;  =&gt; 0,                  #gets |=’d with $NLM_F_REQUEST
    &#039;nlmsg_pid&#039;    =&gt; undef,              #gets put in place
    &#039;nlmsg_seq&#039;    =&gt; 2,                  #default
);

sub _pack_nlmsg_with_header {
    my ( $send_pack_obj, $message_ref, $header_parms_ar ) = @_;

    my $nlmsg = $send_pack_obj-&gt;pack_from_hashref($message_ref);

    if ( !$NLMSG_HEADER_PACK_OBJ ) {
        $NLMSG_HEADER_PACK_OBJ      = Cpanel::Pack-&gt;new( \@NLMSG_HEADER_TEMPLATE );
        $NLMSG_HEADER_PACK_OBJ_SIZE = $NLMSG_HEADER_PACK_OBJ-&gt;sizeof();
    }

    my %header_data = (
        @NETLINK_SEND_HEADER,
        ( $header_parms_ar ? @$header_parms_ar : () ),
        nlmsg_length =&gt; $NLMSG_HEADER_PACK_OBJ_SIZE + length $nlmsg,
        nlmsg_pid    =&gt; $$,
    );

    $header_data{&#039;nlmsg_flags&#039;} |= $NLM_F_REQUEST;

    my $hdr_str = $NLMSG_HEADER_PACK_OBJ-&gt;pack_from_hashref( \%header_data );

    return $hdr_str . $nlmsg;
}

sub _nlmsg_type_indicates_finished_reading {
    return _nlmsg_type_flags_indicates_finished_reading( $_[0]-&gt;{&#039;nlmsg_type&#039;}, $_[0]-&gt;{&#039;nlmsg_flags&#039;} );
}

sub _nlmsg_type_flags_indicates_finished_reading {
    return 0 if !length $_[0];

    return ( $_[0] == $NLMSG_ERROR || ( $_[1] &amp; $NLM_F_MULTI &amp;&amp; $_[0] == $NLMSG_DONE ) || !( $_[1] &amp; $NLM_F_MULTI ) ) ? 1 : 0;
}

sub expect_acknowledgment {
    my ( $my_sysread, $socket, $sequence ) = @_;

    my $NETLINK_HEADER = Cpanel::Pack-&gt;new( \@NLMSG_HEADER_TEMPLATE );

    my $response_buffer = &#039;&#039;;
    my $header_hr;
    my $error_code;

    do {
        while ( length $response_buffer &lt; $NETLINK_HEADER-&gt;sizeof() ) {
            $my_sysread-&gt;( $socket, \$response_buffer, READ_SIZE(), length $response_buffer ) or return &quot;sysread, message header: $!&quot;;
        }
        $header_hr = $NETLINK_HEADER-&gt;unpack_to_hashref( substr( $response_buffer, 0, $NETLINK_HEADER-&gt;sizeof() ) );
        while ( length $response_buffer &lt; $header_hr-&gt;{nlmsg_length} ) {
            $my_sysread-&gt;( $socket, \$response_buffer, READ_SIZE(), length $response_buffer ) or return &quot;sysread, message body: $!&quot;;
        }

        my $message = substr( $response_buffer, 0, $header_hr-&gt;{nlmsg_length}, &#039;&#039; );
        $error_code = 0;
        if ( $header_hr-&gt;{nlmsg_type} == $NLMSG_ERROR ) {
            $error_code = unpack( Cpanel::Pack::Template::PACK_TEMPLATE_U32, substr( $message, $NETLINK_HEADER-&gt;sizeof(), Cpanel::Pack::Template::U32_BYTES_LENGTH ) );
        }
        if ( $header_hr-&gt;{nlmsg_seq} eq $sequence ) {
            if ( $header_hr-&gt;{nlmsg_type} == $NLMSG_ERROR &amp;&amp; $error_code != 0 ) {
                local $! = -$error_code;
                return &quot;Received error code when expecting acknowledgement: $!\n&quot;;
            }
            if ( $header_hr-&gt;{nlmsg_type} == $NLMSG_OVERRUN ) {
                return &quot;Data lost due to message overrun&quot;;
            }
            if ( $header_hr-&gt;{nlmsg_type} == $NLMSG_DONE ) {
                return &quot;Received multipart data when expecting ACK&quot;;
            }
        }
    } while ( $header_hr-&gt;{nlmsg_seq} ne $sequence || $header_hr-&gt;{nlmsg_type} != $NLMSG_ERROR || $error_code != 0 );
    return undef;
}

1;

} # --- END Cpanel/Linux/Netlink.pm


{ # --- BEGIN Cpanel/Linux/Proc/Net/Tcp.pm
package Cpanel::Linux::Proc::Net::Tcp;


use strict;

our $PROC_NET_TCP  = &#039;/proc/net/tcp&#039;;
our $PROC_NET_TCP6 = &#039;/proc/net/tcp6&#039;;

sub connection_lookup {
    my ( $remote_address, $remote_port, $local_address, $local_port ) = @_;

    my ( $tcp_file, $remote_ltl_endian_hex_address, $remote_hex_port, $local_ltl_endian_hex_address, $local_hex_port );

    $remote_hex_port = _dec_port_to_hex_port($remote_port);
    $local_hex_port  = _dec_port_to_hex_port($local_port);

    if ( $remote_address =~ tr/:// ) {    #ipv6
        $tcp_file                      = $PROC_NET_TCP6;
        $remote_ltl_endian_hex_address = _ipv6_text_to_little_endian_hex_address($remote_address);
        $local_ltl_endian_hex_address  = _ipv6_text_to_little_endian_hex_address($local_address);
    }
    else {
        $tcp_file                      = $PROC_NET_TCP;
        $remote_ltl_endian_hex_address = _ipv4_txt_to_little_endian_hex_address($remote_address);
        $local_ltl_endian_hex_address  = _ipv4_txt_to_little_endian_hex_address($local_address);
    }

    if ( open( my $tcp_fh, &#039;&lt;&#039;, $tcp_file ) ) {
        my $uid;
        while ( readline($tcp_fh) ) {
            if (   m/^\s*\d+:\s+([\dA-F]{8}(?:[\dA-F]{24})?):([\dA-F]{4})\s+([\dA-F]{8}(?:[\dA-F]{24})?):([\dA-F]{4})\s+(\S+)\s+\S+\s+\S+\s+\S+\s+(\d+)/
                &amp;&amp; $remote_ltl_endian_hex_address eq $1
                &amp;&amp; $remote_hex_port eq $2
                &amp;&amp; $local_ltl_endian_hex_address eq $3
                &amp;&amp; $local_hex_port eq $4 ) {

                $uid = $6;
                last;
            }

        }
        return $uid;

    }

    return;
}

sub _dec_port_to_hex_port {
    my ($dec_port) = @_;

    return sprintf( &#039;%04X&#039;, $dec_port );
}

sub _ipv4_txt_to_little_endian_hex_address {
    my ($ipv4_txt) = @_;

    return sprintf( &quot;%08X&quot;, unpack( &#039;V&#039;, pack( &#039;C4&#039;, split( /\D/, $ipv4_txt, 4 ) ) ) );
}

sub _ipv6_text_to_little_endian_hex_address {
    my ($ipv6_txt) = @_;

    require Cpanel::IP::Expand;    # hide from exim but not perlcc - not eval quoted

    my $hexip = &#039;&#039;;
    my @ip    = split /:/, Cpanel::IP::Expand::expand_ip( $ipv6_txt, 6 );
    while (@ip) {
        my $block1 = shift @ip;
        my $block2 = shift @ip;
        $hexip .= uc substr( $block2, 2, 2 ) . uc substr( $block2, 0, 2 ) . uc substr( $block1, 2, 2 ) . uc substr( $block1, 0, 2 );
    }
    return $hexip;
}

1;

} # --- END Cpanel/Linux/Proc/Net/Tcp.pm


{ # --- BEGIN Cpanel/Ident.pm
package Cpanel::Ident;


use strict;

our $TESTING_FLAGS = 0;    # FOR TESTING
our $USE_NETLINK   = 1;    # FOR TESTING
our $USE_PROC      = 2;    # FOR TESTING

use constant NOTFOUND =&gt; 0xff_ff_ff_ff;


sub identify_local_connection {
    my ( $source_address, $source_port, $dest_address, $dest_port ) = @_;

    if ( !defined($source_port) || !defined($dest_port) ) {
        die &#039;Need source and destination ports!&#039;;
    }

    my $netlink_failed;
    my $netlink_transient_state;

    if ( !$TESTING_FLAGS || $TESTING_FLAGS == $USE_NETLINK ) {
        require Cpanel::Linux::Netlink;    # hide from exim but not perlcc - not eval quoted
        my $response;

        local $@;

        eval {
            $response = Cpanel::Linux::Netlink::connection_lookup(
                $source_address, $source_port,
                $dest_address,   $dest_port,
            );
        };

        if ($@) {
            $netlink_failed = 1;

            warn;
        }

        elsif ( $response
            &amp;&amp; defined $response-&gt;{&#039;idiag_state&#039;}
            &amp;&amp; ( $response-&gt;{&#039;idiag_state&#039;} != 1 &amp;&amp; $response-&gt;{&#039;idiag_state&#039;} != 8 &amp;&amp; $response-&gt;{&#039;idiag_state&#039;} != 10 ) ) {
            $netlink_transient_state = 1;
        }

        elsif ( $response
            &amp;&amp; ref $response
            &amp;&amp; $response-&gt;{&#039;idiag_dport&#039;}
            &amp;&amp; defined( $response-&gt;{&#039;idiag_uid&#039;} )
            &amp;&amp; $response-&gt;{&#039;idiag_uid&#039;} != NOTFOUND() ) {
            return $response-&gt;{&#039;idiag_uid&#039;};
        }
    }

    if ( $netlink_failed || $netlink_transient_state || $TESTING_FLAGS == $USE_PROC ) {
        require Cpanel::Linux::Proc::Net::Tcp;    # hide from exim but not perlcc - not eval quoted
        my $uid = Cpanel::Linux::Proc::Net::Tcp::connection_lookup( $source_address, $source_port, $dest_address, $dest_port );
        return $uid if defined $uid;
    }

    return;
}

1;

} # --- END Cpanel/Ident.pm


{ # --- BEGIN Cpanel/Autodie.pm
package Cpanel::Autodie;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub _ENOENT { return 2; }
sub _EEXIST { return 17; }
sub _EINTR  { return 4; }

sub import {
    shift;

    _load_function($_) for @_;

    return;
}

our $AUTOLOAD;

sub AUTOLOAD {
    substr( $AUTOLOAD, 0, 1 + rindex( $AUTOLOAD, &#039;:&#039; ) ) = q&lt;&gt;;

    _load_function($AUTOLOAD);

    goto &amp;{ Cpanel::Autodie-&gt;can($AUTOLOAD) };
}

sub _load_function {
    _require(&quot;Cpanel/Autodie/CORE/$_[0].pm&quot;);

    return;
}

sub _require {
    local ( $!, $^E, $@ );

    require $_[0];
    return;
}

1;

} # --- END Cpanel/Autodie.pm


{ # --- BEGIN Cpanel/Autodie/CORE/exists.pm
package Cpanel::Autodie;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub exists {    ## no critic qw( RequireArgUnpacking )
    local ( $!, $^E );

    if ( ${^GLOBAL_PHASE} eq &#039;START&#039; ) {
        _die_err( $_[0], &quot;do not access the filesystem at compile time&quot; );
    }

    return 1 if -e $_[0];
    return 0 if $! == _ENOENT();

    return _die_err( $_[0], $! );
}


sub exists_nofollow {
    my ($path) = @_;


    local ( $!, $^E );

    return 1 if CORE::lstat $path;

    return 0 if $! == _ENOENT();

    return _die_err( $path, $! );
}

sub _die_err {
    my ( $path, $err ) = @_;

    local $@;    # $! is already local()ed.
    require Cpanel::Exception;

    die Cpanel::Exception::create( &#039;IO::StatError&#039;, [ error =&gt; $err, path =&gt; $path ] );
}

1;

} # --- END Cpanel/Autodie/CORE/exists.pm


{ # --- BEGIN Cpanel/Autodie/CORE/exists_nofollow.pm
package Cpanel::Autodie;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Autodie::CORE::exists();    # PPI NO PARSE # perlpkg line 211


1;

} # --- END Cpanel/Autodie/CORE/exists_nofollow.pm


{ # --- BEGIN Cpanel/Autodie/More/Lite.pm
package Cpanel::Autodie::More::Lite;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Autodie                        (); # perlpkg line 211
# use Cpanel::Autodie::CORE::exists          ();    # PPI USE OK - reload so we can map the symbol below # perlpkg line 211
# use Cpanel::Autodie::CORE::exists_nofollow ();    # PPI USE OK - reload so we can map the symbol below # perlpkg line 211

BEGIN {
    *exists          = *Cpanel::Autodie::exists;
    *exists_nofollow = *Cpanel::Autodie::exists_nofollow;
}
1;

} # --- END Cpanel/Autodie/More/Lite.pm


{ # --- BEGIN Cpanel/Services/Enabled/Spamd.pm
package Cpanel::Services::Enabled::Spamd;


use strict;
use warnings;
no warnings &#039;once&#039;;


# use Cpanel::Autodie::More::Lite (); # perlpkg line 211

our $_TOUCHFILE_PATH = &#039;/etc/spamddisable&#039;;


sub is_enabled {
    return !Cpanel::Autodie::More::Lite::exists($_TOUCHFILE_PATH);
}

1;

} # --- END Cpanel/Services/Enabled/Spamd.pm


{ # --- BEGIN Cpanel/FileUtils/Dir.pm
package Cpanel::FileUtils::Dir;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Exception (); # perlpkg line 211

use constant _ENOENT =&gt; 2;

sub directory_has_nodes {
    return directory_has_nodes_if_exists( $_[0] ) // do {
        local $! = _ENOENT();
        die _opendir_err( $_[0] );
    };
}

sub directory_has_nodes_if_exists {
    my ($dir) = @_;

    local $!;

    opendir my $dh, $dir or do {
        if ( $! == _ENOENT() ) {
            return undef;
        }

        die _opendir_err($dir);
    };

    local $!;

    my $has_nodes = 0;
    while ( my $node = readdir $dh ) {
        next if $node eq &#039;.&#039; || $node eq &#039;..&#039;;
        $has_nodes = 1;
        last;
    }

    _check_for_readdir_error($dir) if !$has_nodes;
    _closedir( $dh, $dir );

    return $has_nodes;
}

sub get_directory_nodes_if_exists {
    my ($dir) = @_;

    local $!;

    if ( opendir my $dh, $dir ) {
        return _read_directory_nodes( $dh, $dir );
    }
    elsif ( $! != _ENOENT() ) {
        die _opendir_err($dir);
    }
    return undef;
}

sub get_directory_nodes {
    return _read_directory_nodes( _opendir( $_[0] ), $_[0] );
}

sub _read_directory_nodes {    ## no critic qw(Subroutines::RequireArgUnpacking) -- used in loops
    local $!;
    my @nodes = grep { defined($_) &amp;&amp; $_ ne &#039;.&#039; &amp;&amp; $_ ne &#039;..&#039; } readdir( $_[0] );
    _check_for_readdir_error( $_[0] );
    _closedir( $_[0], $_[1] );
    return \@nodes;
}

sub _check_for_readdir_error {

    if ( $! &amp;&amp; ( $^V &gt;= v5.20.0 ) ) {
        die Cpanel::Exception::create( &#039;IO::DirectoryReadError&#039;, [ path =&gt; $_[0], error =&gt; $! ] );
    }

    return;
}

sub _opendir {
    local $!;
    opendir my $dh, $_[0] or do {
        die _opendir_err( $_[0] );
    };

    return $dh;
}

sub _closedir {
    local $!;
    closedir $_[0] or do {
        die Cpanel::Exception::create( &#039;IO::DirectoryCloseError&#039;, [ path =&gt; $_[1], error =&gt; $! ] );
    };

    return;
}

sub _opendir_err {
    return Cpanel::Exception::create( &#039;IO::DirectoryOpenError&#039;, [ path =&gt; $_[0], error =&gt; $! ] );
}

1;

} # --- END Cpanel/FileUtils/Dir.pm


{ # --- BEGIN Cpanel/DKIM/ValidityCache.pm
package Cpanel::DKIM::ValidityCache;


use strict;
use warnings;
no warnings &#039;once&#039;;


# use Cpanel::Autodie (); # perlpkg line 211

our $BASE_DIRECTORY = &#039;/var/cpanel/domain_keys/validity_cache&#039;;

sub _BASE { return $BASE_DIRECTORY; }


sub get {
    my ( undef, $entry ) = @_;

    return Cpanel::Autodie::exists(&quot;$BASE_DIRECTORY/$entry&quot;);
}


sub get_all {
    require Cpanel::FileUtils::Dir;
    return Cpanel::FileUtils::Dir::get_directory_nodes_if_exists($BASE_DIRECTORY);
}

1;

} # --- END Cpanel/DKIM/ValidityCache.pm


{ # --- BEGIN Cpanel/IP/Loopback.pm
package Cpanel::IP::Loopback;


use strict;
use warnings;
no warnings &#039;once&#039;;

sub is_loopback {
    return (
        length $_[0]
          &amp;&amp; (
            $_[0] eq &#039;localhost&#039;                                          #
            || $_[0] eq &#039;localhost.localdomain&#039;                           #
            || $_[0] eq &#039;0000:0000:0000:0000:0000:0000:0000:0001&#039;         #
            || index( $_[0], &#039;0000:0000:0000:0000:0000:ffff:7f&#039; ) == 0    # ipv4 inside of ipv6 match 127.*
            || index( $_[0], &#039;::ffff:127.&#039; ) == 0                         # ipv4 inside of ipv6 match 127.*
            || index( $_[0], &#039;127.&#039; ) == 0                                # ipv4 needs to match 127.*
            || $_[0] eq &#039;0:0:0:0:0:0:0:1&#039;                                 #
            || $_[0] eq &#039;:1&#039;                                              #
            || $_[0] eq &#039;::1&#039;                                             #
            || $_[0] eq &#039;(null)&#039;                                          #
            || $_[0] eq &#039;(null):0000:0000:0000:0000:0000:0000:0000&#039;       #
            || $_[0] eq &#039;0000:0000:0000:0000:0000:0000:0000:0000&#039;         #
            || $_[0] eq &#039;0.0.0.0&#039;
          )                                                               #
    ) ? 1 : 0;
}

1;

} # --- END Cpanel/IP/Loopback.pm


{ # --- BEGIN Cpanel/Context.pm
package Cpanel::Context;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Exception (); # perlpkg line 211

sub must_be_list {
    return 1 if ( caller(1) )[5];    # 5 = wantarray
    my $msg = ( caller(1) )[3];      # 3 = subroutine
    $msg .= $_[0] if defined $_[0];
    return _die_context( &#039;list&#039;, $msg );
}

sub must_not_be_scalar {
    my ($message) = @_;

    my $wa = ( caller(1) )[5];       # 5 = wantarray

    if ( !$wa &amp;&amp; defined $wa ) {
        _die_context( &#039;list or void&#039;, $message );
    }

    return 1;
}

sub must_not_be_void {
    return if defined( ( caller 1 )[5] );

    return _die_context(&#039;scalar or list&#039;);
}

sub _die_context {
    my ( $context, $message ) = @_;

    local $Carp::CarpInternal{__PACKAGE__} if $INC{&#039;Carp.pm&#039;};

    my $to_throw = length $message ? &quot;Must be $context context ($message)!&quot; : &quot;Must be $context context!&quot;;

    die Cpanel::Exception::create_raw( &#039;ContextError&#039;, $to_throw );
}

1;

} # --- END Cpanel/Context.pm


{ # --- BEGIN Cpanel/ProcessInfo.pm
package Cpanel::ProcessInfo;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Context (); # perlpkg line 211
# use Cpanel::Autodie (); # perlpkg line 211

our $VERSION = &#039;1.0&#039;;


sub get_pid_lineage {
    Cpanel::Context::must_be_list();

    my @lineage;

    my $ppid = getppid();
    while ( $ppid &gt; 1 ) {
        push @lineage, $ppid;
        $ppid = get_parent_pid($ppid);
    }

    return @lineage;
}


sub get_parent_pid {
    _die_if_pid_invalid( $_[0] );

    return getppid() if $_[0] == $$;

    if ( open( my $proc_status_fh, &#039;&lt;&#039;, &quot;/proc/$_[0]/status&quot; ) ) {
        local $/;
        my %status = map { lc $_-&gt;[0] =&gt; $_-&gt;[1] }
          map  { [ ( split( /\s*:\s*/, $_ ) )[ 0, 1 ] ] }
          grep { index( $_, &#039;:&#039; ) &gt; -1 }
          split( /\n/, readline($proc_status_fh) );
        return $status{&#039;ppid&#039;};
    }

    return undef;
}


sub get_pid_exe {
    _die_if_pid_invalid( $_[0] );
    return Cpanel::Autodie::readlink_if_exists( &#039;/proc/&#039; . $_[0] . &#039;/exe&#039; );
}


sub get_pid_cmdline {
    _die_if_pid_invalid( $_[0] );
    if ( open( my $cmdline, &#039;&lt;&#039;, &quot;/proc/$_[0]/cmdline&quot; ) ) {
        local $/;
        my $cmdline = readline($cmdline);
        $cmdline =~ tr{\0}{ };
        $cmdline =~ tr{\r\n}{}d;
        substr( $cmdline, -1, 1, &#039;&#039; ) if substr( $cmdline, -1 ) eq &#039; &#039;;
        return $cmdline;
    }

    return &#039;&#039;;
}


sub get_pid_cwd {
    _die_if_pid_invalid( $_[0] );
    return readlink( &#039;/proc/&#039; . $_[0] . &#039;/cwd&#039; ) || &#039;/&#039;;
}

sub _die_if_pid_invalid {
    die &quot;Invalid PID: $_[0]&quot; if !length $_[0] || $_[0] =~ tr{0-9}{}c;
    return;
}
1;

} # --- END Cpanel/ProcessInfo.pm


{ # --- BEGIN Cpanel/Fcntl/Constants.pm
package Cpanel::Fcntl::Constants;


use strict;
use warnings;
no warnings &#039;once&#039;;


BEGIN {
    our $O_RDONLY  = 0;
    our $O_WRONLY  = 1;
    our $O_RDWR    = 2;
    our $O_ACCMODE = 3;

    our $F_GETFD = 1;
    our $F_SETFD = 2;
    our $F_GETFL = 3;
    our $F_SETFL = 4;

    our $SEEK_SET    = 0;
    our $SEEK_CUR    = 1;
    our $SEEK_END    = 2;
    our $S_IWOTH     = 2;
    our $S_ISUID     = 2048;
    our $S_ISGID     = 1024;
    our $O_CREAT     = 64;
    our $O_EXCL      = 128;
    our $O_TRUNC     = 512;
    our $O_APPEND    = 1024;
    our $O_NONBLOCK  = 2048;
    our $O_DIRECTORY = 65536;
    our $O_NOFOLLOW  = 131072;
    our $O_CLOEXEC   = 524288;

    our $S_IFREG  = 32768;
    our $S_IFDIR  = 16384;
    our $S_IFCHR  = 8192;
    our $S_IFBLK  = 24576;
    our $S_IFIFO  = 4096;
    our $S_IFLNK  = 40960;
    our $S_IFSOCK = 49152;
    our $S_IFMT   = 61440;

    our $LOCK_SH = 1;
    our $LOCK_EX = 2;
    our $LOCK_NB = 4;
    our $LOCK_UN = 8;

    our $FD_CLOEXEC = 1;
}

1;

} # --- END Cpanel/Fcntl/Constants.pm


{ # --- BEGIN Cpanel/Socket/Constants.pm
package Cpanel::Socket::Constants;


use strict;
use warnings;
no warnings &#039;once&#039;;

our $SO_REUSEADDR = 2;

our $AF_UNIX  = 1;
our $AF_INET  = 2;
our $PF_INET  = 2;
our $AF_INET6 = 10;
our $PF_INET6 = 10;

our $PROTO_IP   = 0;
our $PROTO_ICMP = 1;
our $PROTO_TCP  = 6;
our $PROTO_UDP  = 17;

our $IPPROTO_TCP;
*IPPROTO_TCP = \$PROTO_TCP;

our $SO_PEERCRED   = 17;
our $SOL_SOCKET    = 1;
our $SOCK_STREAM   = 1;
our $SOCK_NONBLOCK = 2048;

our $SHUT_RD   = 0;
our $SHUT_WR   = 1;
our $SHUT_RDWR = 2;

our $MSG_PEEK     = 2;
our $MSG_NOSIGNAL = 16384;

1;

} # --- END Cpanel/Socket/Constants.pm


{ # --- BEGIN Cpanel/Hulk/Constants.pm
package Cpanel::Hulk::Constants;


use strict;


# use Cpanel::Fcntl::Constants  (); # perlpkg line 211
# use Cpanel::Socket::Constants (); # perlpkg line 211

*F_GETFL    = \$Cpanel::Fcntl::Constants::F_GETFL;
*F_SETFL    = \$Cpanel::Fcntl::Constants::F_SETFL;
*O_NONBLOCK = \$Cpanel::Fcntl::Constants::O_NONBLOCK;

our $EINTR       = 4;
our $EPIPE       = 32;
our $EINPROGRESS = 115;
our $ETIMEDOUT   = 110;
our $EISCONN     = 106;
our $ECONNRESET  = 104;
our $EAGAIN      = 11;

*PROTO_IP   = \$Cpanel::Socket::Constants::PROTO_IP;
*PROTO_ICMP = \$Cpanel::Socket::Constants::PROTO_ICMP;
*PROTO_TCP  = \$Cpanel::Socket::Constants::PROTO_TCP;

*SO_PEERCRED = \$Cpanel::Socket::Constants::SO_PEERCRED;
*SOL_SOCKET  = \$Cpanel::Socket::Constants::SOL_SOCKET;
*SOCK_STREAM = \$Cpanel::Socket::Constants::SOCK_STREAM;

*AF_INET6 = \$Cpanel::Socket::Constants::AF_INET6;
*AF_INET  = \$Cpanel::Socket::Constants::AF_INET;
*AF_UNIX  = \$Cpanel::Socket::Constants::AF_UNIX;

our $TOKEN_SALT_BASE = &#039;$6$&#039;;
our $SALT_LENGTH     = 16;

our $TIME_BASE            = 1410000000;
our $SIX_HOURS_IN_SECONDS = 21600;
1;

} # --- END Cpanel/Hulk/Constants.pm


{ # --- BEGIN Cpanel/Fcntl.pm
package Cpanel::Fcntl;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Fcntl::Constants (); # perlpkg line 211

my %CONSTANTS;
my %CACHE;

sub or_flags {
    my (@flags) = @_;
    my $flag_cache_key = join( &#039;|&#039;, @flags );
    return $CACHE{$flag_cache_key} if defined $CACHE{$flag_cache_key};
    my $numeric = 0;
    foreach my $o_const (@flags) {
        $numeric |= (
            $CONSTANTS{$o_const} ||= do {
                my $glob     = $Cpanel::Fcntl::Constants::{$o_const};
                my $number_r = $glob &amp;&amp; *{$glob}{&#039;SCALAR&#039;};

                die &quot;Missing \$Cpanel::Fcntl::Constants::$o_const! (does it need to be added?)&quot; if !$number_r;

                $$number_r;
            }
        );
    }
    return ( $CACHE{$flag_cache_key} = $numeric );
}

1;

} # --- END Cpanel/Fcntl.pm


{ # --- BEGIN Cpanel/Time/Local.pm
package Cpanel::Time::Local;


use strict;


our $server_offset_string;
our ( $timecacheref, $localtimecacheref ) = ( [ -1, &#039;&#039;, -1 ], [ -1, &#039;&#039;, -1 ] );

my $server_offset;
my $localtime_link_or_mtime;
our $ETC_LOCALTIME = q{/etc/localtime};

sub _clear_caches {
    undef $_
      for (
        $server_offset,
        $server_offset_string,
        $timecacheref,
        $localtimecacheref,
        $localtime_link_or_mtime,
      );
    return;
}

sub localtime2timestamp {
    my ( $time, $delimiter ) = @_;
    $delimiter ||= &#039; &#039;;
    $time      ||= time();

    return $localtimecacheref-&gt;[2] if $localtimecacheref-&gt;[0] == $time &amp;&amp; $localtimecacheref-&gt;[1] eq $delimiter;

    my $tz_offset = get_server_offset_as_offset_string($time);

    my ( $sec, $min, $hour, $mday, $mon, $year ) = localtime $time;
    @{$localtimecacheref}[ 0, 1 ] = ( $time, $delimiter );
    return ( $localtimecacheref-&gt;[2] = sprintf( &#039;%04d-%02d-%02d&#039; . $delimiter . &#039;%02d:%02d:%02d %s&#039;, $year + 1900, $mon + 1, $mday, $hour, $min, $sec, $tz_offset ) );
}

sub get_server_offset_as_offset_string {
    my ($time_supplied) = @_;

    if ( !$time_supplied ) {
        my $link_or_mtime;
        if ( -l $ETC_LOCALTIME ) {
            $link_or_mtime = readlink($ETC_LOCALTIME);
        }
        else {
            $link_or_mtime = ( stat($ETC_LOCALTIME) )[9];
        }
        if ( defined $link_or_mtime ) {
            $localtime_link_or_mtime ||= $link_or_mtime;

            if ( $localtime_link_or_mtime ne $link_or_mtime ) {
                _clear_caches();
                $localtime_link_or_mtime = $link_or_mtime;
            }
        }
    }

    if ( $time_supplied || !defined $server_offset_string ) {

      UNTIL_SAME_SECOND: {
            my $starttime = time();
            my $time      = $time_supplied || $starttime;
            my ( $sec, $min, $hour, $mday, $mon, $year, $wday, $yday ) = localtime $time;

            my ( $gmmin, $gmhour, $gmyear, $gmyday ) = ( gmtime($time) )[ 1, 2, 5, 7 ];

            redo UNTIL_SAME_SECOND if time != $starttime;

            my $yday_offset;
            if ( $year == $gmyear ) {
                $yday_offset = ( $yday &lt;=&gt; $gmyday );
            }
            elsif ( $year &lt; $gmyear ) {
                $yday_offset = -1;
            }
            elsif ( $year &gt; $gmyear ) {
                $yday_offset = 1;
            }

            my $gmoffset      = ( $hour * 60 + $min ) - ( $gmhour * 60 + $gmmin ) + 1440 * $yday_offset;
            my $offset_string = sprintf( &#039;%+03d%02d&#039;, int( $gmoffset / 60 ), $gmoffset % 60 );
            if ($time_supplied) {
                return $offset_string;
            }
            else {
                $server_offset_string = $offset_string;
            }
        }
    }
    return $server_offset_string;
}

sub get_server_offset_in_seconds {
    if ( !defined $server_offset ) {
        if ( get_server_offset_as_offset_string() =~ m/([-+]?[0-9]{2})([0-9]{2})/ ) {
            my ( $hours, $minutes ) = ( $1, $2 );
            my $seconds = ( ( abs($hours) * 60 * 60 ) + ( $minutes * 60 ) );
            $server_offset = $hours &lt; 0 ? &quot;-$seconds&quot; : $seconds;
        }
        else {

            $server_offset = 0;
        }
    }
    return $server_offset;
}

1;

} # --- END Cpanel/Time/Local.pm


{ # --- BEGIN Cpanel/FileUtils/Open.pm
package Cpanel::FileUtils::Open;


use strict;

# use Cpanel::Fcntl (); # perlpkg line 211

sub sysopen_with_real_perms {    ##no critic qw(RequireArgUnpacking)
    my ( $file, $mode, $custom_perms ) = ( @_[ 1 .. 3 ] );

    if ( $mode &amp;&amp; substr( $mode, 0, 1 ) eq &#039;O&#039; ) {
        $mode = Cpanel::Fcntl::or_flags( split m&lt;\|&gt;, $mode );
    }

    my ( $sysopen_perms, $original_umask );

    if ( defined $custom_perms ) {
        $custom_perms &amp;= 0777;
        $original_umask = umask( $custom_perms ^ 07777 );
        $sysopen_perms  = $custom_perms;
    }
    else {
        $sysopen_perms = 0666;
    }

    my $ret = sysopen( $_[0], $file, $mode, $sysopen_perms );

    if ( defined $custom_perms ) {

        () = umask($original_umask);
    }

    return $ret;
}

1;

} # --- END Cpanel/FileUtils/Open.pm


{ # --- BEGIN Cpanel/Parser/Vars.pm
package Cpanel::Parser::Vars;


use strict;

our $current_tag            = &#039;&#039;;
our $can_leave_cpanelaction = 1;
our $buffer                 = &#039;&#039;;

our $loaded_api   = 0;
our $trial_mode   = 0;
our $sent_headers = 0;
our $live_socket_file;

our $incpanelaction = 0;
our $altmode        = 0;
our $jsonmode       = 0;
our $javascript     = 0;
our $title          = 0;
our $input          = 0;
our $style          = 0;
our $embtag         = 0;
our $textarea       = 0;

our $file           = &#039;[stdin]&#039;;
our $firstfile      = &#039;[stdin]&#039;;
our $trap_defaultfh = undef;       # Known to be boolean.

our %BACKCOMPAT;

our $cptag;
our $sent_content_type;

1;

} # --- END Cpanel/Parser/Vars.pm


{ # --- BEGIN Cpanel/Encoder/Tiny/Rare.pm
package Cpanel::Encoder::Tiny::Rare;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub angle_bracket_decode {
    my ($string) = @_;
    $string =~ s{ &amp;lt; }{&lt;}xmsg;
    $string =~ s{ &amp;gt; }{&gt;}xmsg;
    return $string;
}


sub decode_utf8_html_entities {
    my $str = shift;
    $str =~ s/&amp;\#(\d{4})\;/chr($1);/eg;
    return $str;
}

my %uri_encoding_cache = (
    &#039;&quot;&#039;  =&gt; &#039;%22&#039;,
    q{&#039;} =&gt; &#039;%27&#039;,
    &#039;(&#039;  =&gt; &#039;%28&#039;,
    &#039;)&#039;  =&gt; &#039;%29&#039;,
    q{ } =&gt; &#039;%20&#039;,
    &quot;\t&quot; =&gt; &#039;%09&#039;,
);


sub css_encode_str {
    my $str = shift;
    $str =~ s{([\(\)\s&quot;&#039;])}{
        $uri_encoding_cache{$1}
        || require Cpanel::Encoder::URI &amp;&amp; Cpanel::Encoder::URI::uri_encode_str($1)
    }ge;
    return $str;
}

1;

} # --- END Cpanel/Encoder/Tiny/Rare.pm


{ # --- BEGIN Cpanel/Encoder/Tiny.pm
package Cpanel::Encoder::Tiny;


use strict;

my %XML_ENCODE_MAP  = ( &#039;&amp;&#039;   =&gt; &#039;&amp;amp;&#039;, &#039;&lt;&#039;  =&gt; &#039;&amp;lt;&#039;, &#039;&gt;&#039;  =&gt; &#039;&amp;gt;&#039;, &#039;&quot;&#039;    =&gt; &#039;&amp;quot;&#039;, &quot;&#039;&quot;    =&gt; &#039;&amp;apos;&#039; );
my %HTML_ENCODE_MAP = ( &#039;&amp;&#039;   =&gt; &#039;&amp;amp;&#039;, &#039;&lt;&#039;  =&gt; &#039;&amp;lt;&#039;, &#039;&gt;&#039;  =&gt; &#039;&amp;gt;&#039;, &#039;&quot;&#039;    =&gt; &#039;&amp;quot;&#039;, &quot;&#039;&quot;    =&gt; &#039;&amp;#39;&#039; );
my %HTML_DECODE_MAP = ( &#039;amp&#039; =&gt; &#039;&amp;&#039;,     &#039;lt&#039; =&gt; &#039;&lt;&#039;,    &#039;gt&#039; =&gt; &#039;&gt;&#039;,    &#039;quot&#039; =&gt; &#039;&quot;&#039;,      &#039;apos&#039; =&gt; q{&#039;}, &#039;#39&#039; =&gt; q{&#039;} );

my $decode_regex = do { my $tmp = join( &#039;|&#039;, keys %HTML_DECODE_MAP ); &quot;&amp;($tmp);&quot;; };

sub angle_bracket_encode {
    my ($string) = @_;
    $string =~ s{&lt;}{&amp;lt;}xmsg;
    $string =~ s{&gt;}{&amp;gt;}xmsg;
    return $string;
}

sub safe_xml_encode_str {
    my $data = join( &#039;&#039;, @_ );
    return $data if $data !~ tr/&amp;&lt;&gt;&quot;&#039;//;
    $data =~ s/([&amp;&lt;&gt;&quot;&#039;])/$XML_ENCODE_MAP{$1}/sg;
    return $data;
}

sub safe_html_encode_str {
    return $_[0] if !defined $_[0] || ( !defined $_[1] &amp;&amp; $_[0] !~ tr/&amp;&lt;&gt;&quot;&#039;// );
    my $data = defined $_[1] ? join( &#039;&#039;, @_ ) : $_[0];
    return $data if $data !~ tr/&amp;&lt;&gt;&quot;&#039;//;
    $data =~ s/([&amp;&lt;&gt;&quot;&#039;])/$HTML_ENCODE_MAP{$1}/sg;
    return $data;
}

sub safe_html_decode_str {
    return undef if !defined $_[0];
    my $data = join( &#039;&#039;, @_ );
    $data =~ s/$decode_regex/$HTML_DECODE_MAP{$1}/g;
    return $data;
}

sub css_encode_str {
    require Cpanel::Encoder::Tiny::Rare;
    *css_encode_str = *Cpanel::Encoder::Tiny::Rare::css_encode_str;
    goto \&amp;Cpanel::Encoder::Tiny::Rare::css_encode_str;
}

1;

} # --- END Cpanel/Encoder/Tiny.pm


{ # --- BEGIN Cpanel/Regex.pm
package Cpanel::Regex;


use strict;

our $VERSION = &#039;0.2.5&#039;;

my $dblquotedstr = q{&quot;([^\\\\&quot;]*(?:\\\\.[^\\\\&quot;]*)*)&quot;};
my $sglquotedstr = $dblquotedstr;
$sglquotedstr =~ tr{&quot;}{&#039;};

my $zero_through_255 = &#039;(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]?|0)&#039;;

our %regex = (
    &#039;emailaddr&#039;              =&gt; &#039;[a-zA-Z0-9!#\$\-=?^_{}~]+(?:\.[a-zA-Z0-9!#\$\-=?^_{}~]+)*(?:\+[a-zA-Z0-9 \.=\-\_]+)*\@[\da-zA-Z](?:[-\da-zA-Z]*[\da-zA-Z])?(?:\.[\da-zA-Z](?:[-\da-zA-Z]*[\da-zA-Z])?)*&#039;,
    &#039;oneplusdot&#039;             =&gt; &#039;\.+&#039;,
    &#039;oneplusspacetab&#039;        =&gt; &#039;[\s\t]+&#039;,
    &#039;multipledot&#039;            =&gt; &#039;\.{2,}&#039;,
    &#039;commercialat&#039;           =&gt; &#039;\@&#039;,
    &#039;plussign&#039;               =&gt; &#039;\+&#039;,
    &#039;singledot&#039;              =&gt; &#039;\.&#039;,
    &#039;newline&#039;                =&gt; &#039;\n&#039;,
    &#039;doubledot&#039;              =&gt; &#039;\.\.&#039;,
    &#039;lineofdigits&#039;           =&gt; &#039;^\d+$&#039;,
    &#039;lineofnonprintingchars&#039; =&gt; &#039;^[\s\t]*$&#039;,
    &#039;getemailtransport&#039;      =&gt; &#039;^from\s+.*\s+by\s+\S+\s+with\s+(\S+)&#039;,
    &#039;getreceivedfrom&#039;        =&gt; &#039;^from\s+(.*)\s+by\s+&#039;,
    &#039;emailheaderterminator&#039;  =&gt; &#039;^[\r\n]*$&#039;,
    &#039;forwardslash&#039;           =&gt; &#039;\/&#039;,

    &#039;backslash&#039;             =&gt; chr(92) x 4,
    &#039;singlequote&#039;           =&gt; q(&#039;),
    &#039;doublequote&#039;           =&gt; &#039;&quot;&#039;,
    &#039;allspacetabchars&#039;      =&gt; &#039;[\s\t]*&#039;,
    &#039;beginswithspaceortabs&#039; =&gt; &#039;^[\s\t]&#039;,

    doublequotedstring =&gt; $dblquotedstr,
    singlequotedstring =&gt; $sglquotedstr,

    DUNS =&gt; &#039;[0-9]{2}(?:-[0-9]{3}-[0-9]{4}|[0-9]{7})&#039;,

    YYYY_MM_DD =&gt; &#039;[0-9]{4}-(?:1[012]|0[1-9])-(?:3[01]|[12][0-9]|0[1-9])&#039;,

    ipv4 =&gt; &quot;(?:$zero_through_255\.){3}$zero_through_255&quot;,

    iso_z_time =&gt; &#039;[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z&#039;,
);

1;

} # --- END Cpanel/Regex.pm


{ # --- BEGIN Cpanel/Carp.pm
package Cpanel::Carp;


use strict;

# use Cpanel::Parser::Vars (); # perlpkg line 211

our ( $SHOW_TRACE, $OUTPUT_FORMAT, $VERBOSE ) = ( 1, &#039;text&#039;, 0 );

my $__CALLBACK_AFTER_DIE_SPEW;    # Set when we need to run a code ref after spewing on die

my $error_count = 0;

sub import { return enable(); }

sub enable {
    my (
        $callback_before_warn_or_die_spew,    # Runs before the spew on warn or die, currently used in cpanel to ensure we emit headers before body in the event of a warn or die spew
        $callback_before_die_spew,            # Runs before the spew on die, not currently used
        $callback_after_die_spew,             # Runs after the spew on die, currently used in whostmgr to ensure we emit the javascript footer when we die to avoid the UI breaking
    ) = @_;

    $SIG{&#039;__WARN__&#039;} = sub {                  ## no critic qw(Variables::RequireLocalizedPunctuationVars)
        my @caller = caller(1);
        return if defined $caller[3] &amp;&amp; index( $caller[3], &#039;eval&#039; ) &gt; -1;    # Case 35335: Quiet spurious warn errors from evals

        ++$error_count;

        my $time = time();
        my ( $sec, $min, $hour, $mday, $mon, $year ) = localtime($time);

        my ( $gmmin, $gmhour, $gmday ) = ( gmtime($time) )[ 1, 2, 3 ];

        my $gmoffset        = ( $hour * 60 + $min ) - ( $gmhour * 60 + $gmmin ) + 1440 * ( $mday &lt;=&gt; $gmday );
        my $tz              = sprintf( &#039;%+03d%02d&#039;, int( $gmoffset / 60 ), $gmoffset % 60 );
        my $error_timestamp = sprintf( &#039;%04d-%02d-%02d %02d:%02d:%02d %s&#039;, $year + 1900, $mon + 1, $mday, $hour, $min, $sec, $tz );

        my $longmess;
        my $ignorable;
        if ( UNIVERSAL::isa( $_[0], &#039;Cpanel::Exception&#039; ) ) {
            $longmess = Cpanel::Carp::safe_longmess( $_[0]-&gt;to_locale_string() );
        }
        elsif ( ref $_[0] eq &#039;Template::Exception&#039; ) {
            $longmess = Cpanel::Carp::safe_longmess( &quot;Template::Exception:\n\t[TYPE]=[&quot; . $_[0]-&gt;[0] . &quot;]\n\t[INFO]=[&quot; . $_[0]-&gt;[1] . &quot;]\n\t[TEXT]=[&quot; . ( ref $_[0]-&gt;[2] eq &#039;SCALAR&#039; ? ${ $_[0]-&gt;[2] } : $_[0]-&gt;[2] ) . &quot;]\n&quot; );
        }
        else {
            $longmess  = Cpanel::Carp::safe_longmess(@_);
            $ignorable = 1 if index( $_[0], &#039;Use of uninitialized value&#039; ) == 0;
        }

        my $error_container_text = &#039;A warning occurred while processing this directive.&#039;;

        my $current_file = $Cpanel::Parser::Vars::file || &#039;unknown&#039;;
        print STDERR &quot;[$error_timestamp] warn [Internal Warning while parsing $current_file $$] $longmess\n\n&quot;;

        return if ( $OUTPUT_FORMAT eq &#039;suppress&#039; || $OUTPUT_FORMAT eq &#039;supress&#039; || $ENV{&#039;CPANEL_PHPENGINE&#039;} );

        return if $ignorable &amp;&amp; !$VERBOSE;

        _run_callback_without_die_handler($callback_before_warn_or_die_spew) if $callback_before_warn_or_die_spew;

        if ( $OUTPUT_FORMAT eq &#039;html&#039; ) {
            if ($SHOW_TRACE) {
                _print_without_die_handler( _generate_html_error_message( &#039;warn&#039;, $error_container_text, $longmess ) );
            }
            else {
                _print_without_die_handler(qq{&lt;span class=&quot;error&quot; style=&quot;cursor:hand;cursor:pointer;&quot;&gt;[$error_container_text]&lt;/span&gt;});
            }
        }
        elsif ( $OUTPUT_FORMAT eq &#039;xml&#039; ) {
            _print_without_die_handler(&quot;&lt;error&gt;$error_container_text&lt;/error&gt;&quot;);
        }
        else {
            _print_without_die_handler(&quot;[$error_container_text]\n&quot;);
        }
    };

    $SIG{&#039;__DIE__&#039;} = sub {    ## no critic qw(Variables::RequireLocalizedPunctuationVars)

        return if $^S;

        die $_[0] unless defined $^S;

        delete $SIG{&#039;__DIE__&#039;};
        _run_callback_without_die_handler($callback_before_warn_or_die_spew) if $callback_before_warn_or_die_spew;
        _run_callback_without_die_handler($callback_before_die_spew)         if $callback_before_die_spew;

        $__CALLBACK_AFTER_DIE_SPEW = $callback_after_die_spew;

        goto \&amp;spew_on_die;
    };

    return 1;
}

sub spew_on_die {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my ($err) = @_;

    ++$error_count;

    my $time = time();
    my ( $sec, $min, $hour, $mday, $mon, $year ) = localtime($time);

    my ( $gmmin, $gmhour, $gmday ) = ( gmtime($time) )[ 1, 2, 3 ];

    my $gmoffset        = ( $hour * 60 + $min ) - ( $gmhour * 60 + $gmmin ) + 1440 * ( $mday &lt;=&gt; $gmday );
    my $tz              = sprintf( &#039;%+03d%02d&#039;, int( $gmoffset / 60 ), $gmoffset % 60 );
    my $error_timestamp = sprintf( &#039;%04d-%02d-%02d %02d:%02d:%02d %s&#039;, $year + 1900, $mon + 1, $mday, $hour, $min, $sec, $tz );

    my $error_text;
    if ( UNIVERSAL::isa( $err, &#039;Cpanel::Exception&#039; ) ) {
        $error_text = Cpanel::Carp::safe_longmess( $err-&gt;to_locale_string() );
    }
    elsif ( UNIVERSAL::isa( $err, &#039;Template::Exception&#039; ) ) {
        $error_text = Cpanel::Carp::safe_longmess( &quot;Template::Exception:\n\t[TYPE]=[&quot; . $err-&gt;type() . &quot;]\n\t[INFO]=[&quot; . $err-&gt;info() . &quot;]\n\t[TEXT]=[&quot; . $err-&gt;text() . &quot;]\n&quot; );
    }
    else {
        $error_text = Cpanel::Carp::safe_longmess(@_);
    }

    my $current_file = $Cpanel::Parser::Vars::file || &#039;unknown&#039;;
    print STDERR &quot;[$error_timestamp] die [Internal Death while parsing $current_file $$] $error_text\n\n&quot;;

    return if ( $OUTPUT_FORMAT eq &#039;suppress&#039; || $OUTPUT_FORMAT eq &#039;supress&#039; || $ENV{&#039;CPANEL_PHPENGINE&#039;} );

    my $error_container_text = &#039;A fatal error or timeout occurred while processing this directive.&#039;;

    if ( $OUTPUT_FORMAT eq &#039;html&#039; ) {
        if ($SHOW_TRACE) {
            _print_without_die_handler( _generate_html_error_message( &#039;error&#039;, $error_container_text, $error_text ) );
        }
        else {
            _print_without_die_handler(qq{&lt;span class=&quot;error&quot; style=&quot;cursor:hand;cursor:pointer;&quot;&gt;[$error_container_text]&lt;/span&gt;});
        }
    }
    elsif ( $OUTPUT_FORMAT eq &#039;xml&#039; ) {
        _print_without_die_handler(&quot;&lt;error&gt;[$error_container_text]&lt;/error&gt;&quot;);
    }
    else {
        _print_without_die_handler(&quot;[$error_container_text]\n&quot;);
    }

    _run_callback_without_die_handler($__CALLBACK_AFTER_DIE_SPEW) if $__CALLBACK_AFTER_DIE_SPEW;

    return;
}

my @SAFE_LONGMESS_KEY_REGEXP_ITEMS = (
    &#039;(?&lt;![a-zA-Z0-9_])pw(?![a-zA-Z0-9_])&#039;,
    qw(
      hash
      pass
      auth
      root
      key
      fullbackup
    ),
);

my @SAFE_LONGMESS_FUNCTION_REGEXP_ITEMS = (
    @SAFE_LONGMESS_KEY_REGEXP_ITEMS,
    &#039;__ANON__&#039;,
);

sub _print_without_die_handler {
    my ($text) = @_;

    local $SIG{&#039;__WARN__&#039;} = sub { };
    local $SIG{&#039;__DIE__&#039;}  = &#039;DEFAULT&#039;;

    return print $text;
}

sub _run_callback_without_die_handler {
    my ($callback) = @_;
    local $SIG{&#039;__WARN__&#039;} = sub { };
    local $SIG{&#039;__DIE__&#039;}  = &#039;DEFAULT&#039;;

    return $callback-&gt;();
}

sub _generate_html_error_message {
    my ( $type, $error_container_message, $error_message ) = @_;

    require Cpanel::Encoder::Tiny;
    my $safe_error_message = Cpanel::Encoder::Tiny::safe_html_encode_str($error_message);


    return qq[
&lt;style type=&quot;text/css&quot;&gt;.cpanel_internal_message_container {display: inline-block; margin: 10px; width: auto;} .cpanel_internal_message { border: 1px solid #fff; outline-style: solid; outline-width: 1px; outline-color: #aaa; padding: 5px; } .cpanel_internal_error_warn { background-color: #FFF6CF; } .cpanel_internal_error_error { background-color: #F8E7E6; }&lt;/style&gt;
&lt;div id=&quot;cpanel_notice_item_$error_count&quot; class=&quot;cjt-pagenotice-container cjt-notice-container cpanel_internal_message_container internal-error-container&quot;&gt;
    &lt;div class=&quot;yui-module cjt-notice cjt-pagenotice cjt-notice-$type&quot;&gt;
        &lt;div class=&quot;cpanel_internal_message cpanel_internal_error_$type bd&quot;&gt;
            &lt;div class=&quot;cjt-notice-content&quot; style=&quot;width: 420px;&quot;&gt;
                &lt;span&gt;
                    $error_container_message
                    &lt;a
                        class=&quot;error&quot;
                        style=&quot;cursor:hand;cursor:pointer;&quot;
                        onClick=&quot;document.getElementById(&#039;cpanel_internal_error_$error_count&#039;).style.display=&#039;&#039;;this.style.display=&#039;none&#039;; return false;&quot;&gt;
                        [show]
                    &lt;/a&gt;
                    &lt;a
                        class=&quot;error&quot;
                        style=&quot;cursor:hand;cursor:pointer;&quot;
                        onClick=&quot;document.getElementById(&#039;cpanel_notice_item_$error_count&#039;).style.display=&#039;none&#039;; return false;&quot;&gt;
                        [close]
                    &lt;/a&gt;
                &lt;/span&gt;
                &lt;div id=&quot;cpanel_internal_error_$error_count&quot; style=&quot;display:none;&quot;&gt;
                    &lt;textarea class=&quot;cpanel_internal_error_$type&quot; style=&quot;font-weight:900; height:200px; width:410px; color: black;&quot;&gt;$safe_error_message&lt;/textarea&gt;
                &lt;/div&gt;
            &lt;/div&gt;
        &lt;/div&gt;
    &lt;/div&gt;
&lt;/div&gt;
    ];
}

sub safe_longmess {
    require Carp;
    $Carp::Internal{&#039;Cpanel::Carp&#039;} = 1;
    return sanitize_longmess( scalar Carp::longmess(@_) );
}

my ( $key_regexp, $key_regexp_double, $function_regexp );

sub sanitize_longmess {

    _build_regexes() if !$key_regexp;

    return join(
        &quot;\n&quot;,
        map {
            ( tr{&#039;&quot;}{} &amp;&amp; ( m{$key_regexp}o || m{$key_regexp_double}o || ( ( $_ =~ m{^[ \t]*([^\(]+)\(} )[0] || &#039;&#039; ) =~ m{$function_regexp}o ) )    # matches a line that needs to be sanitized
              &amp;&amp; _sanitize_line($_);                                                                                                                # sanitize
            $_
        } split( m{\n}, $_[0] )
    ) . &quot;\n&quot;;
}

sub error_count {
    return $error_count;
}

sub _sanitize_line {    # Operates directly on $_[0] for speed
    if ( !$INC{&#039;Cpanel/Regex.pm&#039;} ) {    # PPI NO PARSE - inc check
        local $@;
        eval {
            local $SIG{__DIE__};
            local $SIG{__WARN__};
            require Cpanel::Regex;    # PPI NO PARSE - inc check
        };
    }
    $_[0] =~ s/$Cpanel::Regex::regex{&#039;singlequotedstring&#039;}/__CPANEL_HIDDEN__/go if index( $_[0], q{&#039;} ) != -1;
    $_[0] =~ s/$Cpanel::Regex::regex{&#039;doublequotedstring&#039;}/__CPANEL_HIDDEN__/go if index( $_[0], q{&quot;} ) != -1;
    return 1;
}

sub _build_regexes {

    my $key_regexp_items = join &#039;|&#039;, @SAFE_LONGMESS_KEY_REGEXP_ITEMS;
    $key_regexp = qr&lt;
        &#039;
        .*?
        (?:
            $key_regexp_items
        )
        .*?
        &#039;
        \s*
        ,
    &gt;x;

    $key_regexp_double = $key_regexp;
    $key_regexp_double =~ tr{&#039;}{&quot;};    # &quot;&#039; fix for poor editors

    my $function_regexp_items = join &#039;|&#039;, @SAFE_LONGMESS_FUNCTION_REGEXP_ITEMS;
    $function_regexp = qr&lt;
        ::
        .*?
        (?:
            $function_regexp_items
        )
        .*?
        $
    &gt;x;

    return 1;
}

1;

} # --- END Cpanel/Carp.pm


{ # --- BEGIN Cpanel/Set.pm
package Cpanel::Set;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub difference {
    my ($super_ar) = @_;

    my %lookup;
    @lookup{ map { @$_ } @_[ 1 .. $#_ ] } = ();

    return grep { !exists $lookup{$_} } @$super_ar;
}


sub intersection {
    my ( $super_ar, $sub_ar ) = @_;

    my %lookup;
    @lookup{@$sub_ar} = ();

    return grep { exists $lookup{$_} } @$super_ar;
}

1;

} # --- END Cpanel/Set.pm


{ # --- BEGIN Cpanel/TimeHiRes.pm
package Cpanel::TimeHiRes;


use strict;
use warnings;
no warnings &#039;once&#039;;


use constant {
    _gettimeofday =&gt; 96,

    _clock_gettime  =&gt; 228,
    _CLOCK_REALTIME =&gt; 0,

    _EINTR =&gt; 4,

    _PACK_TEMPLATE =&gt; &#039;L!L!&#039;,
};


sub clock_gettime {
    my $timeval = pack( _PACK_TEMPLATE, () );

    _get_time_from_syscall(
        _clock_gettime,
        _CLOCK_REALTIME,
        $timeval,
    );

    return unpack( _PACK_TEMPLATE, $timeval );
}


sub time {
    my ( $secs, $nsecs ) = clock_gettime();

    return $secs + ( $nsecs / 1_000_000_000 );
}


sub sleep {
    my ($secs) = @_;


    local $!;
    my $retval = select( undef, undef, undef, $secs );
    if ( $retval == -1 &amp;&amp; $! != _EINTR ) {
        require Cpanel::Exception;
        die &#039;Cpanel::Exception&#039;-&gt;can(&#039;create&#039;)-&gt;( &#039;SystemCall&#039;, &#039;The system failed to suspend command execution for [quant,_1,second,seconds] because of an error: [_2]&#039;, [ $secs, $! ] );
    }

    return $secs;
}


sub gettimeofday {
    my $timeval = pack( _PACK_TEMPLATE, () );

    _get_time_from_syscall(
        _gettimeofday,
        $timeval,
        undef,
    );

    return unpack( _PACK_TEMPLATE, $timeval );
}


sub _get_time_from_syscall {    ##no critic qw(RequireArgUnpacking)
    my $syscall_num = shift;

    local $!;
    my $retval = syscall( $syscall_num, @_ );
    if ( $retval == -1 ) {
        require Cpanel::Exception;
        die &#039;Cpanel::Exception&#039;-&gt;can(&#039;create&#039;)-&gt;( &#039;SystemCall&#039;, &#039;The system failed to retrieve the time because of an error: [_1]&#039;, [$!] );
    }

    return;
}

1;

} # --- END Cpanel/TimeHiRes.pm


{ # --- BEGIN Cpanel/SafeFileLock.pm
package Cpanel::SafeFileLock;


use strict;
use warnings;
no warnings &#039;once&#039;;


use constant {
    _ENOENT =&gt; 2,
    _EDQUOT =&gt; 122,
    DEBUG   =&gt; 0,

    MAX_LOCKFILE_SIZE =&gt; 8192,
};


sub new {
    my ( $class, $path_to_lockfile, $fh, $path_to_file_being_locked ) = @_;

    if ( scalar @_ != 4 ) {
        die &#039;Usage: Cpanel::SafeFileLock-&gt;new($path_to_lockfile, $fh, $path_to_file_being_locked)&#039;;
    }

    if ($fh) {
        write_lock_contents( $fh, $path_to_lockfile ) or return;
    }


    my $self = bless [
        $path_to_lockfile,
        $fh,
        $path_to_file_being_locked,
    ], $class;

    push @$self, @{ $self-&gt;stat_ar() }[ 1, 9 ];

    return $self;
}

sub new_before_lock {
    my ( $class, $path_to_lockfile, $path_to_file_being_locked ) = @_;

    if ( scalar @_ != 3 ) {
        die &#039;Usage: Cpanel::SafeFileLock-&gt;new_before_lock($path_to_lockfile, $path_to_file_being_locked)&#039;;
    }

    return bless [
        $path_to_lockfile,
        undef,
        $path_to_file_being_locked,
    ], $class;
}

sub set_filehandle_and_unlinker_after_lock {

    $_[0][1] = $_[1];

    push @{ $_[0] }, @{ $_[0]-&gt;stat_ar() }[ 1, 9 ];

    $_[0][5] = $_[2];
    return $_[0];
}

sub get_path {
    return $_[0]-&gt;[0];
}

sub get_path_to_file_being_locked {
    return $_[0]-&gt;[2] // die &quot;get_path_to_file_being_locked requires the object to be instantiated with the path_to_file_being_locked&quot;;
}

sub set_filehandle {
    $_[0][1] = $_[1];
    return $_[0];
}

sub get_filehandle {
    return $_[0]-&gt;[1];
}

sub get_inode {
    return $_[0]-&gt;[3];
}

sub get_mtime {
    return $_[0]-&gt;[4];
}

sub get_path_fh_inode_mtime {
    return @{ $_[0] }[ 0, 1, 3, 4 ];
}

sub stat_ar {
    return [ stat( ( $_[0]-&gt;[1] &amp;&amp; fileno( $_[0]-&gt;[1] ) ) ? $_[0]-&gt;[1] : $_[0]-&gt;[0] ) ];
}

sub lstat_ar {

    return [ $_[0]-&gt;[1] &amp;&amp; fileno( $_[0]-&gt;[1] ) ? stat( $_[0]-&gt;[1] ) : lstat( $_[0]-&gt;[0] ) ];
}

sub close {

    return close $_[0]-&gt;[1] if ref $_[0]-&gt;[1];

    $_[0]-&gt;[5] = undef;

    return;
}


sub write_lock_contents {    ## no critic qw(Subroutines::RequireArgUnpacking) -- only unpack on the failure case
    local $!;

    if (DEBUG) {
        require Cpanel::Carp;
        return 1 if syswrite( $_[0], &quot;$$\n$0\n&quot; . Cpanel::Carp::safe_longmess() . &quot;\n&quot; );
    }
    return 1 if syswrite( $_[0], &quot;$$\n$0\n&quot; );

    my ( $fh, $path_to_lockfile ) = @_;
    my $write_error = $!;

    CORE::close($fh);
    unlink $path_to_lockfile;

    require Cpanel::Exception;
    die Cpanel::Exception::create( &#039;IO::FileWriteError&#039;, [ &#039;path&#039; =&gt; $path_to_lockfile, &#039;error&#039; =&gt; $write_error ] );
}

sub fetch_lock_contents_if_exists {
    my ($lockfile) = @_;

    die &#039;Need lock file!&#039; if !$lockfile;

    open my $lockfile_fh, &#039;&lt;:stdio&#039;, $lockfile or do {
        return if $! == _ENOENT();

        die &quot;open($lockfile): $!&quot;;
    };

    my $buffer;
    my $read_result = read( $lockfile_fh, $buffer, MAX_LOCKFILE_SIZE );

    if ( !defined $read_result ) {
        die &quot;read($lockfile): $!&quot;;
    }

    my ( $pid_line, $lock_name, $lock_obj ) = split( /\n/, $buffer, 3 );
    chomp($lock_name) if length $lock_name;
    my ($lock_pid) = $pid_line &amp;&amp; ( $pid_line =~ m/(\d+)/ );

    return ( $lock_pid, $lock_name || &#039;unknown&#039;, $lock_obj || &#039;unknown&#039;, $lockfile_fh );
}


1;


} # --- END Cpanel/SafeFileLock.pm


{ # --- BEGIN Cpanel/FHUtils/Tiny.pm
package Cpanel::FHUtils::Tiny;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub is_a {
    return !ref $_[0] ? 0 : ( ref $_[0] eq &#039;IO::Handle&#039; || ref $_[0] eq &#039;GLOB&#039; || UNIVERSAL::isa( $_[0], &#039;GLOB&#039; ) ) ? 1 : 0;
}


sub are_same {
    my ( $fh1, $fh2 ) = @_;

    return 1 if $fh1 eq $fh2;

    if ( fileno($fh1) &amp;&amp; ( fileno($fh1) != -1 ) &amp;&amp; fileno($fh2) &amp;&amp; ( fileno($fh2) != -1 ) ) {
        return 1 if fileno($fh1) == fileno($fh2);
    }

    return 0;
}


sub to_bitmask {
    my @fhs = @_;

    my $mask = q&lt;&gt;;

    for my $fh (@fhs) {
        vec( $mask, ref($fh) ? fileno($fh) : $fh, 1 ) = 1;
    }

    return $mask;
}

1;

} # --- END Cpanel/FHUtils/Tiny.pm


{ # --- BEGIN Cpanel/Hash.pm
package Cpanel::Hash;


use strict;


*get_fastest_hash = \&amp;fnv1a_32;


use constant FNV1_32A_INIT =&gt; 0x811c9dc5;

use constant FNV_32_PRIME =&gt; 0x01000193;

use constant FNV_32_MOD =&gt; 2**32;    # AKA 0x100000000 but that it non-portable;
sub fnv1a_32 {
    my $fnv32 = FNV1_32A_INIT();
    ( $fnv32 = ( ( $fnv32 ^ $_ ) * FNV_32_PRIME() ) % FNV_32_MOD ) for unpack( &#039;C*&#039;, $_[0] );
    return $fnv32;
}

1;

} # --- END Cpanel/Hash.pm


{ # --- BEGIN Cpanel/SafeFile/LockInfoCache.pm
package Cpanel::SafeFile::LockInfoCache;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::SafeFileLock (); # perlpkg line 211


sub new {
    my ( $class, $pathname ) = @_;

    die &#039;need path!&#039; if !$pathname;

    return bless { _path =&gt; $pathname }, $class;
}


sub get {
    my ( $self, $inode, $mtime ) = @_;

    die &#039;Need an inode &amp; an mtime!&#039; if !defined $inode || !defined $mtime;

    if ( !exists $self-&gt;{&quot;_inode_${inode}_$mtime&quot;} ) {
        my ( $pid, $name, $obj, $fh ) = Cpanel::SafeFileLock::fetch_lock_contents_if_exists( $self-&gt;{&#039;_path&#039;} );

        if ($pid) {

            my ( $real_inode, $real_mtime ) = ( stat $fh )[ 1, 9 ];
            $self-&gt;{&quot;_inode_${real_inode}_$real_mtime&quot;} = [ $pid, $name, $obj ];
        }
    }

    return $self-&gt;{&quot;_inode_${inode}_$mtime&quot;} ||= undef;
}

1;

} # --- END Cpanel/SafeFile/LockInfoCache.pm


{ # --- BEGIN Cpanel/SafeFile/LockWatcher.pm
package Cpanel::SafeFile::LockWatcher;


use strict;
use warnings;
no warnings &#039;once&#039;;

use constant _ENOENT =&gt; 2;

use constant _FILEHANDLE_TTL =&gt; 2;


sub new {
    my ( $class, $lockfile ) = @_;

    my $self = bless { _path =&gt; $lockfile, _new =&gt; 1 }, $class;

    return $self-&gt;reload_from_disk();
}


sub reload_from_disk {
    my ($self) = @_;

    my $old_inode = $self-&gt;{&#039;inode&#039;};
    @{$self}{qw( inode  uid  size mtime)} = $self-&gt;_get_inode_uid_size_mtime();

    if ( delete $self-&gt;{&#039;_new&#039;} ) {
        $self-&gt;{&#039;changed&#039;} = 0;
    }
    else {
        $self-&gt;{&#039;changed&#039;} = ( $self-&gt;{&#039;inode&#039;} || 0 ) != ( $old_inode || 0 ) ? 1 : 0;
    }

    return $self;
}

sub _get_inode_uid_size_mtime {
    my ($self) = @_;

    my ( $inode, $uid, $size, $mtime );

    local $!;

    if ( open my $fh, &#039;&lt;&#039;, $self-&gt;{&#039;_path&#039;} ) {
        ( $inode, $uid, $size, $mtime ) = ( stat $fh )[ 1, 4, 7, 9 ];

        $self-&gt;_add_fh_if_needed( $fh, $inode );
    }
    elsif ( $! != _ENOENT ) {
        die &quot;open(&lt;, $self-&gt;{&#039;_path&#039;}): $!&quot;;
    }

    return ( $inode, $uid, $size, $mtime );
}

sub _add_fh_if_needed {
    my ( $self, $fh, $inode ) = @_;

    my $now        = time;
    my $fhs_hr     = $self-&gt;{&#039;_time_fhs&#039;} //= {};
    my $seen_inode = 0;

    for my $time ( keys %$fhs_hr ) {

        if ( ( $now - $time ) &gt; _FILEHANDLE_TTL() ) {
            delete $fhs_hr-&gt;{$time};
            next;
        }

        if ( !$seen_inode ) {
            foreach my $entry ( @{ $fhs_hr-&gt;{$time} } ) {
                if ( $entry-&gt;[1] == $inode ) {
                    $seen_inode = 1;
                    last;
                }
            }
        }
    }

    return if $seen_inode;

    push @{ $fhs_hr-&gt;{ time() } }, [ $fh, $inode ];

    return;
}

1;

} # --- END Cpanel/SafeFile/LockWatcher.pm


{ # --- BEGIN Cpanel/Syscall.pm
package Cpanel::Syscall;


use strict;

my %NAME_TO_NUMBER = qw(
  close             3
  fcntl            72
  getrandom       318
  lchown           94
  getrlimit        97
  getsid          124
  gettimeofday     96
  sendfile         40
  setrlimit       160
  splice          275
  write             1
  setsid          112
  getsid          124
  inotify_init1     294
  inotify_add_watch 254
  inotify_rm_watch  255
  setresuid       117
  setresgid       119
  setgroups       116
  umount2         166
);

sub name_to_number {
    my ($name) = @_;

    return $NAME_TO_NUMBER{$name} || _die_unknown_syscall($name);
}

sub _die_unknown_syscall {
    my ($name) = @_;

    die &quot;Unknown system call: “$name”&quot;;
}

sub syscall {    ##no critic qw(RequireArgUnpacking)
    local $!;

    _die_unknown_syscall( $_[0] ) unless defined $_[0] &amp;&amp; $NAME_TO_NUMBER{ $_[0] };

    my $ret = CORE::syscall( $NAME_TO_NUMBER{ $_[0] }, scalar @_ &gt; 1 ? @_[ 1 .. $#_ ] : () );
    if ( ( $ret == -1 ) &amp;&amp; $! ) {
        if ( $INC{&#039;Cpanel/Exception.pm&#039;} ) {
            die Cpanel::Exception::create( &#039;SystemCall&#039;, [ name =&gt; $_[0], error =&gt; $!, arguments =&gt; [ @_[ 1 .. $#_ ] ] ] );
        }
        else {
            die &quot;Failed system call “$_[0]”: $!&quot;;
        }
    }

    return $ret;
}

1;

} # --- END Cpanel/Syscall.pm


{ # --- BEGIN Cpanel/Inotify.pm
package Cpanel::Inotify;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Autodie          (); # perlpkg line 211
# use Cpanel::Context          (); # perlpkg line 211
# use Cpanel::Exception        (); # perlpkg line 211
# use Cpanel::Fcntl::Constants (); # perlpkg line 211
# use Cpanel::Pack             (); # perlpkg line 211
# use Cpanel::Syscall          (); # perlpkg line 211

use constant POLL_SIZE =&gt; 65536;

use constant READ_TEMPLATE =&gt; (
    wd     =&gt; &#039;i&#039;,    #int        Watch descriptor
    mask   =&gt; &#039;I&#039;,    #uint32_t   Mask of events
    cookie =&gt; &#039;I&#039;,    #uint32_t   Unique cookie associating related events
    len    =&gt; &#039;I&#039;,    #uint32_t   Size of “name” field
);

my %add_flags;
my %read_flags;
my %init1_flag;

my $UNPACK_OBJ;
my $UNPACK_SIZE;


sub new {
    my ( $class, %opts ) = @_;

    if ( !$UNPACK_OBJ ) {
        $UNPACK_OBJ  = Cpanel::Pack-&gt;new( [ READ_TEMPLATE() ] );
        $UNPACK_SIZE = $UNPACK_OBJ-&gt;sizeof();

        _setup_flags();
    }

    my @given_flags = $opts{&#039;flags&#039;} ? @{ $opts{&#039;flags&#039;} } : ();

    my $mask = 0;
    for my $f (@given_flags) {
        $mask |= $init1_flag{$f} || do {
            die Cpanel::Exception-&gt;create_raw(&quot;Invalid inotify_init1 flag: “$f”&quot;);
        };
    }

    my $fd = Cpanel::Syscall::syscall( &#039;inotify_init1&#039;, $mask );

    my %self = (
        _fd =&gt; $fd,
    );
    Cpanel::Autodie::open( $self{&#039;_fh&#039;}, &#039;&lt;&amp;=&#039;, $fd );

    return bless \%self, $class;
}


sub add {
    my ( $self, $path, %opts ) = @_;

    my @flags = @{ $opts{&#039;flags&#039;} };

    my $mask = 0;
    for my $f (@flags) {
        $mask |= $add_flags{$f} || do {
            die Cpanel::Exception-&gt;create_raw(&quot;Invalid inotify_add_watch flag: “$f”&quot;);
        };
    }

    my $wd = Cpanel::Syscall::syscall(
        &#039;inotify_add_watch&#039;,
        $self-&gt;{&#039;_fd&#039;},
        $path,
        $mask,
    );

    if ( $wd &lt; 1 ) {
        die Cpanel::Exception-&gt;create_raw(&quot;inotify watch descriptor “$wd” means something is wrong?&quot;);
    }

    $self-&gt;{&#039;_watches&#039;}{$wd} = $path;

    return $wd;
}


sub remove {
    my ( $self, $wd ) = @_;

    Cpanel::Syscall::syscall( &#039;inotify_rm_watch&#039;, $self-&gt;{&#039;_fd&#039;}, $wd );

    return;
}


sub poll {
    my ($self) = @_;

    Cpanel::Context::must_be_list();

    my $buf = q&lt;&gt;;

    Cpanel::Autodie::sysread_sigguard( $self-&gt;{&#039;_fh&#039;}, $buf, POLL_SIZE() );

    my @events;

    while ( length $buf ) {
        my $evt = $UNPACK_OBJ-&gt;unpack_to_hashref( substr( $buf, 0, $UNPACK_SIZE, q&lt;&gt; ) );
        $evt-&gt;{&#039;name&#039;} = substr( $buf, 0, delete( $evt-&gt;{&#039;len&#039;} ), q&lt;&gt; );
        $evt-&gt;{&#039;name&#039;} =~ s&lt;\0+\z&gt;&lt;&gt;;    #trailing NULs

        $evt-&gt;{&#039;flags&#039;} = _mask_to_flags_ar( delete $evt-&gt;{&#039;mask&#039;} );

        push @events, $evt;
    }

    return @events;
}


sub fileno {
    my ($self) = @_;
    return fileno( $self-&gt;{&#039;_fh&#039;} );
}


sub _mask_to_flags_ar {
    my ($mask) = @_;

    my @flags;
    for my $k ( keys %read_flags ) {
        push @flags, $k if $mask &amp; $read_flags{$k};
    }

    @flags = sort @flags;

    return \@flags;
}

sub _setup_flags {

    my %flag_num = (
        ACCESS        =&gt; 0x1,      # File was accessed
        MODIFY        =&gt; 0x2,      # File was modified
        ATTRIB        =&gt; 0x4,      # Metadata changed
        CLOSE_WRITE   =&gt; 0x8,      # File opened for writing was closed
        CLOSE_NOWRITE =&gt; 0x10,     # File not opened for writing was closed
        OPEN          =&gt; 0x20,     # File was opened
        MOVED_FROM    =&gt; 0x40,     # File was moved from X
        MOVED_TO      =&gt; 0x80,     # File was moved to Y
        CREATE        =&gt; 0x100,    # Subfile was created
        DELETE        =&gt; 0x200,    # Subfile was deleted
        DELETE_SELF   =&gt; 0x400,    # Self was deleted
        MOVE_SELF     =&gt; 0x800,    # Self was moved
    );

    %read_flags = (
        %flag_num,

        UNMOUNT    =&gt; 0x00002000,    # Backing fs was unmounted
        Q_OVERFLOW =&gt; 0x00004000,    # Event queued overflowed (&#039;wd&#039; is -1)
        IGNORED    =&gt; 0x00008000,    # Watch was removed
        ISDIR      =&gt; 0x40000000,    # event occurred against dir
    );

    %add_flags = (
        %flag_num,

        ONLYDIR     =&gt; 0x01000000,    # only watch the path if it is a directory
        DONT_FOLLOW =&gt; 0x02000000,    # don&#039;t follow a sym link
        EXCL_UNLINK =&gt; 0x04000000,    # exclude events on unlinked objects
        MASK_ADD    =&gt; 0x20000000,    # add to the mask of an already existing watch
        ONESHOT     =&gt; 0x80000000,    # only send event once

        CLOSE =&gt; $read_flags{&#039;CLOSE_WRITE&#039;} | $read_flags{&#039;CLOSE_NOWRITE&#039;},
        MOVE  =&gt; $read_flags{&#039;MOVED_FROM&#039;} | $read_flags{&#039;MOVED_TO&#039;},
    );

    my $mask = 0;
    $mask |= $_ for values %flag_num;

    $add_flags{&#039;ALL_EVENTS&#039;} = $mask;

    %init1_flag = (
        CLOEXEC  =&gt; $Cpanel::Fcntl::Constants::O_CLOEXEC,
        NONBLOCK =&gt; $Cpanel::Fcntl::Constants::O_NONBLOCK,
    );

    return;
}

1;

} # --- END Cpanel/Inotify.pm


{ # --- BEGIN Cpanel/SafeFile.pm
package Cpanel::SafeFile;


use strict;
use warnings;
no warnings &#039;once&#039;;


# use Cpanel::TimeHiRes        (); # perlpkg line 211
# use Cpanel::Fcntl::Constants (); # perlpkg line 211
# use Cpanel::SafeFileLock     (); # perlpkg line 211
# use Cpanel::FHUtils::Tiny    (); # perlpkg line 211

use constant {
    _EWOULDBLOCK =&gt; 11,
    _EACCES      =&gt; 13,
    _EDQUOT      =&gt; 122,
    _ENOENT      =&gt; 2,
    _EINTR       =&gt; 4,
    _EEXIST      =&gt; 17,
    _ENOSPC      =&gt; 28,
    _EPERM       =&gt; 1,

    MAX_LOCK_CREATE_ATTEMPTS =&gt; 90,

    NO_PERM_TO_WRITE_TO_DOTLOCK_DIR =&gt; -1,

    INOTIFY_FILE_DISAPPEARED =&gt; 2,

    CREATE_FCNTL_VALUE =&gt; ( $Cpanel::Fcntl::Constants::O_WRONLY | $Cpanel::Fcntl::Constants::O_EXCL | $Cpanel::Fcntl::Constants::O_CREAT | $Cpanel::Fcntl::Constants::O_NONBLOCK ),
    UNLOCK_FCNTL_VALUE =&gt; $Cpanel::Fcntl::Constants::LOCK_UN,

    LOCK_FILE_PERMS =&gt; 0644,

    DEFAULT_LOCK_WAIT_TIME =&gt; 196,

    MAX_LOCK_WAIT_TIME =&gt; 400,

    MAX_LOCK_FILE_LENGTH =&gt; 225,
};

$Cpanel::SafeFile::VERSION = &#039;5.0&#039;;

my $OVERWRITE_FCNTL_VALUE;
my $verbose = 0;    # initialized in safelock

our $LOCK_WAIT_TIME;    #allow lock wait time to be overwritten

my $OPEN_LOCKS = 0;

our $TIME_BETWEEN_DOTLOCK_CHECKS = 0.3;
our $TIME_BETWEEN_FLOCK_CHECKS   = 0.05;
our $MAX_FLOCK_WAIT              = 60;     # allowed to be overwritten in tests

our $_SKIP_DOTLOCK_WHEN_NO_PERMS = 0;

our $_SKIP_WARN_ON_OPEN_FAIL = 0;


my $DOUBLE_LOCK_DETECTED = 4096;

sub safeopen {    #fh, open()-style mode, path
    my ( $mode, $file ) = _get_open_args( @_[ 1 .. $#_ ] );

    my $open_method_coderef = sub {
        my $ret = open( $_[0], $_[1], $_[2] ) || do {
            _log_warn(&quot;open($_[1], $_[2]): $!&quot;);
            return undef;
        };
        return $ret;
    };

    return _safe_open( $_[0], $mode, $file, $open_method_coderef, &#039;safeopen&#039; );
}

sub safesysopen_no_warn_on_fail {
    local $_SKIP_WARN_ON_OPEN_FAIL = 1;

    return safesysopen(@_);
}

sub safesysopen_skip_dotlock_if_not_root {
    local $_SKIP_DOTLOCK_WHEN_NO_PERMS = $&gt; == 0 ? 0 : 1;

    return safesysopen(@_);
}

sub safeopen_skip_dotlock_if_not_root {
    local $_SKIP_DOTLOCK_WHEN_NO_PERMS = $&gt; == 0 ? 0 : 1;

    return safeopen(@_);
}

sub safelock_skip_dotlock_if_not_root {
    local $_SKIP_DOTLOCK_WHEN_NO_PERMS = $&gt; == 0 ? 0 : 1;

    return safelock(@_);
}

sub safereopen {    ##no critic qw(RequireArgUnpacking)
    my $fh = shift;

    if ( !$fh ) {
        require Cpanel::Carp;
        die Cpanel::Carp::safe_longmess(&quot;Undefined filehandle not allowed!&quot;);
    }
    elsif ( !fileno $fh ) {
        require Cpanel::Carp;
        die Cpanel::Carp::safe_longmess(&quot;Closed filehandle ($fh) not allowed!&quot;);
    }

    my ( $mode, $file ) = _get_open_args(@_);

    my $open_method_coderef = sub {
        return open( $_[0], $_[1], $_[2] ) || do {
            _log_warn(&quot;open($_[1], $_[2]): $!&quot;);
            return undef;
        };
    };

    return _safe_re_open( $fh, $mode, $file, $open_method_coderef, &#039;safereopen&#039; );
}

sub safesysopen {    ##no critic qw(RequireArgUnpacking)
    my ( $file, $open_mode, $custom_perms ) = ( @_[ 1 .. 3 ] );

    my ( $sysopen_perms, $original_umask );

    $open_mode = _sanitize_open_mode($open_mode);

    my $open_method_coderef = sub {
        return sysopen( $_[0], $_[2], $_[1], $sysopen_perms ) || do {
            _log_warn(&quot;open($_[2], $_[1], $sysopen_perms): $!&quot;) unless $_SKIP_WARN_ON_OPEN_FAIL;
            return undef;
        };
    };

    if ( defined $custom_perms ) {
        $custom_perms &amp;= 0777;
        $original_umask = umask( $custom_perms ^ 07777 );
        $sysopen_perms  = $custom_perms;
    }
    else {
        $sysopen_perms = 0666;
    }

    my $lock_ref;

    local $@;
    my $ok = eval {
        $lock_ref = _safe_open( $_[0], $open_mode, $file, $open_method_coderef, &#039;safesysopen&#039; );
        1;
    };

    if ( defined $custom_perms ) {
        umask($original_umask);
    }

    die if !$ok;

    return $lock_ref;
}

sub safeclose {
    my ( $fh, $lockref, $do_something_before_releasing_lock ) = @_;

    if ( $do_something_before_releasing_lock &amp;&amp; ref $do_something_before_releasing_lock eq &#039;CODE&#039; ) {
        $do_something_before_releasing_lock-&gt;();
    }

    my $success = 1;
    if ( $fh &amp;&amp; defined fileno $fh ) {

        flock( $fh, UNLOCK_FCNTL_VALUE ) or _log_warn( &quot;flock(LOCK_UN) on “&quot; . $lockref-&gt;get_path() . &quot;” failed with error: $!&quot; );    # LOCK_UN
        $success = close $fh;
    }

    my $safe_unlock = safeunlock($lockref);

    $OPEN_LOCKS-- if ( $safe_unlock &amp;&amp; $success );

    return ( $safe_unlock &amp;&amp; $success );
}

sub safelock {
    my ($file) = @_;

    my $lock_obj = _safelock($file);


    return if !ref $lock_obj;

    return $lock_obj;
}

sub _safelock {
    my ($file) = @_;
    if ( !$file || $file =~ tr/\0// ) {
        _log_warn(&#039;safelock: Invalid arguments&#039;);
        return;
    }
    $verbose ||= ( _verbose_flag_file_exists() ? 1 : -1 );

    my $lockfile      = _calculate_lockfile($file);
    my $safefile_lock = Cpanel::SafeFileLock-&gt;new_before_lock( $lockfile, $file );
    my ( $lock_status, $lock_fh, $attempts, $last_err );

    {
        local $@;

        while ( ++$attempts &lt; MAX_LOCK_CREATE_ATTEMPTS ) {

            ( $lock_status, $lock_fh ) = _lock_wait( $file, $safefile_lock, $lockfile );

            last if $lock_status;

            $last_err = $!;

            if ( $lock_fh &amp;&amp; $lock_fh == $DOUBLE_LOCK_DETECTED ) {
                return 0;
            }
        }

    }

    if ( $lock_fh == 1 ) {
        return 1;
    }
    elsif ( $lock_status &amp;&amp; $lock_fh ) {
        return $safefile_lock;
    }

    _log_warn( &#039;safelock: waited for lock (&#039; . $lockfile . &#039;) &#039; . $attempts . &#039; times&#039; );
    require Cpanel::Exception;
    die Cpanel::Exception::create( &#039;IO::FileCreateError&#039;, [ &#039;path&#039; =&gt; $lockfile, &#039;error&#039; =&gt; $last_err ] );
}

sub _write_temp_lock_file {
    my ($lockfile) = @_;

    my $temp_file = sprintf(
        &#039;%s-%x-%x-%x&#039;,
        $lockfile,
        substr( rand, 2 ),
        scalar( reverse time ),
        scalar( reverse $$ ),
    );

    my ( $ok, $fh_or_err ) = _create_lockfile($temp_file);
    if ( !$ok ) {


        if ( $fh_or_err == _EPERM() || $fh_or_err == _EACCES() ) {

            local $!;

            my $lock_dir = _getdir($lockfile);
            if ( !-w $lock_dir ) {


                if ($_SKIP_DOTLOCK_WHEN_NO_PERMS) {    # A hack to allow /etc/valiases to still be flock()ed until we can refactor
                    return ( NO_PERM_TO_WRITE_TO_DOTLOCK_DIR, $fh_or_err );
                }
                else {
                    _log_warn(&quot;safelock: Failed to create a lockfile &#039;$temp_file&#039; in the directory &#039;$lock_dir&#039; that isn&#039;t writable: $fh_or_err&quot;);
                }
            }
        }

        return ( 0, $fh_or_err );
    }

    Cpanel::SafeFileLock::write_lock_contents( $fh_or_err, $temp_file );

    return ( $temp_file, $fh_or_err );
}

sub _try_to_install_lockfile {
    my ( $temp_file, $lockfile ) = @_;

    link( $temp_file =&gt; $lockfile ) or do {
        return 0 if $! == _EEXIST;

        require Cpanel::Exception;

        die Cpanel::Exception::create( &#039;IO::LinkError&#039;, [ oldpath =&gt; $temp_file, newpath =&gt; $lockfile, error =&gt; $! ] );
    };

    return 1;
}

sub safeunlock {
    my $lockref = shift;

    if ( !$lockref ) {
        _log_warn(&#039;safeunlock: Invalid arguments&#039;);
        return;
    }
    elsif ( !ref $lockref ) {
        return 1 if $lockref eq &#039;1&#039;;    # No lock file created so just succeed
        $lockref = Cpanel::SafeFileLock-&gt;new( $lockref, undef, undef );
        if ( !$lockref ) {
            _log_warn(&quot;safeunlock: failed to generate a Cpanel::SafeFileLock object from a path&quot;);
            return;
        }
    }
    my ( $lock_path, $fh, $lock_inode, $lock_mtime ) = $lockref-&gt;get_path_fh_inode_mtime();

    my ( $filesys_lock_ino, $filesys_lock_mtime ) = ( lstat $lock_path )[ 1, 9 ];

    if ( $fh &amp;&amp; !defined fileno($fh) ) {

        return 1;
    }
    elsif ( !$filesys_lock_mtime ) {
        _log_warn( &#039;Lock on &#039; . $lockref-&gt;get_path_to_file_being_locked() . &#039; lost!&#039; );
        $lockref-&gt;close();
        return;    # return false on false
    }

    elsif ( $lock_inode &amp;&amp; ( $lock_inode == $filesys_lock_ino ) &amp;&amp; $lock_path &amp;&amp; ( $lock_mtime == $filesys_lock_mtime ) ) {
        unlink $lock_path or do {
            _log_warn(&quot;Could not unlink lock file “$lock_path” as ($&gt;/$)): $!\n&quot;);
            $lockref-&gt;close();
            return;    # return false on false
        };
        return $lockref-&gt;close();
    }

    $lockref-&gt;close();
    my ( $lock_pid, $lock_name, $lock_obj ) = Cpanel::SafeFileLock::fetch_lock_contents_if_exists($lock_path);

    if ($lock_pid) {

        if ( $lock_pid == $$ ) {
            unlink $lock_path;    # best-effort; ignore failure
            return 1;
        }

        $lock_inode ||= 0;
        $lock_mtime ||= 0;

        _log_warn(&quot;[$$] Attempt to unlock file that was locked by another process [LOCK_PATH]=[$lock_path] [LOCK_PID]=[$lock_pid] [LOCK_PROCESS]=[$lock_name] [LOCK_INODE]=[$filesys_lock_ino] [LOCK_MTIME]=[$filesys_lock_mtime] -- [NON_LOCK_PID]=[$$] [NON_LOCK_PROCESS]=[$0] [NON_LOCK_INODE]=[$lock_inode] [NON_LOCK_MTIME]=[$lock_mtime]&quot;);
    }
    return;
}

sub _safe_open {

    my ( undef, $open_mode, $file, $open_method_coderef, $open_method ) = @_;

    if ( !defined $open_mode || !$open_method_coderef || !$file || $file =~ tr/\0// ) {
        _log_warn(&#039;_safe_open: Invalid arguments&#039;);
        return;
    }
    elsif ( defined $_[0] ) {
        my $fh_type = ref $_[0];
        if ( !Cpanel::FHUtils::Tiny::is_a( $_[0] ) ) {
            _log_warn(&quot;Invalid file handle type &#039;$fh_type&#039; provided for $open_method of &#039;$file&#039;&quot;);
            return;
        }
    }

    if ( my $lockref = _safelock($file) ) {
        if ( $open_method_coderef-&gt;( $_[0], $open_mode, $file ) ) {
            if ( my $err = _do_flock_or_return_exception( $_[0], $open_mode, $file ) ) {
                safeunlock($lockref);
                local $@ = $err;
                die;
            }

            $OPEN_LOCKS++;
            return $lockref;
        }
        else {

            local $!;

            safeunlock($lockref);
            return;
        }
    }
    else {
        _log_warn(&quot;safeopen: could not acquire a lock for &#039;$file&#039;: $!&quot;);
        return;
    }
}

my $_lock_ex_nb;
my $_lock_sh_nb;

sub _do_flock_or_return_exception {
    my ( $fh, $open_mode, $path ) = @_;

    my $flock_start_time;

    my $lock_op =
      _is_write_open_mode($open_mode)
      ? ( $_lock_ex_nb //= $Cpanel::Fcntl::Constants::LOCK_EX | $Cpanel::Fcntl::Constants::LOCK_NB )
      : ( $_lock_sh_nb //= $Cpanel::Fcntl::Constants::LOCK_SH | $Cpanel::Fcntl::Constants::LOCK_NB );

    local $!;
    my $flock_err;

    my $flock_max_wait_time_is_whole_number = int($MAX_FLOCK_WAIT) == $MAX_FLOCK_WAIT;

    while ( !flock $fh, $lock_op ) {
        $flock_err = $!;

        if ( $flock_err == _EINTR || $flock_err == _EWOULDBLOCK ) {
            if ( !$flock_start_time ) {
                $flock_start_time = $flock_max_wait_time_is_whole_number ? time() : Cpanel::TimeHiRes::time();
                next;
            }

            if ( ( ( $flock_max_wait_time_is_whole_number ? time() : Cpanel::TimeHiRes::time() ) - $flock_start_time ) &gt; $MAX_FLOCK_WAIT ) {
                require Cpanel::Exception;
                return _timeout_exception( $path, $MAX_FLOCK_WAIT );
            }
            else {
                Cpanel::TimeHiRes::sleep($TIME_BETWEEN_FLOCK_CHECKS);
            }
            next;
        }

        require Cpanel::Exception;
        return Cpanel::Exception::create( &#039;IO::FlockError&#039;, [ path =&gt; $path, error =&gt; $flock_err, operation =&gt; $lock_op ] );
    }

    return undef;
}

sub _safe_re_open {
    my ( $fh, $open_mode, $file, $open_method_coderef, $open_method ) = @_;

    if ( !defined $open_mode || !$open_method_coderef || !$file || $file =~ tr/\0// ) {
        _log_warn(&#039;_safe_re_open: Invalid arguments&#039;);
        return;
    }
    else {
        my $fh_type = ref $fh;
        if ( !Cpanel::FHUtils::Tiny::is_a($fh) ) {
            _log_warn(&quot;Invalid file handle type &#039;$fh_type&#039; provided for $open_method of &#039;$file&#039;&quot;);
            return;
        }
    }

    close $fh;
    if ( $open_method_coderef-&gt;( $fh, $open_mode, $file ) ) {
        if ( my $err = _do_flock_or_return_exception( $fh, $open_mode, $file ) ) {
            die $err;
        }

        return $fh;
    }
    return;
}

sub _log_warn {
    require Cpanel::Debug;
    goto &amp;Cpanel::Debug::log_warn;
}

sub _get_open_args {
    my ( $mode, $file ) = @_;
    if ( !$file ) {
        ( $mode, $file ) = $mode =~ m/^([&lt;&gt;+|]+|)(.*)/;
        if ( $file &amp;&amp; !$mode ) {
            $mode = &#039;&lt;&#039;;
        }
        elsif ( !$file ) {
            return;
        }
    }

    $mode =
        $mode eq &#039;&lt;&#039;   ? &#039;&lt;&#039;
      : $mode eq &#039;&gt;&#039;   ? &#039;&gt;&#039;
      : $mode eq &#039;&gt;&gt;&#039;  ? &#039;&gt;&gt;&#039;
      : $mode eq &#039;+&lt;&#039;  ? &#039;+&lt;&#039;
      : $mode eq &#039;+&gt;&#039;  ? &#039;+&gt;&#039;
      : $mode eq &#039;+&gt;&gt;&#039; ? &#039;+&gt;&gt;&#039;
      :                  return;

    return ( $mode, $file );
}

sub _sanitize_open_mode {
    my ($mode) = @_;

    return if $mode =~ m/[^0-9]/;

    my $safe_mode = ( $mode &amp; $Cpanel::Fcntl::Constants::O_RDONLY );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_WRONLY );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_RDWR );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_CREAT );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_EXCL );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_APPEND );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_TRUNC );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_NONBLOCK );

    return $safe_mode;
}

sub _calculate_lockfile {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my $lockfile = $_[0] =~ tr{&lt;&gt;}{} ? ( ( $_[0] =~ /^[&gt;&lt;]*(.*)/ )[0] . &#039;.lock&#039; ) : $_[0] . &#039;.lock&#039;;

    return $lockfile if ( length $lockfile &lt;= MAX_LOCK_FILE_LENGTH );

    require File::Basename;
    my $lock_basename = File::Basename::basename($lockfile);

    return $lockfile if ( length $lock_basename &lt;= MAX_LOCK_FILE_LENGTH );

    require Cpanel::Hash;
    my $hashed_lock_basename = Cpanel::Hash::get_fastest_hash($lock_basename) . &quot;.lock&quot;;

    if ( $lockfile eq $lock_basename ) {
        return $hashed_lock_basename;
    }
    else {
        return File::Basename::dirname($lockfile) . &#039;/&#039; . $hashed_lock_basename;
    }
}

sub is_locked {
    my ($file) = @_;
    my $lockfile = _calculate_lockfile($file);
    my ( $lock_pid, $lock_name, $lock_obj ) = Cpanel::SafeFileLock::fetch_lock_contents_if_exists($lockfile);

    if ( _is_valid_pid($lock_pid) &amp;&amp; _pid_is_alive($lock_pid) ) {
        return 1;
    }

    return 0;
}

sub _timeout_exception {
    my ( $path, $waited ) = @_;

    require Cpanel::Exception;
    return Cpanel::Exception::create( &#039;Timeout&#039;, &#039;The system failed to lock the file “[_1]” after [quant,_2,second,seconds].&#039;, [ $path, $waited ] );
}

sub _die_if_file_is_flocked_cuz_already_waited_a_while {
    my ( $file, $waited ) = @_;

    if ( _open_to_write( my $fh, $file ) ) {
        $_lock_ex_nb //= $Cpanel::Fcntl::Constants::LOCK_EX | $Cpanel::Fcntl::Constants::LOCK_NB;
        if ( flock( $fh, $_lock_ex_nb ) == 1 ) {


            flock $fh, UNLOCK_FCNTL_VALUE or die &quot;Failed to unlock “$file” after having just locked it: $!&quot;;
        }
        else {
            require Cpanel::Exception;

            if ( $! == _EWOULDBLOCK ) {
                die _timeout_exception( $file, $waited );
            }
            else {
                die Cpanel::Exception::create( &#039;IO::FlockError&#039;, [ path =&gt; $file, error =&gt; $!, operation =&gt; $_lock_ex_nb ] );
            }
        }
    }

    return;
}

sub _lock_wait {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my ( $file, $safefile_lock, $lockfile ) = @_;

    my ( $temp_file, $fh ) = _write_temp_lock_file( $lockfile, $file );

    if ( $temp_file eq NO_PERM_TO_WRITE_TO_DOTLOCK_DIR ) {
        return ( 1, 1 );
    }

    if ( !$temp_file ) {
        return ( 0, $fh );
    }

    $safefile_lock-&gt;set_filehandle_and_unlinker_after_lock( $fh, Cpanel::SafeFile::_temp-&gt;new($temp_file) );

    return ( 1, $fh ) if _try_to_install_lockfile( $temp_file, $lockfile );

    local $0 = ( $verbose == 1 ) ? &quot;$0 - waiting for lock on $file&quot; : &quot;$0 - waiting for lock&quot;;

    require Cpanel::SafeFile::LockInfoCache;
    require Cpanel::SafeFile::LockWatcher;

    my $watcher = Cpanel::SafeFile::LockWatcher-&gt;new($lockfile);

    my $waittime = _calculate_waittime_for_file($file);

    my ( $inotify_obj, $inotify_mask, $inotify_file_disappeared );

    my $start_time = time;
    my $waited     = 0;

    my $lockfile_cache = Cpanel::SafeFile::LockInfoCache-&gt;new($lockfile);

    my ( $inotify_inode, $inotify_mtime );

  LOCK_WAIT:
    while (1) {
        $waited = ( time() - $start_time );

        if ( $waited &gt; $waittime ) {

            _die_if_file_is_flocked_cuz_already_waited_a_while( $file, $waited );

            if ( defined $watcher-&gt;{&#039;inode&#039;} ) {
                require Cpanel::Debug;
                Cpanel::Debug::log_warn( sprintf &quot;Replacing stale lock file: $lockfile. The kernel’s lock is gone, last modified %s seconds ago (mtime=$watcher-&gt;{&#039;mtime&#039;}), and waited over $waittime seconds.&quot;, time - $watcher-&gt;{&#039;mtime&#039;} );
            }

            return ( 1, $fh ) if _overwrite_lockfile_if_inode_mtime_matches( $temp_file, $lockfile, $watcher-&gt;{&#039;inode&#039;}, $watcher-&gt;{&#039;mtime&#039;} );

            die _timeout_exception( $file, $waittime );
        }

        if ( $watcher-&gt;{&#039;inode&#039;} ) {
            my $lock_get = $lockfile_cache-&gt;get( @{$watcher}{ &#039;inode&#039;, &#039;mtime&#039; } );

            if ( !$lock_get ) {


                my $size_before_reload = $watcher-&gt;{&#039;size&#039;};
                $watcher-&gt;reload_from_disk();

                if ( $size_before_reload == 0 &amp;&amp; $watcher-&gt;{&#039;size&#039;} == 0 ) {
                    _log_warn(&quot;[$$] UID $&gt; clobbering empty lock file “$lockfile” (UID $watcher-&gt;{&#039;uid&#039;}) written by “unknown” at $watcher-&gt;{&#039;mtime&#039;}&quot;);


                    return ( 1, $fh ) if _overwrite_lockfile_if_inode_mtime_matches( $temp_file, $lockfile, $watcher-&gt;{&#039;inode&#039;}, $watcher-&gt;{&#039;mtime&#039;} );
                }

                next LOCK_WAIT;
            }

            my ( $lock_pid, $lock_name, $lock_obj ) = @$lock_get;

            if ( $lock_pid == $$ ) {
                $watcher-&gt;reload_from_disk();

                _log_warn(&quot;[$$] Double locking detected by self [LOCK_PATH]=[$lockfile] [LOCK_PID]=[$lock_pid] [LOCK_OBJ]=[$lock_obj] [LOCK_PROCESS]=[$lock_name] [ACTUAL_INODE]=[$watcher-&gt;{&#039;inode&#039;}] [ACTUAL_MTIME]=[$watcher-&gt;{&#039;mtime&#039;}]&quot;);
                return ( 0, $DOUBLE_LOCK_DETECTED );
            }
            elsif ( !_pid_is_alive($lock_pid) ) {

                my $time = time();

                if ( _overwrite_lockfile_if_inode_mtime_matches( $temp_file, $lockfile, $watcher-&gt;{&#039;inode&#039;}, $watcher-&gt;{&#039;mtime&#039;} ) ) {
                    _log_warn(&quot;[$$] TIME $time UID $&gt; clobbered stale lock file “$lockfile” (NAME “$lock_name”, UID $watcher-&gt;{&#039;uid&#039;}) written by PID $lock_pid at $watcher-&gt;{&#039;mtime&#039;}&quot;);
                    return ( 1, $fh );
                }

                $watcher-&gt;reload_from_disk();
                next LOCK_WAIT;
            }
            else {
                require Cpanel::Debug;
                Cpanel::Debug::log_info(&quot;[$$] Waiting for lock on $file held by $lock_name with pid $lock_pid&quot;) if $verbose == 1;
            }
        }

        return ( 1, $fh ) if _try_to_install_lockfile( $temp_file, $lockfile );


        $watcher-&gt;reload_from_disk();

        if ( !$inotify_obj || !$inotify_inode || !$watcher-&gt;{&#039;inode&#039;} || $inotify_inode != $watcher-&gt;{&#039;inode&#039;} || $inotify_mtime != $watcher-&gt;{&#039;mtime&#039;} ) {

          INOTIFY: {
                ( $inotify_obj, $inotify_mask, $inotify_file_disappeared ) = _generate_inotify_for_lock_file($lockfile);

                $watcher-&gt;reload_from_disk();

                if ( $inotify_file_disappeared || !$watcher-&gt;{&#039;inode&#039;} ) {

                    undef $inotify_obj;

                    next LOCK_WAIT;
                }

                redo INOTIFY if $watcher-&gt;{&#039;changed&#039;};

                ( $inotify_inode, $inotify_mtime ) = @{$watcher}{ &#039;inode&#039;, &#039;mtime&#039; };
            }
        }

        my $selected = _select( my $m = $inotify_mask, undef, undef, $TIME_BETWEEN_DOTLOCK_CHECKS );

        if ( $selected == -1 ) {

            die &quot;select() error: $!&quot; if $! != _EINTR();
        }
        elsif ($selected) {
            return ( 1, $fh ) if _try_to_install_lockfile( $temp_file, $lockfile );

            $watcher-&gt;reload_from_disk();

            () = $inotify_obj-&gt;poll();
        }
    }

    return;
}

sub _select {
    return select( $_[0], $_[1], $_[2], $_[3] );
}

sub _generate_inotify_for_lock_file {
    my ($file) = @_;
    require Cpanel::Inotify;
    my $inotify_obj;
    my $rin = &#039;&#039;;

    local $@;
    eval {
        $inotify_obj = Cpanel::Inotify-&gt;new( flags =&gt; [&#039;NONBLOCK&#039;] );

        $inotify_obj-&gt;add( $file, flags =&gt; [ &#039;ATTRIB&#039;, &#039;DELETE_SELF&#039; ] );

        vec( $rin, $inotify_obj-&gt;fileno(), 1 ) = 1;
    };

    if ($@) {
        my $err = $@;

        if ( eval { $err-&gt;isa(&#039;Cpanel::Exception::SystemCall&#039;) } ) {
            my $err = $err-&gt;get(&#039;error&#039;);
            if ( $err == _ENOENT ) {
                return ( undef, undef, INOTIFY_FILE_DISAPPEARED );
            }
            elsif ( $err != _EACCES ) {    # Don’t warn if EACCES
                local $@ = $err;
                warn;
            }
        }
        else {
            local $@ = $err;
            warn;
        }

        return;
    }

    return ( $inotify_obj, $rin, 0 );
}

sub _pid_is_alive {
    my ($pid) = @_;

    local $!;

    if ( kill( 0, $pid ) ) {
        return 1;
    }

    elsif ( $! == _EPERM ) {
        return !!( stat &quot;/proc/$pid&quot; )[0];
    }

    return 0;
}

sub _calculate_waittime_for_file {
    my ($file) = @_;

    return $LOCK_WAIT_TIME if $LOCK_WAIT_TIME;

    my $waittime = DEFAULT_LOCK_WAIT_TIME;

    if ( -e $file ) {
        $waittime = int( ( stat _ )[7] / 10000 );

        $waittime = $waittime &gt; MAX_LOCK_WAIT_TIME ? MAX_LOCK_WAIT_TIME : $waittime &lt; DEFAULT_LOCK_WAIT_TIME ? DEFAULT_LOCK_WAIT_TIME : $waittime;
    }

    return $waittime;
}

sub _is_valid_pid {
    my $pid = shift;

    return 0 unless defined $pid;

    return $pid =~ tr{0-9}{}c ? 0 : 1;
}

sub _getdir {
    my @path = split( /\/+/, $_[0] );
    return join( &#039;/&#039;, (@path)[ 0 .. ( $#path - 1 ) ] ) || &#039;.&#039;;
}

sub _create_lockfile {
    my $lock_fh;

    return sysopen( $lock_fh, $_[0], CREATE_FCNTL_VALUE, LOCK_FILE_PERMS ) ? ( 1, $lock_fh ) : ( 0, $! );
}

sub _open_to_write {
    my $path = $_[1];

    $OVERWRITE_FCNTL_VALUE ||= ( $Cpanel::Fcntl::Constants::O_WRONLY | $Cpanel::Fcntl::Constants::O_NONBLOCK | $Cpanel::Fcntl::Constants::O_APPEND | $Cpanel::Fcntl::Constants::O_NOFOLLOW );

    return sysopen( $_[0], $path, $OVERWRITE_FCNTL_VALUE, LOCK_FILE_PERMS );
}

sub _overwrite_lockfile_if_inode_mtime_matches {
    my ( $temp_file, $lockfile, $lockfile_inode, $lockfile_mtime ) = @_;

    my ( $inode, $mtime ) = ( stat $lockfile )[ 1, 9 ];

    if ( !$inode ) {
        die &quot;stat($lockfile): $!&quot; if $! != _ENOENT();
    }


    if ( !$inode || ( $inode == $lockfile_inode &amp;&amp; $mtime == $lockfile_mtime ) ) {
        rename( $temp_file, $lockfile ) or do {
            require Cpanel::Exception;
            die Cpanel::Exception::create( &#039;IO::RenameError&#039;, [ oldpath =&gt; $temp_file, newpath =&gt; $lockfile, error =&gt; $! ] );
        };

        return 1;
    }

    return 0;
}

sub _is_write_open_mode {
    my ($mode) = @_;

    if ( $mode =~ tr{0-9}{}c ) {
        if ( $mode &amp;&amp; ( -1 != index( $mode, &#039;&gt;&#039; ) || -1 != index( $mode, &#039;+&#039; ) ) ) {
            return 1;
        }
    }
    else {
        if ( $mode &amp;&amp; ( ( $mode &amp; $Cpanel::Fcntl::Constants::O_WRONLY ) || ( $mode &amp; $Cpanel::Fcntl::Constants::O_RDWR ) ) ) {
            return 1;
        }
    }
    return 0;
}

sub _verbose_flag_file_exists {
    return -e &#039;/var/cpanel/safefile_verbose&#039;;
}


package Cpanel::SafeFile::_temp;


use constant _ENOENT =&gt; 2;

sub new { return bless [ $_[1], $_SKIP_DOTLOCK_WHEN_NO_PERMS, $$ ], $_[0]; }

sub DESTROY {
    local $!;

    unlink $_[0]-&gt;[0] or do {
        if ( !$_[0]-&gt;[1] &amp;&amp; $! != _ENOENT &amp;&amp; $_[0]-&gt;[2] == $$ ) {
            warn &quot;unlink($_[0]-&gt;[0]): $!&quot;;
        }
    };

    return;
}

1;


} # --- END Cpanel/SafeFile.pm


{ # --- BEGIN Cpanel/LoadModule.pm
package Cpanel::LoadModule;


use strict;

# use Cpanel::Exception         (); # perlpkg line 211
# use Cpanel::LoadModule::Utils (); # perlpkg line 211

my $logger;
my $has_perl_dir = 0;


sub _logger_warn {
    my ( $msg, $fail_ok ) = @_;

    return if $fail_ok &amp;&amp; $ENV{&#039;CPANEL_BASE_INSTALL&#039;} &amp;&amp; index( $^X, &#039;/usr/local/cpanel&#039; ) == -1;

    if ( $INC{&#039;Cpanel/Logger.pm&#039;} ) {
        $logger ||= &#039;Cpanel::Logger&#039;-&gt;new();
        $logger-&gt;warn($msg);
    }
    return warn $msg;
}


sub _reset_has_perl_dir {
    $has_perl_dir = 0;
    return;
}

sub load_perl_module {    ## no critic qw(Subroutines::RequireArgUnpacking)
    if ( -1 != index( $_[0], q&lt;&#039;&gt; ) ) {
        die Cpanel::Exception::create_raw( &#039;InvalidParameter&#039;, &quot;Module names with single-quotes are prohibited. ($_[0])&quot; );
    }

    return $_[0] if Cpanel::LoadModule::Utils::module_is_loaded( $_[0] );

    my ( $mod, @LIST ) = @_;

    local ( $!, $@ );

    if ( !is_valid_module_name($mod) ) {
        die Cpanel::Exception::create( &#039;InvalidParameter&#039;, &#039;“[_1]” is not a valid name for a Perl module.&#039;, [$mod] );
    }

    my $args_str;
    if (@LIST) {
        $args_str = join &#039;,&#039;, map {
            die &quot;Only scalar arguments allowed in LIST! (@LIST)&quot; if ref;
            _single_quote($_);
        } @LIST;
    }
    else {
        $args_str = q&lt;&gt;;
    }

    eval &quot;use $mod ($args_str);&quot;;    ## no critic qw(BuiltinFunctions::ProhibitStringyEval)

    if ($@) {
        die Cpanel::Exception::create( &#039;ModuleLoadError&#039;, [ module =&gt; $mod, error =&gt; $@ ] );
    }

    return $mod;
}


sub load_error_string {
    my ($err) = @_;

    return $err if !ref $err;

    local $@;
    my $plain = eval { $err-&gt;isa(&#039;Cpanel::Exception::ModuleLoadError&#039;) &amp;&amp; $err-&gt;get(&#039;error&#039;) };

    return $plain || &quot;$err&quot;;
}


*module_is_loaded = *Cpanel::LoadModule::Utils::module_is_loaded;


*is_valid_module_name = *Cpanel::LoadModule::Utils::is_valid_module_name;


sub loadmodule {
    return 1 if cpanel_namespace_module_is_loaded( $_[0] );

    return _modloader( $_[0] );
}


sub lazy_load_module {
    my $mod = shift;

    my $mod_path = $mod;
    $mod_path =~ s{::}{/}g;
    if ( exists $INC{ $mod_path . &#039;.pm&#039; } ) {
        return;
    }

    if ( !is_valid_module_name($mod) ) {
        _logger_warn(&quot;Cpanel::LoadModule: Invalid module name ($mod)&quot;);
        return;
    }

    eval &quot;use $mod ();&quot;;

    if ($@) {
        delete $INC{ $mod_path . &#039;.pm&#039; };
        _logger_warn( &quot;Cpanel::LoadModule:: Failed to load module $mod - $@&quot;, 1 );
        return;
    }

    return 1;
}


sub cpanel_namespace_module_is_loaded {
    my ($modpart) = @_;
    $modpart =~ s{::}{/}g;
    return exists $INC{&quot;Cpanel/$modpart.pm&quot;} ? 1 : 0;
}

sub _modloader {
    my $module = shift;
    if ( !$module ) {
        _logger_warn(&quot;Empty module name passed to modloader&quot;);
        return;
    }
    if ( !is_valid_module_name($module) ) {
        _logger_warn(&quot;Invalid module name ($module) passed to modloader&quot;);
        return;
    }

    eval qq[ use Cpanel::${module}; Cpanel::${module}::${module}_init() if &quot;Cpanel::${module}&quot;-&gt;can(&quot;${module}_init&quot;); ];    # PPI USE OK - This looks like usage of the Cpanel module and it&#039;s not.

    if ($@) {
        _logger_warn(&quot;Error loading module $module - $@&quot;);
        return;
    }

    return 1;
}

sub _single_quote {
    local ($_) = $_[0];
    s/([\\&#039;])/\\$1/g;
    return qq(&#039;$_&#039;);
}


1;

} # --- END Cpanel/LoadModule.pm


{ # --- BEGIN Cpanel/Linux/Constants.pm
package Cpanel::Linux::Constants;


use strict;
use warnings;
no warnings &#039;once&#039;;

use constant {
    NAME_MAX =&gt; 255,
    PATH_MAX =&gt; 4096,
};

1;

} # --- END Cpanel/Linux/Constants.pm


{ # --- BEGIN Cpanel/Validate/FilesystemNodeName.pm
package Cpanel::Validate::FilesystemNodeName;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Exception        (); # perlpkg line 211
# use Cpanel::Linux::Constants (); # perlpkg line 211

sub is_valid {
    my ($node) = @_;

    local $@;
    eval { validate_or_die($node); };

    return $@ ? 0 : 1;
}

sub validate_or_die {
    my ($name) = @_;

    if ( !length $name ) {
        die Cpanel::Exception::create(&#039;Empty&#039;);
    }
    elsif ( $name eq &#039;.&#039; || $name eq &#039;..&#039; ) {
        die Cpanel::Exception::create( &#039;Reserved&#039;, [ value =&gt; $name ] );
    }
    elsif ( length $name &gt; Cpanel::Linux::Constants::NAME_MAX() ) {
        die Cpanel::Exception::create( &#039;TooManyBytes&#039;, [ value =&gt; $name, maxlength =&gt; Cpanel::Linux::Constants::NAME_MAX() ] );
    }
    elsif ( index( $name, &#039;/&#039; ) != -1 ) {
        die Cpanel::Exception::create( &#039;InvalidCharacters&#039;, [ value =&gt; $name, invalid_characters =&gt; [&#039;/&#039;] ] );
    }
    elsif ( index( $name, &quot;\0&quot; ) != -1 ) {
        die Cpanel::Exception::create( &#039;InvalidCharacters&#039;, &#039;This value may not contain a [asis,NUL] byte.&#039;, [ value =&gt; $name, invalid_characters =&gt; [&quot;\0&quot;] ] );
    }

    return 1;
}

1;

} # --- END Cpanel/Validate/FilesystemNodeName.pm


{ # --- BEGIN Cpanel/Notify.pm
package Cpanel::Notify;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Set                          (); # perlpkg line 211
# use Cpanel::Fcntl                        (); # perlpkg line 211
# use Cpanel::SafeFile                     (); # perlpkg line 211
# use Cpanel::LoadModule                   (); # perlpkg line 211
# use Cpanel::Validate::FilesystemNodeName (); # perlpkg line 211
# use Cpanel::Exception                    (); # perlpkg line 211
# use Cpanel::Debug                        (); # perlpkg line 211

our $VERSION = &#039;1.8&#039;;

my $DEFAULT_CONTENT_TYPE = &#039;text/plain; charset=utf-8&#039;;
our $NOTIFY_INTERVAL_STORAGE_DIR = &#039;/var/cpanel/notifications&#039;;

sub notification_class {
    my (%args) = @_;

    if ( !defined $args{&#039;interval&#039;} ) {
        $args{&#039;interval&#039;} = 1;
    }

    if ( !defined $args{&#039;status&#039;} ) {
        $args{&#039;status&#039;} = &#039;No status set&#039;;
    }

    foreach my $param (qw(application status class constructor_args)) {
        die Cpanel::Exception::create( &#039;MissingParameter&#039;, [ &#039;name&#039; =&gt; $param ] ) if !defined $args{$param};
    }

    if ( my @unwelcome_params = Cpanel::Set::difference( [ keys %args ], [qw(application status class constructor_args interval)] ) ) {
        die Cpanel::Exception::create_raw(
            &#039;InvalidParameters&#039;,
            &quot;The following parameters don&#039;t belong as an argument to notification_class(); you may have meant to pass these in constructor_args instead: &quot; . join( &#039; &#039;, @unwelcome_params )
        );
    }

    my $constructor_args = { @{ $args{&#039;constructor_args&#039;} } };

    if ( $constructor_args-&gt;{&#039;skip_send&#039;} ) {
        my $class = &quot;Cpanel::iContact::Class::$args{&#039;class&#039;}&quot;;
        Cpanel::LoadModule::load_perl_module($class);

        return $class-&gt;new(%$constructor_args);
    }

    return _notification_backend(
        $args{&#039;application&#039;},
        $args{&#039;status&#039;},
        $args{&#039;interval&#039;},
        sub {
            my $class = &quot;Cpanel::iContact::Class::$args{&#039;class&#039;}&quot;;
            Cpanel::LoadModule::load_perl_module($class);
            return $class-&gt;new(%$constructor_args);
        },
    );
}

sub notification {
    my %AGS = @_;

    my $app = $AGS{&#039;app&#039;} || $AGS{&#039;application&#039;} || &#039;Notice&#039;;

    return _notification_backend(
        $app,
        $AGS{&#039;status&#039;},
        $AGS{&#039;interval&#039;} || 0,
        sub {
            my $module = &quot;Cpanel::iContact&quot;;
            Cpanel::LoadModule::load_perl_module($module);

            my $from              = $AGS{&#039;from&#039;};
            my $to                = $AGS{&#039;to&#039;};
            my $msgheader         = $AGS{&#039;msgheader&#039;} || $AGS{&#039;subject&#039;};
            my $message           = $AGS{&#039;message&#039;};
            my $plaintext_message = $AGS{&#039;plaintext_message&#039;};
            my $priority          = $AGS{&#039;priority&#039;}     || 3;
            my $attach_files      = $AGS{&#039;attach_files&#039;} || [];

            my $content_type = $AGS{&#039;content-type&#039;} || $DEFAULT_CONTENT_TYPE;

            &quot;$module&quot;-&gt;can(&#039;icontact&#039;)-&gt;(
                &#039;attach_files&#039;      =&gt; $attach_files,
                &#039;application&#039;       =&gt; $app,
                &#039;level&#039;             =&gt; $priority,
                &#039;from&#039;              =&gt; $from,
                &#039;to&#039;                =&gt; $to,
                &#039;subject&#039;           =&gt; $msgheader,
                &#039;message&#039;           =&gt; $message,
                &#039;plaintext_message&#039; =&gt; $plaintext_message,
                &#039;content-type&#039;      =&gt; $content_type,
            );
        }
    );
}

sub _notification_backend {
    my ( $app, $status, $interval, $todo_cr ) = @_;

    my $is_ready = _checkstatusinterval(
        &#039;app&#039;      =&gt; $app,
        &#039;status&#039;   =&gt; $status,
        &#039;interval&#039; =&gt; $interval,
    );

    if ($is_ready) {
        return $todo_cr-&gt;();
    }
    elsif ( $Cpanel::Debug::level &gt; 3 ) {
        Cpanel::Debug::log_warn(&quot;not sending notify app=[$app] status=[$status] interval=[$interval]&quot;);
    }

    return $is_ready ? 1 : 0;
}

sub notify_blocked {
    my %AGS      = @_;
    my $app      = $AGS{&#039;app&#039;};
    my $status   = $AGS{&#039;status&#039;};
    my $interval = $AGS{&#039;interval&#039;};

    return 0 if $interval &lt;= 1;    # Special Case (ignore interval check);

    $app    =~ s{/}{_}g;           # Its possible to have slashes in the app name
    $status =~ s{:}{_}g;           # Its possible to have colons in the status

    my $db_file = &quot;$NOTIFY_INTERVAL_STORAGE_DIR/$app&quot;;

    return 0 if !-e $db_file;

    my %notifications;
    my $notify_db_fh;
    if (
        my $nlock = Cpanel::SafeFile::safesysopen(
            $notify_db_fh, $db_file, Cpanel::Fcntl::or_flags(&#039;O_RDONLY&#039;),
            0600
        )
    ) {
        local $/;
        %notifications = map { ( split( /:/, $_, 2 ) )[ 0, 1 ] } split( m{\n}, readline($notify_db_fh) );
        Cpanel::SafeFile::safeclose( $notify_db_fh, $nlock );
    }
    else {
        Cpanel::Debug::log_warn(&quot;Could not open $db_file: $!&quot;);
        return;
    }

    if ( $notifications{$status} &amp;&amp; ( ( $notifications{$status} + $interval ) &gt; time() ) ) {
        return 1;
    }

    return 0;
}

{
    no warnings &#039;once&#039;;
    *update_notification_time_if_interval_reached = \&amp;_checkstatusinterval;
}

sub _checkstatusinterval {
    my %AGS      = @_;
    my $app      = $AGS{&#039;app&#039;};
    my $status   = $AGS{&#039;status&#039;};
    my $interval = $AGS{&#039;interval&#039;};

    return 1 if $interval &lt;= 1;    # Special Case (ignore interval check);

    $app    =~ s{/}{_}g;           # Its possible to have slashes in the app name
    $status =~ s{:}{_}g;           # Its possible to have colons in the status
    Cpanel::Validate::FilesystemNodeName::validate_or_die($app);

    my $notify = 0;

    if ( !-e $NOTIFY_INTERVAL_STORAGE_DIR ) {
        Cpanel::LoadModule::load_perl_module(&#039;Cpanel::SafeDir::MK&#039;);
        Cpanel::SafeDir::MK::safemkdir( $NOTIFY_INTERVAL_STORAGE_DIR, &#039;0700&#039; );
        if ( !-d $NOTIFY_INTERVAL_STORAGE_DIR ) {
            Cpanel::Debug::log_warn(&quot;Failed to setup notifications directory: $NOTIFY_INTERVAL_STORAGE_DIR: $!&quot;);
            return;
        }
    }

    my %notifications;
    my $notify_db_fh;
    my $db_file = &quot;$NOTIFY_INTERVAL_STORAGE_DIR/$app&quot;;
    if ( my $nlock = Cpanel::SafeFile::safesysopen( $notify_db_fh, $db_file, Cpanel::Fcntl::or_flags(qw( O_RDWR O_CREAT )), 0600 ) ) {
        local $/;
        %notifications = map { ( split( /:/, $_, 2 ) )[ 0, 1 ] } split( m{\n}, readline($notify_db_fh) );
        if ( !exists $notifications{$status} || ( int( $notifications{$status} ) + int($interval) ) &lt; time() ) {
            $notifications{$status} = time;
            $notify = 1;
        }
        seek( $notify_db_fh, 0, 0 );
        print {$notify_db_fh} join( &quot;\n&quot;, map { $_ . &#039;:&#039; . $notifications{$_} } sort keys %notifications );
        truncate( $notify_db_fh, tell($notify_db_fh) );
        Cpanel::SafeFile::safeclose( $notify_db_fh, $nlock );
    }
    else {
        Cpanel::Debug::log_warn(&quot;Could not open $db_file: $!&quot;);
        return;
    }

    return $notify;
}

1;

} # --- END Cpanel/Notify.pm


{ # --- BEGIN Cpanel/Server/Utils.pm
package Cpanel::Server::Utils;


use strict;

sub is_subprocess_of_cpsrvd {
    return 0 if $INC{&#039;cpanel/cpsrvd.pm&#039;};    # If we ARE cpsrvd we do not want this behavior
    return $ENV{&#039;CPANEL&#039;} ? 1 : 0;
}

1;

} # --- END Cpanel/Server/Utils.pm


{ # --- BEGIN Cpanel/Logger.pm
package Cpanel::Logger;


use strict;

# use Cpanel::Time::Local (); # perlpkg line 211

my $is_sandbox;
my $is_smoker;
our $VERSION = 1.3;

use constant TRACE_TOUCH_FILE =&gt; &#039;/var/cpanel/log_stack_traces&#039;;

our $ENABLE_BACKTRACE;

our $DISABLE_OUTPUT;    # used by cpanminus
our $ALWAYS_OUTPUT_TO_STDERR;

our $STD_LOG_FILE   = &#039;/usr/local/cpanel/logs/error_log&#039;;
our $PANIC_LOG_FILE = &#039;/usr/local/cpanel/logs/panic_log&#039;;

my ( $cached_progname, $cached_prog_pid, %singleton_stash );


sub new {
    my ( $class, $hr_args ) = @_;

    if ( $hr_args-&gt;{&#039;open_now&#039;} &amp;&amp; $hr_args-&gt;{&#039;use_no_files&#039;} ) {
        die &quot;“open_now” and “use_no_files” mutually exclude!&quot;;
    }

    my $args_sig = &#039;no_args&#039;;
    if ( $hr_args &amp;&amp; ref($hr_args) eq &#039;HASH&#039; ) {

        $args_sig = join( &#039;,&#039;, map { $_ . &#039;=&gt;&#039; . $hr_args-&gt;{$_} } sort keys %{$hr_args} );    # Storable::freeze($hr_args);
    }

    my $no_load_from_cache = $hr_args-&gt;{&#039;no_load_from_cache&#039;} ? 1 : 0;

    if ( exists $singleton_stash{$class}{$args_sig} and !$no_load_from_cache ) {
        $singleton_stash{$class}{$args_sig}-&gt;{&#039;cloned&#039;}++;
    }
    else {
        $singleton_stash{$class}{$args_sig} = bless( {}, $class );
        if ( $hr_args &amp;&amp; ref($hr_args) eq &#039;HASH&#039; ) {
            foreach my $k ( keys %$hr_args ) {
                $singleton_stash{$class}{$args_sig}-&gt;{$k} = $hr_args-&gt;{$k};
            }
        }
    }
    my $self = $singleton_stash{$class}{$args_sig};

    if ( !$self-&gt;{&#039;cloned&#039;} ) {

        if ( $self-&gt;{&#039;open_now&#039;} &amp;&amp; !$self-&gt;{&#039;use_no_files&#039;} ) {
            $self-&gt;_open_logfile();
        }
    }

    $self-&gt;_set_backtrace( $ENABLE_BACKTRACE // $self-&gt;{&#039;backtrace&#039;} // _get_backtrace_touchfile() );

    return $self;
}

sub __Logger_pushback {
    if ( @_ &amp;&amp; index( ref( $_[0] ), __PACKAGE__ ) == 0 ) {
        return @_;
    }
    return ( __PACKAGE__-&gt;new(), @_ );
}

sub invalid {
    my ( $self, @list ) = __Logger_pushback(@_);

    my %log = (
        &#039;message&#039;   =&gt; $list[0],
        &#039;level&#039;     =&gt; &#039;invalid&#039;,
        &#039;output&#039;    =&gt; 0,
        &#039;service&#039;   =&gt; $self-&gt;find_progname(),
        &#039;backtrace&#039; =&gt; $self-&gt;get_backtrace(),
        &#039;die&#039;       =&gt; 0,
    );

    if ( is_sandbox() ) {
        if ( !-e &#039;/var/cpanel/DEBUG&#039; ) {
            $self-&gt;notify( &#039;invalid&#039;, \%log );
        }
        $log{&#039;output&#039;} = _stdin_is_tty() ? 2 : 1;
    }
    return $self-&gt;logger( \%log );
}    # end of invalid

sub is_sandbox {
    return 0           if $INC{&#039;B/C.pm&#039;};        # avoid cache during compile
    return $is_sandbox if defined $is_sandbox;
    return ( $is_sandbox = -e &#039;/var/cpanel/dev_sandbox&#039; ? 1 : 0 );
}

sub is_smoker {
    return 0          if $INC{&#039;B/C.pm&#039;};         # avoid cache during compile
    return $is_smoker if defined $is_smoker;
    return ( $is_smoker = -e &#039;/var/cpanel/smoker&#039; ? 1 : 0 );
}

sub deprecated {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my ( $self, @list ) = __Logger_pushback(@_);

    my %log = (
        &#039;message&#039;   =&gt; $list[0],
        &#039;level&#039;     =&gt; &#039;deprecated&#039;,
        &#039;output&#039;    =&gt; 0,
        &#039;service&#039;   =&gt; $self-&gt;find_progname(),
        &#039;backtrace&#039; =&gt; $self-&gt;get_backtrace(),
        &#039;die&#039;       =&gt; 0,
    );

    unless ( is_sandbox() ) {
        $self-&gt;logger( \%log );
        return;
    }

    $self-&gt;notify( &#039;deprecated&#039;, \%log );

    $log{&#039;output&#039;} = _stdin_is_tty() ? 2 : 1;
    $log{&#039;die&#039;}    = 1;

    return $self-&gt;logger( \%log );
}


sub debug {
    my ( $self, $message, $conf_hr ) = @_;    # not appropriate for debug() : __Logger_pushback(@_);

    $self = $self-&gt;new() if !ref $self;

    $conf_hr ||= {
        &#039;force&#039;     =&gt; 0,
        &#039;backtrace&#039; =&gt; 0,
        &#039;output&#039;    =&gt; 1,    # Logger&#039;s debug level should output to STDOUT
    };
    return unless $conf_hr-&gt;{&#039;force&#039;} || ( defined $Cpanel::Debug::level &amp;&amp; $Cpanel::Debug::level );    ## PPI NO PARSE - avoid recursive use statements

    if ( !defined $message ) {
        my @caller = caller();
        $message = &quot;debug() at $caller[1] line $caller[2].&quot;;
    }

    my %log = (
        &#039;message&#039;   =&gt; $message,
        &#039;level&#039;     =&gt; &#039;debug&#039;,
        &#039;output&#039;    =&gt; $conf_hr-&gt;{&#039;output&#039;},
        &#039;backtrace&#039; =&gt; $conf_hr-&gt;{&#039;backtrace&#039;},
    );

    if ( ref $log{&#039;message&#039;} ) {

        my $outmsg = $log{&#039;message&#039;};
        eval &#039;local $SIG{__DIE__}; local $SIG{__WARN__}; require Cpanel::YAML::Syck; $outmsg = YAML::Syck::Dump($outmsg);&#039;;
        my @caller = caller();
        $log{&#039;message&#039;} = &quot;$log{&#039;message&#039;} at $caller[1] line $caller[2]:\n&quot; . $outmsg;
    }
    elsif ( $log{&#039;message&#039;} =~ m/\A\d+(?:\.\d+)?\z/ ) {
        $log{&#039;message&#039;} = &quot;debug() number $log{&#039;message&#039;}&quot;;
    }

    $self-&gt;logger( \%log );

    return \%log;
}


sub info {
    my ( $self, @list ) = __Logger_pushback(@_);
    return $self-&gt;logger(
        {
            &#039;message&#039; =&gt; $list[0],
            &#039;level&#039;   =&gt; &#039;info&#039;,

            &#039;output&#039;    =&gt; $self-&gt;{&#039;open_now&#039;} ? 0 : 1,    # FB#59177: info level should output to STDOUT
            &#039;backtrace&#039; =&gt; 0

        }
    );
}    # end of info


sub warn {
    my ( $self, @list ) = __Logger_pushback(@_);
    return $self-&gt;logger(
        {
            &#039;message&#039;   =&gt; $list[0],
            &#039;level&#039;     =&gt; &#039;warn&#039;,
            &#039;output&#039;    =&gt; _stdin_is_tty() ? 2 : 0,
            &#039;backtrace&#039; =&gt; $self-&gt;get_backtrace()
        }
    );
}    # end of warn


sub error {
    my ( $self, @list ) = __Logger_pushback(@_);
    return $self-&gt;logger(
        {
            &#039;message&#039;   =&gt; $list[0],
            &#039;level&#039;     =&gt; &#039;error&#039;,
            &#039;output&#039;    =&gt; -t STDIN ? 2 : 0,
            &#039;backtrace&#039; =&gt; $self-&gt;get_backtrace()
        }
    );
}    # end of error


sub die {
    my ( $self, @list ) = __Logger_pushback(@_);
    my %log = (
        &#039;message&#039;   =&gt; $list[0],
        &#039;level&#039;     =&gt; &#039;die&#039;,
        &#039;output&#039;    =&gt; _stdin_is_tty() ? 2 : 0,
        &#039;backtrace&#039; =&gt; $self-&gt;get_backtrace()
    );
    return $self-&gt;logger( \%log );
}    # end of die


sub panic {
    my ( $self, @list ) = __Logger_pushback(@_);
    my %log = (
        &#039;message&#039;   =&gt; $list[0],
        &#039;level&#039;     =&gt; &#039;panic&#039;,
        &#039;output&#039;    =&gt; 2,
        &#039;backtrace&#039; =&gt; $self-&gt;get_backtrace()
    );
    return $self-&gt;logger( \%log );
}    # end of panic

sub raw {
    return $_[0]-&gt;logger(
        {
            &#039;message&#039;   =&gt; $_[1],
            &#039;level&#039;     =&gt; &#039;raw&#039;,
            &#039;output&#039;    =&gt; 0,
            &#039;backtrace&#039; =&gt; 0
        }
    );
}

sub cplog {
    my $msg      = shift;
    my $loglevel = shift;
    my $service  = shift;
    my $nostdout = shift;
    if ( !$nostdout ) {
        $nostdout = 1;
    }
    else {
        $nostdout = 0;
    }
    logger( { &#039;message&#039; =&gt; $msg, &#039;level&#039; =&gt; $loglevel, &#039;service&#039; =&gt; $service, &#039;output&#039; =&gt; $nostdout, &#039;backtrace&#039; =&gt; $ENABLE_BACKTRACE // _get_backtrace_touchfile() } );
}    # end of cplog (deprecated)


sub _get_configuration_for_logger {
    my ( $self, $cfg_or_msg ) = @_;

    my $hr = ref($cfg_or_msg) eq &#039;HASH&#039; ? $cfg_or_msg : { &#039;message&#039; =&gt; $cfg_or_msg };

    $hr-&gt;{&#039;message&#039;} ||= &#039;Something is wrong&#039;;

    $hr-&gt;{&#039;level&#039;}  ||= &#039;&#039;;
    $hr-&gt;{&#039;output&#039;} ||= 0;

    $hr-&gt;{&#039;output&#039;} = 0 if $DISABLE_OUTPUT;
    if ( !exists $hr-&gt;{&#039;backtrace&#039;} ) {
        $hr-&gt;{&#039;backtrace&#039;} = $self-&gt;get_backtrace();
    }

    $hr-&gt;{&#039;use_no_files&#039;} ||= 0;
    $hr-&gt;{&#039;use_fullmsg&#039;}  ||= 0;

    return $hr;
}

sub _write {
    return print { $_[0] } $_[1];
}

sub get_backtrace {
    my ($self) = __Logger_pushback(@_);

    return $ENABLE_BACKTRACE // $self-&gt;{&#039;backtrace&#039;};
}

sub _set_backtrace {
    my ( $self, @args ) = __Logger_pushback(@_);
    $self-&gt;{&#039;backtrace&#039;} = $args[0] ? 1 : 0;
    return;
}

sub _get_backtrace_touchfile {
    return -e TRACE_TOUCH_FILE ? 1 : 0;
}

sub get_fh {
    my ($self) = @_;
    return $self-&gt;{&#039;log_fh&#039;};
}

sub set_fh {
    my ( $self, $fh ) = @_;
    $self-&gt;{&#039;log_fh&#039;} = $fh;
    return 1;
}
sub logger {    ## no critic(RequireArgUnpacking)
    my ( $self, @list ) = __Logger_pushback(@_);
    my $hr = $self-&gt;_get_configuration_for_logger( $list[0] );
    my ( $msg, $time, $status );
    $status = 1;

    my ($msg_maybe_bt) = $hr-&gt;{&#039;backtrace&#039;} ? $self-&gt;backtrace( $hr-&gt;{&#039;message&#039;} ) : $hr-&gt;{&#039;message&#039;} . &quot;\n&quot;;

    if ( $hr-&gt;{&#039;level&#039;} eq &#039;raw&#039; ) {
        $msg = $hr-&gt;{&#039;message&#039;};
    }
    else {
        $time ||= Cpanel::Time::Local::localtime2timestamp();
        $hr-&gt;{&#039;service&#039;} ||= $self-&gt;find_progname();                       # only compute the service name if we HAVE to do so as it can be expensive

        if ( $self-&gt;{&#039;log_pid&#039;} ) {
            $msg = &quot;[$time] $hr-&gt;{&#039;level&#039;} [$hr-&gt;{&#039;service&#039;}] [$$] $msg_maybe_bt&quot;;
        }
        else {
            $msg = &quot;[$time] $hr-&gt;{&#039;level&#039;} [$hr-&gt;{&#039;service&#039;}] $msg_maybe_bt&quot;;
        }
    }
    unless ( $hr-&gt;{&#039;use_no_files&#039;} ) {

        local $self-&gt;{&#039;log_fh&#039;} = \*STDERR if $ALWAYS_OUTPUT_TO_STDERR;

        $self-&gt;_open_logfile() if !$self-&gt;{&#039;log_fh&#039;} || ( !eval { fileno( $self-&gt;{&#039;log_fh&#039;} ) } &amp;&amp; !UNIVERSAL::isa( $self-&gt;{&#039;log_fh&#039;}, &#039;IO::Scalar&#039; ) );
        _write( $self-&gt;{&#039;log_fh&#039;}, $msg ) or $status = 0;

        if ( $hr-&gt;{&#039;level&#039;} eq &#039;panic&#039; || $hr-&gt;{&#039;level&#039;} eq &#039;invalid&#039; || $hr-&gt;{&#039;level&#039;} eq &#039;deprecated&#039; ) {
            my $panic_fh;
            require Cpanel::FileUtils::Open;
            if ( Cpanel::FileUtils::Open::sysopen_with_real_perms( $panic_fh, $PANIC_LOG_FILE, &#039;O_WRONLY|O_APPEND|O_CREAT&#039;, 0600 ) ) {
                $time ||= Cpanel::Time::Local::localtime2timestamp();
                $hr-&gt;{&#039;service&#039;} ||= $self-&gt;find_progname();                       # only compute the service name if we HAVE to do so as it can be expensive
                _write( $panic_fh, &quot;$time $hr-&gt;{level} [$hr-&gt;{&#039;service&#039;}] $msg_maybe_bt&quot; );
                close $panic_fh;
            }
        }
    }

    if ( $hr-&gt;{&#039;output&#039;} ) {
        $hr-&gt;{&#039;service&#039;} ||= $self-&gt;find_progname();    # only compute the service name if we HAVE to do so as it can be expensive
        my $out = &quot;$hr-&gt;{level} [$hr-&gt;{&#039;service&#039;}] $hr-&gt;{&#039;message&#039;}\n&quot;;
        if ( $self-&gt;{&#039;timestamp_prefix&#039;} ) {
            $out = &quot;[$time] $out&quot;;
        }
        $out = $msg if $hr-&gt;{&#039;use_fullmsg&#039;};

        $status &amp;&amp;= $self-&gt;_write_message( $hr, $out );
    }

    if ( ( $hr-&gt;{&#039;level&#039;} eq &#039;die&#039; || $hr-&gt;{&#039;level&#039;} eq &#039;panic&#039; || $hr-&gt;{&#039;die&#039;} ) ) {
        CORE::die &quot;exit level [$hr-&gt;{&#039;level&#039;}] [pid=$$] ($hr-&gt;{&#039;message&#039;})\n&quot;;    # make sure we die if die is overwritten
    }

    return $status;
}    # end of logger

sub _write_message {
    my ( $self, $hr, $out ) = @_;
    my $status = 1;

    if ( $hr-&gt;{&#039;output&#039;} == 3 ) {
        _write( \*STDOUT, $out ) or $status = 0;
        _write( \*STDERR, $out ) or $status = 0;
    }
    elsif ( $hr-&gt;{&#039;output&#039;} == 1 &amp;&amp; ( $self-&gt;{&#039;use_stdout&#039;} || _stdout_is_tty() ) ) {
        _write( \*STDOUT, $out ) or $status = 0;
    }
    elsif ( $hr-&gt;{&#039;output&#039;} == 2 ) {
        _write( \*STDERR, $out ) or $status = 0;
    }
    return $status;
}

sub find_progname {
    if ( $cached_progname &amp;&amp; $cached_prog_pid == $$ ) {
        return $cached_progname;
    }
    my $s = $0;

    if ( !length $s ) {    # Someone _could_ set $0 = &#039;&#039;;
        my $i = 1;         # 0 is always find_progname
        while ( my @service = caller( $i++ ) ) {
            last             if ( $service[3] =~ /::BEGIN$/ );
            $s = $service[1] if ( $service[1] ne &#039;&#039; );
        }
    }

    $s =~ s@.+/(.+)$@$1@ if $s =~ tr{/}{};

    $s =~ s@\..+$@@ if $s =~ tr{\.}{};

    $s =~ s@ .*$@@ if $s =~ tr{ }{};

    $cached_progname = $s;
    $cached_prog_pid = $$;

    return $s;
}

sub backtrace {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my ( $self, @list ) = __Logger_pushback(@_);
    if ( ref $list[0] ) {
        return $list[0] if scalar @list == 1;
        return (@list);
    }
    require Cpanel::Carp;
    local $_;    # Protect surrounding program - just in case...
    local $Carp::Internal{ (__PACKAGE__) } = 1;
    local $Carp::Internal{&#039;Cpanel::Debug&#039;} = 1;
    return Cpanel::Carp::safe_longmess(@list);

}

sub redirect_stderr_to_error_log {
    return open( STDERR, &#039;&gt;&gt;&#039;, $STD_LOG_FILE );
}

sub notify {
    my ( $self, $call, $log_ref ) = @_;

    my $time = Cpanel::Time::Local::localtime2timestamp();
    my ($bt) = $self-&gt;backtrace( $log_ref-&gt;{&#039;message&#039;} );
    $log_ref-&gt;{&#039;service&#039;} //= &#039;&#039;;
    my $logfile = qq{$time [$log_ref-&gt;{&#039;service&#039;}] } . ( $bt // &#039;&#039; );

    if ( eval { require Cpanel::LoadModule; Cpanel::LoadModule::load_perl_module(&#039;Cpanel::iContact::Class::Logger::Notify&#039;); 1; } ) {

        eval {
            require Cpanel::Notify;
            Cpanel::Notify::notification_class(
                &#039;class&#039;            =&gt; &#039;Logger::Notify&#039;,
                &#039;application&#039;      =&gt; &#039;Logger::Notify&#039;,
                &#039;constructor_args&#039; =&gt; [
                    &#039;origin&#039;       =&gt; $log_ref-&gt;{&#039;service&#039;},
                    &#039;logger_call&#039;  =&gt; $call,
                    &#039;attach_files&#039; =&gt; [ { name =&gt; &#039;cpanel-logger-log.txt&#039;, content =&gt; \$logfile } ],
                    &#039;subject&#039;      =&gt; $log_ref-&gt;{&#039;subject&#039;},
                ]
            );
        };

    }

    elsif ( eval { require Cpanel::LoadModule; Cpanel::LoadModule::load_perl_module(&#039;Cpanel::iContact&#039;); 1; } ) {
        Cpanel::iContact::icontact(
            &#039;application&#039; =&gt; $log_ref-&gt;{&#039;service&#039;},
            &#039;subject&#039;     =&gt; $log_ref-&gt;{&#039;subject&#039;} ? $log_ref-&gt;{&#039;subject&#039;} : qq{Cpanel::Logger::$call called in $log_ref-&gt;{&#039;service&#039;}},
            &#039;message&#039;     =&gt; $logfile,
        );

    }
    else {
        CORE::warn( $log_ref-&gt;{&#039;subject&#039;} ? $log_ref-&gt;{&#039;subject&#039;} : qq{Cpanel::Logger::$call called in $log_ref-&gt;{&#039;service&#039;}} . &quot;: $logfile&quot; );
    }

    return;
}

*fatal   = *die;
*out     = *info;
*success = *info;
*throw   = *die;
*warning = *warn;

sub _is_subprocess_of_cpsrvd {
    require Cpanel::Server::Utils;
    goto \&amp;Cpanel::Server::Utils::is_subprocess_of_cpsrvd;
}

sub _open_logfile {
    my ($self) = @_;
    my $usingstderr = 0;
    my $log_fh;

    $self-&gt;{&#039;alternate_logfile&#039;} ||= $STD_LOG_FILE;
    if ( $STD_LOG_FILE eq $self-&gt;{&#039;alternate_logfile&#039;} &amp;&amp; _is_subprocess_of_cpsrvd() ) {
        $log_fh      = \*STDERR;
        $usingstderr = 1;
    }
    else {
        require Cpanel::FileUtils::Open;
        if ( !Cpanel::FileUtils::Open::sysopen_with_real_perms( $log_fh, $self-&gt;{&#039;alternate_logfile&#039;}, &#039;O_WRONLY|O_APPEND|O_CREAT&#039;, 0600 ) ) {
            ( $usingstderr, $log_fh ) = ( 1, \*STDERR );
        }

        select( ( select($log_fh), $| = 1 )[0] );    ## no critic qw(Variables::RequireLocalizedPunctuationVars InputOutput::ProhibitOneArgSelect) -- Cpanel::FHUtils::Autoflush would be expensive to load every time
    }

    $self-&gt;{&#039;log_fh&#039;}      = $log_fh;
    $self-&gt;{&#039;usingstderr&#039;} = $usingstderr;
    return 1;
}

sub _stdin_is_tty {
    local $@;
    return eval { -t STDIN };
}

sub _stdout_is_tty {
    local $@;
    return eval { -t STDOUT };
}

sub clear_singleton_stash {
    %singleton_stash = ();
    return;
}

1;


} # --- END Cpanel/Logger.pm


{ # --- BEGIN Cpanel/Debug.pm
package Cpanel::Debug;


use strict;
use warnings;
no warnings &#039;once&#039;;


our $HOOKS_DEBUG_FILE = &#039;/var/cpanel/debughooks&#039;;

our $level = ( exists $ENV{&#039;CPANEL_DEBUG_LEVEL&#039;} &amp;&amp; $ENV{&#039;CPANEL_DEBUG_LEVEL&#039;} ? int $ENV{&#039;CPANEL_DEBUG_LEVEL&#039;} : 0 );


my $debug_hooks_value;
my $logger;


sub debug_level {
    my ($level) = @_;
    $Cpanel::Debug::level = $level if defined $level;
    return $Cpanel::Debug::level;
}


sub logger {
    $logger = shift if (@_);    # Set method for $logger if something is passed in.

    return $logger ||= do {
        local ( $@, $! );
        require Cpanel::Logger;

        Cpanel::Logger-&gt;new();
    };
}


sub log_error {
    local $!;                   #prevent logger from overwriting $!
    return logger()-&gt;error( $_[0] );
}


sub log_warn {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;warn( $_[0] );
}


sub log_warn_no_backtrace {
    local $!;    #prevent logger from overwriting $!

    my $logger = logger();

    no warnings &#039;once&#039;;
    local $Cpanel::Logger::ENABLE_BACKTRACE = 0;

    return $logger-&gt;warn( $_[0] );
}


sub log_invalid {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;invalid( $_[0] );
}


sub log_deprecated {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;deprecated( $_[0] );
}


sub log_panic {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;panic( $_[0] );
}


sub log_die {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;die( $_[0] );
}


sub log_info {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;info( $_[0] );
}


sub log_debug {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;debug( $_[0] );
}


sub log_dump {
    require Data::Dumper;
    no warnings &#039;once&#039;;
    local $Data::Dumper::Sortkeys = 1;
    return log_info( Data::Dumper::Dumper( $_[0] ) );
}


sub debug_hooks_value {
    return $debug_hooks_value if defined $debug_hooks_value;
    return ( $debug_hooks_value = ( stat($HOOKS_DEBUG_FILE) )[7] || 0 );
}


1;

} # --- END Cpanel/Debug.pm


{ # --- BEGIN Cpanel/NSCD/Constants.pm
package Cpanel::NSCD::Constants;


use strict;

our $NSCD_CONFIG_FILE = &#039;/etc/nscd.conf&#039;;
our $NSCD_SOCKET      = &#039;/var/run/nscd/socket&#039;;

1;

} # --- END Cpanel/NSCD/Constants.pm


{ # --- BEGIN Cpanel/Socket/UNIX/Micro.pm
package Cpanel::Socket::UNIX::Micro;


use strict;

my $MAX_PATH_LENGTH        = 107;
my $LITTLE_ENDIAN_TEMPLATE = &#039;vZ&#039; . ( 1 + $MAX_PATH_LENGTH );    # x86_64 is always little endian
my $AF_UNIX                = 1;
my $SOCK_STREAM            = 1;

sub connect {
    socket( $_[0], $AF_UNIX, $SOCK_STREAM, 0 ) or warn &quot;socket(AF_UNIX, SOCK_STREAM): $!&quot;;
    return connect( $_[0], micro_sockaddr_un( $_[1] ) );
}

sub micro_sockaddr_un {

    if ( length( $_[0] ) &gt; $MAX_PATH_LENGTH ) {
        my $excess = length( $_[0] ) - $MAX_PATH_LENGTH;
        die &quot;“$_[0]” is $excess character(s) too long to be a path to a local socket ($MAX_PATH_LENGTH bytes maximum)!&quot;;
    }

    return pack( &#039;va*&#039;, $AF_UNIX, $_[0] ) if 0 == rindex( $_[0], &quot;\0&quot;, 0 );

    return pack(
        $LITTLE_ENDIAN_TEMPLATE,    # x86_64 is always little endian
        $AF_UNIX,
        $_[0],
    );
}

sub unpack_sockaddr_un {

    return substr( $_[0], 2 ) if 2 == rindex( $_[0], &quot;\0&quot;, 2 );

    return ( unpack $LITTLE_ENDIAN_TEMPLATE, $_[0] )[1];
}

1;

} # --- END Cpanel/Socket/UNIX/Micro.pm


{ # --- BEGIN Cpanel/NSCD/Check.pm
package Cpanel::NSCD::Check;


use strict;

# use Cpanel::NSCD::Constants     (); # perlpkg line 211
# use Cpanel::Socket::UNIX::Micro (); # perlpkg line 211

our $CACHE_TTL = 600;

my $last_check_time = 0;
my $nscd_is_running_cache;

sub nscd_is_running {
    my $now = time();
    if ( $last_check_time &amp;&amp; $last_check_time + $CACHE_TTL &gt; $now ) {
        return $nscd_is_running_cache;
    }

    $last_check_time = $now;
    my $socket;
    if ( Cpanel::Socket::UNIX::Micro::connect( $socket, $Cpanel::NSCD::Constants::NSCD_SOCKET ) ) {
        return ( $nscd_is_running_cache = 1 );
    }
    return ( $nscd_is_running_cache = 0 );
}

1;

} # --- END Cpanel/NSCD/Check.pm


{ # --- BEGIN Cpanel/PwCache/Helpers.pm
package Cpanel::PwCache::Helpers;


use strict;
use warnings;
no warnings &#039;once&#039;;

my $skip_uid_cache = 0;

sub no_uid_cache { $skip_uid_cache = 1; return }
sub uid_cache    { $skip_uid_cache = 0; return }

sub skip_uid_cache {
    return $skip_uid_cache;
}

sub init {
    my ( $totie, $skip_uid_cache_value ) = @_;

    tiedto($totie);
    $skip_uid_cache = $skip_uid_cache_value;

    return;
}

{    # debugging helpers
    sub confess { require Carp; return Carp::confess(@_) }
    sub cluck   { require Carp; return Carp::cluck(@_) }
}

{    # tie logic and cache

    my $pwcacheistied = 0;
    my $pwcachetie;

    sub istied { return $pwcacheistied }
    sub deinit { $pwcacheistied = 0; return; }

    sub tiedto {
        my $v = shift;

        if ( !defined $v ) {    # get
            return $pwcacheistied ? $pwcachetie : undef;
        }
        else {                  # set
            $pwcacheistied = 1;
            $pwcachetie    = $v;
        }

        return;
    }

}

{
    my $SYSTEM_CONF_DIR  = &#039;/etc&#039;;
    my $PRODUCT_CONF_DIR = &#039;/var/cpanel&#039;;

    sub default_conf_dir    { return $SYSTEM_CONF_DIR }
    sub default_product_dir { return $PRODUCT_CONF_DIR; }
}

1;

} # --- END Cpanel/PwCache/Helpers.pm


{ # --- BEGIN Cpanel/PwCache/Cache.pm
package Cpanel::PwCache::Cache;


use strict;
use warnings;
no warnings &#039;once&#039;;

my %_cache;
my %_homedir_cache;
use constant get_cache         =&gt; \%_cache;
use constant get_homedir_cache =&gt; \%_homedir_cache;

our $pwcache_inited = 0;
my $PWCACHE_IS_SAFE = 1;

sub clear {    # clear all
    %_cache         = ();
    %_homedir_cache = ();
    $pwcache_inited = 0;
    return;
}

sub remove_key {
    my ($pwkey) = @_;
    return delete $_cache{$pwkey};
}

sub replace {
    my $h = shift;
    %_cache = %$h if ref $h eq &#039;HASH&#039;;
    return;
}

sub is_safe {
    $PWCACHE_IS_SAFE = $_[0] if defined $_[0];
    return $PWCACHE_IS_SAFE;
}

sub pwmksafecache {
    return if $PWCACHE_IS_SAFE;
    $_cache{$_}{&#039;contents&#039;}-&gt;[1] = &#039;x&#039; for keys %_cache;
    $PWCACHE_IS_SAFE = 1;
    return;
}

1;

} # --- END Cpanel/PwCache/Cache.pm


{ # --- BEGIN Cpanel/LoadFile/ReadFast.pm
package Cpanel::LoadFile::ReadFast;


use strict;
use warnings;
no warnings &#039;once&#039;;


use constant READ_CHUNK =&gt; 1 &lt;&lt; 18;    # 262144

use constant _EINTR =&gt; 4;


sub read_fast {
    $_[1] //= q&lt;&gt;;

    return ( @_ &gt; 3 ? sysread( $_[0], $_[1], $_[2], $_[3] ) : sysread( $_[0], $_[1], $_[2] ) ) // do {
        goto \&amp;read_fast if $! == _EINTR;
        die &quot;Failed to read data: $!&quot;;
    };
}


my $_ret;

sub read_all_fast {
    $_[1] //= q&lt;&gt;;

    $_ret = 1;
    while ($_ret) {
        $_ret = sysread( $_[0], $_[1], READ_CHUNK, length $_[1] ) // do {
            redo if $! == _EINTR;
            die &quot;Failed to read data: $!&quot;;
        }
    }
    return;
}

1;

} # --- END Cpanel/LoadFile/ReadFast.pm


{ # --- BEGIN Cpanel/PwCache/Find.pm
package Cpanel::PwCache::Find;


use strict;

# use Cpanel::LoadFile::ReadFast (); # perlpkg line 211

our $PW_CHUNK_SIZE = 1 &lt;&lt; 17;

sub field_with_value_in_pw_file {
    my ( $passwd_fh, $field, $value, $lc_flag ) = @_;

    return if ( $value =~ tr{\x{00}-\x{1f}\x{7f}:}{} );

    my $needle = $field == 0 ? &quot;\n${value}:&quot; : &quot;:${value}&quot;;
    my $haystack;

    my $match_pos = 0;
    my $line_start;
    my $line_end;
    my $not_eof;
    my $data = &quot;\n&quot;;

    while ( ( $not_eof = Cpanel::LoadFile::ReadFast::read_fast( $passwd_fh, $data, $PW_CHUNK_SIZE, length $data ) ) || length($data) &gt; 1 ) {

        $haystack = $not_eof ? substr( $data, 0, rindex( $data, &quot;\n&quot; ), &#039;&#039; ) : $data;

        if ( $lc_flag &amp;&amp; $lc_flag == 1 ) {
            $haystack = lc $haystack;
            $needle   = lc $needle;
        }

        while ( -1 &lt; ( $match_pos = index( $haystack, $needle, $match_pos ) ) ) {

            $line_start = ( !$field ? $match_pos : rindex( $haystack, &quot;\n&quot;, $match_pos ) ) + 1;
            if (
                !$field || (

                    $field == ( substr( $haystack, $line_start, $match_pos - $line_start + 1 ) =~ tr{:}{} )

                    &amp;&amp; ( length($haystack) == $match_pos + length($needle) || substr( $haystack, $match_pos + length($needle), 1 ) =~ tr{:\n}{} )
                )
            ) {
                $line_end = index( $haystack, &quot;\n&quot;, $match_pos + length($needle) );
                my $line = substr( $haystack, $line_start, ( $line_end &gt; -1 ? $line_end : length($haystack) ) - $line_start );

                return split( &#039;:&#039;, $line );
            }
            $match_pos += length($needle);
        }
        last unless $not_eof;
    }
    return;
}

1;

} # --- END Cpanel/PwCache/Find.pm


{ # --- BEGIN Cpanel/JSON/Unicode.pm
package Cpanel::JSON::Unicode;


use strict;
use warnings;
no warnings &#039;once&#039;;


use constant {

    _LEAD_SURROGATE_MIN =&gt; 0xd800,
    _TAIL_SURROGATE_MIN =&gt; 0xdc00,

    _SURROGATE_MASK =&gt; 0xfc00,

    _BACKSLASH_ORD    =&gt; 0x5c,
    _DOUBLE_QUOTE_ORD =&gt; 0x22,
};

my $UNICODE_ESCAPE_REGEXP = qr/

    (?&lt;!\x5c)

    (

        (?:\x5c\x5c)*

        \x5c u ([0-9a-fA-F]{4})
    )
/x;


sub replace_unicode_escapes_with_utf8 {
    my ($json_sr) = @_;

    my $lead_surrogate;

    my $ret = $$json_sr =~ s&lt;$UNICODE_ESCAPE_REGEXP&gt;&lt;
        _replacement(\$lead_surrogate, $json_sr, $+[0], @{^CAPTURE})
    &gt;ge;

    if ($lead_surrogate) {
        die sprintf &quot;Incomplete surrogate pair (0x%04x)&quot;, $lead_surrogate;
    }

    return $ret;
}

sub _replacement {
    my ( $lead_surrogate_sr, $json_sr, $match_end, @captures ) = @_;

    my $num = hex $captures[1];

    if ( ( $num &amp; _SURROGATE_MASK ) == _TAIL_SURROGATE_MIN ) {
        if ($$lead_surrogate_sr) {
            my $utf8 = _decode_surrogates( $$lead_surrogate_sr, $num );
            $$lead_surrogate_sr = undef;
            return $utf8;
        }

        die sprintf &quot;Unpaired trailing surrogate (0x%04x)&quot;, $num;
    }
    elsif ( ( $num &amp; _SURROGATE_MASK ) == _LEAD_SURROGATE_MIN ) {
        my $next2 = substr( $$json_sr, $match_end, 2 );
        if ( !$next2 || $next2 ne &#039;\\u&#039; ) {
            die sprintf &quot;Unpaired leading surrogate (0x%04x)&quot;, $num;
        }

        $$lead_surrogate_sr = $num;
        return q&lt;&gt;;
    }
    elsif ( $num &lt; 0x20 || $num == _BACKSLASH_ORD || $num == _DOUBLE_QUOTE_ORD ) {
        return $captures[0];
    }

    my $utf8 = chr $num;
    utf8::encode($utf8);
    return $utf8;
}

sub _decode_surrogates {
    my ( $lead, $tail ) = @_;

    my $uni = 0x10000 + ( ( $lead - 0xd800 ) &lt;&lt; 10 ) + ( $tail - 0xdc00 );

    my $un = chr $uni;
    utf8::encode($un);

    return $un;
}

1;

} # --- END Cpanel/JSON/Unicode.pm


{ # --- BEGIN Cpanel/Encoder/ASCII.pm
package Cpanel::Encoder::ASCII;


use strict;
use warnings;
no warnings &#039;once&#039;;

sub to_hex {
    my ($readable) = @_;

    $readable =~ s&lt;\\&gt;&lt;\\\\&gt;g;
    $readable =~ s&lt;([\0-\x{1f}\x{7f}-\x{ff}])&gt;&lt;sprintf &#039;\x{%02x}&#039;, ord $1&gt;eg;

    return $readable;
}

1;

} # --- END Cpanel/Encoder/ASCII.pm


{ # --- BEGIN Cpanel/UTF8/Strict.pm
package Cpanel::UTF8::Strict;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub decode {

    utf8::decode( $_[0] ) or do {
        local ( $@, $! );
        require Cpanel::Encoder::ASCII;
        die sprintf &quot;Invalid UTF-8 in string: “%s”&quot;, Cpanel::Encoder::ASCII::to_hex( $_[0] );
    };

    return $_[0];
}

1;

} # --- END Cpanel/UTF8/Strict.pm


{ # --- BEGIN Cpanel/JSON.pm
package Cpanel::JSON;


use strict;

# use Cpanel::Fcntl::Constants   (); # perlpkg line 211
# use Cpanel::FHUtils::Tiny      (); # perlpkg line 211
# use Cpanel::JSON::Unicode      (); # perlpkg line 211
# use Cpanel::LoadFile::ReadFast (); # perlpkg line 211
use JSON::XS                   ();
# use Cpanel::UTF8::Strict       (); # perlpkg line 211

our $NO_DECODE_UTF8 = 0;
our $DECODE_UTF8    = 1;

our $LOAD_STRICT  = 0;
our $LOAD_RELAXED = 1;

our $MAX_LOAD_LENGTH_UNLIMITED = 0;
our $MAX_LOAD_LENGTH           = 65535;

our $MAX_PRIV_LOAD_LENGTH = 4194304;    # four megs

our $VERSION = &#039;2.5&#039;;

my $copied_boolean = 0;


sub DumpFile {
    return _dumpFile( @_, 0, 0 );
}

sub DumpFilePretty {
    return _dumpFile( @_, 1, 0 );
}

sub DumpFileCanonical {
    return _dumpFile( @_, 0, 1 );
}

sub DumpFilePrettyCanonical {
    return _dumpFile( @_, 1, 1 );
}

sub _dumpFile {
    my @args = @_;
    my %opts = map { $_ =&gt; shift @args } qw{file data pretty canon};
    my $fh;
    $fh = $opts{&#039;file&#039;} if Cpanel::FHUtils::Tiny::is_a( $opts{&#039;file&#039;} );
    if ( $fh || open( $fh, &#039;&gt;&#039;, $opts{&#039;file&#039;} ) ) {
        my %json_opts;
        $json_opts{&#039;pretty&#039;}    = 1 if $opts{&#039;pretty&#039;};
        $json_opts{&#039;canonical&#039;} = 1 if $opts{&#039;canon&#039;};
        print {$fh} _create_new_json_object(%json_opts)-&gt;encode( $opts{&#039;data&#039;} ) or return 0;
        return 1;
    }
    return 0;
}


sub copy_boolean {

    if ( !$copied_boolean ) {
        *Types::Serialiser::Boolean:: = *JSON::PP::Boolean::;
        $copied_boolean               = 1;
    }
    return;
}


sub _create_new_json_object {
    my (%opts) = @_;
    copy_boolean() if !$copied_boolean;
    my $obj = JSON::XS-&gt;new()-&gt;shrink(1)-&gt;allow_nonref(1)-&gt;convert_blessed(1);

    $obj-&gt;can($_)-&gt;( $obj, $opts{$_} ) for keys(%opts);
    return $obj;
}


sub true {
    copy_boolean() if !$copied_boolean;
    my $x = 1;
    return bless \$x, &#039;Types::Serialiser::Boolean&#039;;
}


sub false {
    copy_boolean() if !$copied_boolean;
    my $x = 0;
    return bless \$x, &#039;Types::Serialiser::Boolean&#039;;
}


sub pretty_dump {
    return _create_new_json_object()-&gt;pretty(1)-&gt;encode( $_[0] );
}


sub canonical_dump {
    return _create_new_json_object()-&gt;canonical(1)-&gt;encode( $_[0] );
}


sub pretty_canonical_dump {
    return _create_new_json_object()-&gt;canonical(1)-&gt;indent-&gt;space_before-&gt;space_after-&gt;encode( $_[0] );
}


sub Dump {
    return _create_new_json_object()-&gt;encode( $_[0] );
}


sub Load {
    local $@;

    _replace_unicode_escapes_if_needed( \$_[0] );

    return eval { _create_new_json_object()-&gt;decode( $_[0] ); } // ( ( $@ &amp;&amp; _throw_json_error( $@, $_[1], \$_[0] ) ) || undef );
}


sub LoadRelaxed {
    local $@;

    _replace_unicode_escapes_if_needed( \$_[0] );

    return eval { _create_new_json_object()-&gt;relaxed(1)-&gt;decode( $_[0] ); } // ( ( $@ &amp;&amp; _throw_json_error( $@, $_[1], \$_[0] ) ) || undef );
}


sub _throw_json_error {
    my ( $exception, $path, $dataref ) = @_;

    local $@;
    require Cpanel::Exception;
    die $exception if $@;
    die &#039;Cpanel::Exception&#039;-&gt;can(&#039;create&#039;)-&gt;( &#039;JSONParseError&#039;, { &#039;error&#039; =&gt; $exception, &#039;path&#039; =&gt; $path, &#039;dataref&#039; =&gt; $dataref } );
}


sub LoadNoSetUTF8 {
    local $@;

    _replace_unicode_escapes_if_needed( \$_[0] );

    return eval { _create_new_no_set_utf8_json_object()-&gt;decode( $_[0] ); } // ( ( $@ &amp;&amp; _throw_json_error( $@, $_[1], \$_[0] ) ) || undef );
}


sub LoadNoSetUTF8Relaxed {
    local $@;

    _replace_unicode_escapes_if_needed( \$_[0] );

    return eval { _create_new_no_set_utf8_json_object()-&gt;relaxed(1)-&gt;decode( $_[0] ); } // ( ( $@ &amp;&amp; _throw_json_error( $@, $_[1], \$_[0] ) ) || undef );
}

sub _create_new_no_set_utf8_json_object {
    my $obj = _create_new_json_object();
    if ( $obj-&gt;can(&#039;no_set_utf8&#039;) ) {
        $obj-&gt;no_set_utf8(1);
    }
    else {
        warn &quot;JSON::XS is missing the no_set_utf8 flag&quot;;
    }
    return $obj;
}

sub _replace_unicode_escapes_if_needed {
    my $json_r = shift;

    return unless defined $$json_r;
    if ( -1 != index( $$json_r, &#039;\\u&#039; ) ) {
        Cpanel::JSON::Unicode::replace_unicode_escapes_with_utf8($json_r);
    }

    return;
}


sub SafeLoadFile {    # only allow a small bit of data to be loaded
    return _LoadFile( $_[0], $MAX_LOAD_LENGTH, $_[2] || $NO_DECODE_UTF8, $_[1], $LOAD_STRICT );
}


sub LoadFile {
    return _LoadFile( $_[0], $MAX_LOAD_LENGTH_UNLIMITED, $_[2] || $NO_DECODE_UTF8, $_[1], $LOAD_STRICT );
}


sub LoadFileRelaxed {
    return _LoadFile( $_[0], $MAX_LOAD_LENGTH_UNLIMITED, $_[2] || $NO_DECODE_UTF8, $_[1], $LOAD_RELAXED );
}


sub LoadFileNoSetUTF8 {
    return _LoadFile( $_[0], $_[1] || $MAX_LOAD_LENGTH_UNLIMITED, $DECODE_UTF8, $_[2], $LOAD_STRICT );
}

sub _LoadFile {
    my ( $file, $max, $decode_utf8, $path, $relaxed ) = @_;

    my $data;
    if ( Cpanel::FHUtils::Tiny::is_a($file) ) {
        if ($max) {
            my $togo = $max;
            $data = &#039;&#039;;
            my $bytes_read;
            while ( $bytes_read = read( $file, $data, $togo, length $data ) &amp;&amp; length $data &lt; $max ) {
                $togo -= $bytes_read;
            }
        }
        else {
            Cpanel::LoadFile::ReadFast::read_all_fast( $file, $data );
        }
    }
    else {
        local $!;
        open( my $fh, &#039;&lt;:stdio&#039;, $file ) or do {
            my $err = $!;

            require Cpanel::Carp;
            die Cpanel::Carp::safe_longmess(&quot;Cannot open “$file”: $err&quot;);
        };
        Cpanel::LoadFile::ReadFast::read_all_fast( $fh, $data );
        if ( !length $data ) {
            require Cpanel::Carp;
            die Cpanel::Carp::safe_longmess(&quot;“$file” is empty.&quot;);
        }
        close $fh or warn &quot;close($file) failed: $!&quot;;
    }

    if ( $decode_utf8 &amp;&amp; $decode_utf8 == $DECODE_UTF8 ) {

        Cpanel::UTF8::Strict::decode($data);

        return $relaxed ? LoadNoSetUTF8Relaxed( $data, $path || $file ) : LoadNoSetUTF8( $data, $path || $file );
    }

    return $relaxed ? LoadRelaxed( $data, $path || $file ) : Load( $data, $path || $file );
}


sub SafeDump {
    my $raw_json = _create_new_json_object()-&gt;encode( $_[0] );
    $raw_json =~ s{\/}{\\/}g if $raw_json =~ tr{/}{};    # / fix for editors
    return $raw_json;
}


sub _fh_looks_like_json {
    my ($fh) = @_;

    my $bytes_read = 0;

    my $buffer = q{};

    local $!;

    while ( $buffer !~ tr{ \t\r\n\f}{}c &amp;&amp; !eof $fh ) {
        $bytes_read += ( read( $fh, $buffer, 1, length $buffer ) // die &quot;read() failed: $!&quot; );
    }

    return (
        _string_looks_like_json($buffer),
        \$buffer,
    );
}

sub _string_looks_like_json {    ##no critic qw(RequireArgUnpacking)
    return $_[0] =~ m/\A\s*[\[\{&quot;0-9]/ ? 1 : 0;
}

sub looks_like_json {    ##no critic qw(RequireArgUnpacking)
    if ( Cpanel::FHUtils::Tiny::is_a( $_[0] ) ) {
        my $fh = $_[0];

        my ( $looks_like_json, $fragment_ref ) = _fh_looks_like_json($fh);
        my $bytes_read = length $$fragment_ref;

        if ($bytes_read) {
            seek( $fh, -$bytes_read, $Cpanel::Fcntl::Constants::SEEK_CUR ) or die &quot;seek() failed: $!&quot;;
        }

        return $looks_like_json;
    }

    return _string_looks_like_json( $_[0] );
}


sub to_bool {
    my ($val) = @_;

    $val = 0 if defined $val &amp;&amp; $val eq &#039;false&#039;;
    return !!$val ? true() : false();
}


1;

} # --- END Cpanel/JSON.pm


{ # --- BEGIN Cpanel/JSON/FailOK.pm
package Cpanel::JSON::FailOK;


use strict;
use warnings;
no warnings &#039;once&#039;;

sub LoadJSONModule {
    local $@;

    my $load_ok = eval {
        local $SIG{&#039;__DIE__&#039;};     # Suppress spewage as we may be reading an invalid cache
        local $SIG{&#039;__WARN__&#039;};    # and since failure is ok to throw it away
        require Cpanel::JSON;      # PPI NO PARSE - FailOK
        1;
    };

    if ( !$load_ok &amp;&amp; !$ENV{&#039;CPANEL_BASE_INSTALL&#039;} &amp;&amp; index( $^X, &#039;/usr/local/cpanel&#039; ) == 0 ) {
        warn $@;
    }

    return $load_ok ? 1 : 0;
}

sub LoadFile {
    return undef if !$INC{&#039;Cpanel/JSON.pm&#039;};

    return eval {
        local $SIG{&#039;__DIE__&#039;};         # Suppress spewage as we may be reading an invalid cache
        local $SIG{&#039;__WARN__&#039;};        # and since failure is ok to throw it away
        Cpanel::JSON::LoadFile(@_);    # PPI NO PARSE - inc check above
    };
}
1;

} # --- END Cpanel/JSON/FailOK.pm


{ # --- BEGIN Cpanel/Destruct.pm
package Cpanel::Destruct;


use strict;
my $in_global_destruction = 0;
my ( $package, $filename, $line, $subroutine );    # preallocate

sub in_dangerous_global_destruction {

    if ( !$INC{&#039;Test2/API.pm&#039;} ) {

        return 1 if in_global_destruction() &amp;&amp; $INC{&#039;Cpanel/BinCheck.pm&#039;};
    }

    return 0;
}

sub in_global_destruction {
    return $in_global_destruction if $in_global_destruction;

    if ( defined( ${^GLOBAL_PHASE} ) ) {
        if ( ${^GLOBAL_PHASE} eq &#039;DESTRUCT&#039; ) {
            $in_global_destruction = 1;
        }
    }

    else {
        local $SIG{&#039;__WARN__&#039;} = \&amp;_detect_global_destruction_pre_514_WARN_handler;
        warn;
    }

    return $in_global_destruction;
}

sub _detect_global_destruction_pre_514_WARN_handler {
    if ( length $_[0] &gt; 26 &amp;&amp; rindex( $_[0], &#039;during global destruction.&#039; ) == ( length( $_[0] ) - 26 ) ) {
        $in_global_destruction = 1;
    }

    return;
}

1;

} # --- END Cpanel/Destruct.pm


{ # --- BEGIN Cpanel/Finally.pm
package Cpanel::Finally;


use cPstrict;
no warnings &#039;once&#039;;

# use Cpanel::Carp     (); # perlpkg line 211
# use Cpanel::Destruct (); # perlpkg line 211
# use Cpanel::Debug    (); # perlpkg line 211


sub new ( $class, @todo_crs ) {

    local $/ = &quot;\n&quot;;    # Carp warns when $/ is undef, breaking tests
    return bless { &#039;pid&#039; =&gt; $$, &#039;todo&#039; =&gt; [@todo_crs], _from =&gt; Cpanel::Carp::safe_longmess() }, $class;
}


sub add ( $self, @new_crs ) {

    $self-&gt;{&#039;todo&#039;} //= [];
    push @{ $self-&gt;{&#039;todo&#039;} }, @new_crs;

    return;
}


sub skip ($self) {
    return delete $self-&gt;{&#039;todo&#039;};
}

sub DESTROY ($self) {

    return if $$ != $self-&gt;{&#039;pid&#039;} || !$self-&gt;{&#039;todo&#039;};

    if ( Cpanel::Destruct::in_dangerous_global_destruction() ) {
        Cpanel::Debug::log_die( qq[PROG $0 - Cpanel::Finally should never be triggered during global destruction\nCalled from ] . $self-&gt;{_from} );
    }

    local $@;    #prevent insidious clobber of error messages

    while ( @{ $self-&gt;{&#039;todo&#039;} } ) {
        my $ok = eval {
            while ( my $item = shift @{ $self-&gt;{&#039;todo&#039;} } ) {
                $item-&gt;();
            }

            1;
        };

        warn $@ if !$ok;
    }

    return;
}

1;

} # --- END Cpanel/Finally.pm


{ # --- BEGIN Cpanel/Readlink.pm
package Cpanel::Readlink;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Autodie   (); # perlpkg line 211
# use Cpanel::Exception (); # perlpkg line 211
use Cwd               ();

our $MAX_SYMLINK_DEPTH = 1024;

sub deep {
    my ( $link, $provide_trailing_slash ) = @_;

    die Cpanel::Exception::create( &#039;MissingParameter&#039;, &#039;Provide a link path.&#039; ) if !length $link;

    if ( length($link) &gt; 1 &amp;&amp; substr( $link, -1, 1 ) eq &#039;/&#039; ) {
        $link = substr( $link, 0, length($link) - 1 );
        return deep( $link, 1 );
    }

    if ( !-l $link ) {
        return $provide_trailing_slash ? qq{$link/} : $link;
    }

    my %is_link;
    $is_link{$link} = 1;

    my $depth = 0;

    my $base = _get_base_for($link);

    if ( substr( $link, 0, 1 ) ne &#039;/&#039; ) {
        $base = Cwd::abs_path() . &#039;/&#039; . $base;
    }

    while ( ( $is_link{$link} ||= -l $link ) &amp;&amp; ++$depth &lt;= $MAX_SYMLINK_DEPTH ) {
        $link = Cpanel::Autodie::readlink($link);
        if ( substr( $link, 0, 1 ) ne &#039;/&#039; ) {
            $link = $base . &#039;/&#039; . $link;
        }

        $base = _get_base_for($link);
    }

    return $provide_trailing_slash ? qq{$link/} : $link;
}

sub _get_base_for {
    my $basename = shift;
    my @path     = split( &#039;/&#039;, $basename );
    pop(@path);
    return join( &#039;/&#039;, @path );
}

1;

} # --- END Cpanel/Readlink.pm


{ # --- BEGIN Cpanel/FileUtils/Write.pm
package Cpanel::FileUtils::Write;


use strict;
use warnings;
no warnings &#039;once&#039;;


# use Cpanel::Fcntl::Constants (); # perlpkg line 211
use Cpanel::Autodie ( &#039;rename&#039;, &#039;syswrite_sigguard&#039;, &#039;seek&#039;, &#039;print&#039;, &#039;truncate&#039; );
# use Cpanel::Exception       (); # perlpkg line 211
# use Cpanel::FileUtils::Open (); # perlpkg line 211
# use Cpanel::Finally         (); # perlpkg line 211
# use Cpanel::Debug           (); # perlpkg line 211

our $Errno_EEXIST = 17;

our $MAX_TMPFILE_CREATE_ATTEMPTS = 1024;
my $DEFAULT_PERMS = 0600;
my $_WRONLY_CREAT_EXCL;


sub write_fh {    ##no critic qw(RequireArgUnpacking)
    my $fh = $_[0];

    Cpanel::Autodie::seek( $fh, 0, 0 );
    Cpanel::Autodie::print( $fh, $_[1] );
    Cpanel::Autodie::truncate( $fh, tell($fh) );

    return 1;
}


sub write {
    return _write_to_tmpfile( @_[ 0 .. 2 ], \&amp;_write_finish );
}


sub overwrite {
    return _write_to_tmpfile( @_[ 0 .. 2 ], \&amp;_overwrite_finish );
}

sub overwrite_no_exceptions {
    my $fh;

    local $@;
    eval {
        $fh = overwrite(@_);
        1;
    } or Cpanel::Debug::log_warn(&quot;overwrite exception: $@&quot;);

    return !!$fh;
}

sub _write_to_tmpfile {    ##no critic qw(RequireArgUnpacking)
    my ( $filename, $perms_or_hr, $finish_cr ) = ( $_[0], $_[2], $_[3] );

    if ( !defined $filename ) {
        exists $INC{&#039;Carp.pm&#039;} ? Carp::confess(&quot;write() called with undefined filename&quot;) : die(&quot;write() called with undefined filename&quot;);
    }

    if ( ref $filename ) {
        die &quot;Use write_fh to write to a file handle. ($filename is a filehandle, right?)&quot;;
    }

    my ( $fh, $tmpfile_is_renamed );

    if ( -l $filename ) {
        require Cpanel::Readlink;
        $filename = Cpanel::Readlink::deep($filename);
    }


    my ( $callback_cr, $tmp_perms );

    if ( &#039;HASH&#039; eq ref $perms_or_hr ) {
        $callback_cr = $perms_or_hr-&gt;{&#039;before_installation&#039;};
    }
    else {
        $tmp_perms = $perms_or_hr;
    }

    $tmp_perms //= $DEFAULT_PERMS;

    my ( $tmpfile, $attempts ) = ( &#039;&#039;, 0 );

    while (1) {
        local $!;
        my $rand = rand(99999999);
        $rand = sprintf( &#039;%x&#039;, substr( $rand, 2 ) );

        my $last_slash_idx = rindex( $filename, &#039;/&#039; );
        $tmpfile = $filename;
        substr( $tmpfile, 1 + $last_slash_idx, 0 ) = &quot;.tmp.$rand.&quot;;

        last if Cpanel::FileUtils::Open::sysopen_with_real_perms(
            $fh,
            $tmpfile,
            ( $_WRONLY_CREAT_EXCL ||= ( $Cpanel::Fcntl::Constants::O_CREAT | $Cpanel::Fcntl::Constants::O_EXCL | $Cpanel::Fcntl::Constants::O_WRONLY ) ),
            $tmp_perms,
        );

        if ( $! != $Errno_EEXIST ) {
            die Cpanel::Exception::create( &#039;IO::FileCreateError&#039;, [ error =&gt; $!, path =&gt; $tmpfile, permissions =&gt; $tmp_perms ] );
        }

        ++$attempts;
        if ( $attempts &gt;= $MAX_TMPFILE_CREATE_ATTEMPTS ) {
            die Cpanel::Exception::create_raw( &#039;IO::FileCreateError&#039;, &quot;Too many ($MAX_TMPFILE_CREATE_ATTEMPTS) failed attempts to create a temp file as EUID $&gt; and GID $) based on “$filename”! The last tried file was “$tmpfile”, and the last error was: $!&quot; );
        }
    }

    my $finally = Cpanel::Finally-&gt;new(
        sub {
            if ( !$tmpfile_is_renamed ) {
                Cpanel::Autodie::unlink_if_exists($tmpfile);

            }
            return;
        }
    );

    if ( my $ref = ref $_[1] ) {
        if ( $ref eq &#039;SCALAR&#039; ) {
            _write_fh( $fh, ${ $_[1] } );
        }
        else {
            die Cpanel::Exception::create( &#039;InvalidParameter&#039;, &#039;Invalid content type “[_1]”, expect a scalar.&#039;, [$ref] );
        }
    }
    else {
        _write_fh( $fh, $_[1] );
    }

    $callback_cr-&gt;($fh) if $callback_cr;

    $tmpfile_is_renamed = $finish_cr-&gt;( $tmpfile, $filename );

    if ( !$tmpfile_is_renamed ) {
        Cpanel::Autodie::unlink_if_exists($tmpfile);
    }

    $finally-&gt;skip();

    return $fh;
}

*_syswrite = *Cpanel::Autodie::syswrite_sigguard;

our $DEBUG_WRITE;

sub _write_fh {
    if ( length $_[1] ) {
        my $pos = 0;

        do {

            local $SIG{&#039;XFSZ&#039;} = &#039;IGNORE&#039; if $pos;

            $pos += _syswrite( $_[0], $_[1], length( $_[1] ), $pos ) || do {

                die &quot;Zero bytes written, non-error!&quot;;
            };
        } while $pos &lt; length( $_[1] );
    }

    return;
}

sub _write_finish {

    Cpanel::Autodie::link(@_);
    return 0;
}

*_overwrite_finish = *Cpanel::Autodie::rename;

1;

} # --- END Cpanel/FileUtils/Write.pm


{ # --- BEGIN Cpanel/FileUtils/Write/JSON/Lazy.pm
package Cpanel::FileUtils::Write::JSON::Lazy;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub write_file {
    my ( $file_or_fh, $data, $perms ) = @_;

    if ( exists $INC{&#039;Cpanel/JSON.pm&#039;} &amp;&amp; exists $INC{&#039;JSON/XS.pm&#039;} &amp;&amp; ( my $Dump = &#039;Cpanel::JSON&#039;-&gt;can(&#039;Dump&#039;) ) ) {    # PPI NO PARSE -- check earlier - must be quoted or it ends up in the stash
        require Cpanel::FileUtils::Write if !$INC{&#039;Cpanel/FileUtils/Write.pm&#039;};
        require Cpanel::FHUtils::Tiny    if !$INC{&#039;Cpanel/FHUtils/Tiny.pm&#039;};
        my $func = Cpanel::FHUtils::Tiny::is_a($file_or_fh) ? &#039;write_fh&#039; : &#039;overwrite&#039;;

        if ( $func eq &#039;write_fh&#039; ) {
            if ( !defined $perms ) {
                $perms = 0600;
            }

            chmod( $perms, $file_or_fh ) or die &quot;Failed to set permissions on the file handle passed to Cpanel::FileUtils::Write::JSON::Lazy::write_file because of an error: $!&quot;;
        }

        return Cpanel::FileUtils::Write-&gt;can($func)-&gt;(
            $file_or_fh,
            $Dump-&gt;($data),
            $perms
        );
    }
    return 0;
}


sub write_file_pretty {
    my ( $file_or_fh, $data, $perms ) = @_;

    if ( exists $INC{&#039;Cpanel/JSON.pm&#039;} &amp;&amp; exists $INC{&#039;JSON/XS.pm&#039;} &amp;&amp; ( my $Dump = &#039;Cpanel::JSON&#039;-&gt;can(&#039;pretty_dump&#039;) ) ) {    # PPI NO PARSE -- check earlier - must be quoted or it ends up in the stash
        require Cpanel::FileUtils::Write if !$INC{&#039;Cpanel/FileUtils/Write.pm&#039;};
        require Cpanel::FHUtils::Tiny    if !$INC{&#039;Cpanel/FHUtils/Tiny.pm&#039;};
        my $func = Cpanel::FHUtils::Tiny::is_a($file_or_fh) ? &#039;write_fh&#039; : &#039;overwrite&#039;;

        if ( $func eq &#039;write_fh&#039; ) {
            if ( !defined $perms ) {
                $perms = 0600;
            }

            chmod( $perms, $file_or_fh ) or die &quot;Failed to set permissions on the file handle passed to Cpanel::FileUtils::Write::JSON::Lazy::write_file because of an error: $!&quot;;
        }

        return Cpanel::FileUtils::Write-&gt;can($func)-&gt;(
            $file_or_fh,
            $Dump-&gt;($data),
            $perms
        );
    }
    return 0;
}

1;

} # --- END Cpanel/FileUtils/Write/JSON/Lazy.pm


{ # --- BEGIN Cpanel/PwCache/Build.pm
package Cpanel::PwCache::Build;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Debug                        (); # perlpkg line 211
# use Cpanel::JSON::FailOK                 (); # perlpkg line 211
# use Cpanel::FileUtils::Write::JSON::Lazy (); # perlpkg line 211
# use Cpanel::PwCache::Helpers             (); # perlpkg line 211
# use Cpanel::PwCache::Cache               (); # perlpkg line 211
# use Cpanel::LoadFile::ReadFast           (); # perlpkg line 211


my ( $MIN_FIELDS_FOR_VALID_ENTRY, $pwcache_has_uid_cache ) = ( 0, 6 );

sub pwmksafecache {
    return if Cpanel::PwCache::Cache::is_safe();
    my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();

    $pwcache_ref-&gt;{$_}{&#039;contents&#039;}-&gt;[1] = &#039;x&#039; for keys %{$pwcache_ref};

    Cpanel::PwCache::Cache::is_safe(1);

    return;
}

sub pwclearcache {    # also known as clear_this_process_cache
    $pwcache_has_uid_cache = undef;

    Cpanel::PwCache::Cache::clear();

    return;
}

sub init_pwcache {
    Cpanel::PwCache::Cache::is_safe(0);
    return _build_pwcache();
}

sub init_passwdless_pwcache {
    return _build_pwcache( &#039;nopasswd&#039; =&gt; 1 );
}

sub fetch_pwcache {
    init_passwdless_pwcache() unless pwcache_is_initted();
    my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();
    if ( scalar keys %$pwcache_ref &lt; 3 ) {
        die &quot;The password cache unexpectedly had less than 3 entries&quot;;
    }
    return [ map { $pwcache_ref-&gt;{$_}-&gt;{&#039;contents&#039;} } grep { substr( $_, 0, 1 ) eq &#039;0&#039; } keys %{$pwcache_ref} ];
}

sub _write_json_cache {
    my ($cache_file) = @_;
    if ( !Cpanel::PwCache::Helpers::istied() &amp;&amp; exists $INC{&#039;Cpanel/JSON.pm&#039;} ) {
        my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();
        if ( !ref $pwcache_ref || scalar keys %$pwcache_ref &lt; 3 ) {
            die &quot;The system failed build the password cache&quot;;
        }

        Cpanel::FileUtils::Write::JSON::Lazy::write_file( $cache_file, $pwcache_ref, 0600 );
    }
    return;
}

sub _write_tied_cache {
    my ( $crypted_passwd_ref, $passwdmtime, $hpasswdmtime ) = @_;
    my $SYSTEM_CONF_DIR = Cpanel::PwCache::Helpers::default_conf_dir();
    local $!;
    if ( open( my $pwcache_passwd_fh, &#039;&lt;:stdio&#039;, &quot;$SYSTEM_CONF_DIR/passwd&quot; ) ) {
        local $/;
        my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();
        my $data        = &#039;&#039;;
        Cpanel::LoadFile::ReadFast::read_all_fast( $pwcache_passwd_fh, $data );
        die &quot;The file “$SYSTEM_CONF_DIR/passwd” was unexpectedly empty&quot; if !length $data;
        my @fields;
        my $skip_uid_cache = Cpanel::PwCache::Helpers::skip_uid_cache();

        foreach my $line ( split( /\n/, $data ) ) {
            next unless length $line;
            @fields = split( /:/, $line );
            next if scalar @fields &lt; $MIN_FIELDS_FOR_VALID_ENTRY || $fields[0] =~ tr/[A-Z][a-z][0-9]._-//c;
            $pwcache_ref-&gt;{ &#039;0:&#039; . $fields[0] } = {
                &#039;cachetime&#039;  =&gt; $passwdmtime,
                &#039;hcachetime&#039; =&gt; $hpasswdmtime,
                &#039;contents&#039;   =&gt; [ $fields[0], $crypted_passwd_ref-&gt;{ $fields[0] } || $fields[1], $fields[2], $fields[3], &#039;&#039;, &#039;&#039;, $fields[4], $fields[5], $fields[6], -1, -1, $passwdmtime, $hpasswdmtime ]
            };
            next if $skip_uid_cache || !defined $fields[2] || exists $pwcache_ref-&gt;{ &#039;2:&#039; . $fields[2] };
            $pwcache_ref-&gt;{ &#039;2:&#039; . $fields[2] } = $pwcache_ref-&gt;{ &#039;0:&#039; . $fields[0] };
        }
        close($pwcache_passwd_fh);
    }
    else {
        die &quot;The system failed to read $SYSTEM_CONF_DIR/passwd because of an error: $!&quot;;
    }
    return;
}

sub _cache_ref_is_valid {
    my ( $cache_ref, $passwdmtime, $hpasswdmtime ) = @_;
    my @keys = qw/0:root 0:cpanel 0:bin/;
    return
         $cache_ref
      &amp;&amp; ( scalar keys %{$cache_ref} ) &gt; 2
      &amp;&amp; scalar @keys == grep {    #
             $cache_ref-&gt;{$_}-&gt;{&#039;hcachetime&#039;}
          &amp;&amp; $cache_ref-&gt;{$_}-&gt;{&#039;hcachetime&#039;} == $hpasswdmtime
          &amp;&amp; $cache_ref-&gt;{$_}-&gt;{&#039;cachetime&#039;}
          &amp;&amp; $cache_ref-&gt;{$_}-&gt;{&#039;cachetime&#039;} == $passwdmtime
      } @keys;
}

sub _build_pwcache {
    my %OPTS = @_;

    if ( $INC{&#039;B/C.pm&#039;} ) {
        Cpanel::PwCache::Helpers::confess(&quot;Cpanel::PwCache::Build::_build_pwcache cannot be run under B::C (see case 162857)&quot;);
    }

    my $SYSTEM_CONF_DIR = Cpanel::PwCache::Helpers::default_conf_dir();

    my ( $cache_file, $passwdmtime, $cache_file_mtime, $crypted_passwd_ref, $crypted_passwd_file, $hpasswdmtime ) = ( &quot;$SYSTEM_CONF_DIR/passwd.cache&quot;, ( stat(&quot;$SYSTEM_CONF_DIR/passwd&quot;) )[9] );

    if ( $OPTS{&#039;nopasswd&#039;} ) {

        $hpasswdmtime = ( stat(&quot;$SYSTEM_CONF_DIR/shadow&quot;) )[9];
        $cache_file   = &quot;$SYSTEM_CONF_DIR/passwd&quot; . ( Cpanel::PwCache::Helpers::skip_uid_cache() ? &#039;.nouids&#039; : &#039;&#039; ) . &#039;.cache&#039;;
    }
    elsif ( -r &quot;$SYSTEM_CONF_DIR/shadow&quot; ) {
        Cpanel::PwCache::Cache::is_safe(0);
        $hpasswdmtime        = ( stat(_) )[9];
        $crypted_passwd_file = &quot;$SYSTEM_CONF_DIR/shadow&quot;;
        $cache_file          = &quot;$SYSTEM_CONF_DIR/shadow&quot; . ( Cpanel::PwCache::Helpers::skip_uid_cache() ? &#039;.nouids&#039; : &#039;&#039; ) . &#039;.cache&#039;;
    }
    else {
        $hpasswdmtime = 0;
    }

    if ( !Cpanel::PwCache::Helpers::istied() &amp;&amp; exists $INC{&#039;Cpanel/JSON.pm&#039;} ) {
        if ( open( my $cache_fh, &#039;&lt;:stdio&#039;, $cache_file ) ) {
            my $cache_file_mtime = ( stat($cache_fh) )[9] || 0;
            if ( $cache_file_mtime &gt; $hpasswdmtime &amp;&amp; $cache_file_mtime &gt; $passwdmtime ) {
                my $cache_ref = Cpanel::JSON::FailOK::LoadFile($cache_fh);
                Cpanel::Debug::log_debug(&quot;[read pwcache from $cache_file]&quot;) if ( $Cpanel::Debug::level &gt; 3 );
                if ( _cache_ref_is_valid( $cache_ref, $passwdmtime, $hpasswdmtime ) ) {
                    Cpanel::Debug::log_debug(&quot;[validated pwcache from $cache_file]&quot;) if ( $Cpanel::Debug::level &gt; 3 );
                    my $memory_pwcache_ref = Cpanel::PwCache::Cache::get_cache();
                    @{$cache_ref}{ keys %$memory_pwcache_ref } = values %$memory_pwcache_ref;
                    Cpanel::PwCache::Cache::replace($cache_ref);
                    $Cpanel::PwCache::Cache::pwcache_inited = ( $OPTS{&#039;nopasswd&#039;} ? 1 : 2 );
                    return;
                }

            }
        }
    }

    if ($crypted_passwd_file) { $crypted_passwd_ref = _load_pws($crypted_passwd_file); }
    $Cpanel::PwCache::Cache::pwcache_inited = ( $OPTS{&#039;nopasswd&#039;}                          ? 1 : 2 );
    $pwcache_has_uid_cache                  = ( Cpanel::PwCache::Helpers::skip_uid_cache() ? 0 : 1 );

    _write_tied_cache( $crypted_passwd_ref, $passwdmtime, $hpasswdmtime );
    _write_json_cache($cache_file) if $&gt; == 0;

    return 1;
}

sub pwcache_is_initted {
    return ( $Cpanel::PwCache::Cache::pwcache_inited ? $Cpanel::PwCache::Cache::pwcache_inited : 0 );
}

sub _load_pws {
    my $lookup_file = shift;

    if ( $INC{&#039;B/C.pm&#039;} ) {
        Cpanel::PwCache::Helpers::confess(&quot;Cpanel::PwCache::Build::_load_pws cannot be run under B::C (see case 162857)&quot;);
    }

    my %PW;
    if ( open my $lookup_fh, &#039;&lt;:stdio&#039;, $lookup_file ) {
        my $data = &#039;&#039;;
        Cpanel::LoadFile::ReadFast::read_all_fast( $lookup_fh, $data );
        die &quot;The file “$lookup_file” was unexpectedly empty&quot; if !length $data;
        %PW = map { ( split(/:/) )[ 0, 1 ] } split( /\n/, $data );
        if ( index( $data, &#039;#&#039; ) &gt; -1 ) {
            delete @PW{ &#039;&#039;, grep { index( $_, &#039;#&#039; ) == 0 } keys %PW };
        }
        else {
            delete $PW{&#039;&#039;};
        }
        close $lookup_fh;
    }
    return \%PW;
}

1;

} # --- END Cpanel/PwCache/Build.pm


{ # --- BEGIN Cpanel/PwCache.pm
package Cpanel::PwCache;


use strict;

# use Cpanel::Debug            (); # perlpkg line 211
# use Cpanel::NSCD::Check      (); # perlpkg line 211
# use Cpanel::PwCache::Helpers (); # perlpkg line 211
# use Cpanel::PwCache::Cache   (); # perlpkg line 211
# use Cpanel::PwCache::Find    (); # perlpkg line 211

use constant DUMMY_PW_RETURNS =&gt; ( -1, -1, 0, 0 );
use constant DEBUG            =&gt; 0;                  # Must set $ENV{&#039;CPANEL_DEBUG_LEVEL&#039;} = 5 as well

our $VERSION = &#039;4.2&#039;;

my %FIXED_KEYS = (
    &#039;0:root&#039;        =&gt; 1,
    &#039;0:nobody&#039;      =&gt; 1,
    &#039;0:cpanel&#039;      =&gt; 1,
    &#039;0:cpanellogin&#039; =&gt; 1,
    &#039;0:mail&#039;        =&gt; 1,
    &#039;2:0&#039;           =&gt; 1,
    &#039;2:99&#039;          =&gt; 1
);

our $_WANT_ENCRYPTED_PASSWORD;


sub getpwnam_noshadow {
    $_WANT_ENCRYPTED_PASSWORD = 0;
    goto &amp;_getpwnam;
}

sub getpwuid_noshadow {
    $_WANT_ENCRYPTED_PASSWORD = 0;
    goto &amp;_getpwuid;
}


sub getpwnam {
    $_WANT_ENCRYPTED_PASSWORD = !!wantarray;
    goto &amp;_getpwnam;
}

sub getpwuid {
    $_WANT_ENCRYPTED_PASSWORD = !!wantarray;
    goto &amp;_getpwuid;
}


sub gethomedir {

    my $uid_or_name = $_[0] // $&gt;;

    my $hd = Cpanel::PwCache::Cache::get_homedir_cache();

    unless ( exists $hd-&gt;{$uid_or_name} ) {
        $_WANT_ENCRYPTED_PASSWORD = 0;
        if ( $uid_or_name !~ tr{0-9}{}c ) {
            $hd-&gt;{$uid_or_name} = ( _getpwuid($uid_or_name) )[7];
        }
        else {
            $hd-&gt;{$uid_or_name} = ( _getpwnam($uid_or_name) )[7];
        }
    }

    return $hd-&gt;{$uid_or_name};
}


sub getusername {

    my $uid = defined $_[0] ? $_[0] : $&gt;;

    $_WANT_ENCRYPTED_PASSWORD = 0;
    return scalar _getpwuid($uid);
}


sub init_passwdless_pwcache {
    require Cpanel::PwCache::Build;
    *init_passwdless_pwcache = \&amp;Cpanel::PwCache::Build::init_passwdless_pwcache;
    goto &amp;Cpanel::PwCache::Build::init_passwdless_pwcache;
}


sub _getpwuid {    ## no critic qw(Subroutines::RequireArgUnpacking)
    return unless ( length( $_[0] ) &amp;&amp; $_[0] !~ tr/0-9//c );

    my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();

    if ( !exists $pwcache_ref-&gt;{&quot;2:$_[0]&quot;} &amp;&amp; $&gt; != 0 &amp;&amp; !Cpanel::PwCache::Helpers::istied() &amp;&amp; Cpanel::NSCD::Check::nscd_is_running() ) {
        return CORE::getpwuid( $_[0] ) if !wantarray;

        my @ret = CORE::getpwuid( $_[0] );

        return @ret ? ( @ret, DUMMY_PW_RETURNS() ) : ();
    }

    if ( my $pwref = _pwfunc( $_[0], 2 ) ) {
        return wantarray ? @$pwref : $pwref-&gt;[0];
    }
    return;    #important not to return 0
}

sub _getpwnam {    ## no critic qw(Subroutines::RequireArgUnpacking)
    return unless ( length( $_[0] ) &amp;&amp; $_[0] !~ tr{\x{00}-\x{20}\x{7f}:/#}{} );

    my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();

    if ( !exists $pwcache_ref-&gt;{&quot;0:$_[0]&quot;} &amp;&amp; $&gt; != 0 &amp;&amp; !Cpanel::PwCache::Helpers::istied() &amp;&amp; Cpanel::NSCD::Check::nscd_is_running() ) {
        return CORE::getpwnam( $_[0] ) if !wantarray;

        my @ret = CORE::getpwnam( $_[0] );

        return @ret ? ( @ret, DUMMY_PW_RETURNS() ) : ();
    }

    if ( my $pwref = _pwfunc( $_[0], 0 ) ) {
        return wantarray ? @$pwref : $pwref-&gt;[2];
    }
    return;    #important not to return 0
}

sub _pwfunc {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my ( $value, $field, $pwkey ) = ( $_[0], ( $_[1] || 0 ), $_[1] . &#039;:&#039; . ( $_[0] || 0 ) );

    if ( Cpanel::PwCache::Helpers::istied() ) {

        Cpanel::Debug::log_debug(&quot;cache tie (tied) value[$value] field[$field]&quot;) if (DEBUG);
        my $pwcachetie = Cpanel::PwCache::Helpers::tiedto();

        if ( ref $pwcachetie eq &#039;HASH&#039; ) {
            my $cache = $pwcachetie-&gt;{$pwkey};
            if ( ref $cache eq &#039;HASH&#039; ) {
                return $pwcachetie-&gt;{$pwkey}-&gt;{&#039;contents&#039;};
            }
        }
        return undef;
    }
    my $SYSTEM_CONF_DIR = Cpanel::PwCache::Helpers::default_conf_dir();

    my $lookup_encrypted_pass = 0;
    if ($_WANT_ENCRYPTED_PASSWORD) {

        $lookup_encrypted_pass = $&gt; == 0 ? 1 : 0;
    }

    my ( $passwdmtime, $hpasswdmtime );

    my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();

    if ( my $cache_entry = $pwcache_ref-&gt;{$pwkey} ) {
        Cpanel::Debug::log_debug(&quot;exists in cache value[$value] field[$field]&quot;) if (DEBUG);
        if (
            ( exists( $cache_entry-&gt;{&#039;contents&#039;} ) &amp;&amp; $cache_entry-&gt;{&#039;contents&#039;}-&gt;[1] ne &#039;x&#039; )    # Has shadow entry
            || !$lookup_encrypted_pass                                                            # Or we do not need it
          ) {                                                                                     # If we are root and missing the password field we could fail authentication
            if ( $FIXED_KEYS{$pwkey} ) {                                                          # We assume root, nobody, and cpanellogin will never change during execution
                Cpanel::Debug::log_debug(&quot;cache (never change) hit value[$value] field[$field]&quot;) if (DEBUG);
                return $cache_entry-&gt;{&#039;contents&#039;};
            }

            $passwdmtime  = ( stat(&quot;$SYSTEM_CONF_DIR/passwd&quot;) )[9];
            $hpasswdmtime = $lookup_encrypted_pass ? ( stat(&quot;$SYSTEM_CONF_DIR/shadow&quot;) )[9] : 0;

            if (   ( $lookup_encrypted_pass &amp;&amp; $hpasswdmtime &amp;&amp; $hpasswdmtime != $cache_entry-&gt;{&#039;hcachetime&#039;} )
                || ( $passwdmtime &amp;&amp; $passwdmtime != $cache_entry-&gt;{&#039;cachetime&#039;} ) ) {    #timewarp safe
                DEBUG &amp;&amp; Cpanel::Debug::log_debug( &quot;cache miss value[$value] field[$field] pwkey[$pwkey] &quot; . qq{hpasswdmtime: $hpasswdmtime != $cache_entry-&gt;{hcachetime} } . qq{passwdmtime: $passwdmtime != $cache_entry-&gt;{cachetime} } );

                if ( defined $cache_entry &amp;&amp; defined $cache_entry-&gt;{&#039;contents&#039;} ) {

                    Cpanel::PwCache::Cache::clear();    #If the passwd file mtime changes everything is invalid
                }
            }
            else {
                Cpanel::Debug::log_debug(&quot;cache hit value[$value] field[$field]&quot;) if (DEBUG);
                return $cache_entry-&gt;{&#039;contents&#039;};
            }
        }
        elsif (DEBUG) {
            Cpanel::Debug::log_debug( &quot;cache miss pwkey[$pwkey] value[$value] field[$field] passwdmtime[$passwdmtime] pwcacheistied[&quot; . Cpanel::PwCache::Helpers::istied() . &quot;] hpasswdmtime[$hpasswdmtime]&quot; );
        }
    }
    elsif (DEBUG) {
        Cpanel::Debug::log_debug( &quot;cache miss (no entry) pwkey[$pwkey] value[$value] field[$field] pwcacheistied[&quot; . Cpanel::PwCache::Helpers::istied() . &quot;]&quot; );
    }
    my $pwdata = _getpwdata( $value, $field, $passwdmtime, $hpasswdmtime, $lookup_encrypted_pass );

    _cache_pwdata( $pwdata, $pwcache_ref ) if $pwdata &amp;&amp; @$pwdata;

    return $pwdata;
}

sub _getpwdata {
    my ( $value, $field, $passwdmtime, $shadowmtime, $lookup_encrypted_pass ) = @_;
    return if ( !defined $value || !defined $field || $value =~ tr/\0// );

    if ($lookup_encrypted_pass) {
        return [ _readshadow( $value, $field, $passwdmtime, $shadowmtime ) ];
    }

    return [ _readpasswd( $value, $field, $passwdmtime, $shadowmtime ) ];
}

sub _readshadow {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my $SYSTEM_CONF_DIR = Cpanel::PwCache::Helpers::default_conf_dir();
    my ( $value, $field, $passwdmtime, $shadowmtime ) = ( $_[0], ( $_[1] || 0 ), ( $_[2] || ( stat(&quot;$SYSTEM_CONF_DIR/passwd&quot;) )[9] ), ( $_[3] || ( stat(&quot;$SYSTEM_CONF_DIR/shadow&quot;) )[9] ) );
    my @PW = _readpasswd( $value, $field, $passwdmtime, $shadowmtime );
    return if !@PW;

    $value = $PW[0];

    if ( open my $shadow_fh, &#039;&lt;&#039;, &quot;$SYSTEM_CONF_DIR/shadow&quot; ) {
        if ( my @SH = Cpanel::PwCache::Find::field_with_value_in_pw_file( $shadow_fh, 0, $value ) ) {

            ( $PW[1], $PW[9], $PW[10], $PW[11], $PW[12] ) = (
                $SH[1],    #encrypted pass
                $SH[5],    #expire time
                $SH[2],    #change time
                $passwdmtime,
                $shadowmtime
            );
            close $shadow_fh;
            Cpanel::PwCache::Cache::is_safe(0);
            return @PW;
        }
    }
    else {
        Cpanel::PwCache::Helpers::cluck(&quot;Unable to open $SYSTEM_CONF_DIR/shadow: $!&quot;);
    }

    Cpanel::PwCache::Helpers::cluck(&quot;Entry for $value missing in $SYSTEM_CONF_DIR/shadow&quot;);
    return @PW;
}

sub _readpasswd {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my $SYSTEM_CONF_DIR = Cpanel::PwCache::Helpers::default_conf_dir();
    my ( $value, $field, $passwdmtime, $shadowmtime, $block ) = ( $_[0], ( $_[1] || 0 ), ( $_[2] || ( stat(&quot;$SYSTEM_CONF_DIR/passwd&quot;) )[9] ), $_[3] );

    if ( $INC{&#039;B/C.pm&#039;} ) {
        die(&quot;Cpanel::PwCache::_readpasswd cannot be run under B::C (see case 162857)&quot;);
    }

    if ( open( my $passwd_fh, &#039;&lt;&#039;, &quot;$SYSTEM_CONF_DIR/passwd&quot; ) ) {
        if ( my @PW = Cpanel::PwCache::Find::field_with_value_in_pw_file( $passwd_fh, $field, $value ) ) {

            return ( $PW[0], $PW[1], $PW[2], $PW[3], &#039;&#039;, &#039;&#039;, $PW[4], $PW[5], $PW[6], -1, -1, $passwdmtime, ( $shadowmtime || $passwdmtime ) );
        }
        close($passwd_fh);
    }
    else {
        Cpanel::PwCache::Helpers::cluck(&quot;open($SYSTEM_CONF_DIR/passwd): $!&quot;);
    }

    return;
}

sub _cache_pwdata {
    my ( $pwdata, $pwcache_ref ) = @_;

    $pwcache_ref ||= Cpanel::PwCache::Cache::get_cache();

    if ( $pwdata-&gt;[2] != 0 || $pwdata-&gt;[0] eq &#039;root&#039; ) {    # special case for multiple uid 0 users
        @{ $pwcache_ref-&gt;{ &#039;2&#039; . &#039;:&#039; . $pwdata-&gt;[2] } }{ &#039;cachetime&#039;, &#039;hcachetime&#039;, &#039;contents&#039; } = ( $pwdata-&gt;[11], $pwdata-&gt;[12], $pwdata );
    }
    @{ $pwcache_ref-&gt;{ &#039;0&#039; . &#039;:&#039; . $pwdata-&gt;[0] } }{ &#039;cachetime&#039;, &#039;hcachetime&#039;, &#039;contents&#039; } = ( $pwdata-&gt;[11], $pwdata-&gt;[12], $pwdata );
    return 1;
}

1;

} # --- END Cpanel/PwCache.pm


{ # --- BEGIN Cpanel/SV.pm
package Cpanel::SV;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub untaint {
    return $_[0] unless ${^TAINT};
    require    # Cpanel::Static OK - we should not untaint variables as part of updatenow.static
      Taint::Util;
    Taint::Util::untaint( $_[0] );
    return $_[0];
}

1;

} # --- END Cpanel/SV.pm


{ # --- BEGIN Cpanel/SafetyBits/Chown.pm
package Cpanel::SafetyBits::Chown;


require 5.004;
use strict;
# use Cpanel::Fcntl   (); # perlpkg line 211
# use Cpanel::Debug   (); # perlpkg line 211
# use Cpanel::PwCache (); # perlpkg line 211
# use Cpanel::SV      (); # perlpkg line 211

our $USER_GID = -2;

sub safe_chown {
    my ( $uid, $gid, @files ) = @_;
    my $count = 0;

    my ( $in_uid, $in_gid ) = ( $uid, $gid );
    $in_uid = &#039;undefined id&#039; unless defined $in_uid;
    $in_gid = &#039;undefined id&#039; unless defined $in_gid;

    if ( $uid !~ m/^(?:\d+|-1)$/a ) {
        if ( defined $gid &amp;&amp; $gid =~ m/^-?\d+$/a &amp;&amp; $gid == $USER_GID ) {
            ( $uid, $gid ) = ( Cpanel::PwCache::getpwnam($uid) )[ 2, 3 ];
        }
        else {
            $uid = ( Cpanel::PwCache::getpwnam($uid) )[2];
        }
    }
    if ( defined $gid &amp;&amp; $gid =~ m/^-?\d+$/a &amp;&amp; $gid == $USER_GID ) {    # can be -1 or -2
        $gid = ( Cpanel::PwCache::getpwuid($uid) )[3];
    }
    elsif ( $gid !~ m/^(?:\d+|-1)$/a ) {
        $gid = ( getgrnam($gid) )[2];
    }

    if ( !defined $uid ) { Cpanel::Debug::log_die(&quot;safe_chown: Error fetching uid &#039;$in_uid&#039;&quot;); }
    if ( !defined $gid ) { Cpanel::Debug::log_die(&quot;safe_chown: Error fetching gid &#039;$in_gid&#039;&quot;); }

    my $sysopen_flags = Cpanel::Fcntl::or_flags(qw( O_RDONLY O_NOFOLLOW O_EXCL ));

    for my $file (@files) {
        Cpanel::SV::untaint($file);

        sysopen( my $fh, $file, $sysopen_flags ) or do {
            Cpanel::Debug::log_warn(&quot;Failed to open “$file” for chown(): $!&quot;);
            next;
        };

        if ( my $hard_links = ishardlink($fh) ) {
            Cpanel::Debug::log_warn(&quot;Refusing to chown() multiply-linked file “$file” ($hard_links)&quot;);
            next;
        }

        chown( $uid, $gid, $fh ) or do {
            Cpanel::Debug::log_warn(&quot;chown($uid, $gid, $file) failed: $!&quot;);
        };

        $count++;
    }

    return $count;
}

sub safe_chown_guess_gid {
    my $uid = shift;

    return safe_chown( $uid, $USER_GID, @_ );
}

sub ishardlink {
    my $file    = shift;
    my $linkage = ( UNIVERSAL::isa( $file, &#039;GLOB&#039; ) ? stat($file) : lstat($file) )[3];
    return unless -e _;
    return if -d _;
    return ( $linkage &gt; 1 ) ? $linkage : 0;
}

1;

} # --- END Cpanel/SafetyBits/Chown.pm


{ # --- BEGIN Cpanel/LoadFile.pm
package Cpanel::LoadFile;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Exception          (); # perlpkg line 211
# use Cpanel::Fcntl::Constants   (); # perlpkg line 211
# use Cpanel::LoadFile::ReadFast (); # perlpkg line 211

sub loadfileasarrayref {
    my $fileref = _load_file( shift, { &#039;array_ref&#039; =&gt; 1 } );
    return ref $fileref eq &#039;ARRAY&#039; ? $fileref : undef;
}

sub loadbinfile {
    my $fileref = _load_file( shift, { &#039;binmode&#039; =&gt; 1 } );
    return ref $fileref eq &#039;SCALAR&#039; ? $$fileref : undef;
}

sub slurpfile {
    my $fh      = shift;
    my $fileref = _load_file(shift);
    if ( ref $fileref eq &#039;SCALAR&#039; ) {
        print {$fh} $$fileref;
    }
    return;
}

sub loadfile {
    my $fileref = _load_file(@_);
    return ref $fileref eq &#039;SCALAR&#039; ? $$fileref : undef;
}

sub loadfile_r {
    my ( $file, $arg_ref ) = @_;

    if ( open my $lf_fh, &#039;&lt;:stdio&#039;, $file ) {
        if ( $arg_ref-&gt;{&#039;binmode&#039;} ) { binmode $lf_fh; }

        my $data;
        if ( $arg_ref-&gt;{&#039;array_ref&#039;} ) {
            @{$data} = readline $lf_fh;
            close $lf_fh;
            return $data;
        }
        else {
            $data = &#039;&#039;;
            local $@;

            eval { Cpanel::LoadFile::ReadFast::read_all_fast( $lf_fh, $data ); };
            return $@ ? undef : \$data;
        }
    }

    return;
}

*_load_file = *loadfile_r;

sub _open {
    return _open_if_exists( $_[0] ) || die Cpanel::Exception::create( &#039;IO::FileNotFound&#039;, [ path =&gt; $_[0], error =&gt; _ENOENT() ] );
}

sub _open_if_exists {
    local $!;
    open my $fh, &#039;&lt;:stdio&#039;, $_[0] or do {

        if ( $! == _ENOENT() || $! == _ENOTDIR() ) {
            return undef;
        }
        die Cpanel::Exception::create( &#039;IO::FileOpenError&#039;, [ path =&gt; $_[0], error =&gt; $!, mode =&gt; &#039;&lt;&#039; ] );
    };

    return $fh;
}

sub _open_nofollow_if_exists {
    local $!;
    sysopen( my $fh, $_[0], $Cpanel::Fcntl::Constants::O_RDONLY | $Cpanel::Fcntl::Constants::O_NOFOLLOW ) or do {
        if ( $! == _ENOENT() || $! == _ENOTDIR() || $! == _ELOOP() ) {
            return undef;
        }
        die Cpanel::Exception::create( &#039;IO::FileOpenError&#039;, [ path =&gt; $_[0], error =&gt; $!, mode =&gt; &#039;&lt;&#039; ] );
    };

    return $fh;
}

sub load_if_exists {
    my $ref = _load_r( \&amp;_open_if_exists, @_ );
    return $ref ? $$ref : undef;
}

sub load_nofollow_if_exists {
    my $ref = _load_r( \&amp;_open_nofollow_if_exists, @_ );
    return $ref ? $$ref : undef;
}

sub load_r_if_exists {
    return _load_r( \&amp;_open_if_exists, @_ );
}

sub load {
    return ${ _load_r( \&amp;_open, @_ ) };
}

sub load_r {
    return _load_r( \&amp;_open, @_ );
}

sub _load_r {
    my ( $open_coderef, $path, $offset, $length ) = @_;

    my $fh = $open_coderef-&gt;($path) or return undef;

    local $!;

    if ($offset) {
        sysseek( $fh, $offset, $Cpanel::Fcntl::Constants::SEEK_SET );

        if ($!) {
            die Cpanel::Exception::create(
                &#039;IO::FileSeekError&#039;,
                [
                    path     =&gt; $path,
                    position =&gt; $offset,
                    whence   =&gt; $Cpanel::Fcntl::Constants::SEEK_SET,
                    error    =&gt; $!,
                ]
            );
        }
    }

    my $data = q&lt;&gt;;

    if ( !defined $length ) {

        my $bytes_read = Cpanel::LoadFile::ReadFast::read_fast( $fh, $data, Cpanel::LoadFile::ReadFast::READ_CHUNK );

        if ( $bytes_read == Cpanel::LoadFile::ReadFast::READ_CHUNK ) {
            my $file_size = -f $fh &amp;&amp; -s _;

            if ($file_size) {

                Cpanel::LoadFile::ReadFast::read_fast( $fh, $data, $file_size, length $data ) // die _read_err($path);
            }
        }

        Cpanel::LoadFile::ReadFast::read_all_fast( $fh, $data );
    }
    else {
        my $togo = $length;
        my $bytes_read;
        while ( $bytes_read = Cpanel::LoadFile::ReadFast::read_fast( $fh, $data, $togo, length $data ) &amp;&amp; length $data &lt; $length ) {
            $togo -= $bytes_read;
        }
    }

    if ($!) {
        die Cpanel::Exception::create( &#039;IO::FileReadError&#039;, [ path =&gt; $path, error =&gt; $! ] );
    }

    close $fh or warn &quot;The system failed to close the file “$path” because of an error: $!&quot;;

    return \$data;
}

sub _ENOENT  { return 2; }
sub _ENOTDIR { return 20; }
sub _ELOOP   { return 40; }
1;

} # --- END Cpanel/LoadFile.pm


{ # --- BEGIN Cpanel/Slurper.pm
package Cpanel::Slurper;


use cPstrict;
no warnings &#039;once&#039;;

# use Cpanel::Exception        (); # perlpkg line 211
# use Cpanel::LoadFile         (); # perlpkg line 211
# use Cpanel::FileUtils::Write (); # perlpkg line 211


sub read ($file) {
    return scalar Cpanel::LoadFile::load($file);
}


sub read_lines ($file) {
    return split( qr{\n}, __PACKAGE__-&gt;can(&#039;read&#039;)-&gt;($file) );
}


sub read_dir ($path) {
    my $dh;
    opendir( $dh, $path )    #
      or die Cpanel::Exception::create( &quot;IO::DirectoryOpenError&quot;, [ path =&gt; $path, error =&gt; $! ] );
    return ( grep { defined $_ &amp;&amp; $_ ne &#039;.&#039; &amp;&amp; $_ ne &#039;..&#039; } readdir($dh) );
}


sub write ( $file, $content, $perms_or_callback = undef ) {
    return !!Cpanel::FileUtils::Write::overwrite( $file, $content, $perms_or_callback );
}


1;

} # --- END Cpanel/Slurper.pm


{ # --- BEGIN Cpanel/ApacheServerStatus.pm
package Cpanel::ApacheServerStatus;


use cPstrict;
no warnings &#039;once&#039;;

# use Cpanel::Hulk::Constants   (); # perlpkg line 211
# use Cpanel::SafetyBits::Chown (); # perlpkg line 211
# use Cpanel::Slurper           (); # perlpkg line 211


our $WHM_SERVER_STATUS_KEY_FILE = &#039;/var/cpanel/whm_server_status_key&#039;;

sub new {
    my ($class) = @_;

    my $obj = {};

    bless $obj, $class;

    my $html = $obj-&gt;fetch_server_status_html();

    $html =~ m/&lt;table[^\&gt;]*&gt;(.*?)&lt;\/table[^\&gt;]*&gt;/is;

    my $inner_table = $1;
    $inner_table =~ s/[\r\n\0]//g;
    my $line_count = 0;

    my ( @index, @data, %server_status );

    while ( $inner_table =~ m/&lt;tr[^\&gt;]*&gt;(.*?)&lt;\/tr[^\&gt;]*&gt;/isg ) {
        my $contents = $1;
        @data = map { s/^\s+//; s/\s+$//; lc $_; } ( $contents =~ m/(?:&lt;[^\&gt;]+&gt;)+([^\&lt;]+)/isg );
        if ( $line_count == 0 ) {
            @index = @data;
        }
        else {
            my $count      = 0;
            my %named_data = map { $index[ $count++ ] =&gt; $_; } @data;
            $server_status{ $named_data{&#039;pid&#039;} } = \%named_data;

        }
        $line_count++;
    }

    $obj-&gt;{&#039;server_status&#039;} = \%server_status;

    return $obj;
}

sub get_status_by_pid {
    my ( $self, $pid ) = @_;

    return $self-&gt;{&#039;server_status&#039;}-&gt;{$pid};

}

sub get_apache_port {
    if ( open( my $ap_port_fh, &#039;&lt;&#039;, &#039;/var/cpanel/config/apache/port&#039; ) ) {
        my $port_txt = readline($ap_port_fh);
        chomp($port_txt);
        if ( $port_txt =~ m/:/ ) {
            return ( split( m/:/, $port_txt ) )[1];
        }
        elsif ( $port_txt =~ /^[0-9]+$/ ) {
            return $port_txt;
        }
    }
}

sub fetch_server_status_html {
    my ($self) = @_;

    my $port = 80;
    my $html;

    eval {
        my $socket_scc;
        if ( !socket( $socket_scc, $Cpanel::Hulk::Constants::AF_INET, $Cpanel::Hulk::Constants::SOCK_STREAM, $Cpanel::Hulk::Constants::PROTO_TCP ) || !$socket_scc ) {
            die &quot;Could not setup tcp socket for connection to $port: $!&quot;;
        }
        if ( !connect( $socket_scc, pack( &#039;S n a4 x8&#039;, $Cpanel::Hulk::Constants::AF_INET, $port, ( pack &#039;C4&#039;, ( split /\./, &quot;127.0.0.1&quot; ) ) ) ) ) {
            my $non_default_port = $self-&gt;get_apache_port();
            if ( $non_default_port &amp;&amp; $non_default_port != $port ) {
                if ( !connect( $socket_scc, pack( &#039;S n a4 x8&#039;, $Cpanel::Hulk::Constants::AF_INET, $non_default_port, ( pack &#039;C4&#039;, ( split /\./, &quot;127.0.0.1&quot; ) ) ) ) ) {
                    die &quot;Unable to connect to port $non_default_port on 127.0.0.1: $!&quot;;

                }
            }
        }

        my $key = get_whm_server_status_key();

        syswrite( $socket_scc, &quot;GET /$key HTTP/1.0\r\nHost: localhost\r\nConnection: close\r\n\r\n&quot; );

        local $/;

        $html = readline($socket_scc);

        close($socket_scc);
    };

    $html;
}

sub get_whm_server_status_key {
    die &#039;No Apache whm-server-status key file found.&#039; unless -e $WHM_SERVER_STATUS_KEY_FILE;
    my $key = Cpanel::Slurper::read($WHM_SERVER_STATUS_KEY_FILE);
    $key =~ s/\s+//g;
    return $key;
}

sub apply_key_file_permissions {
    return undef unless -e $WHM_SERVER_STATUS_KEY_FILE;

    my $munin_gid = ( getgrnam(&#039;munin&#039;) )[2];
    my $mode      = defined $munin_gid ? 0640 : 0600;

    chmod $mode, $WHM_SERVER_STATUS_KEY_FILE;

    if ( defined $munin_gid ) {
        Cpanel::SafetyBits::Chown::safe_chown( &#039;root&#039;, &#039;munin&#039;, $WHM_SERVER_STATUS_KEY_FILE );
    }

    return $mode;
}

1;

} # --- END Cpanel/ApacheServerStatus.pm


{ # --- BEGIN Cpanel/Sys/Uname.pm
package Cpanel::Sys::Uname;


use strict;

our $SYS_UNAME       = 63;
our $UNAME_ELEMENTS  = 6;
our $_UTSNAME_LENGTH = 65;
my $UNAME_PACK_TEMPLATE   = ( &#039;c&#039; . $_UTSNAME_LENGTH ) x $UNAME_ELEMENTS;
my $UNAME_UNPACK_TEMPLATE = ( &#039;Z&#039; . $_UTSNAME_LENGTH ) x $UNAME_ELEMENTS;

my @uname_cache;

sub get_uname_cached {
    return ( @uname_cache ? @uname_cache : ( @uname_cache = syscall_uname() ) );
}

sub clearcache {
    @uname_cache = ();
    return;
}

sub syscall_uname {
    my $uname;
    if ( syscall( $SYS_UNAME, $uname = pack( $UNAME_PACK_TEMPLATE, () ) ) == 0 ) {
        return unpack( $UNAME_UNPACK_TEMPLATE, $uname );
    }
    else {
        die &quot;The uname() system call failed because of an error: $!&quot;;
    }
    return;
}
1;

} # --- END Cpanel/Sys/Uname.pm


{ # --- BEGIN Cpanel/Sys/Hostname/Fallback.pm
package Cpanel::Sys::Hostname::Fallback;


use strict;
use warnings;
no warnings &#039;once&#039;;

use Socket             ();
# use Cpanel::Sys::Uname (); # perlpkg line 211


sub get_canonical_hostname {
    my @uname = Cpanel::Sys::Uname::get_uname_cached();
    my ( $err, @results ) = Socket::getaddrinfo( $uname[1], 0, { flags =&gt; Socket::AI_CANONNAME() } );
    if ( @results &amp;&amp; $results[0]-&gt;{&#039;canonname&#039;} ) {
        return $results[0]-&gt;{&#039;canonname&#039;};
    }

    return undef;

}

1;

} # --- END Cpanel/Sys/Hostname/Fallback.pm


{ # --- BEGIN Cpanel/Sys/Hostname.pm
package Cpanel::Sys::Hostname;


use strict;
use warnings;
no warnings &#039;once&#039;;

our $VERSION = 2.0;

# use Cpanel::Sys::Uname (); # perlpkg line 211

our $cachedhostname = &#039;&#039;;


sub gethostname {
    my $nocache = shift || 0;
    if ( !$nocache &amp;&amp; length $cachedhostname ) { return $cachedhostname }

    my $hostname = _gethostname($nocache);

    if ( length $hostname ) {
        $hostname =~ tr{A-Z}{a-z};    # hostnames must be lowercase (see Cpanel::Sys::Hostname::Modify::make_hostname_lowercase_fqdn)
        $cachedhostname = $hostname;
    }
    return $hostname;
}

sub _gethostname {
    my $nocache = shift || 0;

    my $hostname;
    Cpanel::Sys::Uname::clearcache() if $nocache;
    my @uname = Cpanel::Sys::Uname::get_uname_cached();
    if ( $uname[1] &amp;&amp; index( $uname[1], &#039;.&#039; ) &gt; -1 ) {
        $hostname = $uname[1];
        $hostname =~ tr{A-Z}{a-z};    # hostnames must be lowercase (see Cpanel::Sys::Hostname::Modify::make_hostname_lowercase_fqdn)
        return $hostname;
    }

    eval {
        require Cpanel::Sys::Hostname::Fallback;
        $hostname = Cpanel::Sys::Hostname::Fallback::get_canonical_hostname();
    };
    if ($hostname) {
        $hostname =~ tr{A-Z}{a-z};    # hostnames must be lowercase (see Cpanel::Sys::Hostname::Modify::make_hostname_lowercase_fqdn)
        return $hostname;
    }

    require Cpanel::LoadFile;
    chomp( $hostname = Cpanel::LoadFile::loadfile( &#039;/proc/sys/kernel/hostname&#039;, { &#039;skip_exists_check&#039; =&gt; 1 } ) );
    if ($hostname) {
        $hostname =~ tr{A-Z}{a-z};    # hostnames must be lowercase (see Cpanel::Sys::Hostname::Modify::make_hostname_lowercase_fqdn)
        $hostname =~ tr{\r\n}{}d;     # chomp is not enough (not sure if this is required, however we cannot test all kernels so its safer to leave it in)
        return $hostname;
    }

    require Cpanel::Debug;
    Cpanel::Debug::log_warn(&#039;Unable to determine correct hostname&#039;);
    return;
}


sub shorthostname {
    my $hostname = gethostname();
    return $hostname if index( $hostname, &#039;.&#039; ) == -1;    # Hostname is not a FQDN (this should never happen)
    return substr( $hostname, 0, index( $hostname, &#039;.&#039; ) );
}

1;

} # --- END Cpanel/Sys/Hostname.pm


{ # --- BEGIN Cpanel/Hostname.pm
package Cpanel::Hostname;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Sys::Hostname (); # perlpkg line 211

our $VERSION = 2.0;

{
    no warnings &#039;once&#039;;
    *gethostname   = *Cpanel::Sys::Hostname::gethostname;
    *shorthostname = *Cpanel::Sys::Hostname::shorthostname;
}

1;

} # --- END Cpanel/Hostname.pm


{ # --- BEGIN Cpanel/ProductConfig.pm

package Cpanel::ProductConfig;


use cPstrict;
no warnings &#039;once&#039;;

use constant {
    auto_domain_for_host_constant                    =&gt; &#039;AUTO_DOMAIN_FOR_HOST_ON_CPANEL&#039;,
    auto_domain_for_website_constant                 =&gt; &#039;AUTO_DOMAIN_FOR_WEBSITE_ON_CPANEL&#039;,
    autoregister_wordpress_instances_on_restore      =&gt; 0,
    default_login_theme                              =&gt; &#039;cpanel&#039;,
    default_user_theme                               =&gt; &#039;jupiter&#039;,
    dns_allow_reserved_domains                       =&gt; [],
    enable_showcase_only_for_products                =&gt; [],
    excluded_transfer_modules                        =&gt; [],
    has_temporary_domains                            =&gt; 1,
    ineligible_transfer_features_from_source_product =&gt; {},
    product_custom_domains                           =&gt; [
        &#039;cpanel&#039;,
    ],
    transfer_check_package_version      =&gt; 0,
    warn_about_missing_theme_on_restore =&gt; 1,
    web_subdomains_for_zone             =&gt; [
        &#039;mail&#039;,
    ],
    websocket_proxy_labels =&gt; [
        &#039;cpanel&#039;,
        &#039;webmail&#039;,
        &#039;whm&#039;,
    ],
    www_docroot_mode =&gt; &#039;legacy&#039;,
};

1;

} # --- END Cpanel/ProductConfig.pm


{ # --- BEGIN Cpanel/NAT/Object.pm
package Cpanel::NAT::Object;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Debug            (); # perlpkg line 211
# use Cpanel::Validate::IP::v4 (); # perlpkg line 211

our $NAT_FILE = &#039;/var/cpanel/cpnat&#039;;

sub new {
    my ( $class, $file ) = @_;

    my $self = {
        &#039;cpnat_file&#039;    =&gt; $file || $NAT_FILE,
        &#039;cpnat_data&#039;    =&gt; {},
        &#039;file_read&#039;     =&gt; 0,
        &#039;only_local_ip&#039; =&gt; [],
        &#039;dups&#039;          =&gt; {},
    };

    bless $self, $class;
    $self-&gt;load_file();

    return $self;
}

sub load_file {
    my ($self) = @_;

    $self-&gt;{&#039;file_read&#039;}  = 0;
    $self-&gt;{&#039;cpnat_data&#039;} = {};

    if ( !-e $self-&gt;{&#039;cpnat_file&#039;} || !-r _ || -z _ ) {
        return;
    }

    my $nat_data;
    {
        local $/;
        open my $fh, &#039;&lt;&#039;, $self-&gt;{&#039;cpnat_file&#039;} or die &quot;Failed to open “$self-&gt;{&#039;cpnat_file&#039;}”: $!&quot;;

        $nat_data = &lt;$fh&gt;;
        close $fh;
    }

    $self-&gt;{&#039;nat_data&#039;}   = $nat_data;
    $self-&gt;{&#039;cpnat_data&#039;} = $self-&gt;_parse_nat_file($nat_data);
    $self-&gt;{&#039;file_read&#039;}  = 1;
    return 1 if %{ $self-&gt;{&#039;cpnat_data&#039;} };

    return;
}

sub enabled {
    my ($self) = @_;
    return $self-&gt;{&#039;file_read&#039;} ? 1 : 0;
}

sub ordered_list {
    my ($self) = @_;
    return ( $self-&gt;{&#039;cpnat_ordered&#039;} ||= $self-&gt;_create_ordered_list( $self-&gt;{&#039;nat_data&#039;} ) );
}

sub get_public_ip {
    return $_[1] if !$_[1] || !$_[0]-&gt;{&#039;file_read&#039;} || !$_[0]-&gt;{&#039;cpnat_data&#039;}-&gt;{ $_[1] };
    return $_[0]-&gt;_get_public_ip( $_[1] );
}

sub get_all_public_ips {
    my ($self) = @_;
    return [ sort values %{ $self-&gt;{cpnat_data} } ];
}

sub get_public_ip_raw {
    my ( $self, $local_ip ) = @_;

    return &#039;FILE NOT READ&#039;    if !$self-&gt;{&#039;file_read&#039;};
    return &#039;INVALID LOCAL IP&#039; if !$self-&gt;{&#039;cpnat_data&#039;}-&gt;{$local_ip} &amp;&amp; !$self-&gt;_find_ip($local_ip) &amp;&amp; !exists $self-&gt;{&#039;dups&#039;}-&gt;{$local_ip};

    return $self-&gt;_get_public_ip($local_ip) || $self-&gt;{&#039;dups&#039;}-&gt;{$local_ip} || &#039;&#039;;
}

sub _find_ip {
    my ( $self, $ip ) = @_;

    my $found = grep { $_ eq $ip } @{ $self-&gt;{&#039;only_local_ip&#039;} };
    return $ip if $found;
    return;
}

sub _get_public_ip {
    my ( $self, $local_ip ) = @_;
    my $public_ip = $self-&gt;{&#039;cpnat_data&#039;}-&gt;{$local_ip};
    return $public_ip;
}

sub get_local_ip {
    my ( $self, $public_ip ) = @_;

    return $public_ip unless $public_ip;
    return $public_ip if !$self-&gt;{&#039;file_read&#039;};

    $self-&gt;{&#039;_public_to_local&#039;} ||= { reverse %{ $self-&gt;{&#039;cpnat_data&#039;} } };

    return $self-&gt;{&#039;_public_to_local&#039;}{$public_ip} || $public_ip;
}

sub _parse_nat_file {
    my ( $self, $nat_data ) = @_;

    return if !$nat_data;

    my $cpnat_hash    = {};
    my @file          = split /\n/, $nat_data;
    my $only_local_ip = $self-&gt;{&#039;only_local_ip&#039;};
    foreach my $line (@file) {
        my ( $local, $public ) = split /\s+/, $line;
        if ( !$public ) {
            push @$only_local_ip, $local;
            next;
        }
        if (   !Cpanel::Validate::IP::v4::is_valid_ipv4($local)
            &amp;&amp; !Cpanel::Validate::IP::v4::is_valid_ipv4($public) ) {

            Cpanel::Debug::log_warn( &#039;Invalid line in cpnat file: &#039; . $line );
            next;
        }
        if ( !grep { $public &amp;&amp; $public eq $_ } values %{$cpnat_hash} ) {
            $cpnat_hash-&gt;{$local} = $public;
        }
        else {
            $self-&gt;{&#039;dups&#039;}-&gt;{$local} = $public;
        }
    }

    return $cpnat_hash;
}

sub _create_ordered_list {
    my ( $self, $nat_data ) = @_;

    return if !$nat_data;

    my $cpnat_array = [];
    my $group_hash  = {};
    my $order       = [];
    my @file        = split /\n/, $nat_data;
    foreach my $line (@file) {
        my ( $local, $public ) = split /\s+/, $line;
        my $key = $public || $local;

        $public ||= &#039;&#039;;

        push @$order,                  $key if !$group_hash-&gt;{$key};
        push @{ $group_hash-&gt;{$key} }, [ $local, $public ];
    }

    foreach my $key (@$order) {
        if ( scalar @{ $group_hash-&gt;{$key} } == 1 ) {
            push @$cpnat_array, pop @{ $group_hash-&gt;{$key} };
        }
        else {
            push @$cpnat_array, $group_hash-&gt;{$key};
        }
    }

    return $cpnat_array;
}

1;

} # --- END Cpanel/NAT/Object.pm


{ # --- BEGIN Cpanel/NAT.pm
package Cpanel::NAT;


use strict;

# use Cpanel::NAT::Object (); # perlpkg line 211

my $nat;

sub set_cpnat {
    $nat = shift;
    return;
}

sub cpnat {
    return $nat ||= Cpanel::NAT::Object-&gt;new();
}

sub reload {
    return cpnat()-&gt;load_file();
}

sub get_public_ip {
    return ( $nat ||= cpnat() )-&gt;get_public_ip( $_[0] );
}

sub get_local_ip {
    return ( $nat ||= cpnat() )-&gt;get_local_ip( $_[0] );
}

sub get_public_ip_raw {
    return ( $nat ||= cpnat() )-&gt;get_public_ip_raw( $_[0] );
}

sub ordered_list {
    return cpnat()-&gt;ordered_list();
}

sub get_all_public_ips {
    return cpnat()-&gt;get_all_public_ips();
}

sub is_nat {
    return cpnat()-&gt;enabled();
}

1;

} # --- END Cpanel/NAT.pm


{ # --- BEGIN Cpanel/Struct/Common/Time.pm
package Cpanel::Struct::Common::Time;


use strict;
use warnings;
no warnings &#039;once&#039;;


use constant PACK_TEMPLATE =&gt; &#039;L!L!&#039;;

my %CLASS_PRECISION;


sub float_to_binary {
    return pack(
        PACK_TEMPLATE(),

        int( $_[1] ),

        int( 0.5 + ( $_[0]-&gt;_PRECISION() * $_[1] ) - ( $_[0]-&gt;_PRECISION() * int( $_[1] ) ) ),
    );
}


sub binary_to_float {
    return $_[0]-&gt;_binary_to_float( PACK_TEMPLATE(), $_[1] )-&gt;[0];
}


sub binaries_to_floats_at {
    return $_[0]-&gt;_binary_to_float(
        &quot;\@$_[3] &quot; . ( PACK_TEMPLATE() x $_[2] ),
        $_[1],
    );
}


my ( $i, $precision, @sec_psec_pairs );

sub _binary_to_float {    ## no critic qw(RequireArgUnpacking)
    @sec_psec_pairs = unpack( $_[1], $_[2] );

    $i = 0;

    my @floats;

    $precision = $CLASS_PRECISION{ $_[0] } ||= $_[0]-&gt;_PRECISION();

    while ( $i &lt; @sec_psec_pairs ) {


        push @floats, 0 + ( q&lt;&gt; . ( $sec_psec_pairs[$i] + ( $sec_psec_pairs[ $i + 1 ] / $precision ) ) );
        $i += 2;
    }

    return \@floats;
}

1;

} # --- END Cpanel/Struct/Common/Time.pm


{ # --- BEGIN Cpanel/Struct/timespec.pm
package Cpanel::Struct::timespec;


use strict;
use warnings;
no warnings &#039;once&#039;;


# use parent Cpanel::Struct::Common::Time (); # perlpkg line 238
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Struct::Common::Time); }

use constant {
    _PRECISION =&gt; 1_000_000_000,    # nanoseconds
};

1;

} # --- END Cpanel/Struct/timespec.pm


{ # --- BEGIN Cpanel/NanoStat.pm
package Cpanel::NanoStat;


use strict;
use warnings;
no warnings &#039;once&#039;;


# use Cpanel::Struct::timespec (); # perlpkg line 211

use constant {
    _NR_stat  =&gt; 4,
    _NR_fstat =&gt; 5,
    _NR_lstat =&gt; 6,
};

use constant _PACK_TEMPLATE =&gt; q&lt;
    Q       # st_dev
    Q       # st_ino

    @24 L   # st_mode
    @16 Q   # st_nlink

    @28
    L       # st_uid
    L       # st_gid

    x![Q]
    Q       # st_rdev
    Q       # st_size
    Q       # st_blksize
    Q       # st_blocks
&gt;;

my $pre_times_pack_len = length pack _PACK_TEMPLATE();

my $buf = ( &quot;\0&quot; x 144 );


sub stat {
    return _syscall( _NR_stat(), $_[0] );
}


sub lstat {
    return _syscall( _NR_lstat(), $_[0] );
}


sub fstat {
    return _syscall( _NR_fstat(), 0 + ( ref( $_[0] ) ? fileno( $_[0] ) : $_[0] ) );
}


sub _syscall {    ## no critic qw(RequireArgUnpacking)
    my $arg_dupe = $_[1];
    return undef if -1 == syscall( $_[0], $arg_dupe, $buf );
    my @vals = unpack _PACK_TEMPLATE(), $buf;
    splice(
        @vals, 8, 0,
        @{ Cpanel::Struct::timespec-&gt;binaries_to_floats_at( $buf, 3, $pre_times_pack_len ) },
    );

    return @vals;
}

1;

} # --- END Cpanel/NanoStat.pm


{ # --- BEGIN Cpanel/NanoUtime.pm
package Cpanel::NanoUtime;


use strict;
use warnings;
no warnings &#039;once&#039;;


# use Cpanel::Struct::timespec (); # perlpkg line 211

use constant {
    _NR_utimensat =&gt; 280,

    _AT_FDCWD            =&gt; -100,
    _AT_SYMLINK_NOFOLLOW =&gt; 0x100,
};


sub utime {
    return _syscall( 0 + _AT_FDCWD(), $_[2], @_[ 0, 1 ], 0 );
}


sub futime {
    return _syscall(
        0 + ( ref( $_[2] ) ? fileno( $_[2] ) : $_[2] ),
        undef,
        @_[ 0, 1 ],
        0,
    );
}


sub lutime {
    return _syscall( 0 + _AT_FDCWD(), $_[2], @_[ 0, 1 ], 0 + _AT_SYMLINK_NOFOLLOW() );
}

my ( $path, $buf ) = @_;

sub _syscall {

    if ( defined $_[-3] ) {
        if ( defined $_[-2] ) {
            $buf = Cpanel::Struct::timespec-&gt;float_to_binary( $_[-3] ) . Cpanel::Struct::timespec-&gt;float_to_binary( $_[-2] );
        }
        else {
            die &quot;atime is “$_[-3]”, but mtime is undef!&quot;;
        }
    }
    elsif ( defined $_[-2] ) {
        die &quot;atime is undef, but mtime is “$_[-2]”!&quot;;
    }
    else {
        $buf = undef;
    }

    $path = $_[1];

    return undef if -1 == syscall( 0 + _NR_utimensat(), $_[0], $path // undef, $buf // undef, $_[-1] );

    return 1;
}

1;

} # --- END Cpanel/NanoUtime.pm


{ # --- BEGIN Cpanel/HiRes.pm
package Cpanel::HiRes;


use strict;
use warnings;
no warnings &#039;once&#039;;


my %_routes = (


    &#039;fstat&#039; =&gt; [ &#039;NanoStat&#039;, &#039;fstat&#039;, &#039;stat&#039;,  1 ],
    &#039;lstat&#039; =&gt; [ &#039;NanoStat&#039;, &#039;lstat&#039;, &#039;lstat&#039;, 1 ],
    &#039;stat&#039;  =&gt; [ &#039;NanoStat&#039;, &#039;stat&#039;,  &#039;stat&#039;,  1 ],

    &#039;time&#039; =&gt; [ &#039;TimeHiRes&#039;, &#039;time&#039;, &#039;time&#039; ],

    &#039;utime&#039;  =&gt; [ &#039;NanoUtime&#039;, &#039;utime&#039;,  &#039;utime&#039; ],
    &#039;futime&#039; =&gt; [ &#039;NanoUtime&#039;, &#039;futime&#039;, &#039;utime&#039; ],

    &#039;lutime&#039; =&gt; [ &#039;NanoUtime&#039;, &#039;lutime&#039;, undef ],
);

my $preloaded;


sub import {
    my ( $class, %opts ) = @_;

    if ( my $preload = $opts{&#039;preload&#039;} ) {
        if ( $preload eq &#039;xs&#039; ) {
            require Time::HiRes;
        }
        elsif ( $preload eq &#039;perl&#039; ) {
            if ( !$preloaded ) {
                require Cpanel::TimeHiRes;    # PPI USE OK - preload
                require Cpanel::NanoStat;     # PPI USE OK - preload
                require Cpanel::NanoUtime;    # PPI USE OK - preload
            }
        }
        else {
            die &quot;Unknown “preload”: “$preload”&quot;;
        }

        $preloaded = $preload;
    }

    return;
}

our $AUTOLOAD;


sub AUTOLOAD {    ## no critic qw(Subroutines::RequireArgUnpacking)
    substr( $AUTOLOAD, 0, 1 + rindex( $AUTOLOAD, &#039;:&#039; ) ) = q&lt;&gt;;

    if ( !$AUTOLOAD || !$_routes{$AUTOLOAD} ) {
        die &quot;Unknown function in Cpanel::HiRes::$_[0]&quot;;
    }

    my $function = $AUTOLOAD;

    undef $AUTOLOAD;

    my ( $pp_module, $pp_function, $xs_function, $xs_needs_closure ) = @{ $_routes{$function} };

    no strict &#039;refs&#039;;

    if ( $INC{&#039;Time/HiRes.pm&#039;} &amp;&amp; $xs_function ) {
        *$function = *{&quot;Time::HiRes::$xs_function&quot;};
        return Time::HiRes-&gt;can($xs_function)-&gt;(@_);
    }
    else {

        _require(&quot;Cpanel/${pp_module}.pm&quot;) if !$INC{&quot;Cpanel/${pp_module}.pm&quot;};

        my $pp_cr = &quot;Cpanel::${pp_module}&quot;-&gt;can($pp_function);

        if ($xs_function) {
            *$function = sub {

                if ( $INC{&#039;Time/HiRes.pm&#039;} ) {
                    *$function = *{&quot;Time::HiRes::$xs_function&quot;};
                    return Time::HiRes-&gt;can($xs_function)-&gt;(@_);
                }

                goto &amp;$pp_cr;
            };
        }
        else {
            *$function = $pp_cr;
        }
    }

    goto &amp;$function;
}

sub _require {
    local ( $!, $^E, $@ );

    require $_[0];
    return;
}

1;

} # --- END Cpanel/HiRes.pm


{ # --- BEGIN Cpanel/Path/Normalize.pm
package Cpanel::Path::Normalize;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub normalize {
    my $uncleanpath = shift || return;

    my $is_abspath = ( 0 == index( $uncleanpath, &#039;/&#039; ) );

    my @pathdirs = split( m[/], $uncleanpath );

    my @cleanpathdirs;
    my $leading_dot_dots = 0;

    foreach my $dir (@pathdirs) {
        next if !length $dir;    #Remove extraneous &quot;//&quot; and leading &quot;/&quot;

        next if $dir eq &#039;.&#039;;

        if ( $dir eq &#039;..&#039; ) {
            if (@cleanpathdirs) {
                pop(@cleanpathdirs);
            }
            else {
                $leading_dot_dots++;
            }
        }
        else {
            push( @cleanpathdirs, $dir );
        }
    }

    if ($is_abspath) {
        return ( &#039;/&#039; . join( &#039;/&#039;, @cleanpathdirs ) );
    }

    unshift @cleanpathdirs, (&#039;..&#039;) x $leading_dot_dots;

    return join( &#039;/&#039;, @cleanpathdirs );
}


1;

} # --- END Cpanel/Path/Normalize.pm


{ # --- BEGIN Cpanel/Hash/Stringify.pm
package Cpanel::Hash::Stringify;


use strict;
use warnings;
no warnings &#039;once&#039;;


sub sorted_hashref_string {
    my ($hashref) = @_;
    return (
        ( scalar keys %$hashref )
        ? join(
            &#039;_____&#039;, map { $_, ( ref $hashref-&gt;{$_} eq &#039;HASH&#039; ? sorted_hashref_string( $hashref-&gt;{$_} ) : ref $hashref-&gt;{$_} eq &#039;ARRAY&#039; ? join( &#039;_____&#039;, @{ $hashref-&gt;{$_} } ) : defined $hashref-&gt;{$_} ? $hashref-&gt;{$_} : &#039;&#039; ) }
              sort keys %$hashref
          )
        : &#039;&#039;
    );    #sort is important for order;
}

1;

} # --- END Cpanel/Hash/Stringify.pm


{ # --- BEGIN Cpanel/AdminBin/Serializer.pm
package Cpanel::AdminBin::Serializer;


use strict;
use warnings;
no warnings &#039;once&#039;;


# use Cpanel::JSON (); # perlpkg line 211


our $VERSION = &#039;2.4&#039;;

our $MAX_LOAD_LENGTH;
our $MAX_PRIV_LOAD_LENGTH;

BEGIN {
    *MAX_LOAD_LENGTH      = \$Cpanel::JSON::MAX_LOAD_LENGTH;
    *MAX_PRIV_LOAD_LENGTH = \$Cpanel::JSON::MAX_PRIV_LOAD_LENGTH;
    *DumpFile             = *Cpanel::JSON::DumpFile;
}


BEGIN {
    *Dump = *Cpanel::JSON::Dump;

    *SafeDump = *Cpanel::JSON::SafeDump;

    *LoadFile = *Cpanel::JSON::LoadFileNoSetUTF8;

    *Load = *Cpanel::JSON::Load;

    *looks_like_serialized_data = *Cpanel::JSON::looks_like_json;
}


sub SafeLoadFile {
    return Cpanel::JSON::_LoadFile( $_[0], $Cpanel::JSON::MAX_LOAD_LENGTH, $Cpanel::JSON::DECODE_UTF8, $_[1], $Cpanel::JSON::LOAD_STRICT );
}


sub SafeLoad {
    utf8::decode( $_[0] );
    return Cpanel::JSON::LoadNoSetUTF8(@_);
}


sub clone {
    return Cpanel::JSON::LoadNoSetUTF8( Cpanel::JSON::Dump( $_[0] ) );
}

1;

} # --- END Cpanel/AdminBin/Serializer.pm


{ # --- BEGIN Cpanel/AdminBin/Serializer/FailOK.pm
package Cpanel::AdminBin::Serializer::FailOK;


use strict;
use warnings;
no warnings &#039;once&#039;;

sub LoadModule {
    local $@;

    return 1 if $INC{&#039;Cpanel/AdminBin/Serializer.pm&#039;};

    my $load_ok = eval {
        local $SIG{&#039;__DIE__&#039;};     # Suppress spewage as we may be reading an invalid cache
        local $SIG{&#039;__WARN__&#039;};    # and since failure is ok to throw it away
        require Cpanel::AdminBin::Serializer;
        1;
    };

    if ( !$load_ok &amp;&amp; !$ENV{&#039;CPANEL_BASE_INSTALL&#039;} &amp;&amp; index( $^X, &#039;/usr/local/cpanel&#039; ) == 0 ) {
        warn $@;
    }

    return $load_ok ? 1 : 0;
}

sub LoadFile {
    my ( $file_or_fh, $path ) = @_;

    return undef if !$INC{&#039;Cpanel/AdminBin/Serializer.pm&#039;};

    return eval {
        local $SIG{&#039;__DIE__&#039;};     # Suppress spewage as we may be reading an invalid cache
        local $SIG{&#039;__WARN__&#039;};    # and since failure is ok to throw it away
        Cpanel::AdminBin::Serializer::LoadFile( $file_or_fh, undef, $path );
    };
}
1;

} # --- END Cpanel/AdminBin/Serializer/FailOK.pm


{ # --- BEGIN Cpanel/Umask.pm
package Cpanel::Umask;


use strict;

# use parent Cpanel::Finally (); # perlpkg line 238
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Finally); }

sub new {
    my ( $class, $new ) = @_;

    my $old = umask();

    umask($new);

    return $class-&gt;SUPER::new(
        sub {
            my $cur = umask();

            if ( $cur != $new ) {
                my ( $cur_o, $old_o, $new_o ) = map { &#039;0&#039; . sprintf( &#039;%o&#039;, $_ ) } ( $cur, $old, $new );

                warn &quot;I want to umask($old_o). I expected the current umask to be $new_o, but it’s actually $cur_o.&quot;;
            }

            umask($old);
        }
    );
}

1;

} # --- END Cpanel/Umask.pm


{ # --- BEGIN Cpanel/Config/LoadConfig.pm
package Cpanel::Config::LoadConfig;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Hash::Stringify              (); # perlpkg line 211
# use Cpanel::Debug                        (); # perlpkg line 211
# use Cpanel::FileUtils::Write::JSON::Lazy (); # perlpkg line 211
# use Cpanel::AdminBin::Serializer::FailOK (); # perlpkg line 211
# use Cpanel::LoadFile::ReadFast           (); # perlpkg line 211
# use Cpanel::HiRes                        (); # perlpkg line 211
# use Cpanel::SV                           (); # perlpkg line 211

use constant _ENOENT =&gt; 2;

my $logger;
our $PRODUCT_CONF_DIR = &#039;/var/cpanel&#039;;

our $_DEBUG_SAFEFILE = 0;

my %COMMON_CACHE_NAMES = (
    &#039;:__^\s*[#;]____0__&#039;                                                                           =&gt; &#039;default_colon&#039;,
    &#039;:\s+__^\s*[#;]____0__&#039;                                                                        =&gt; &#039;default_colon_any_space&#039;,
    &#039;: __^\s*[#;]____0__&#039;                                                                          =&gt; &#039;default_colon_with_one_space&#039;,
    &#039;=__^\s*[#;]____0__skip_readable_check_____1&#039;                                                  =&gt; &#039;default_skip_readable&#039;,
    &#039;=__^\s*[#;]____0__&#039;                                                                           =&gt; &#039;default&#039;,
    &#039;=__^\s*[#;]__(?^:\s+)__0__&#039;                                                                   =&gt; &#039;default_with_preproc_newline&#039;,
    &#039;=__^\s*[#;]____1__&#039;                                                                           =&gt; &#039;default_allow_undef&#039;,
    &#039;\s*[:]\s*__^\s*[#;]____0__&#039;                                                                   =&gt; &#039;default_colon_before_after_space&#039;,
    &#039;\s*=\s*__^\s*[#;]____1__&#039;                                                                     =&gt; &#039;default_equal_before_after_space_allow_undef&#039;,
    &#039;\s*[\=]\s*__^\s*[#]____0__use_reverse_____0&#039;                                                  =&gt; &#039;default_equal_before_after_space&#039;,
    &#039;: __^\s*[#;]____0__limit_____10000000000_____use_reverse_____0&#039;                               =&gt; &#039;default_with_10000000000_limit&#039;,
    &#039;\s*[:]\s*__^\s*[#;]____0__use_hash_of_arr_refs_____0_____use_reverse_____0&#039;                   =&gt; &#039;default_use_hash_of_arr_refs&#039;,
    &#039;: __^\s*[#;]____0__limit__________use_reverse_____0&#039;                                          =&gt; &#039;default_colon_single_space_no_limit&#039;,
    &#039;: __^\s*[#;]____1__skip_keys_____nobody_____use_hash_of_arr_refs_____0_____use_reverse_____0&#039; =&gt; &#039;default_colon_skip_nobody_no_limit&#039;,
    &#039;: __^\s*[#;]____1__use_reverse_____1&#039;                                                         =&gt; &#039;default_reverse_allow_undef&#039;,
    &#039;\s+__^\s*[#;]____0__&#039;                                                                         =&gt; &#039;default_space_seperated_config&#039;,
    &#039;\s*=\s*__^\s*[#;]__^\s*__0__&#039;                                                                 =&gt; &#039;default_equal_space_seperated_config&#039;,           #ea4.conf
);

my $DEFAULT_DELIMITER      = &#039;=&#039;;
my $DEFAULT_COMMENT_REGEXP = &#039;^\s*[#;]&#039;;                                                                                                                #Keep in sync with tr{} below!!
my @BOOLEAN_OPTIONS        = qw(
  allow_undef_values
  use_hash_of_arr_refs
  use_reverse
);

my $CACHE_DIR_PERMS = 0700;

sub _process_parse_args {
    my (%opts) = @_;

    if ( !defined $opts{&#039;delimiter&#039;} ) {
        $opts{&#039;delimiter&#039;} = $DEFAULT_DELIMITER;
    }

    $opts{&#039;regexp_to_preprune&#039;} ||= q{};

    $opts{&#039;comment&#039;} ||= $DEFAULT_COMMENT_REGEXP;

    $opts{&#039;comment&#039;} = &#039;&#039; if $opts{&#039;comment&#039;} eq &#039;0E0&#039;;

    $opts{$_} ||= 0 for @BOOLEAN_OPTIONS;

    return %opts;
}

{
    no warnings &#039;once&#039;;
    *get_homedir_and_cache_dir = *_get_homedir_and_cache_dir;
}

sub _get_homedir_and_cache_dir {
    my ( $homedir, $cache_dir );

    if ( $&gt; == 0 ) {
        $cache_dir = &quot;$PRODUCT_CONF_DIR/configs.cache&quot;;
    }
    else {
        {
            no warnings &#039;once&#039;;
            $homedir = $Cpanel::homedir;
        }
        if ( !$homedir ) {
            eval &#039;local $SIG{__DIE__}; local $SIG{__WARN__}; require Cpanel::PwCache&#039;;    ## no critic qw(ProhibitStringyEval) # PPI USE OK - just after
            $homedir = Cpanel::PwCache::gethomedir() if $INC{&#039;Cpanel/PwCache.pm&#039;};
            return unless $homedir;                                                       # undef for homedir and cache_dir avoid issues later when using undef as hash key
        }

        Cpanel::SV::untaint($homedir);

        $homedir =~ tr{/}{}s;

        return ( $homedir, undef ) if $homedir eq &#039;/&#039;;

        $cache_dir = undef;
    }

    return ( $homedir, $cache_dir );
}

sub loadConfig {    ## no critic qw(Subroutines::ProhibitExcessComplexity Subroutines::ProhibitManyArgs)
    my ( $file, $conf_ref, $delimiter, $comment, $regexp_to_preprune, $allow_undef_values, $arg_ref ) = @_;

    $conf_ref ||= -1;

    my %processed_positional_args = _process_parse_args(
        delimiter          =&gt; $delimiter,
        comment            =&gt; $comment,
        regexp_to_preprune =&gt; $regexp_to_preprune,
        allow_undef_values =&gt; $allow_undef_values,
        $arg_ref ? %$arg_ref : (),
    );

    my $empty_is_invalid = ( defined $arg_ref ) ? delete $arg_ref-&gt;{&#039;empty_is_invalid&#039;} : undef;

    my ( $use_reverse, $use_hash_of_arr_refs );
    ( $delimiter, $comment, $regexp_to_preprune, $allow_undef_values, $use_reverse, $use_hash_of_arr_refs ) = @processed_positional_args{
        qw(
          delimiter
          comment
          regexp_to_preprune
          allow_undef_values
          use_reverse
          use_hash_of_arr_refs
        )
    };


    if ( !$file || $file =~ tr/\0// ) {
        _do_logger( &#039;warn&#039;, &#039;loadConfig requires valid filename&#039; );
        if ( $arg_ref-&gt;{&#039;keep_locked_open&#039;} ) {
            return ( undef, undef, undef, &quot;loadConfig requires valid filename&quot; );
        }

        return;
    }

    my $filesys_mtime = ( Cpanel::HiRes::stat($file) )[9] or do {
        if ( $arg_ref-&gt;{&#039;keep_locked_open&#039;} ) {
            return ( undef, undef, undef, &quot;Unable to stat $file: $!&quot; );
        }
        return;
    };

    my $load_into_conf_ref = ( !ref $conf_ref &amp;&amp; $conf_ref == -1 ) ? 0 : 1;

    if ($load_into_conf_ref) {
        $conf_ref = _hashify_ref($conf_ref);
    }

    $conf_ref = {} if !$load_into_conf_ref;

    my $conf_fh;
    my $conflock;
    my $locked;
    if ( $arg_ref-&gt;{&#039;keep_locked_open&#039;} || $arg_ref-&gt;{&#039;rw&#039;} ) {
        require Cpanel::SafeFile;
        $locked   = 1;
        $conflock = Cpanel::SafeFile::safeopen( $conf_fh, &#039;+&lt;&#039;, $file );
    }
    else {
        $conflock = open( $conf_fh, &#039;&lt;&#039;, $file );
    }

    if ( !$conflock ) {
        my $open_err = $! || &#039;(unspecified error)&#039;;

        local $_DEBUG_SAFEFILE = 1;

        require Cpanel::Logger;
        my $is_root = ( $&gt; == 0 ? 1 : 0 );

        if ( !$is_root &amp;&amp; !$arg_ref-&gt;{&#039;skip_readable_check&#039;} ) {
            if ( !-r $file ) {
                my $msg;

                if ( my $err = $! ) {
                    $msg = &quot;$file’s readability check failed: $err&quot;;
                }
                else {
                    my $euser = getpwuid $&gt;;
                    $msg = &quot;$file is not readable as $euser.&quot;;
                }

                _do_logger( &#039;warn&#039;, $msg );

                if ( $arg_ref-&gt;{&#039;keep_locked_open&#039;} ) {
                    return ( undef, undef, undef, $msg );
                }

                return;
            }
        }
        my $verb = ( $locked ? &#039;lock/&#039; : q&lt;&gt; ) . &#039;open&#039;;
        my $msg  = &quot;Unable to $verb $file as UIDs $&lt;/$&gt;: $open_err&quot;;

        Cpanel::Logger::cplog( $msg, &#039;warn&#039;, __PACKAGE__ );
        if ( $arg_ref-&gt;{&#039;keep_locked_open&#039;} ) {
            return ( undef, undef, undef, $msg );
        }
        return;
    }

    my ( $parse_ok, $parsed ) = _parse_from_filehandle(
        $conf_fh,
        comment              =&gt; $comment,
        delimiter            =&gt; $delimiter,
        regexp_to_preprune   =&gt; $regexp_to_preprune,
        allow_undef_values   =&gt; $allow_undef_values,
        use_reverse          =&gt; $use_reverse,
        use_hash_of_arr_refs =&gt; $use_hash_of_arr_refs,
        $arg_ref ? %$arg_ref : (),
    );

    if ( $locked &amp;&amp; !$arg_ref-&gt;{&#039;keep_locked_open&#039;} ) {
        require Cpanel::SafeFile;
        Cpanel::SafeFile::safeclose( $conf_fh, $conflock );
    }

    if ( !$parse_ok ) {
        require Cpanel::Logger;
        Cpanel::Logger::cplog( &quot;Unable to parse $file: $parsed&quot;, &#039;warn&#039;, __PACKAGE__ );
        if ( $arg_ref-&gt;{&#039;keep_locked_open&#039;} ) {
            return ( undef, undef, undef, &quot;Unable to parse $file: $parsed&quot; );
        }
        return;
    }

    @{$conf_ref}{ keys %$parsed } = values %$parsed;

    if ( $arg_ref-&gt;{&#039;keep_locked_open&#039;} ) {
        return $conf_ref, $conf_fh, $conflock, &quot;open success&quot;;
    }

    return $conf_ref;
}

sub load_from_cache_if_valid {
    my (%opts) = @_;

    my $cache_file = $opts{&#039;cache_file&#039;} or die &quot;need cache_file!&quot;;

    my $file               = $opts{&#039;file&#039;};
    my $conf_ref           = $opts{&#039;conf_ref&#039;};
    my $load_into_conf_ref = $opts{&#039;load_into_conf_ref&#039;};
    my $filesys_mtime      = $opts{&#039;filesys_mtime&#039;} || ( Cpanel::HiRes::stat($file) )[9];

    open( my $cache_fh, &#039;&lt;:stdio&#039;, $cache_file ) or do {
        my $err = $!;

        my $msg = &quot;non-fatal error: open($cache_file): $err&quot;;

        warn $msg if $! != _ENOENT();

        return ( 0, $msg );
    };

    my ( $cache_filesys_mtime, $now, $cache_conf_ref ) = ( ( Cpanel::HiRes::fstat($cache_fh) )[9], Cpanel::HiRes::time() );    # stat the file after we have it open to avoid a race condition

    if ( ( $Cpanel::Debug::level || 0 ) &gt;= 5 ) {
        print STDERR __PACKAGE__ . &quot;::loadConfig file:$file, cache_file:$cache_file, cache_filesys_mtime:$cache_filesys_mtime, filesys_mtime:$filesys_mtime, now:$now\n&quot;;
    }

    if ( $filesys_mtime &amp;&amp; _greater_with_same_precision( $cache_filesys_mtime, $filesys_mtime ) &amp;&amp; _greater_with_same_precision( $now, $cache_filesys_mtime ) ) {
        if ( ( $Cpanel::Debug::level || 0 ) &gt;= 5 ) {
            print STDERR __PACKAGE__ . &quot;::loadConfig using cache_file:$cache_file\n&quot;;
        }

        Cpanel::AdminBin::Serializer::FailOK::LoadModule() if !$INC{&#039;Cpanel/AdminBin/Serializer.pm&#039;};
        if ( $cache_conf_ref = Cpanel::AdminBin::Serializer::FailOK::LoadFile($cache_fh) ) {    #zero keys is a valid file still it may just be all comments or empty
            close($cache_fh);

            if ( $opts{&#039;empty_is_invalid&#039;} &amp;&amp; scalar keys %$cache_conf_ref == 0 ) {
                return ( 0, &#039;Cache is empty&#039; );
            }

            my $ref_to_return;
            if ($load_into_conf_ref) {
                @{$conf_ref}{ keys %$cache_conf_ref } = values %$cache_conf_ref;
                $ref_to_return = $conf_ref;
            }
            else {
                $ref_to_return = $cache_conf_ref;
            }

            return ( 1, $ref_to_return );
        }
        elsif ( ( $Cpanel::Debug::level || 0 ) &gt;= 5 ) {
            print STDERR __PACKAGE__ . &quot;::loadConfig failed to load cache_file:$cache_file\n&quot;;
        }

    }
    else {
        if ( ( $Cpanel::Debug::level || 0 ) &gt;= 5 ) {
            print STDERR __PACKAGE__ . &quot;::loadConfig NOT using cache_file:$cache_file\n&quot;;
        }
    }

    return ( 0, &#039;Cache not valid&#039; );
}

sub _greater_with_same_precision {
    my ( $float1, $float2 ) = @_;
    my ( $int1,   $int2 )   = ( int($float1), int($float2) );
    if ( $float1 == $int1 or $float2 == $int2 ) {
        return $int1 &gt; $int2;
    }
    return $float1 &gt; $float2;
}

sub get_cache_file {    ## no critic qw(Subroutines::RequireArgUnpacking) - Args unpacked by _process_parse_args
    my %opts = _process_parse_args(@_);

    die &#039;need cache_dir!&#039; if !$opts{&#039;cache_dir&#039;};

    my $stringified_args = join(
        &#039;__&#039;,
        @opts{qw(delimiter comment regexp_to_preprune allow_undef_values)}, ( scalar keys %{ $opts{&#039;arg_ref&#039;} } ? Cpanel::Hash::Stringify::sorted_hashref_string( $opts{&#039;arg_ref&#039;} ) : &#039;&#039; )
    );
    if ( ( $Cpanel::Debug::level || 0 ) &gt;= 5 ) {    # PPI NO PARSE -  ok missing
        print STDERR __PACKAGE__ . &quot;::loadConfig stringified_args[$stringified_args]\n&quot;;
    }

    my $safe_filename = $opts{&#039;file&#039;};
    $safe_filename =~ tr{/}{_};

    return $opts{&#039;cache_dir&#039;} . &#039;/&#039; . $safe_filename . &#039;___&#039; . ( $COMMON_CACHE_NAMES{$stringified_args} || _get_fastest_hash($stringified_args) );
}

sub _get_fastest_hash {
    require Cpanel::Hash;
    goto \&amp;Cpanel::Hash::get_fastest_hash;
}

sub write_cache {
    my (%opts)     = @_;
    my $cache_file = $opts{&#039;cache_file&#039;};
    my $cache_dir  = $opts{&#039;cache_dir&#039;};
    my $homedir    = $opts{&#039;homedir&#039;};
    my $is_root    = $opts{&#039;is_root&#039;};
    my $parsed     = $opts{&#039;data&#039;};

    my @dirs = ($cache_dir);
    if ( !$is_root ) {
        if ( $ENV{&#039;TEAM_USER&#039;} ) {
            unshift @dirs, &quot;$homedir/$ENV{&#039;TEAM_USER&#039;}&quot;, &quot;$homedir/$ENV{&#039;TEAM_USER&#039;}/.cpanel&quot;, &quot;$homedir/$ENV{&#039;TEAM_USER&#039;}/.cpanel/caches&quot;;
        }
        else {
            unshift @dirs, &quot;$homedir/.cpanel&quot;, &quot;$homedir/.cpanel/caches&quot;;
        }
    }

    foreach my $dir (@dirs) {
        Cpanel::SV::untaint($dir);

        chmod( $CACHE_DIR_PERMS, $dir ) or do {
            if ( $! == _ENOENT() ) {

                require Cpanel::Umask;
                my $umask = Cpanel::Umask-&gt;new(0);

                mkdir( $dir, $CACHE_DIR_PERMS ) or do {
                    _do_logger( &#039;warn&#039;, &quot;Failed to create dir “$dir”: $!&quot; );
                };
            }
            else {
                _do_logger( &#039;warn&#039;, &quot;chmod($dir): $!&quot; );
            }
        };

    }

    my $wrote_ok = eval { Cpanel::FileUtils::Write::JSON::Lazy::write_file( $cache_file, $parsed, 0600 ) };
    my $error    = $@;

    $error ||= &quot;Unknown error&quot; if !defined $wrote_ok;
    if ($error) {
        _do_logger( &#039;warn&#039;, &quot;Could not create cache file “$cache_file”: $error&quot; );
        unlink $cache_file;    #outdated
    }
    if ( ( $Cpanel::Debug::level || 0 ) &gt; 4 ) {    # PPI NO PARSE -  ok missing
        print STDERR __PACKAGE__ . &quot;::loadConfig [lazy write cache file] [$cache_file] wrote_ok:[$wrote_ok]\n&quot;;
    }
    return 1;
}

sub _do_logger {
    my ( $action, $msg ) = @_;

    require Cpanel::Logger;
    $logger ||= Cpanel::Logger-&gt;new();

    return $logger-&gt;$action($msg);
}

sub parse_from_filehandle {
    my ( $conf_fh, %opts ) = @_;
    return _parse_from_filehandle( $conf_fh, _process_parse_args(%opts) );
}

sub _parse_from_filehandle {
    my ( $conf_fh, %opts ) = @_;


    my ( $comment, $limit, $regexp_to_preprune, $delimiter, $allow_undef_values, $use_hash_of_arr_refs, $skip_keys, $use_reverse ) = @opts{
        qw(
          comment
          limit
          regexp_to_preprune
          delimiter
          allow_undef_values
          use_hash_of_arr_refs
          skip_keys
          use_reverse
        )
    };

    my $conf_ref = {};

    my $parser_code;
    my ( $k, $v );    ## no critic qw(Variables::ProhibitUnusedVariables)
    my $keys           = 0;
    my $key_value_text = $use_reverse ? &#039;1,0&#039; : &#039;0,1&#039;;
    my $cfg_txt        = &#039;&#039;;
    Cpanel::LoadFile::ReadFast::read_all_fast( $conf_fh, $cfg_txt );
    my $has_cr = index( $cfg_txt, &quot;\r&quot; ) &gt; -1 ? 1 : 0;
    _remove_comments_from_text( \$cfg_txt, $comment, \$has_cr ) if $cfg_txt &amp;&amp; $comment;

    my $split_on = $has_cr ? &#039;\r?\n&#039; : &#039;\n&#039;;

    if ( !$limit &amp;&amp; !$regexp_to_preprune &amp;&amp; !$use_hash_of_arr_refs &amp;&amp; length $delimiter ) {
        if ($allow_undef_values) {
            $parser_code = qq&lt;
                  \$conf_ref = {
                      map {
                          (split(m/&gt; . $delimiter . qq&lt;/, \$_, 2))[$key_value_text]
                      } split(/&gt; . $split_on . qq&lt;/, \$cfg_txt)
                  };
              &gt;;
        }
        else {
            $parser_code = &#039; $conf_ref = {  map { &#039; . &#039;($k,$v) = (split(m/&#039; . $delimiter . &#039;/, $_, 2))[&#039; . $key_value_text . &#039;]; &#039; . &#039;defined($v) ? ($k,$v) : () &#039; . &#039;} split(/&#039; . $split_on . &#039;/, $cfg_txt ) }&#039;;
        }
    }
    else {
        if ( ( $Cpanel::Debug::level || 0 ) &gt; 4 ) {    # PPI NO PARSE - ok if not there
            $limit ||= 0;
            print STDERR __PACKAGE__ . &quot;::parse_from_filehandle [slow LoadConfig parser used] LIMIT:[!$limit] REGEXP_TO_DELETE[!$regexp_to_preprune] USE_HASH_OF_ARR_REFS[$use_hash_of_arr_refs)]\n&quot;;
        }
        $parser_code = &#039;foreach (split(m/&#039; . $split_on . &#039;/, $cfg_txt)) {&#039; . &quot;\n&quot;                                                                            #
          . q{next if !length;} . &quot;\n&quot;                                                                                                                       #
          . ( $limit ? q{last if $keys++ == } . $limit . &#039;;&#039; : &#039;&#039; ) . &quot;\n&quot; . ( $regexp_to_preprune ? q{ s/} . $regexp_to_preprune . q{//g;} : &#039;&#039; ) . &quot;\n&quot;    #
          . (
            length $delimiter ?                                                                                                                              #
              (
                q{( $k, $v ) = (split( /} . $delimiter . q{/, $_, 2 ))[} . $key_value_text . q{];} . &quot;\n&quot; .                                                  #
                  ( !$allow_undef_values  ? q{ next if !defined($v); }          : &#039;&#039; ) . &quot;\n&quot; .                                                              #
                  ( $use_hash_of_arr_refs ? q{ push @{ $conf_ref-&gt;{$k} }, $v; } : q{ $conf_ref-&gt;{$k} = $v; } ) . &quot;\n&quot;                                        #
              )
            : q{$conf_ref-&gt;{$_} = 1; } . &quot;\n&quot;
          ) . &#039;};&#039;;
    }

    $parser_code .= &quot;; 1&quot;;
    $parser_code =~ tr{\n}{\r};    ## no critic qw(Cpanel::TransliterationUsage)
    eval($parser_code) or do {     ## no critic qw(BuiltinFunctions::ProhibitStringyEval)
        $parser_code =~ tr{\r}{\n};    ## no critic qw(Cpanel::TransliterationUsage)
        _do_logger( &#039;panic&#039;, &quot;Failed to parse :: $parser_code: $@&quot; );
        return ( 0, &quot;$@\n$parser_code&quot; );
    };

    delete $conf_ref-&gt;{&#039;&#039;} if !defined( $conf_ref-&gt;{&#039;&#039;} );

    if ($skip_keys) {
        my $skip_keys_ar;
        if ( ref $skip_keys eq &#039;ARRAY&#039; ) {
            $skip_keys_ar = $skip_keys;
        }
        elsif ( ref $skip_keys eq &#039;HASH&#039; ) {
            $skip_keys_ar = [ keys %$skip_keys ];
        }
        else {
            return ( 0, &#039;skip_keys must be an ARRAY or HASH reference&#039; );
        }
        delete @{$conf_ref}{@$skip_keys_ar};
    }

    return ( 1, $conf_ref );
}

sub _hashify_ref {
    my $conf_ref = shift;

    if ( !defined($conf_ref) ) {
        $conf_ref = {};
        return $conf_ref;
    }

    unless ( ref $conf_ref eq &#039;HASH&#039; ) {
        if ( ref $conf_ref ) {
            require Cpanel::Logger;
            Cpanel::Logger::cplog( &#039;hashifying non-HASH reference&#039;, &#039;warn&#039;, __PACKAGE__ );

            ${$conf_ref} = {};
            $conf_ref = ${$conf_ref};
        }
        else {
            require Cpanel::Logger;
            Cpanel::Logger::cplog( &#039;defined value encountered where reference expected&#039;, &#039;die&#039;, __PACKAGE__ );
        }
    }
    return $conf_ref;
}

sub default_product_dir {
    $PRODUCT_CONF_DIR = shift if @_;
    return $PRODUCT_CONF_DIR;
}

sub _remove_comments_from_text {
    my ( $cfg_txt_sr, $comment, $has_cr_sr ) = @_;
    if ($$has_cr_sr) {
        $$cfg_txt_sr = join( &quot;\n&quot;, grep ( !m/$comment/, split( m{\r?\n}, $$cfg_txt_sr ) ) );
        $$has_cr_sr  = 0;
    }
    elsif ( $comment eq $DEFAULT_COMMENT_REGEXP ) {

        if ( rindex( $$cfg_txt_sr, &#039;#&#039;, 0 ) == 0 &amp;&amp; index( $$cfg_txt_sr, &quot;\n&quot; ) &gt; -1 ) {
            substr( $$cfg_txt_sr, 0, index( $$cfg_txt_sr, &quot;\n&quot; ) + 1, &#039;&#039; );
        }
        $$cfg_txt_sr =~ s{$DEFAULT_COMMENT_REGEXP.*}{}omg if $$cfg_txt_sr =~ tr{#;}{};
    }
    else {
        $$cfg_txt_sr =~ s{$comment.*}{}mg;
    }
    return 1;
}

1;

} # --- END Cpanel/Config/LoadConfig.pm


{ # --- BEGIN Cpanel/Config/LoadWwwAcctConf.pm
package Cpanel::Config::LoadWwwAcctConf;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::HiRes (); # perlpkg line 211

# use Cpanel::Path::Normalize (); # perlpkg line 211
# use Cpanel::Debug           (); # perlpkg line 211
# use Cpanel::JSON::FailOK    (); # perlpkg line 211

my $SYSTEM_CONF_DIR = &#039;/etc&#039;;
my $wwwconf_cache;
my $wwwconf_mtime = 0;

my $has_serializer;

our $wwwacctconf       = &quot;$SYSTEM_CONF_DIR/wwwacct.conf&quot;;
our $wwwacctconfshadow = &quot;$SYSTEM_CONF_DIR/wwwacct.conf.shadow&quot;;

sub import {
    my $this = shift;
    if ( !exists $INC{&#039;Cpanel/JSON.pm&#039;} ) {
        Cpanel::JSON::FailOK::LoadJSONModule();
    }
    if ( $INC{&#039;Cpanel/JSON.pm&#039;} ) {
        $has_serializer = 1;
    }
    return Exporter::import( $this, @_ );
}

sub loadwwwacctconf {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    if ( $INC{&#039;Cpanel/JSON.pm&#039;} ) { $has_serializer = 1; }    #something else loaded it

    my $filesys_mtime = ( Cpanel::HiRes::stat($wwwacctconf) )[9];

    return if !$filesys_mtime;

    if ( $filesys_mtime == $wwwconf_mtime &amp;&amp; $wwwconf_cache ) {
        return wantarray ? %{$wwwconf_cache} : $wwwconf_cache;
    }

    my $wwwacctconf_cache       = &quot;$wwwacctconf.cache&quot;;
    my $wwwacctconfshadow_cache = &quot;$wwwacctconfshadow.cache&quot;;
    my $is_root                 = $&gt; ? 0 : 1;

    if ($has_serializer) {
        my $cache_file;
        my $cache_filesys_mtime;
        my $have_valid_cache = 1;

        if ( $is_root &amp;&amp; -e $wwwacctconfshadow_cache ) {
            $cache_filesys_mtime = ( Cpanel::HiRes::stat($wwwacctconfshadow_cache) )[9];    #shadow cache&#039;s mtime

            my $shadow_file_mtime = ( Cpanel::HiRes::stat $wwwacctconfshadow )[9] || 0;
            if ( $shadow_file_mtime &lt; $cache_filesys_mtime ) {
                $cache_file = $wwwacctconfshadow_cache;
            }
            else {    #don&#039;t use shadow cache if shadow file is newer
                $have_valid_cache = undef;
            }
        }

        elsif ( -e $wwwacctconf_cache &amp;&amp; !( $is_root &amp;&amp; -r $wwwacctconfshadow ) ) {
            $cache_filesys_mtime = ( Cpanel::HiRes::stat $wwwacctconf_cache )[9];    #regular cache&#039;s mtime
            $cache_file          = $wwwacctconf_cache;
        }
        else {
            $have_valid_cache = undef;
        }
        my $now = Cpanel::HiRes::time();

        if ( $Cpanel::Debug::level &gt;= 5 ) {
            print STDERR __PACKAGE__ . &quot;::loadwwwacctconf cache_filesys_mtime = $cache_filesys_mtime , filesys_mtime: $filesys_mtime , now : $now\n&quot;;
        }

        if ( $have_valid_cache &amp;&amp; $cache_filesys_mtime &gt; $filesys_mtime &amp;&amp; $cache_filesys_mtime &lt; $now ) {
            my $wwwconf_ref;
            if ( open( my $conf_fh, &#039;&lt;&#039;, $cache_file ) ) {
                $wwwconf_ref = Cpanel::JSON::FailOK::LoadFile($conf_fh);
                close($conf_fh);
            }

            if ( $wwwconf_ref &amp;&amp; ( scalar keys %{$wwwconf_ref} ) &gt; 0 ) {
                if ( $Cpanel::Debug::level &gt;= 5 ) { print STDERR __PACKAGE__ . &quot;::loadwwwconf file system cache hit\n&quot;; }
                $wwwconf_cache = $wwwconf_ref;
                $wwwconf_mtime = $filesys_mtime;
                return wantarray ? %{$wwwconf_ref} : $wwwconf_ref;
            }
        }
    }

    my @configfiles;
    push @configfiles, $wwwacctconf;

    if ($is_root) { push @configfiles, $wwwacctconfshadow; }    #shadow file must be last as the cache gets written for each file with all the files before it in it

    my $can_write_cache;
    if ( $is_root &amp;&amp; $has_serializer ) {
        $can_write_cache = 1;
    }

    my %CONF = (
        &#039;ADDR&#039;         =&gt; undef,
        &#039;CONTACTEMAIL&#039; =&gt; undef,
        &#039;DEFMOD&#039;       =&gt; undef,
        &#039;ETHDEV&#039;       =&gt; undef,
        &#039;HOST&#039;         =&gt; undef,
        &#039;NS&#039;           =&gt; undef,
        &#039;NS2&#039;          =&gt; undef,
    );
    require Cpanel::Config::LoadConfig;
    foreach my $configfile (@configfiles) {
        Cpanel::Config::LoadConfig::loadConfig( $configfile, \%CONF, &#039;\s+&#039;, undef, undef, undef, { &#039;nocache&#039; =&gt; 1 } );

        foreach ( keys %CONF ) {

            $CONF{$_} =~ s{\s+$}{} if defined $CONF{$_};
        }

        $CONF{&#039;HOMEMATCH&#039;} =~ s{/+$}{} if defined $CONF{&#039;HOMEMATCH&#039;};    # Remove trailing slashes

        $CONF{&#039;HOMEDIR&#039;} = Cpanel::Path::Normalize::normalize( $CONF{&#039;HOMEDIR&#039;} ) if defined $CONF{&#039;HOMEDIR&#039;};

        if ($can_write_cache) {
            my $cache_file = $configfile . &#039;.cache&#039;;
            require Cpanel::FileUtils::Write::JSON::Lazy;
            Cpanel::FileUtils::Write::JSON::Lazy::write_file( $cache_file, \%CONF, ( $configfile eq $wwwacctconfshadow ) ? 0600 : 0644 );
        }
    }

    $wwwconf_mtime = $filesys_mtime;
    $wwwconf_cache = \%CONF;

    return wantarray ? %CONF : \%CONF;
}

sub reset_mem_cache {
    ( $wwwconf_mtime, $wwwconf_cache ) = ( 0, undef );
}

sub reset_has_serializer {
    $has_serializer = 0;
}

sub default_conf_dir {
    $SYSTEM_CONF_DIR = shift if @_;

    $wwwacctconf       = &quot;$SYSTEM_CONF_DIR/wwwacct.conf&quot;;
    $wwwacctconfshadow = &quot;$SYSTEM_CONF_DIR/wwwacct.conf.shadow&quot;;

    return $SYSTEM_CONF_DIR;
}

sub reset_caches {
    my @cache_files = map { &quot;$_.cache&quot; } ( $wwwacctconf, $wwwacctconfshadow );

    for my $cache_file (@cache_files) {
        unlink $cache_file if -e $cache_file;
    }

    reset_mem_cache();

    return;
}

1;

} # --- END Cpanel/Config/LoadWwwAcctConf.pm


{ # --- BEGIN Cpanel/StatCache.pm
package Cpanel::StatCache;


use strict;
use warnings;
no warnings &#039;once&#039;;

our $VERSION = 0.4;

my %STATCACHE;


our $USE_LSTAT = 0;

sub StatCache_init { }


sub cachedmtime {
    return (
        exists $STATCACHE{ $_[0] } ? $STATCACHE{ $_[0] }-&gt;[0]
        : (
            $STATCACHE{ $_[0] } = (
                  $USE_LSTAT &amp;&amp; -l $_[0] ? [ ( lstat(_) )[ 9, 7, 10 ] ]
                : -e $_[0]               ? [ ( stat(_) )[ 9, 7, 10 ] ]
                :                          [ 0, 0, 0 ]
            )
        )-&gt;[0]
    );
}


sub cachedmtime_size {
    return (
        exists $STATCACHE{ $_[0] } ? @{ $STATCACHE{ $_[0] } }[ 0, 1 ]
        : @{
            (
                $STATCACHE{ $_[0] } = (
                      $USE_LSTAT &amp;&amp; -l $_[0] ? [ ( lstat(_) )[ 9, 7, 10 ] ]
                    : -e $_[0]               ? [ ( stat(_) )[ 9, 7, 10 ] ]
                    :                          [ 0, 0, 0 ]
                )
            )
        }[ 0, 1 ]
    );
}


sub cachedmtime_ctime {
    return (
        exists $STATCACHE{ $_[0] } ? @{ $STATCACHE{ $_[0] } }[ 0, 2 ]
        : @{
            (
                $STATCACHE{ $_[0] } = (
                      $USE_LSTAT &amp;&amp; -l $_[0] ? [ ( lstat(_) )[ 9, 7, 10 ] ]
                    : -e $_[0]               ? [ ( stat(_) )[ 9, 7, 10 ] ]
                    :                          [ 0, 0, 0 ]
                )
            )
        }[ 0, 2 ]
    );
}


sub clearcache {
    %STATCACHE = ();
    return 1;
}

1;

} # --- END Cpanel/StatCache.pm


{ # --- BEGIN Cpanel/SafeDir/MK.pm
package Cpanel::SafeDir::MK;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Debug (); # perlpkg line 211

my $DEFAULT_PERMISSIONS = 0755;


sub safemkdir_or_die {
    my ( $dir, $mode, $created ) = @_;
    my $ok = safemkdir( $dir, $mode, $created );
    if ( !$ok ) {
        my $error = $!;
        require Cpanel::Exception;
        die Cpanel::Exception::create(
            &#039;IO::DirectoryCreateError&#039;,
            [
                path  =&gt; $dir,
                error =&gt; $error,
            ]
        );
    }
    return $ok;
}


sub safemkdir {    ## no critic(Subroutines::ProhibitExcessComplexity)  -- Refactoring this function is a project, not a bug fix
    my ( $dir, $mode, $errors, $created ) = @_;

    if ( defined $mode ) {
        if ( $mode eq &#039;&#039; ) {
            $mode = undef;
        }
        elsif ( index( $mode, &#039;0&#039; ) == 0 ) {
            if ( length $mode &lt; 3 || $mode =~ tr{0-7}{}c || !defined oct $mode ) {
                $mode = $DEFAULT_PERMISSIONS;
            }
            else {
                $mode = oct($mode);
            }
        }
        elsif ( $mode =~ tr{0-9}{}c ) {
            $mode = $DEFAULT_PERMISSIONS;
        }
    }
    $dir =~ tr{/}{}s;

    my $default = &#039;&#039;;
    if ( index( $dir, &#039;/&#039; ) == 0 ) {
        $default = &#039;/&#039;;
    }
    elsif ( $dir eq &#039;.&#039; || $dir eq &#039;./&#039; ) {
        if ( !-l $dir &amp;&amp; defined $mode ) {
            return chmod $mode, $dir;
        }
        return 1;
    }
    else {
        substr( $dir, 0, 2, &#039;&#039; ) if index( $dir, &#039;./&#039; ) == 0;
    }

    if ( _has_dot_dot($dir) ) {
        Cpanel::Debug::log_warn(&quot;Possible improper directory $dir specified&quot;);
        my @dir_parts = split m{/}, $dir;
        my @good_parts;
        my $first;
        foreach my $part (@dir_parts) {
            next if ( !defined $part || $part eq &#039;&#039; );
            next if $part eq &#039;.&#039;;
            if ( $part eq &#039;..&#039; ) {
                if ( !$first || !@good_parts ) {
                    Cpanel::Debug::log_warn(&quot;Will not proceed above first directory part $first&quot;);
                    return 0;
                }
                if ( $first eq $good_parts[$#good_parts] ) {
                    undef $first;
                }
                pop @good_parts;
                next;
            }
            elsif ( $part !~ tr{.}{}c ) {
                Cpanel::Debug::log_warn(&quot;Total stupidity found in directory $dir&quot;);
                return 0;
            }
            push @good_parts, $part;
            if ( !$first ) { $first = $part }
        }
        $dir = $default . join &#039;/&#039;, @good_parts;
        if ( !$dir ) {
            Cpanel::Debug::log_warn(&quot;Could not validate given directory&quot;);
            return;
        }
        Cpanel::Debug::log_warn(&quot;Improper directory updated to $dir&quot;);
    }

    if ( -d $dir ) {
        if ( !-l $dir &amp;&amp; defined $mode ) {
            return chmod $mode, $dir;
        }
        return 1;
    }
    elsif ( -e _ ) {
        Cpanel::Debug::log_warn(&quot;$dir was expected to be a directory!&quot;);
        require Errno;
        $! = Errno::ENOTDIR();    ## no critic qw(Variables::RequireLocalizedPunctuationVars) -- for legacy reasons
        return 0;
    }

    my @dir_parts = split m{/}, $dir;

    if ( scalar @dir_parts &gt; 100 ) {
        Cpanel::Debug::log_warn(&quot;Encountered excessive directory length. This should never happen.&quot;);
        return 0;
    }
    my $returnvalue;
    foreach my $i ( 0 .. $#dir_parts ) {
        my $newdir = join( &#039;/&#039;, @dir_parts[ 0 .. $i ] );
        next if $newdir eq &#039;&#039;;
        my $is_dir = -d $newdir;
        my $exists = -e _;

        if ( !$exists ) {
            my $local_mode = defined $mode ? $mode : $DEFAULT_PERMISSIONS;
            if ( mkdir( $newdir, $local_mode ) ) {
                push @{$created}, $newdir if $created;
                $returnvalue++;
            }
            else {
                Cpanel::Debug::log_warn(&quot;mkdir $newdir failed: $!&quot;);
                return;
            }
        }
        elsif ( !$is_dir ) {
            Cpanel::Debug::log_warn(&quot;Encountered non-directory $newdir in path of $dir: $!&quot;);
            require Errno;
            $! = Errno::ENOTDIR();    ## no critic qw(Variables::RequireLocalizedPunctuationVars) -- for legacy reasons
            last;
        }
    }
    return $returnvalue;
}

sub _has_dot_dot {    ## no critic qw(RequireArgUnpacking)
    return 1 if $_[0] eq &#039;..&#039;;
    return 1 if -1 != index( $_[0], &#039;/../&#039; );
    return 1 if 0 == index( $_[0], &#039;../&#039; );
    return 1 if ( length( $_[0] ) - 3 ) == rindex( $_[0], &#039;/..&#039; );

    return 0;
}

1;

} # --- END Cpanel/SafeDir/MK.pm


{ # --- BEGIN Cpanel/CachedCommand/Utils.pm
package Cpanel::CachedCommand::Utils;


# use Cpanel::SV (); # perlpkg line 211

my ( $cached_datastore_myuid, $cached_datastore_dir );

sub destroy {
    my %OPTS       = @_;
    my $cache_file = _get_datastore_filename( $OPTS{&#039;name&#039;}, ( $OPTS{&#039;args&#039;} ? @{ $OPTS{&#039;args&#039;} } : () ) );
    if ( -e $cache_file ) {
        return unlink $cache_file;
    }
    else {
        return 1;
    }
    return;
}

*get_datastore_filename = *_get_datastore_filename;

sub _get_datastore_filename {
    my ( $bin, @args ) = @_;

    my $file = join( &#039;_&#039;, $bin, @args );
    $file =~ tr{/}{_};
    Cpanel::SV::untaint($file);

    my $datastore_dir = _get_datastore_dir($file);
    Cpanel::SV::untaint($datastore_dir);

    return $datastore_dir . &#039;/&#039; . $file;
}

sub _get_datastore_dir {
    my $file  = shift;
    my $myuid = $&gt;;

    if ( defined $cached_datastore_dir &amp;&amp; length $cached_datastore_dir &gt; 1 &amp;&amp; defined $cached_datastore_myuid &amp;&amp; $myuid == $cached_datastore_myuid ) {
        my $homedir = Cpanel::PwCache::gethomedir();
        $cached_datastore_dir = &quot;$homedir/$ENV{&#039;TEAM_USER&#039;}/.cpanel/datastore&quot; if $ENV{&#039;TEAM_USER&#039;} &amp;&amp; $file =~ /^AVAILABLE_APPLICATIONS_CACHE/;
        return $cached_datastore_dir;
    }

    require Cpanel::PwCache;
    $cached_datastore_dir = Cpanel::SV::untaint( Cpanel::PwCache::gethomedir() );
    $cached_datastore_dir .= &quot;/$ENV{&#039;TEAM_USER&#039;}&quot; if $ENV{&#039;TEAM_USER&#039;} &amp;&amp; $file =~ /^AVAILABLE_APPLICATIONS_CACHE/;

    if ( !-e $cached_datastore_dir . &#039;/.cpanel/datastore&#039; &amp;&amp; $cached_datastore_dir ne &#039;/&#039; ) {    # nobody&#039;s homedir is /
        require Cpanel::SafeDir::MK;
        Cpanel::SafeDir::MK::safemkdir( &quot;$cached_datastore_dir/.cpanel/datastore&quot;, 0700 ) or warn &quot;Failed to mkdir($cached_datastore_dir/.cpanel/datastore): $!&quot;;
    }

    $cached_datastore_myuid = $myuid;
    $cached_datastore_dir .= &#039;/.cpanel/datastore&#039;;
    return $cached_datastore_dir;
}

sub invalidate_cache {
    my $ds_file = get_datastore_filename(@_);
    unlink $ds_file;
    return $ds_file;
}

sub clearcache {
    $cached_datastore_dir   = undef;
    $cached_datastore_myuid = undef;
    return;
}

1;

} # --- END Cpanel/CachedCommand/Utils.pm


{ # --- BEGIN Cpanel/FindBin.pm
package Cpanel::FindBin;


use strict;
use warnings;
no warnings &#039;once&#039;;

use constant _ENOENT =&gt; 2;

our $VERSION = 1.2;

my %bin_cache;
my @default_path = qw( /usr/bin /usr/local/bin /bin /sbin /usr/sbin /usr/local/sbin );

sub findbin {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my $binname = shift;
    return if !$binname;

    my @lookup_path = get_path(@_);

    my $nocache = grep( /nocache/, @_ );

    if ( !$nocache &amp;&amp; exists $bin_cache{$binname} &amp;&amp; $bin_cache{$binname} ne &#039;&#039; ) {
        return $bin_cache{$binname};
    }

    foreach my $path (@lookup_path) {
        next unless -d $path;

        $path .= &quot;/$binname&quot;;

        if ( -e $path ) {
            if ( -x _ ) {
                $bin_cache{$binname} = $path unless $nocache;
                return $path;
            }
            else {
                warn &quot;“$path” exists but is not executable; ignoring.\n&quot;;
            }
        }
        elsif ( $! != _ENOENT() ) {
            warn &quot;stat($path): $!\n&quot;;
        }
    }
    return;
}

sub get_path {
    if ( !$_[0] ) {
        return @default_path;
    }
    elsif ( scalar @_ &gt; 1 ) {
        my %opts;
        %opts = @_ if ( scalar @_ % 2 == 0 );
        if ( exists $opts{&#039;path&#039;} &amp;&amp; ref $opts{&#039;path&#039;} eq &#039;ARRAY&#039; ) {
            return @{ $opts{&#039;path&#039;} };
        }
        else {
            return @_;
        }
    }
    elsif ( ref $_[0] eq &#039;ARRAY&#039; ) {
        return @{ $_[0] };
    }
    return @default_path;
}

1;

} # --- END Cpanel/FindBin.pm


{ # --- BEGIN Cpanel/CachedCommand/Valid.pm
package Cpanel::CachedCommand::Valid;


use strict;
use warnings;
no warnings &#039;once&#039;;
# use Cpanel::StatCache (); # perlpkg line 211
# use Cpanel::Debug     (); # perlpkg line 211


sub is_cache_valid {    ## no critic qw(Subroutines::ProhibitExcessComplexity) -- needs to be refactored
    my %OPTS = @_;
    my ( $datastore_file, $datastore_file_mtime, $datastore_file_size, $binary, $ttl, $mtime, $min_expire_time, $now ) = ( ( $OPTS{&#039;datastore_file&#039;} || &#039;&#039; ), ( $OPTS{&#039;datastore_file_mtime&#039;} || 0 ), ( $OPTS{&#039;datastore_file_size&#039;} || 0 ), ( $OPTS{&#039;binary&#039;} || &#039;&#039; ), ( $OPTS{&#039;ttl&#039;} || 0 ), ( $OPTS{&#039;mtime&#039;} || 0 ), ( $OPTS{&#039;min_expire_time&#039;} || 0 ), ( $OPTS{&#039;now&#039;} || 0 ) );

    if ( !$datastore_file_mtime &amp;&amp; !-e $datastore_file ) {
        print STDERR &quot;is_cache_valid: rejecting $datastore_file because it does not exist.\n&quot; if $Cpanel::Debug::level;
        return 0;
    }

    if ( !$datastore_file_size || !$datastore_file_mtime ) {
        ( $datastore_file_size, $datastore_file_mtime ) = ( stat(_) )[ 7, 9 ];
    }

    if ( $datastore_file_mtime &lt;= 0 ) {
        print STDERR &quot;is_cache_valid: rejecting $datastore_file as mtime is zero.\n&quot; if $Cpanel::Debug::level;
        return 0;
    }

    if ($binary) {
        if ( substr( $binary, 0, 1 ) ne &#039;/&#039; ) {
            require Cpanel::FindBin;
            $binary = Cpanel::FindBin::findbin( $binary, split( /:/, $ENV{&#039;PATH&#039;} ) );
        }
        my ( $binary_mtime, $binary_ctime ) = Cpanel::StatCache::cachedmtime_ctime($binary);
        if ( ( $binary_mtime &amp;&amp; $binary_mtime &gt; $datastore_file_mtime ) || ( $binary_ctime &amp;&amp; $binary_ctime &gt; $datastore_file_mtime ) ) {
            if ($Cpanel::Debug::level) {
                print STDERR &quot;is_cache_valid: rejecting $datastore_file as binary ($binary) ctime or mtime is newer.\n&quot;;
                print STDERR &quot;is_cache_valid: datastore_file:$datastore_file mtime[$datastore_file_mtime]\n&quot;;
                print STDERR &quot;is_cache_valid: binary_file:$binary mtime[$binary_mtime] ctime[$binary_ctime]\n&quot;;
            }
            return 0;
        }
    }
    $now ||= time();
    if ( $datastore_file_mtime &gt; $now ) {
        print STDERR &quot;is_cache_valid: rejecting $datastore_file as it is from the future (time warp safety).\n&quot; if $Cpanel::Debug::level;
        return 0;
    }
    elsif ( $min_expire_time &amp;&amp; $datastore_file_mtime &gt; ( $now - $min_expire_time ) ) {
        print STDERR &quot;is_cache_valid: accept $datastore_file (mtime=$datastore_file_mtime) as min_expire_time ($now - $min_expire_time) is older.\n&quot; if $Cpanel::Debug::level;
        return 1;
    }
    elsif ( $mtime &gt; $datastore_file_mtime ) {
        print STDERR &quot;is_cache_valid: rejecting $datastore_file because mtime ($mtime) is newer then datastore mtime ($datastore_file_mtime).\n&quot; if $Cpanel::Debug::level;
        return 0;
    }
    elsif ( $ttl &amp;&amp; ( $datastore_file_mtime + $ttl ) &lt; $now ) {
        print STDERR &quot;is_cache_valid: rejecting $datastore_file as it has reached its time to live.\n&quot; if $Cpanel::Debug::level;
        return 0;
    }

    print STDERR &quot;is_cache_valid: accepting $datastore_file as it passes all tests.\n&quot; if $Cpanel::Debug::level;

    return 1;
}
1;

} # --- END Cpanel/CachedCommand/Valid.pm


{ # --- BEGIN Cpanel/CachedCommand/Save.pm
package Cpanel::CachedCommand::Save;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::CachedCommand::Utils (); # perlpkg line 211
# use Cpanel::FileUtils::Write     (); # perlpkg line 211
# use Cpanel::Debug                (); # perlpkg line 211
# use Cpanel::Exception            (); # perlpkg line 211

use Try::Tiny;

sub _savefile {
    my ( $filename, $content ) = @_;
    return if !defined $content;    #should be able to store 0

    $filename =~ tr{/}{}s;          # collapse //s to /
    my @path = split( /\//, $filename );
    my $file = pop(@path);
    my $dir  = join( &#039;/&#039;, @path );

    my $dir_uid = ( stat($dir) )[4];

    if ( !defined $dir_uid ) {
        Cpanel::Debug::log_warn(&quot;Unable to write datastore file: $filename: target directory: $dir does not exist.&quot;);
        return;

    }
    elsif ( $dir_uid != $&gt; ) {
        Cpanel::Debug::log_warn(&quot;Unable to write datastore file: $filename: target directory: $dir does not match uid $&gt;&quot;);
        return;
    }

    local $!;
    my $ret;
    try {
        $ret = Cpanel::FileUtils::Write::overwrite( $filename, ( ref $content ? $$content : $content ), 0600 );
    }
    catch {
        my $err = $_;

        Cpanel::Debug::log_warn( Cpanel::Exception::get_string($err) );
    };

    return $ret;
}

sub store {
    my %OPTS = @_;
    _savefile( Cpanel::CachedCommand::Utils::_get_datastore_filename( $OPTS{&#039;name&#039;} ), $OPTS{&#039;data&#039;} );
}

1;

} # --- END Cpanel/CachedCommand/Save.pm


{ # --- BEGIN Cpanel/LocaleString.pm
package Cpanel::LocaleString;


use strict;
use warnings;
no warnings &#039;once&#039;;

sub DESTROY { }


sub new {

    if ( !length $_[1] ) {
        die &#039;Must include at least a string!&#039;;
    }

    return bless \@_, shift;
}


sub set_json_to_freeze {
    no warnings &#039;redefine&#039;;
    *TO_JSON = \&amp;_to_list_ref;
    return ( __PACKAGE__ . &#039;::_JSON_MODE&#039; )-&gt;new();
}


sub thaw {

    if ( ref( $_[1] ) ne &#039;ARRAY&#039; ) {
        die &quot;Call thaw() on an ARRAY reference, not “$_[1]”!&quot;;
    }

    return $_[0]-&gt;new( @{ $_[1] }[ 1 .. $#{ $_[1] } ] );
}


sub is_frozen {
    {
        last if ref( $_[1] ) ne &#039;ARRAY&#039;;
        last if !$_[1][0]-&gt;isa( $_[0] );
        last if @{ $_[1] } &lt; 2;

        return 1;
    }

    return 0;
}


sub to_string {
    return _locale()-&gt;makevar( @{ $_[0] } );
}


sub to_en_string {
    return _locale()-&gt;makethis_base( @{ $_[0] } );
}


sub clone_with_args {
    return ( ref $_[0] )-&gt;new(
        $_[0][0],          #the phrase, currently stored in the object
        @_[ 1 .. $#_ ],    #the new args, supplied by the caller
    );
}


sub to_list {

    if ( !wantarray ) {
        require Cpanel::Context;
        Cpanel::Context::must_be_list();
    }

    return @{ $_[0] };
}

*TO_JSON = \&amp;to_string;


my $_locale;

sub _locale {
    return $_locale if $_locale;
    local $@;

    eval &#039;require Cpanel::Locale;&#039; or do {    ## no critic qw(BuiltinFunctions::ProhibitStringyEval)
        warn &quot;Failed to load Cpanel::Locale; falling back to substitute. Error was: $@&quot;;
    };

    eval { $_locale = Cpanel::Locale-&gt;get_handle() };
    return $_locale || bless {}, &#039;Cpanel::LocaleString::_Cpanel_Locale_unavailable&#039;;
}

sub _put_back {
    no warnings &#039;redefine&#039;;
    *TO_JSON = \&amp;to_string;

    return;
}

sub _to_list_ref {
    return [ ref( $_[0] ), @{ $_[0] } ];
}


package Cpanel::LocaleString::_JSON_MODE;


sub new {
    require Cpanel::Finally;    # PPI USE OK - loaded only when needed
    return $_[0]-&gt;SUPER::new( \&amp;Cpanel::LocaleString::_put_back );
}

package Cpanel::LocaleString::_Cpanel_Locale_unavailable;

BEGIN {
    *Cpanel::LocaleString::_Cpanel_Locale_unavailable::makethis_base = *Cpanel::LocaleString::_Cpanel_Locale_unavailable::makevar;
}

sub makevar {
    my ( $self, $str, @maketext_opts ) = @_;

    local ( $@, $! );
    require Cpanel::Locale::Utils::Fallback;

    return Cpanel::Locale::Utils::Fallback::interpolate_variables( $str, @maketext_opts );
}

1;

} # --- END Cpanel/LocaleString.pm


{ # --- BEGIN Cpanel/Errno.pm
package Cpanel::Errno;


use strict;

my %_err_name_cache;

sub get_name_for_errno_number {
    my ($number) = @_;

    if ( !$INC{&#039;Errno.pm&#039;} ) {
        local ( $@, $! );
        require Errno;
    }

    die &#039;need number!&#039; if !length $number;

    if ( !%_err_name_cache ) {

        my $s = scalar keys %Errno::;    # init iterator
        foreach my $k ( sort keys %Errno:: ) {
            if ( Errno-&gt;EXISTS($k) ) {
                my $v = &#039;Errno&#039;-&gt;can($k)-&gt;();
                $_err_name_cache{$v} = $k;
            }
        }
    }

    return $_err_name_cache{$number};
}

1;

} # --- END Cpanel/Errno.pm


{ # --- BEGIN Cpanel/Config/Constants/Perl.pm
package Cpanel::Config::Constants::Perl;


use strict;

our $ABRT   = 6;
our $ALRM   = 14;
our $BUS    = 7;
our $CHLD   = 17;
our $CLD    = 17;
our $CONT   = 18;
our $FPE    = 8;
our $HUP    = 1;
our $ILL    = 4;
our $INT    = 2;
our $IO     = 29;
our $IOT    = 6;
our $KILL   = 9;
our $NUM32  = 32;
our $NUM33  = 33;
our $NUM35  = 35;
our $NUM36  = 36;
our $NUM37  = 37;
our $NUM38  = 38;
our $NUM39  = 39;
our $NUM40  = 40;
our $NUM41  = 41;
our $NUM42  = 42;
our $NUM43  = 43;
our $NUM44  = 44;
our $NUM45  = 45;
our $NUM46  = 46;
our $NUM47  = 47;
our $NUM48  = 48;
our $NUM49  = 49;
our $NUM50  = 50;
our $NUM51  = 51;
our $NUM52  = 52;
our $NUM53  = 53;
our $NUM54  = 54;
our $NUM55  = 55;
our $NUM56  = 56;
our $NUM57  = 57;
our $NUM58  = 58;
our $NUM59  = 59;
our $NUM60  = 60;
our $NUM61  = 61;
our $NUM62  = 62;
our $NUM63  = 63;
our $PIPE   = 13;
our $POLL   = 29;
our $PROF   = 27;
our $PWR    = 30;
our $QUIT   = 3;
our $RTMAX  = 64;
our $RTMIN  = 34;
our $SEGV   = 11;
our $STKFLT = 16;
our $STOP   = 19;
our $SYS    = 31;
our $TERM   = 15;
our $TRAP   = 5;
our $TSTP   = 20;
our $TTIN   = 21;
our $TTOU   = 22;
our $UNUSED = 31;
our $URG    = 23;
our $USR1   = 10;
our $USR2   = 12;
our $VTALRM = 26;
our $WINCH  = 28;
our $XCPU   = 24;
our $XFSZ   = 25;
our $ZERO   = 0;

our %SIGNAL_NAME = qw(
  0    ZERO
  1    HUP
  10    USR1
  11    SEGV
  12    USR2
  13    PIPE
  14    ALRM
  15    TERM
  16    STKFLT
  17    CHLD
  18    CONT
  19    STOP
  2    INT
  20    TSTP
  21    TTIN
  22    TTOU
  23    URG
  24    XCPU
  25    XFSZ
  26    VTALRM
  27    PROF
  28    WINCH
  29    IO
  3    QUIT
  30    PWR
  31    SYS
  32    NUM32
  33    NUM33
  34    RTMIN
  35    NUM35
  36    NUM36
  37    NUM37
  38    NUM38
  39    NUM39
  4    ILL
  40    NUM40
  41    NUM41
  42    NUM42
  43    NUM43
  44    NUM44
  45    NUM45
  46    NUM46
  47    NUM47
  48    NUM48
  49    NUM49
  5    TRAP
  50    NUM50
  51    NUM51
  52    NUM52
  53    NUM53
  54    NUM54
  55    NUM55
  56    NUM56
  57    NUM57
  58    NUM58
  59    NUM59
  6    ABRT
  60    NUM60
  61    NUM61
  62    NUM62
  63    NUM63
  64    RTMAX
  7    BUS
  8    FPE
  9    KILL
);

1;

} # --- END Cpanel/Config/Constants/Perl.pm


{ # --- BEGIN Cpanel/ChildErrorStringifier.pm
package Cpanel::ChildErrorStringifier;


use strict;

# use Cpanel::LocaleString (); # perlpkg line 211
# use Cpanel::Exception    (); # perlpkg line 211


sub new {
    my ( $class, $CHILD_ERROR, $PROGRAM_NAME ) = @_;

    return bless { _CHILD_ERROR =&gt; $CHILD_ERROR, _PROGRAM_NAME =&gt; $PROGRAM_NAME }, $class;
}

sub CHILD_ERROR {
    my ($self) = @_;

    return $self-&gt;{&#039;_CHILD_ERROR&#039;};
}

sub error_code {
    my ($self) = @_;

    return undef if !$self-&gt;CHILD_ERROR();

    return $self-&gt;CHILD_ERROR() &gt;&gt; 8;
}


sub error_name {
    my ($self) = @_;

    my $error_number = $self-&gt;error_code();

    return &#039;&#039; if ( !defined $error_number );    # Can&#039;t index a hash with undef

    require Cpanel::Errno;
    return Cpanel::Errno::get_name_for_errno_number($error_number) || q&lt;&gt;;
}

sub dumped_core {
    my ($self) = @_;

    return $self-&gt;CHILD_ERROR() &amp;&amp; ( $self-&gt;CHILD_ERROR() &amp; 128 ) ? 1 : 0;
}

sub signal_code {
    my ($self) = @_;

    return if !$self-&gt;CHILD_ERROR();

    return $self-&gt;CHILD_ERROR() &amp; 127;
}

sub signal_name {
    my ($self) = @_;
    require Cpanel::Config::Constants::Perl;
    return $Cpanel::Config::Constants::Perl::SIGNAL_NAME{ $self-&gt;signal_code() };
}

sub exec_failed {
    return $_[0]-&gt;{&#039;_exec_failed&#039;} ? 1 : 0;
}

sub program {
    my ($self) = @_;

    return $self-&gt;{&#039;_PROGRAM_NAME&#039;} || undef;
}

sub set_program {
    my ( $self, $program ) = @_;

    return ( $self-&gt;{&#039;_PROGRAM_NAME&#039;} = $program );
}

sub autopsy {
    my ($self) = @_;

    return undef if !$self-&gt;CHILD_ERROR();

    my @localized_strings = (
        $self-&gt;error_code() ? $self-&gt;_ERROR_PHRASE() : $self-&gt;_SIGNAL_PHRASE(),
        $self-&gt;_core_dump_for_phrase_if_needed(),
        $self-&gt;_additional_phrases_for_autopsy(),
    );

    return join &#039; &#039;, map { $_-&gt;to_string() } @localized_strings;
}

sub terse_autopsy {
    my ($self) = @_;

    my $str;

    if ( $self-&gt;signal_code() ) {
        $str .= &#039;SIG&#039; . $self-&gt;signal_name() . &quot; (#&quot; . $self-&gt;signal_code() . &quot;)&quot;;
    }
    elsif ( my $code = $self-&gt;error_code() ) {
        $str .= &quot;exit $code&quot;;
    }
    else {
        $str = &#039;OK&#039;;
    }

    if ( $self-&gt;dumped_core() ) {
        $str .= &#039; (+core)&#039;;
    }

    return $str;
}

sub die_if_error {
    my ($self) = @_;

    my $err = $self-&gt;to_exception();
    die $err if $err;

    return $self;
}

sub to_exception {
    my ($self) = @_;

    if ( $self-&gt;signal_code() ) {
        return Cpanel::Exception::create(
            &#039;ProcessFailed::Signal&#039;,
            [
                process_name =&gt; $self-&gt;program(),
                signal_code  =&gt; $self-&gt;signal_code(),
                $self-&gt;_extra_error_args_for_die_if_error(),
            ],
        );
    }

    if ( $self-&gt;error_code() ) {
        return Cpanel::Exception::create(
            &#039;ProcessFailed::Error&#039;,
            [
                process_name =&gt; $self-&gt;program(),
                error_code   =&gt; $self-&gt;error_code(),
                $self-&gt;_extra_error_args_for_die_if_error(),
            ],
        );
    }

    return undef;
}

sub _extra_error_args_for_die_if_error { }

sub _additional_phrases_for_autopsy { }

sub _core_dump_for_phrase_if_needed {
    my ($self) = @_;

    if ( $self-&gt;dumped_core() ) {
        return Cpanel::LocaleString-&gt;new(&#039;The process dumped a core file.&#039;);
    }

    return;
}


sub _ERROR_PHRASE {
    my ($self) = @_;

    if ( $self-&gt;program() ) {
        return Cpanel::LocaleString-&gt;new( &#039;The subprocess “[_1]” reported error number [numf,_2] when it ended.&#039;, $self-&gt;program(), $self-&gt;error_code() );
    }

    return Cpanel::LocaleString-&gt;new( &#039;The subprocess reported error number [numf,_1] when it ended.&#039;, $self-&gt;error_code() );
}

sub _SIGNAL_PHRASE {
    my ($self) = @_;

    if ( $self-&gt;program() ) {
        return Cpanel::LocaleString-&gt;new( &#039;The subprocess “[_1]” ended prematurely because it received the “[_2]” ([_3]) signal.&#039;, $self-&gt;program(), $self-&gt;signal_name(), $self-&gt;signal_code() );
    }

    return Cpanel::LocaleString-&gt;new( &#039;The subprocess ended prematurely because it received the “[_1]” ([_2]) signal.&#039;, $self-&gt;signal_name(), $self-&gt;signal_code() );
}


1;

} # --- END Cpanel/ChildErrorStringifier.pm


{ # --- BEGIN Cpanel/Env.pm
package Cpanel::Env;


use strict;
use warnings;
no warnings &#039;once&#039;;

our $VERSION = &#039;1.7&#039;;

my $SAFE_ENV_VARS;

BEGIN {
    $SAFE_ENV_VARS = q&lt;
        ALLUSERSPROFILE
        APPDATA
        BUNDLE_PATH
        CLIENTNAME
        COMMONPROGRAMFILES
        COMPUTERNAME
        COMSPEC
        CPANEL_BASE_INSTALL
        CPANEL_IS_CRON
        CPANEL_RPM_LOCKED_IN_PARENT
        CPBACKUP
        DEBIAN_FRONTEND
        DEBIAN_PRIORITY
        DOCUMENT_ROOT
        FORCEDCPUPDATE
        FP_NO_HOST_CHECK
        HOMEDRIVE
        HOMEPATH
        LANG
        LANGUAGE
        LC_ALL
        LC_MESSAGES
        LC_CTYPE
        LOGONSERVER
        NEWWHMUPDATE
        NOTIFY_SOCKET
        NUMBER_OF_PROCESSORS
        OPENSSL_NO_DEFAULT_ZLIB
        OS
        PATH
        PATHEXT
        PROCESSOR_ARCHITECTURE
        PROCESSOR_IDENTIFIER
        PROCESSOR_LEVEL
        PROCESSOR_REVISION
        PROGRAMFILES
        PROMPT
        PYTHONIOENCODING
        SERVER_SOFTWARE
        SESSIONNAME
        SKIP_DEFERRAL_CHECK
        SSH_CLIENT
        SYSTEMDRIVE
        SYSTEMROOT
        TEMP
        TERM
        TMP
        UPDATENOW_NO_RETRY
        UPDATENOW_PRESERVE_FAILED_FILES
        USERDOMAIN
        USERNAME
        USERPROFILE
        WINDIR
    &gt;;

    $SAFE_ENV_VARS =~ tr&lt;\n &gt;&lt; &gt;s;
    $SAFE_ENV_VARS =~ s&lt;\A\s+&gt;&lt;&gt;;
}


{
    no warnings &#039;once&#039;;
    *cleanenv = *clean_env;
}

sub clean_env {
    my %OPTS = @_;

    my %SAFE_ENV_VARS = map { $_ =&gt; undef } split( m{ }, $SAFE_ENV_VARS );

    if ( defined $OPTS{&#039;keep&#039;} &amp;&amp; ref $OPTS{&#039;keep&#039;} eq &#039;ARRAY&#039; ) {
        @SAFE_ENV_VARS{ @{ $OPTS{&#039;keep&#039;} } } = undef;
    }

    if ( defined $OPTS{&#039;delete&#039;} &amp;&amp; ref $OPTS{&#039;delete&#039;} eq &#039;ARRAY&#039; ) {
        delete @SAFE_ENV_VARS{ @{ $OPTS{&#039;delete&#039;} } };
    }

    delete @ENV{ grep { !exists $SAFE_ENV_VARS{$_} } keys %ENV };
    if ( $OPTS{&#039;http_purge&#039;} ) {
        delete @ENV{ &#039;SERVER_SOFTWARE&#039;, &#039;DOCUMENT_ROOT&#039; };
    }

    return;
}

sub get_safe_env_vars {
    return $SAFE_ENV_VARS;
}

sub get_safe_path {
    return &#039;/usr/local/jdk/bin:/usr/kerberos/sbin:/usr/kerberos/bin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/X11R6/bin:/usr/local/bin:/usr/X11R6/bin:/root/bin:/opt/bin&#039;;
}

sub set_safe_path {
    return ( $ENV{&#039;PATH&#039;} = get_safe_path() );
}

1;

} # --- END Cpanel/Env.pm


{ # --- BEGIN Cpanel/FHUtils/Autoflush.pm
package Cpanel::FHUtils::Autoflush;


use strict;
use warnings;
no warnings &#039;once&#039;;

sub enable {
    select( ( select( $_[0] ), $| = 1 )[0] );    ## no critic qw(InputOutput::ProhibitOneArgSelect Variables::RequireLocalizedPunctuationVars) - aka $socket-&gt;autoflush(1) without importing IO::Socket

    return;
}

1;

} # --- END Cpanel/FHUtils/Autoflush.pm


{ # --- BEGIN Cpanel/FHUtils/OS.pm
package Cpanel::FHUtils::OS;


use strict;
use warnings;
no warnings &#039;once&#039;;


my $fileno;

sub is_os_filehandle {
    local $@;
    $fileno = eval { fileno $_[0] };
    return ( defined $fileno ) &amp;&amp; ( $fileno != -1 );
}

1;

} # --- END Cpanel/FHUtils/OS.pm


{ # --- BEGIN Cpanel/FHUtils/Blocking.pm
package Cpanel::FHUtils::Blocking;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Fcntl::Constants (); # perlpkg line 211
# use Cpanel::Autodie          qw(fcntl); # perlpkg line 248
INIT { Cpanel::Autodie-&gt;import(qw{fcntl}); }

sub set_non_blocking {
    return Cpanel::Autodie::fcntl( $_[0], $Cpanel::Fcntl::Constants::F_SETFL, _get_fl_flags( $_[0] ) | $Cpanel::Fcntl::Constants::O_NONBLOCK ) &amp;&amp; 1;
}

sub set_blocking {
    return Cpanel::Autodie::fcntl( $_[0], $Cpanel::Fcntl::Constants::F_SETFL, _get_fl_flags( $_[0] ) &amp; ~$Cpanel::Fcntl::Constants::O_NONBLOCK ) &amp;&amp; 1;
}

sub is_set_to_block {
    return !( _get_fl_flags( $_[0] ) &amp; $Cpanel::Fcntl::Constants::O_NONBLOCK ) ? 1 : 0;
}

sub _get_fl_flags {

    return int Cpanel::Autodie::fcntl( $_[0], $Cpanel::Fcntl::Constants::F_GETFL, 0 );
}

1;

} # --- END Cpanel/FHUtils/Blocking.pm


{ # --- BEGIN Cpanel/IO/Flush.pm
package Cpanel::IO::Flush;


use strict;
use warnings;
no warnings &#039;once&#039;;


use constant {
    _EAGAIN =&gt; 11,
    _EINTR  =&gt; 4,
};

# use Cpanel::Exception (); # perlpkg line 211
use IO::SigGuard      ();


sub write_all {    ##no critic qw( RequireArgUnpacking )
    my ( $fh, $timeout ) = @_;    # $_[2] = payload

    local ( $!, $^E );

    my $offset = 0;

    {
        my $this_time = IO::SigGuard::syswrite( $fh, $_[2], length( $_[2] ), $offset );
        if ($this_time) {
            $offset += $this_time;
        }
        elsif ( $! == _EAGAIN() ) {
            _wait_until_ready( $fh, $timeout );
        }
        else {
            die Cpanel::Exception::create( &#039;IO::WriteError&#039;, [ error =&gt; $!, length =&gt; length( $_[2] ) - $offset ] );
        }

        redo if $offset &lt; length( $_[2] );
    }

    return;
}

sub _wait_until_ready {
    my ( $fh, $timeout ) = @_;

    my $win;
    vec( $win, fileno($fh), 1 ) = 1;

    my $ready = select( undef, my $wout = $win, undef, $timeout );

    if ( $ready == -1 ) {
        redo if $! == _EINTR();
        die Cpanel::Exception::create( &#039;IO::SelectError&#039;, [ error =&gt; $! ] );
    }
    elsif ( !$ready ) {

        die Cpanel::Exception::create_raw( &#039;Timeout&#039;, &#039;write timeout!&#039; );
    }

    return;
}

1;

} # --- END Cpanel/IO/Flush.pm


{ # --- BEGIN Cpanel/ReadMultipleFH.pm
package Cpanel::ReadMultipleFH;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::FHUtils::Blocking  (); # perlpkg line 211
# use Cpanel::FHUtils::OS        (); # perlpkg line 211
# use Cpanel::IO::Flush          (); # perlpkg line 211
# use Cpanel::LoadFile::ReadFast (); # perlpkg line 211

my $CHUNK_SIZE = 2 &lt;&lt; 16;

my $DEFAULT_TIMEOUT      = 600;    #10 minutes
my $DEFAULT_READ_TIMEOUT = 0;

sub new {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my ( $class, %opts ) = @_;

    my %fh_buffer;
    my %output;

    my @fhs = @{ $opts{&#039;filehandles&#039;} };

    my $read_input  = &#039;&#039;;
    my $read_output = &#039;&#039;;
    my %fhmap;

    my %is_os_filehandle;

    for my $fh_buf_ar (@fhs) {
        if ( UNIVERSAL::isa( $fh_buf_ar, &#039;GLOB&#039; ) ) {
            $fh_buf_ar = [$fh_buf_ar];
        }
        elsif ( !UNIVERSAL::isa( $fh_buf_ar, &#039;ARRAY&#039; ) ) {
            die &#039;items in “filehandles” must be either a filehandle or ARRAY&#039;;
        }

        my $fh = $fh_buf_ar-&gt;[0];

        Cpanel::FHUtils::Blocking::set_non_blocking($fh);

        $fhmap{ fileno($fh) } = $fh;
        vec( $read_input, fileno($fh), 1 ) = 1;

        if ( defined $fh_buf_ar-&gt;[1] &amp;&amp; UNIVERSAL::isa( $fh_buf_ar-&gt;[1], &#039;SCALAR&#039; ) ) {
            $fh_buffer{$fh} = $fh_buf_ar-&gt;[1];
        }
        else {
            my $buf = q{};
            $fh_buffer{$fh} = \$buf;

            if ( defined $fh_buf_ar-&gt;[1] &amp;&amp; UNIVERSAL::isa( $fh_buf_ar-&gt;[1], &#039;GLOB&#039; ) ) {
                $output{$fh} = $fh_buf_ar-&gt;[1];

                $is_os_filehandle{$fh} = Cpanel::FHUtils::OS::is_os_filehandle( $fh_buf_ar-&gt;[1] );
            }
            elsif ( defined $fh_buf_ar-&gt;[1] ) {
                die &#039;2nd value in “filehandles” array member must be undef, SCALAR, or GLOB!&#039;;
            }
        }
    }

    my $finished;

    my $self = {
        _fh_buffer =&gt; \%fh_buffer,
        _finished  =&gt; 0,
    };

    bless $self, $class;

    my ( $nfound, $select_time_left, $select_timeout );

    my $overall_timeout = defined $opts{&#039;timeout&#039;}      ? $opts{&#039;timeout&#039;}      : $DEFAULT_TIMEOUT;
    my $read_timeout    = defined $opts{&#039;read_timeout&#039;} ? $opts{&#039;read_timeout&#039;} : $DEFAULT_READ_TIMEOUT;

    my $has_overall_timeout = $overall_timeout ? 1 : 0;

    my $overall_time_left = $overall_timeout || undef;

  READ_LOOP:
    while (
        !$finished &amp;&amp;                                          # has not finished
        ( !$has_overall_timeout || $overall_time_left &gt; 0 )    # has not reached overall timeout
    ) {
        $select_timeout = _get_shortest_timeout( $overall_time_left, $read_timeout );

        ( $nfound, $select_time_left ) = select( $read_output = $read_input, undef, undef, $select_timeout );

        if ( !$nfound ) {

            $self-&gt;{&#039;_timed_out&#039;} = ( $select_timeout == $read_timeout ) ? $read_timeout : $overall_timeout;
            last;
        }
        elsif ( $nfound != -1 ) {    # case 47309: If we get -1 it probably means we got interrupted by a signal
            for my $fileno ( grep { vec( $read_output, $_, 1 ) } keys %fhmap ) {
                my $fh = $fhmap{$fileno};

                Cpanel::LoadFile::ReadFast::read_fast( $fh, ${ $fh_buffer{$fh} }, $CHUNK_SIZE, length ${ $fh_buffer{$fh} } ) or do {
                    delete $fhmap{$fileno};

                    $finished = !( scalar keys %fhmap );

                    last READ_LOOP if $finished;

                    vec( $read_input, $fileno, 1 ) = 0;

                    next;
                };

                if ( $output{$fh} ) {
                    my $payload_sr = \substr( ${ $fh_buffer{$fh} }, 0, length ${ $fh_buffer{$fh} }, q&lt;&gt; );

                    if ( $is_os_filehandle{$fh} ) {

                        Cpanel::IO::Flush::write_all( $output{$fh}, $read_timeout, $$payload_sr );
                    }
                    else {

                        print { $output{$fh} } $$payload_sr;
                    }
                }
            }
        }

        $overall_time_left -= ( $select_timeout - $select_time_left ) if $has_overall_timeout;
    }

    delete $fh_buffer{$_} for keys %output;

    %fhmap = ();

    $self-&gt;{&#039;_finished&#039;} = $finished;
    if ( !$finished &amp;&amp; defined $overall_time_left &amp;&amp; $overall_time_left &lt;= 0 ) {

        $self-&gt;{&#039;_timed_out&#039;} = $overall_timeout;
    }

    return $self;
}

sub _get_shortest_timeout {
    my ( $overall_time_left, $read_timeout ) = @_;

    return undef if ( !$overall_time_left &amp;&amp; !$read_timeout );

    return $read_timeout if !defined $overall_time_left;

    return ( !$read_timeout || $overall_time_left &lt;= $read_timeout )
      ?

      $overall_time_left
      :

      $read_timeout;
}

sub get_buffer {
    return $_[0]-&gt;{&#039;_fh_buffer&#039;}{ $_[1] };
}

sub did_finish {
    return $_[0]-&gt;{&#039;_finished&#039;} ? 1 : 0;
}

sub timed_out {
    return defined $_[0]-&gt;{&#039;_timed_out&#039;} ? $_[0]-&gt;{&#039;_timed_out&#039;} : 0;
}

1;

} # --- END Cpanel/ReadMultipleFH.pm


{ # --- BEGIN Cpanel/ForkAsync.pm
package Cpanel::ForkAsync;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Exception (); # perlpkg line 211

my $DEFAULT_ERROR_CODE = 127;    #EKEYEXPIRED

our $quiet   = 0;
our $no_warn = 0;


sub do_in_child {
    my ( $code, @args ) = @_;

    local ( $!, $^E );
    my $pid = fork();

    die Cpanel::Exception::create( &#039;IO::ForkError&#039;, [ error =&gt; $! ] ) if !defined $pid;

    if ( !$pid ) {
        local $@;

        if ( !eval { $code-&gt;(@args); 1 } ) {
            my $err    = $@;
            my $io_err = 0 + $!;
            _print($err) unless $quiet;
            exit( $io_err || $DEFAULT_ERROR_CODE );
        }

        exit 0;
    }

    return $pid;
}


sub do_in_child_quiet {
    my ( $code, @args ) = @_;
    local $quiet = 1;
    return do_in_child( $code, @args );
}


sub _print {
    my ($msg) = @_;

    warn $msg unless $no_warn;
    print STDERR $msg;

    return;
}

1;

} # --- END Cpanel/ForkAsync.pm


{ # --- BEGIN Cpanel/SafeRun/Object.pm
package Cpanel::SafeRun::Object;


use cPstrict;
no warnings &#039;once&#039;;

# use parent Cpanel::ChildErrorStringifier (); # perlpkg line 238
our @ISA;
BEGIN { push @ISA, qw(Cpanel::ChildErrorStringifier); }

BEGIN {
    eval { require Proc::FastSpawn; };
}

use IO::SigGuard ();

# use Cpanel::Env                (); # perlpkg line 211
# use Cpanel::Exception          (); # perlpkg line 211
# use Cpanel::FHUtils::Autoflush (); # perlpkg line 211
# use Cpanel::FHUtils::OS        (); # perlpkg line 211
# use Cpanel::ReadMultipleFH     (); # perlpkg line 211
# use Cpanel::LoadModule         (); # perlpkg line 211
# use Cpanel::LocaleString       (); # perlpkg line 211

use constant _ENOENT =&gt; 2;

my $CHUNK_SIZE = 2 &lt;&lt; 16;

my $DEFAULT_TIMEOUT      = 3600;    # 1 hour
my $DEFAULT_READ_TIMEOUT = 0;

our $SAFEKILL_TIMEOUT = 1;


my @_allowed_env_vars_cache;

sub new {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my ( $class, %OPTS ) = @_;

    die &quot;No “program”!&quot; if !length $OPTS{&#039;program&#039;};

    if ( !defined $OPTS{&#039;timeout&#039;} ) {
        $OPTS{&#039;timeout&#039;} = $DEFAULT_TIMEOUT;
    }

    if ( !defined $OPTS{&#039;read_timeout&#039;} ) {
        $OPTS{&#039;read_timeout&#039;} = $DEFAULT_READ_TIMEOUT;
    }

    if ( $OPTS{&#039;program&#039;} =~ tr{&gt;&lt;*?[]`$()|;&amp;#$\\\r\n\t }{} &amp;&amp; !-e $OPTS{&#039;program&#039;} ) {
        die Cpanel::Exception::create( &#039;InvalidParameter&#039;, &#039;A value of “[_1]” is invalid for “[_2]” as it does not permit the following characters: “[_3]”&#039;, [ $OPTS{&#039;program&#039;}, &#039;program&#039;, &#039;&gt;&lt;*?[]`$()|;&amp;#$\\\\\r\\n\\t&#039; ] );
    }

    my $args_ar = $OPTS{&#039;args&#039;} || [];
    die &quot;“args” must be an arrayref&quot; if defined $args_ar &amp;&amp; ref $args_ar ne &#039;ARRAY&#039;;

    die Cpanel::Exception::create( &#039;InvalidParameter&#039;, &#039;The “[_1]” argument is invalid.&#039;, [&#039;logger&#039;] ) if $OPTS{&#039;logger&#039;};

    die &quot;Undefined value given as argument! (@$args_ar)&quot; if grep { !defined } @$args_ar;

    my $pump_stdin_filehandle_into_child;

    my ( %parent_read_fh, %child_write_fh );

    my $merge_output_yn = $OPTS{&#039;stdout&#039;} &amp;&amp; $OPTS{&#039;stderr&#039;} &amp;&amp; ( $OPTS{&#039;stdout&#039;} eq $OPTS{&#039;stderr&#039;} );

    local $!;

    for my $handle_name (qw(stdout stderr)) {
        my $custom_fh = $OPTS{$handle_name} &amp;&amp; UNIVERSAL::isa( $OPTS{$handle_name}, &#039;GLOB&#039; ) &amp;&amp; $OPTS{$handle_name};

        my $dupe_filehandle_will_work = $custom_fh &amp;&amp; !tied(*$custom_fh) &amp;&amp; ( fileno($custom_fh) &gt; -1 );

        if ( !$custom_fh &amp;&amp; $OPTS{$handle_name} ) {
            die &quot;“$handle_name” must be a filehandle or undef, not $OPTS{$handle_name}&quot;;
        }

        if ($dupe_filehandle_will_work) {

            if ( fileno($custom_fh) &lt; 3 ) {
                open my $copy, &#039;&gt;&amp;&#039;, $custom_fh or die &quot;dup($handle_name): $!&quot;;
                $child_write_fh{$handle_name} = $copy;
            }
            else {
                $child_write_fh{$handle_name} = $custom_fh;
            }
        }

        elsif ( $merge_output_yn &amp;&amp; $handle_name eq &#039;stderr&#039; ) {
            $parent_read_fh{&#039;stderr&#039;} = $parent_read_fh{&#039;stdout&#039;};
            $child_write_fh{&#039;stderr&#039;} = $child_write_fh{&#039;stdout&#039;};
        }

        else {
            pipe $parent_read_fh{$handle_name}, $child_write_fh{$handle_name}    #
              or die &quot;pipe() failed: $!&quot;;
        }
    }

    my ( $child_reads, $parent_writes );
    my $close_child_reads = 0;

    if ( !defined $OPTS{&#039;stdin&#039;} || !length $OPTS{&#039;stdin&#039;} ) {
        open $child_reads, &#039;&lt;&#039;, &#039;/dev/null&#039; or die &quot;open(&lt;, /dev/null) failed: $!&quot;;
        $close_child_reads = 1;
    }
    elsif ( UNIVERSAL::isa( $OPTS{&#039;stdin&#039;}, &#039;GLOB&#039; ) ) {
        my $fileno = fileno $OPTS{&#039;stdin&#039;};

        if ( !defined $fileno || $fileno == -1 ) {
            $pump_stdin_filehandle_into_child = 1;
        }
        else {
            $child_reads = $OPTS{&#039;stdin&#039;};
        }
    }

    if ( !$child_reads ) {
        $close_child_reads = 1;
        pipe( $child_reads, $parent_writes ) or die &quot;pipe() failed: $!&quot;;
    }

    my $self = bless {
        _program =&gt; $OPTS{&#039;program&#039;},
        _args    =&gt; $OPTS{&#039;args&#039;} || [],
    }, $class;

    local $SIG{&#039;CHLD&#039;} = &#039;DEFAULT&#039;;

    my $exec_failed_message = &quot;exec($OPTS{&#039;program&#039;}) failed:&quot;;
    my $used_fastspawn      = 0;
    if (
        $INC{&#039;Proc/FastSpawn.pm&#039;}                                   # may not be available yet due to upcp.static or updatenow.static
        &amp;&amp; !$OPTS{&#039;before_exec&#039;}
        &amp;&amp; !$Cpanel::AccessIds::ReducedPrivileges::PRIVS_REDUCED    # PPI NO PARSE - We not ever be set if its not loaded
    ) {
        $used_fastspawn = 1;
        my @env;

        if ( !$OPTS{&#039;keep_env&#039;} ) {
            if ( !@_allowed_env_vars_cache ) {
                @_allowed_env_vars_cache = ( split( m{ }, Cpanel::Env::get_safe_env_vars() ) );
            }
            @env = map { exists $ENV{$_} ? ( $_ . &#039;=&#039; . ( $ENV{$_} // &#039;&#039; ) ) : () } @_allowed_env_vars_cache;
        }
        my $user    = $OPTS{&#039;user&#039;};
        my $homedir = $OPTS{&#039;homedir&#039;};
        if ( !$user || !$homedir ) {
            my ( $pw_user, $pw_homedir ) = ( getpwuid $&gt; )[ 0, 7 ];
            $user    ||= $pw_user;
            $homedir ||= $pw_homedir;
        }
        die &quot;Invalid EUID: $&gt;&quot; if !$user || !$homedir;

        push @env, &quot;HOME=$homedir&quot;,    &quot;USER=$user&quot;;                                  # need to always be set since we start clean and don&#039;t have before_exec
        push @env, &quot;TMP=$homedir/tmp&quot;, &quot;TEMP=$homedir/tmp&quot; if !defined $ENV{&#039;TMP&#039;};

        $self-&gt;{&#039;_child_pid&#039;} = Proc::FastSpawn::spawn_open3(
            fileno($child_reads),                                                            # stdin
            defined $child_write_fh{&#039;stdout&#039;} ? fileno( $child_write_fh{&#039;stdout&#039;} ) : -1,    # stdout
            defined $child_write_fh{&#039;stderr&#039;} ? fileno( $child_write_fh{&#039;stderr&#039;} ) : -1,    # stderr
            $OPTS{&#039;program&#039;},                                                                # program
            [ $OPTS{&#039;program&#039;}, @$args_ar ],                                                 # args
            $OPTS{&#039;keep_env&#039;} ? () : \@env                                                   # env
        );

        if ( !$self-&gt;{_child_pid} ) {
            $self-&gt;{&#039;_CHILD_ERROR&#039;} = $! &lt;&lt; 8;
            $self-&gt;{&#039;_exec_failed&#039;} = 1;
            ${ $self-&gt;{&#039;_stdout&#039;} } = &#039;&#039;;
            ${ $self-&gt;{&#039;_stderr&#039;} } .= &quot;$exec_failed_message $!&quot;;
        }
    }
    else {
        require Cpanel::ForkAsync;
        $self-&gt;{&#039;_child_pid&#039;} = Cpanel::ForkAsync::do_in_child(
            sub {
                $SIG{&#039;__DIE__&#039;} = &#039;DEFAULT&#039;;    ## no critic qw(Variables::RequireLocalizedPunctuationVars) -- will never be unset

                if ( $parent_read_fh{&#039;stdout&#039;} ) {
                    close $parent_read_fh{&#039;stdout&#039;} or die &quot;child close parent stdout failed: $!&quot;;
                }

                if ( $parent_read_fh{&#039;stderr&#039;} &amp;&amp; !$merge_output_yn ) {
                    close $parent_read_fh{&#039;stderr&#039;} or die &quot;child close parent stderr failed: $!&quot;;
                }

                if ($parent_writes) {
                    close $parent_writes or die &quot;close() failed: $!&quot;;
                }

                open( *STDIN, &#039;&lt;&amp;=&#039; . fileno $child_reads ) or die &quot;open(STDIN) failed: $!&quot;;    ##no critic qw(ProhibitTwoArgOpen)

                my $fileno_stdout = fileno \*STDOUT;
                if ( $fileno_stdout != fileno( $child_write_fh{&#039;stdout&#039;} ) ) {

                    if ( $fileno_stdout != 1 ) {
                        close *STDOUT            or die &quot;close(STDOUT) failed: $!&quot;;
                        open( *STDOUT, &#039;&gt;&gt;&amp;=1&#039; ) or die &quot;open(STDOUT, &#039;&gt;&gt;&amp;=1&#039;) failed: $!&quot;;    ##no critic qw(ProhibitTwoArgOpen)
                    }

                    open( *STDOUT, &#039;&gt;&gt;&amp;=&#039; . fileno $child_write_fh{&#039;stdout&#039;} ) or die &quot;open(STDOUT) failed: $!&quot;;    ##no critic qw(ProhibitTwoArgOpen)
                }

                my $fileno_stderr = fileno \*STDERR;
                if ( $fileno_stderr != fileno( $child_write_fh{&#039;stderr&#039;} ) ) {

                    if ( $fileno_stderr != 2 ) {
                        close *STDERR            or die &quot;close(STDOUT) failed: $!&quot;;
                        open( *STDERR, &#039;&gt;&gt;&amp;=2&#039; ) or die &quot;open(STDERR, &#039;&gt;&gt;&amp;=2&#039;) failed: $!&quot;;    ##no critic qw(ProhibitTwoArgOpen)
                    }

                    open( *STDERR, &#039;&gt;&gt;&amp;=&#039; . fileno $child_write_fh{&#039;stderr&#039;} ) or die &quot;open(STDERR) failed: $!&quot;;    ##no critic qw(ProhibitTwoArgOpen)
                }

                if ( !$OPTS{&#039;keep_env&#039;} ) {
                    Cpanel::Env::clean_env();
                }

                if ($Cpanel::AccessIds::ReducedPrivileges::PRIVS_REDUCED) {    # PPI NO PARSE --  can&#039;t be reduced if the module isn&#039;t loaded
                    my $target_euid = &quot;$&gt;&quot;;
                    my $target_egid = ( split( m{ }, &quot;$)&quot; ) )[0];
                    Cpanel::AccessIds::ReducedPrivileges::_restore_privileges( 0, 0 );    # PPI NO PARSE -- we will never get here if ReducedPrivileges wasn&#039;t loaded
                    Cpanel::LoadModule::load_perl_module(&#039;Cpanel::Sys::Setsid::Fast&#039;) if !$INC{&#039;Cpanel/Sys/Setsid/Fast.pm&#039;};
                    Cpanel::Sys::Setsid::Fast::fast_setsid();
                    Cpanel::LoadModule::load_perl_module(&#039;Cpanel::AccessIds::SetUids&#039;) if !$INC{&#039;Cpanel/AccessIds/SetUids.pm&#039;};
                    Cpanel::AccessIds::SetUids::setuids( $target_euid, $target_egid );
                }

                if ( $OPTS{&#039;before_exec&#039;} ) {
                    $OPTS{&#039;before_exec&#039;}-&gt;();
                }

                my $user    = $OPTS{&#039;user&#039;};
                my $homedir = $OPTS{&#039;homedir&#039;};
                if ( !$user || !$homedir ) {
                    Cpanel::LoadModule::load_perl_module(&#039;Cpanel::PwCache&#039;) if !$INC{&#039;Cpanel/PwCache.pm&#039;};
                    my ( $pw_user, $pw_homedir ) = ( Cpanel::PwCache::getpwuid_noshadow($&gt;) )[ 0, 7 ];
                    $user    ||= $pw_user;
                    $homedir ||= $pw_homedir;
                }
                die &quot;Invalid EUID: $&gt;&quot; if !$user || !$homedir;

                $ENV{&#039;HOME&#039;} = $homedir       if !defined $ENV{&#039;HOME&#039;};    # always cleared by clean_env, but may be reset in before_exec
                $ENV{&#039;USER&#039;} = $user          if !defined $ENV{&#039;USER&#039;};    # always cleared by clean_env, but may be reset in before_exec
                $ENV{&#039;TMP&#039;}  = &quot;$homedir/tmp&quot; if !defined $ENV{&#039;TMP&#039;};
                $ENV{&#039;TEMP&#039;} = &quot;$homedir/tmp&quot; if !defined $ENV{&#039;TEMP&#039;};

                exec( $OPTS{&#039;program&#039;}, @$args_ar ) or die &quot;$exec_failed_message $!&quot;;
            }
        );
    }

    if ( $OPTS{&#039;after_fork&#039;} ) {
        $OPTS{&#039;after_fork&#039;}-&gt;( $self-&gt;{&#039;_child_pid&#039;} );
    }

    if ($close_child_reads) {    #only close it if we opened it
        close $child_reads or die &quot;close() failed: $!&quot;;
    }

    if ( $parent_read_fh{&#039;stdout&#039;} ) {
        close $child_write_fh{&#039;stdout&#039;} or die &quot;close() failed: $!&quot;;
    }

    if ( !$merge_output_yn &amp;&amp; $parent_read_fh{&#039;stderr&#039;} ) {
        close $child_write_fh{&#039;stderr&#039;} or die &quot;close() failed: $!&quot;;
    }

    if ($parent_writes) {
        if ( ref $OPTS{&#039;stdin&#039;} eq &#039;CODE&#039; ) {

            $OPTS{&#039;stdin&#039;}-&gt;($parent_writes);
        }
        else {

            local $SIG{&#039;PIPE&#039;} = &#039;IGNORE&#039;;
            Cpanel::FHUtils::Autoflush::enable($parent_writes);

            if ($pump_stdin_filehandle_into_child) {
                my $buffer;

                my $is_os_stdin = Cpanel::FHUtils::OS::is_os_filehandle( $OPTS{&#039;stdin&#039;} );

                local $!;

                if ($is_os_stdin) {
                    while ( IO::SigGuard::sysread( $OPTS{&#039;stdin&#039;}, $buffer, $CHUNK_SIZE ) ) {
                        $self-&gt;_write_buffer_to_fh( $buffer, $parent_writes );
                    }
                }
                else {
                    while ( read $OPTS{&#039;stdin&#039;}, $buffer, $CHUNK_SIZE ) {
                        $self-&gt;_write_buffer_to_fh( $buffer, $parent_writes );
                    }
                }

                if ($!) {
                    die Cpanel::Exception::create( &#039;IO::ReadError&#039;, &#039;The system failed to read up to [format_bytes,_1] from the filehandle that contains standard input for the process that is running the command “[_2]”. This failure happened because of an error: [_3]&#039;, [ $CHUNK_SIZE, &quot;$OPTS{&#039;program&#039;} @$args_ar&quot;, &quot;$!&quot; ] );
                }
            }
            else {
                my $to_print_r = ( ref $OPTS{&#039;stdin&#039;} eq &#039;SCALAR&#039; ) ? $OPTS{&#039;stdin&#039;} : \$OPTS{&#039;stdin&#039;};

                if ( length $$to_print_r ) {
                    $self-&gt;_write_buffer_to_fh( $$to_print_r, $parent_writes );
                }
            }
        }

        close $parent_writes or warn &quot;close() failed: $!&quot;;
    }

    my $reader;
    my $err_obj;

    my @filehandles = map { $parent_read_fh{$_} ? [ $parent_read_fh{$_}, $OPTS{$_} ] : () } qw( stdout stderr );

    if (@filehandles) {
        local $@;
        eval {
            $reader = Cpanel::ReadMultipleFH-&gt;new(
                filehandles  =&gt; \@filehandles,
                timeout      =&gt; $OPTS{&#039;timeout&#039;},
                read_timeout =&gt; $OPTS{&#039;read_timeout&#039;},
            );
        };
        $err_obj = $@;
    }

    if ( $parent_read_fh{&#039;stdout&#039;} ) {
        close $parent_read_fh{&#039;stdout&#039;} or warn &quot;parent close(stdout) failed: $!&quot;;
    }

    if ( $parent_read_fh{&#039;stderr&#039;} &amp;&amp; !$merge_output_yn ) {
        close $parent_read_fh{&#039;stderr&#039;} or warn &quot;parent close(stderr) failed: $!&quot;;
    }

    if ($err_obj) {
        $self-&gt;{&#039;_CHILD_ERROR&#039;} = $self-&gt;_safe_kill_child();
        die $err_obj;
    }
    elsif ($reader) {
        if ( !$reader-&gt;did_finish() ) {
            $self-&gt;{&#039;_timed_out_after&#039;} = $reader-&gt;timed_out();
            $self-&gt;{&#039;_CHILD_ERROR&#039;}     = $self-&gt;_safe_kill_child();
        }

        $self-&gt;{&quot;_stdout&quot;} = $parent_read_fh{stdout} &amp;&amp; $reader-&gt;get_buffer( $parent_read_fh{stdout} );

        if ( !$self-&gt;{&quot;_stderr&quot;} ) {
            $self-&gt;{&quot;_stderr&quot;} = $parent_read_fh{stderr} &amp;&amp; $reader-&gt;get_buffer( $parent_read_fh{stderr} );
        }
    }

    if ( !defined $self-&gt;{&#039;_CHILD_ERROR&#039;} ) {

        local $?;

        waitpid( $self-&gt;{&#039;_child_pid&#039;}, 0 ) if defined $self-&gt;{&#039;_child_pid&#039;};
        $self-&gt;{&#039;_CHILD_ERROR&#039;} = $?;

        if ( $self-&gt;{&#039;_CHILD_ERROR&#039;} ) {
            $self-&gt;{&#039;_exec_failed&#039;} = 1;
        }
    }

    if ( $used_fastspawn &amp;&amp; $self-&gt;{&#039;_CHILD_ERROR&#039;} == 32512 ) {
        $self-&gt;{&#039;_CHILD_ERROR&#039;} = _ENOENT() &lt;&lt; 8;
        $self-&gt;{&#039;_exec_failed&#039;} = 1;
        ${ $self-&gt;{&#039;_stderr&#039;} } .= &quot;$exec_failed_message $!&quot;;

    }
    elsif ( !$used_fastspawn &amp;&amp; $self-&gt;{&#039;_stderr&#039;} &amp;&amp; $self-&gt;{&#039;_CHILD_ERROR&#039;} &amp;&amp; ( $self-&gt;{&#039;_CHILD_ERROR&#039;} &gt;&gt; 8 ) == 2 &amp;&amp; index( ${ $self-&gt;{&#039;_stderr&#039;} }, $exec_failed_message ) &gt; -1 ) {
        $self-&gt;{&#039;_exec_failed&#039;} = 1;
    }

    return $self;
}

sub _write_buffer_to_fh ( $self, $buffer, $fh ) {
    while ( length $buffer ) {
        my $wrote = IO::SigGuard::syswrite( $fh, $buffer ) or die $self-&gt;_write_error( \$buffer, $! );
        substr( $buffer, 0, $wrote, q&lt;&gt; );
    }

    return;
}

sub new_or_die {
    my ( $class, @args ) = @_;
    return $class-&gt;new(@args)-&gt;die_if_error();
}

sub to_exception {
    my ($self) = @_;

    if ( $self-&gt;timed_out() ) {
        return Cpanel::Exception::create(
            &#039;ProcessFailed::Timeout&#039;,
            [
                process_name =&gt; $self-&gt;program(),
                ( $self-&gt;child_pid() ? ( pid =&gt; $self-&gt;child_pid() ) : () ),
                timeout =&gt; $self-&gt;timed_out(),
                $self-&gt;_extra_error_args_for_die_if_error(),
            ],
        );
    }

    return $self-&gt;SUPER::to_exception();
}

sub _extra_error_args_for_die_if_error {
    my ($self) = @_;
    return (
        stdout =&gt; $self-&gt;{&#039;_stdout&#039;} ? $self-&gt;stdout() : &#039;&#039;,
        stderr =&gt; $self-&gt;{&#039;_stderr&#039;} ? $self-&gt;stderr() : &#039;&#039;,
    );
}

sub _safe_kill_child {
    my ($self) = @_;
    Cpanel::LoadModule::load_perl_module(&#039;Cpanel::Kill::Single&#039;);
    return &#039;Cpanel::Kill::Single&#039;-&gt;can(&#039;safekill_single_pid&#039;)-&gt;( $self-&gt;{&#039;_child_pid&#039;}, $SAFEKILL_TIMEOUT );    # One second to die
}

sub stdout_r {
    if ( !$_[0]-&gt;{&#039;_stdout&#039;} ) {
        Cpanel::LoadModule::load_perl_module(&#039;Cpanel::Carp&#039;);
        die &#039;Cpanel::Carp&#039;-&gt;can(&#039;safe_longmess&#039;)-&gt;(&quot;STDOUT output went to filehandle!&quot;);
    }

    return $_[0]-&gt;{&#039;_stdout&#039;};
}

sub _additional_phrases_for_autopsy {
    if ( $_[0]-&gt;timed_out() ) {
        return Cpanel::LocaleString-&gt;new( &#039;The system aborted the subprocess because it reached the timeout of [quant,_1,second,seconds].&#039;, $_[0]-&gt;timed_out() );
    }

    return;
}

sub stdout {
    return ${ $_[0]-&gt;stdout_r() };
}

sub stderr_r {
    if ( !$_[0]-&gt;{&#039;_stderr&#039;} ) {
        Cpanel::LoadModule::load_perl_module(&#039;Cpanel::Carp&#039;);
        die &#039;Cpanel::Carp&#039;-&gt;can(&#039;safe_longmess&#039;)-&gt;(&quot;STDERR output went to filehandle!&quot;);
    }

    return $_[0]-&gt;{&#039;_stderr&#039;};
}

sub stderr {
    return ${ $_[0]-&gt;stderr_r() };
}

sub child_pid {
    return $_[0]-&gt;{&#039;_child_pid&#039;};
}

sub timed_out {
    return $_[0]-&gt;{&#039;_timed_out_after&#039;};
}

sub program {
    return $_[0]-&gt;{&#039;_program&#039;};
}

sub _program_with_args_str {
    my $args_ar = $_[0]-&gt;{&#039;_args&#039;};
    return $_[0]-&gt;{&#039;_program&#039;} . ( ( $args_ar &amp;&amp; ref $args_ar &amp;&amp; scalar @$args_ar ) ? &quot; @$args_ar&quot; : &#039;&#039; );
}


sub _ERROR_PHRASE {
    my ($self) = @_;

    return Cpanel::LocaleString-&gt;new( &#039;The “[_1]” command (process [_2]) reported error number [_3] when it ended.&#039;, $self-&gt;_program_with_args_str(), $self-&gt;{&#039;_child_pid&#039;}, $self-&gt;error_code() );
}

sub _SIGNAL_PHRASE {
    my ($self) = @_;

    return Cpanel::LocaleString-&gt;new( &#039;The “[_1]” command (process [_2]) ended prematurely because it received the “[_3]” ([_4]) signal.&#039;, $self-&gt;_program_with_args_str(), $self-&gt;{&#039;_child_pid&#039;}, $self-&gt;signal_name(), $self-&gt;signal_code() );
}


sub _write_error {
    my ( $self, $buffer_sr, $OS_ERROR ) = @_;

    my @cmd = ( $self-&gt;{&#039;_program&#039;}, @{ $self-&gt;{&#039;_args&#039;} } );

    return Cpanel::Exception::create( &#039;IO::WriteError&#039;, &#039;The system failed to send [format_bytes,_1] to the process that is running the command “[_2]” because of an error: [_3]&#039;, [ length($$buffer_sr), &quot;@cmd&quot;, $OS_ERROR ], { length =&gt; length($$buffer_sr), error =&gt; $OS_ERROR } );
}


1;

} # --- END Cpanel/SafeRun/Object.pm


{ # --- BEGIN Cpanel/SafeRun/Env.pm
package Cpanel::SafeRun::Env;


use strict;

# use Cpanel::Env   (); # perlpkg line 211
# use Cpanel::Debug (); # perlpkg line 211

our $VERSION = &#039;1.0&#039;;

sub saferun_r_cleanenv {
    return saferun_cleanenv2( { &#039;command&#039; =&gt; \@_, &#039;return_ref&#039; =&gt; 1, &#039;cleanenv&#039; =&gt; { &#039;http_purge&#039; =&gt; 1 } } );
}

sub saferun_cleanenv2 {
    my $args_hr = shift;
    return unless ( defined $args_hr-&gt;{&#039;command&#039;} &amp;&amp; ref $args_hr-&gt;{&#039;command&#039;} eq &#039;ARRAY&#039; );
    if ($Cpanel::AccessIds::ReducedPrivileges::PRIVS_REDUCED) {    # PPI NO PARSE --  can&#039;t be reduced if the module isn&#039;t loaded
        die __PACKAGE__ . &quot; cannot be used with ReducedPrivileges. Use Cpanel::SafeRun::Object instead&quot;;
    }

    my @command                   = @{ $args_hr-&gt;{&#039;command&#039;} };
    my $return_reference          = $args_hr-&gt;{&#039;return_ref&#039;};
    my $error_output              = $args_hr-&gt;{&#039;errors&#039;};
    my %cleanenv_args             = defined $args_hr-&gt;{&#039;cleanenv&#039;} &amp;&amp; ref $args_hr-&gt;{&#039;cleanenv&#039;} eq &#039;HASH&#039; ? %{ $args_hr-&gt;{&#039;cleanenv&#039;} }             : ();
    my $check_cpanel_homedir_user = defined $args_hr-&gt;{&#039;check_cpanel_homedir_user&#039;}                        ? $args_hr-&gt;{&#039;check_cpanel_homedir_user&#039;} : 1;

    return if ( substr( $command[0], 0, 1 ) eq &#039;/&#039; &amp;&amp; !-x $command[0] );
    my $output;
    if ( !@command ) {
        Cpanel::Debug::log_warn(&#039;Cannot execute a null program&#039;);
        return \$output if $return_reference;
        return $output;
    }
    require Cpanel::Env;
    local ( $/, *PROG, *RNULL );

    no strict &#039;refs&#039;;
    open( RNULL, &#039;&lt;&#039;, &#039;/dev/null&#039; );    ## no critic(InputOutput::ProhibitBarewordFileHandles InputOutput::RequireCheckedOpen)
    my $pid = open( PROG, &quot;-|&quot; );       ## no critic(InputOutput::ProhibitBarewordFileHandles)
    if ( $pid &gt; 0 ) {
        $output = &lt;PROG&gt;;
    }
    elsif ( $pid == 0 ) {
        open( STDIN, &#039;&lt;&amp;RNULL&#039; );
        if ($error_output) {
            open STDERR, &#039;&gt;&amp;STDOUT&#039;;
        }
        Cpanel::Env::clean_env(%cleanenv_args);
        if ( $check_cpanel_homedir_user &amp;&amp; ( !$Cpanel::homedir || !$Cpanel::user ) ) {
            ( $ENV{&#039;USER&#039;}, $ENV{&#039;HOME&#039;} ) = ( getpwuid($&gt;) )[ 0, 7 ];    #do not use PwCache here
        }
        exec(@command) or exit(1);                                        # Not reached
    }
    else {
        Cpanel::Debug::log_warn(&#039;Could not fork new process&#039;);
        return \$output if $return_reference;
        return $output;
    }
    close(PROG);
    close(RNULL);
    waitpid( $pid, 0 );
    return \$output if $return_reference;
    return $output;
}

1;

} # --- END Cpanel/SafeRun/Env.pm


{ # --- BEGIN Cpanel/CachedCommand.pm
package Cpanel::CachedCommand;


use strict;
use warnings;
no warnings &#039;once&#039;;
# use Cpanel::StatCache            (); # perlpkg line 211
# use Cpanel::LoadFile             (); # perlpkg line 211
# use Cpanel::CachedCommand::Utils (); # perlpkg line 211
# use Cpanel::CachedCommand::Valid (); # perlpkg line 211
# use Cpanel::Debug                (); # perlpkg line 211

our $VERSION = &#039;2.8&#039;;

my %MEMORY_CACHE;

sub _is_memory_cache_valid {
    my %OPTS           = @_;
    my $datastore_file = $OPTS{&#039;datastore_file&#039;};

    if ( !exists $MEMORY_CACHE{$datastore_file} ) {
        print STDERR &quot;_is_memory_cache_valid: rejecting $datastore_file because it does not exist in memory.\n&quot; if $Cpanel::Debug::level;
        return 0;
    }

    my $ttl   = $OPTS{&#039;ttl&#039;};
    my $mtime = $OPTS{&#039;mtime&#039;};

    if ( !$ttl &amp;&amp; $mtime &amp;&amp; $MEMORY_CACHE{$datastore_file}-&gt;{&#039;mtime&#039;} == $mtime ) {
        print STDERR &quot;_is_memory_cache_valid: accepting $datastore_file because it passes the mtime test.\n&quot; if $Cpanel::Debug::level;
        return 1;
    }
    else {
        my $now = time();
        if ( $ttl &amp;&amp; $MEMORY_CACHE{$datastore_file}-&gt;{&#039;mtime&#039;} &gt; ( $now - $ttl ) ) {
            print STDERR &quot;_is_memory_cache_valid: accepting $datastore_file because it passes the ttl test.\n&quot; if $Cpanel::Debug::level;
            return 1;
        }
    }

    print STDERR &quot;_is_memory_cache_valid: rejecting $datastore_file because it not pass the ttl or mtime test.\n&quot; if $Cpanel::Debug::level;
    delete $MEMORY_CACHE{$datastore_file};
    return 0;
}

sub invalidate_cache {
    my $ds_file = Cpanel::CachedCommand::Utils::invalidate_cache(@_);
    delete $MEMORY_CACHE{$ds_file};

    return;
}

sub _cached_cmd {
    my %OPTS = @_;

    my ( $binary, $ttl, $mtime, $exact, $regexcheck, $args_hr, $min_expire_time, $get_result_cr ) = (
        ( $OPTS{&#039;binary&#039;}          || &#039;&#039; ),
        ( $OPTS{&#039;ttl&#039;}             || 0 ),
        ( $OPTS{&#039;mtime&#039;}           || 0 ),
        ( $OPTS{&#039;exact&#039;}           || 0 ),
        ( $OPTS{&#039;regexcheck&#039;}      || &#039;&#039; ),
        ( $OPTS{&#039;args_hr&#039;}         || {} ),
        ( $OPTS{&#039;min_expire_time&#039;} || 0 ),
        ( $OPTS{&#039;get_result_cr&#039;}   || \&amp;_default_get_result_cr ),
    );

    my @AG;
    if ( ref $OPTS{&#039;args&#039;} eq &#039;ARRAY&#039; ) {
        @AG = @{ $OPTS{&#039;args&#039;} };
    }

    if ( substr( $binary, 0, 1 ) eq &#039;/&#039; &amp;&amp; !-x $binary ) {
        return &quot;$binary is missing or not executable&quot;;
    }
    my @SAFEAG = @AG;
    if ( !$exact &amp;&amp; scalar @SAFEAG &gt; 4 ) {

        splice( @SAFEAG, 4 );
    }

    my $datastore_file = Cpanel::CachedCommand::Utils::_get_datastore_filename( $binary, @SAFEAG );

    if (
        _is_memory_cache_valid(
            &#039;binary&#039;         =&gt; $binary,
            &#039;datastore_file&#039; =&gt; $datastore_file,
            &#039;ttl&#039;            =&gt; $ttl,
            &#039;mtime&#039;          =&gt; $mtime
        )
    ) {
        return $MEMORY_CACHE{$datastore_file}-&gt;{&#039;contents&#039;};
    }

    my ( $datastore_file_size, $datastore_file_mtime ) = ( stat($datastore_file) )[ 7, 9 ];
    my $data_mtime;

    my ( $used_cache, $res );
    if (
        Cpanel::CachedCommand::Valid::is_cache_valid(
            &#039;binary&#039;               =&gt; $binary,
            &#039;datastore_file&#039;       =&gt; $datastore_file,
            &#039;datastore_file_mtime&#039; =&gt; $datastore_file_mtime,
            &#039;ttl&#039;                  =&gt; $ttl,
            &#039;mtime&#039;                =&gt; $mtime,
            &#039;min_expire_time&#039;      =&gt; $min_expire_time,
        )
    ) {
        $res        = Cpanel::LoadFile::loadfile_r( $datastore_file, { &#039;skip_exists_check&#039; =&gt; 1 } );
        $data_mtime = $datastore_file_mtime;
        if ( $res &amp;&amp; ( !$regexcheck || $$res =~ m/$regexcheck/ ) ) {
            $used_cache = 1;
        }
    }

    if ( !$used_cache ) {
        $data_mtime = _time();

        $res = $get_result_cr-&gt;( { binary =&gt; $binary, args =&gt; \@AG } );

        if ( !$regexcheck || ( defined $res &amp;&amp; ( ref $res ? $$res : $res ) =~ m/$regexcheck/ ) ) {
            print STDERR &quot;_cached_command: writing datastore file: $datastore_file &quot; . ( $regexcheck ? &quot;regex_check: $regexcheck&quot; : &#039;&#039; ) . &quot;\n&quot; if $Cpanel::Debug::level;

            require Cpanel::CachedCommand::Save;
            Cpanel::CachedCommand::Save::_savefile( $datastore_file, $res );
        }
        else {
            print STDERR &quot;_cached_command: failed regex check NOT writing datastore file: $datastore_file &quot; . ( $regexcheck ? &quot;regex_check: $regexcheck&quot; : &#039;&#039; ) . &quot;\n&quot; if $Cpanel::Debug::level;
        }
    }

    return _cache_res_if_needed( $res, $ttl, $datastore_file, $data_mtime );
}

sub _cache_res_if_needed {
    my ( $res, $ttl, $datastore_file, $data_mtime ) = @_;

    if ( ref $res ) {
        if ( $ttl &amp;&amp; ( !defined $$res || length($$res) &lt; 32768 ) ) { $MEMORY_CACHE{$datastore_file} = { &#039;mtime&#039; =&gt; $data_mtime, &#039;contents&#039; =&gt; $res }; }
        return $res;
    }
    else {
        if ( $ttl &amp;&amp; ( !defined $res || length($res) &lt; 32768 ) ) { $MEMORY_CACHE{$datastore_file} = { &#039;mtime&#039; =&gt; $data_mtime, &#039;contents&#039; =&gt; \$res }; }
        return \$res;
    }
}

sub _default_get_result_cr {
    my ($opts) = @_;

    return _get_cmd_output( &#039;program&#039; =&gt; $opts-&gt;{binary}, &#039;args&#039; =&gt; $opts-&gt;{args}, &#039;stderr&#039; =&gt; \*STDERR );
}

sub _get_memory_cache {
    return \%MEMORY_CACHE;
}

sub _time {
    return time();
}

sub _get_cmd_output {
    my (@key_val) = @_;

    return eval {
        require Cpanel::SafeRun::Object;
        my $run = Cpanel::SafeRun::Object-&gt;new(@key_val);
        $run-&gt;stdout();
    };
}


sub has_cache {
    my ( $ttl, $bin, @AG ) = @_;
    my @SAFEAG = @AG;
    if ( scalar @SAFEAG &gt; 3 ) {
        splice( @SAFEAG, 3 );
    }
    my $datastore_file = Cpanel::CachedCommand::Utils::_get_datastore_filename( $bin, @SAFEAG );
    return (
        Cpanel::CachedCommand::Valid::is_cache_valid(
            &#039;datastore_file&#039; =&gt; $datastore_file,
            &#039;binary&#039;         =&gt; $bin,
            &#039;ttl&#039;            =&gt; $ttl
        )
    ) ? 1 : 0;
}

sub cachedcommand {
    my ( $binary, @ARGS ) = @_;

    my $cache_ref = _cached_cmd(
        &#039;binary&#039;     =&gt; $binary,
        &#039;regexcheck&#039; =&gt; qr/./,     # only cache data that actually exists
        &#039;args&#039;       =&gt; \@ARGS
    );
    if ( ref $cache_ref eq &#039;SCALAR&#039; ) { return $$cache_ref; }
    return $cache_ref;
}

sub cachedcommand_no_errors {
    my (%OPTS) = @_;

    return _cached_cmd(
        binary =&gt; $OPTS{&#039;binary&#039;},
        args   =&gt; $OPTS{&#039;args&#039;},
        ( defined $OPTS{&#039;mtime&#039;} ? ( mtime =&gt; $OPTS{&#039;mtime&#039;} ) : () ),
        ( defined $OPTS{&#039;ttl&#039;}   ? ( ttl   =&gt; $OPTS{&#039;ttl&#039;} )   : () ),
        get_result_cr =&gt; sub {
            my ($opts) = @_;

            return _get_cmd_output( &#039;program&#039; =&gt; $opts-&gt;{binary}, &#039;args&#039; =&gt; $opts-&gt;{args}, ( $OPTS{ttl} ? ( &#039;timeout&#039; =&gt; $OPTS{ttl}, &#039;read_timeout&#039; =&gt; $OPTS{ttl} ) : () ) );
        }
    );
}

sub cachedcommand_multifile {
    my ( $test_file_ar, $binary, @ARGS ) = @_;
    my ( $mtime, $ctime ) = Cpanel::StatCache::cachedmtime_ctime($binary);
    if ( $ctime &gt; $mtime ) {
        $mtime = $ctime;
    }
    foreach my $file (@$test_file_ar) {
        my @test_times = Cpanel::StatCache::cachedmtime_ctime($file);
        foreach my $new_time (@test_times) {
            if ( $new_time &gt; $mtime ) {
                $mtime = $new_time;
            }
        }
    }
    my $cache_ref = _cached_cmd(
        &#039;binary&#039; =&gt; $binary,
        &#039;args&#039;   =&gt; \@ARGS,
        &#039;mtime&#039;  =&gt; $mtime
    );
    if ( ref $cache_ref eq &#039;SCALAR&#039; ) { return $$cache_ref; }
    return $cache_ref;
}

sub cachedmcommand {
    my ( $ttl, $binary, @ARGS ) = @_;
    my $cache_ref = _cached_cmd(
        &#039;ttl&#039;    =&gt; $ttl,
        &#039;binary&#039; =&gt; $binary,
        &#039;args&#039;   =&gt; \@ARGS
    );
    if ( ref $cache_ref eq &#039;SCALAR&#039; ) { return $$cache_ref; }
    return $cache_ref;
}

sub cachedmcommand_r_cleanenv {
    my ( $ttl, $binary, @ARGS ) = @_;
    my $cache_ref = _cached_cmd(
        &#039;ttl&#039;           =&gt; $ttl,
        &#039;binary&#039;        =&gt; $binary,
        &#039;args&#039;          =&gt; \@ARGS,
        &#039;get_result_cr&#039; =&gt; sub {
            my ($opts) = @_;

            require Cpanel::SafeRun::Env;
            return Cpanel::SafeRun::Env::saferun_r_cleanenv( $opts-&gt;{binary}, @{ $opts-&gt;{args} } );
        },
    );
    if ( ref $cache_ref ne &#039;SCALAR&#039; ) { return \$cache_ref; }
    return $cache_ref;
}

sub cachedmcommand_cleanenv2 {
    my ( $ttl, $args_hr ) = @_;
    my @cmd       = @{ $args_hr-&gt;{&#039;command&#039;} };
    my $binary    = shift @cmd;
    my @ARGS      = @cmd;
    my $cache_ref = _cached_cmd(
        &#039;ttl&#039;           =&gt; $ttl,
        &#039;binary&#039;        =&gt; $binary,
        &#039;args&#039;          =&gt; \@ARGS,
        &#039;get_result_cr&#039; =&gt; sub {

            require Cpanel::SafeRun::Env;
            return Cpanel::SafeRun::Env::saferun_cleanenv2($args_hr);
        },
    );
    return $cache_ref;
}

sub cachedmcommand_r {
    my ( $ttl, $binary, @ARGS ) = @_;
    my $cache_ref = _cached_cmd(
        &#039;ttl&#039;    =&gt; $ttl,
        &#039;binary&#039; =&gt; $binary,
        &#039;args&#039;   =&gt; \@ARGS
    );
    if ( ref $cache_ref ne &#039;SCALAR&#039; ) { return \$cache_ref; }
    return $cache_ref;
}

sub cachedmcommand2 {
    my $arg_ref = shift;

    my $bin        = $arg_ref-&gt;{&#039;bin&#039;};
    my $ttl        = $arg_ref-&gt;{&#039;age&#039;};
    my $timer      = $arg_ref-&gt;{&#039;timer&#039;};
    my $exact      = $arg_ref-&gt;{&#039;exact&#039;};
    my $regexcheck = $arg_ref-&gt;{&#039;regexcheck&#039;};
    my @AG         = @{ $arg_ref-&gt;{&#039;ARGS&#039;} };

    my $cache_ref = _cached_cmd(
        &#039;binary&#039;        =&gt; $bin,
        &#039;ttl&#039;           =&gt; $ttl,
        &#039;exact&#039;         =&gt; $exact,
        &#039;regexcheck&#039;    =&gt; $regexcheck,
        &#039;args&#039;          =&gt; \@AG,
        &#039;get_result_cr&#039; =&gt; sub {
            my ($opts) = @_;

            return _get_cmd_output( &#039;program&#039; =&gt; $opts-&gt;{binary}, &#039;args&#039; =&gt; $opts-&gt;{&#039;args&#039;}, &#039;stderr&#039; =&gt; \*STDERR, ( int($timer) &gt; 0 ? ( &#039;timeout&#039; =&gt; $timer, &#039;read_timeout&#039; =&gt; $timer ) : () ) );
        },
    );
    if ( ref $cache_ref eq &#039;SCALAR&#039; ) { return $$cache_ref; }
    return $cache_ref;
}

sub noncachedcommand {
    my ( $bin, @AG ) = @_;

    if ( substr( $bin, 0, 1 ) eq &#039;/&#039; &amp;&amp; !-x $bin ) {
        return &quot;$bin is missing or not executable&quot;;
    }
    my $datastore_file = Cpanel::CachedCommand::Utils::_get_datastore_filename( $bin, $AG[0] );

    if ( -e $datastore_file ) {
        unlink $datastore_file;
    }

    return _get_cmd_output( &#039;program&#039; =&gt; $bin, &#039;args&#039; =&gt; \@AG );
}

sub retrieve {
    my %OPTS = @_;
    return Cpanel::LoadFile::loadfile( Cpanel::CachedCommand::Utils::_get_datastore_filename( $OPTS{&#039;name&#039;} ) );
}

sub clear_memory_cache {
    %MEMORY_CACHE = ();
}

1;

} # --- END Cpanel/CachedCommand.pm


{ # --- BEGIN Cpanel/GlobalCache.pm
package Cpanel::GlobalCache;


use strict;

# use Cpanel::JSON::FailOK (); # perlpkg line 211

my $GCACHEref = {};
our $PRODUCT_CONF_DIR = &#039;/var/cpanel&#039;;

sub get_cache_mtime {
    my ($cachename) = @_;
    if ( !exists $GCACHEref-&gt;{$cachename} ) { load_cache($cachename); }
    return $GCACHEref-&gt;{$cachename}{&#039;mtime&#039;};
}

sub load_cache {
    my ($cachename) = @_;
    if ( open( my $cache_fh, &#039;&lt;&#039;, &quot;$PRODUCT_CONF_DIR/globalcache/$cachename.cache&quot; ) ) {
        $GCACHEref-&gt;{$cachename} ||= {};
        my $cache_ref = $GCACHEref-&gt;{$cachename};

        require Cpanel::JSON;
        $cache_ref-&gt;{&#039;data&#039;} = Cpanel::JSON::FailOK::LoadFile($cache_fh);

        if ( ref $cache_ref-&gt;{&#039;data&#039;} eq &#039;HASH&#039; ) {
            $cache_ref-&gt;{&#039;mtime&#039;} = ( stat($cache_fh) )[9];
        }
        else {
            $cache_ref-&gt;{&#039;data&#039;} = {};
        }
        close($cache_fh);
    }
    return;
}

sub cachedmcommand {    ## no critic(RequireArgUnpacking)
    my $cachename = shift;

    require Cpanel::CachedCommand;

    if ( !exists $GCACHEref-&gt;{$cachename} ) { load_cache($cachename); }
    my $cache_max_mtime = shift;
    my $key             = join( &#039;_&#039;, @_ );
    return (
        ( exists $GCACHEref-&gt;{$cachename}{&#039;data&#039;}{&#039;command&#039;}{$key} &amp;&amp; ( $cache_max_mtime + $GCACHEref-&gt;{$cachename}{&#039;mtime&#039;} ) &gt; time() )
        ? $GCACHEref-&gt;{$cachename}{&#039;data&#039;}{&#039;command&#039;}{$key}
        : &#039;Cpanel::CachedCommand&#039;-&gt;can(&#039;cachedmcommand&#039;)-&gt;( $cache_max_mtime, @_ )
    );
}

sub cachedcommand {    ## no critic(RequireArgUnpacking)
    my $cachename = shift;

    require Cpanel::CachedCommand;
    require Cpanel::StatCache;

    if ( !exists $GCACHEref-&gt;{$cachename} ) { load_cache($cachename); }
    my ( $file_mtime, $file_ctime ) = &#039;Cpanel::StatCache&#039;-&gt;can(&#039;cachedmtime_ctime&#039;)-&gt;( $_[0] );
    my $key = join( &#039;_&#039;, @_ );
    return (
        ( exists $GCACHEref-&gt;{$cachename}{&#039;data&#039;}{&#039;command&#039;}{$key} &amp;&amp; $GCACHEref-&gt;{$cachename}{&#039;mtime&#039;} &gt; $file_mtime &amp;&amp; $GCACHEref-&gt;{$cachename}{&#039;mtime&#039;} &gt; $file_ctime )
        ? $GCACHEref-&gt;{$cachename}{&#039;data&#039;}{&#039;command&#039;}{$key}
        : &#039;Cpanel::CachedCommand&#039;-&gt;can(&#039;cachedcommand&#039;)-&gt;(@_)
    );
}

sub loadfile {
    my $cachename = shift;
    if ( !exists $GCACHEref-&gt;{$cachename} ) { load_cache($cachename); }
    my $file       = shift;
    my $file_mtime = shift;
    unless ( defined $file_mtime ) {
        $file_mtime = ( stat($file) )[9] || 0;
    }

    require Cpanel::LoadFile;
    return (
        ( exists $GCACHEref-&gt;{$cachename}{&#039;data&#039;}{&#039;file&#039;}{$file} &amp;&amp; $GCACHEref-&gt;{$cachename}{&#039;mtime&#039;} &gt; $file_mtime )
        ? $GCACHEref-&gt;{$cachename}{&#039;data&#039;}{&#039;file&#039;}{$file}
        : &#039;Cpanel::LoadFile&#039;-&gt;can(&#039;loadfile&#039;)-&gt;($file)
    );
}

sub data {
    my $cachename = shift;
    if ( !exists $GCACHEref-&gt;{$cachename} ) { load_cache($cachename); }
    my $data       = shift;
    my $test_mtime = shift || 0;

    return ( ( exists $GCACHEref-&gt;{$cachename}{&#039;data&#039;}{&#039;data&#039;}{$data} &amp;&amp; $GCACHEref-&gt;{$cachename}{&#039;mtime&#039;} &gt; $test_mtime ) ? $GCACHEref-&gt;{$cachename}{&#039;data&#039;}{&#039;data&#039;}{$data} : undef );
}

sub clearcache {
    $GCACHEref = {};
    return;
}

sub default_product_dir {
    $PRODUCT_CONF_DIR = shift if @_;
    return $PRODUCT_CONF_DIR;
}

1;

} # --- END Cpanel/GlobalCache.pm


{ # --- BEGIN Cpanel/IP/NonlocalBind/Cache.pm
package Cpanel::IP::NonlocalBind::Cache;


use strict;
use warnings;
no warnings &#039;once&#039;;


use constant {
    DISABLED =&gt; &#039;&#039;,    # 0-bytes
    ENABLED  =&gt; 1,     # 1-byte
    UNKNOWN  =&gt; 22,    # 2-bytes

    _ENOENT =&gt; 2,
};

our $CACHE_FILE = &#039;/var/cpanel/ipv4_ip_nonlocal_bind&#039;;

our $_ipv4_ip_nonlocal_bind_cache_length;


sub ipv4_ip_nonlocal_bind_is_enabled {


    if ( !defined $_ipv4_ip_nonlocal_bind_cache_length ) {
        $_ipv4_ip_nonlocal_bind_cache_length = ( stat($CACHE_FILE) )[7];

        if ( !defined $_ipv4_ip_nonlocal_bind_cache_length ) {
            if ( $! != _ENOENT() ) {
                warn &quot;stat($CACHE_FILE): $!&quot;;
            }
        }
    }

    if ( defined $_ipv4_ip_nonlocal_bind_cache_length ) {
        return 1 if $_ipv4_ip_nonlocal_bind_cache_length == length ENABLED();
        return 0 if $_ipv4_ip_nonlocal_bind_cache_length == length DISABLED();

        if ( $_ipv4_ip_nonlocal_bind_cache_length != length UNKNOWN() ) {
            warn &quot;“$CACHE_FILE” has unrecognized length: $_ipv4_ip_nonlocal_bind_cache_length&quot;;
        }
    }

    return undef;
}

1;

} # --- END Cpanel/IP/NonlocalBind/Cache.pm


{ # --- BEGIN Cpanel/FileUtils/TouchFile.pm
package Cpanel::FileUtils::TouchFile;


use strict;
use warnings;
no warnings &#039;once&#039;;


use constant {
    _ENOENT =&gt; 2,
};

my $logger;

our $VERSION = &#039;1.3&#039;;

sub _log {
    my ( $level, $msg ) = @_;

    require Cpanel::Logger;
    $logger ||= Cpanel::Logger-&gt;new();
    $logger-&gt;$level($msg);

    return;
}

my $mtime;

sub touchfile {
    my ( $file, $verbose, $fail_ok ) = @_;

    if ( !defined $file ) {
        _log( &#039;warn&#039;, &quot;touchfile called with undefined file&quot; );
        return;
    }

    my $mtime;

    if ( utime undef, undef, $file ) {
        return 1;
    }
    elsif ( $! != _ENOENT() ) {
        _log( &#039;warn&#039;, &quot;utime($file) as $&gt;: $!&quot; );

        $mtime = -e $file ? ( stat _ )[9] : 0;    # for warnings-safe numeric comparison

        if ( !$mtime &amp;&amp; $! != _ENOENT ) {
            _log( &#039;warn&#039;, &quot;Failed to stat($file) as $&gt;: $!&quot; );
            return;
        }
    }

    $mtime = ( stat $file )[9] // 0;

    if ( open my $fh, &#039;&gt;&gt;&#039;, $file ) {    # append so we don&#039;t wipe out contents
        my $mtime_after_open = ( stat $fh )[9] || 0;    # for warnings safe numeric comparison
        return 1 if $mtime != $mtime_after_open;        # in case open does not change it, see comment below
    }
    else {
        _log( &#039;warn&#039;, &quot;Failed to open(&gt;&gt; $file) as $&gt;: $!&quot; ) unless $fail_ok;
    }

    if ($fail_ok) { return; }

    my $at_this_point = ( stat $file )[9] || 0;    # for warnings safe numeric comparison
    if ( $mtime == $at_this_point ) {

        my $new_at_this_point = ( stat $file )[9] || 0;    # for warnings safe numeric comparison
        if ( $mtime == $new_at_this_point ) {
            if ($verbose) {
                _log( &#039;info&#039;, &#039;Trying to do system “touch” command!&#039; );
            }
            if ( system( &#039;touch&#039;, $file ) != 0 ) {
                if ($verbose) {
                    _log( &#039;info&#039;, &#039;system method 1 failed.&#039; );
                }
            }
        }
    }

    if ( !-e $file ) {    # obvisouly it didn&#039;t touch it if it doesn&#039;t exist...
        _log( &#039;warn&#039;, &quot;Failed to create $file: $!&quot; );
        return;
    }
    else {

        my $after_all_that = ( stat $file )[9] || 0;    # for warnings safe numeric comparison
        if ( $mtime &amp;&amp; $mtime == $after_all_that ) {
            _log( &#039;warn&#039;, &quot;mtime of “$file” not changed!&quot; );
            return;
        }
        return 1;
    }
}

1;

} # --- END Cpanel/FileUtils/TouchFile.pm


{ # --- BEGIN Cpanel/Linux/NetlinkConstants.pm
package Cpanel::Linux::NetlinkConstants;


use strict;
use warnings;
no warnings &#039;once&#039;;

our $VERSION = &#039;1.00&#039;;

# use Cpanel::Pack::Template (); # perlpkg line 211

use constant IFA_ADDRESS   =&gt; 1;
use constant IFA_LOCAL     =&gt; 2;
use constant IFA_LABEL     =&gt; 3;
use constant IFA_CACHEINFO =&gt; 6;

use constant RT_SCOPE_UNIVERSE =&gt; 0;
use constant RT_SCOPE_SITE     =&gt; 200;
use constant RT_SCOPE_LINK     =&gt; 253;
use constant RT_SCOPE_HOST     =&gt; 254;
use constant RT_SCOPE_NOWHERE  =&gt; 255;

use constant RTM_GETLINK  =&gt; 18;
use constant RTM_GETADDR  =&gt; 22;
use constant RTM_GETROUTE =&gt; 26;

use constant RTA_DST     =&gt; 1;
use constant RTA_PREFSRC =&gt; 7;

our @IFINFOMSG_TEMPLATE = (    #struct ifinfomsg
    &#039;ifi_family&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,     #  unsigned char ifi_family;
    &#039;__ifi_pad&#039;  =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,     #  unsigned char __ifi_pad;
    &#039;ifi_type&#039;   =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U16,    #  unsigned short  ifi_type;   /* ARPHRD_* */
    &#039;ifi_index&#039;  =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,    #  int   ifi_index;    /* Link index */
    &#039;ifi_flags&#039;  =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,    # unsigned  ifi_flags;    /* IFF_* flags  */
    &#039;ifi_change&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32     # unsigned  ifi_change;   /* IFF_* change mask */
);

our @IFA_CACHEINFO_TEMPLATE = (                                   #struct ifa_cacheinfo
    &#039;ifa_prefered&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,    # __u32 ifa_prefered;  # See: https://en,wiktionary,org/wiki/prefered   -- It is mispelled upstream
    &#039;ifa_valid&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,    # __u32 ifa_valid;
    &#039;cstamp&#039;       =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32,    # __u32 cstamp; /* created timestamp, hundredths of seconds */
    &#039;tstamp&#039;       =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32     # __u32 tstamp; /* updated timestamp, hundredths of seconds */
);

our @IFADDRMSG_TEMPLATE = (                                         # struct ifaddrmsg
    &#039;ifa_family&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,    #  __u8    ifa_family;
    &#039;ifa_prefixlen&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,    #  __u8    ifa_prefixlen;  /* The prefix length    */
    &#039;ifa_flags&#039;     =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,    #  __u8    ifa_flags;  /* Flags      */
    &#039;ifa_scope&#039;     =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,    #  __u8    ifa_scope;  /* Address scope    */
    &#039;ifa_index&#039;     =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32    #  __u32   ifa_index;  /* Link index     */
);

our @RTMSG_TEMPLATE = (                                             # struct rtmsg
    &#039;rtm_family&#039;  =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,      #  __u8    rtm_family;
    &#039;rtm_dst_len&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,      #  __u8    rtm_dst_len;
    &#039;rtm_src_len&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,      #  __u8    rtm_src_len;
    &#039;rtm_tos&#039;     =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,      #  __u8    rtm_tos;

    &#039;rtm_table&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,     #  __u8    rtm_table;  /* Routing table id */
    &#039;rtm_protocol&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,     #  __u8    rtm_protocol;  /* Routing protocol */
    &#039;rtm_scope&#039;    =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,     #  __u8    rtm_scope;  /* Address scope    */
    &#039;rtm_type&#039;     =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U8,     #  __u8    rtm_type;

    &#039;rtm_flags&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U32        #  __u32   rtm_flags;  /* Flags     */
);

our @RTATTR_HEADER_TEMPLATE = (
    &#039;rta_len&#039;  =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U16,
    &#039;rta_type&#039; =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U16,
);
1;

} # --- END Cpanel/Linux/NetlinkConstants.pm


{ # --- BEGIN Cpanel/Linux/RtNetlink.pm
package Cpanel::Linux::RtNetlink;


use cPstrict;
no warnings &#039;once&#039;;

# use Cpanel::Linux::Netlink          (); # perlpkg line 211
# use Cpanel::Linux::NetlinkConstants (); # perlpkg line 211
# use Cpanel::Pack                    (); # perlpkg line 211
# use Cpanel::Pack::Template          (); # perlpkg line 211
# use Cpanel::Socket::Constants       (); # perlpkg line 211

# use Socket qw(inet_pton inet_ntop); # perlpkg line 248
INIT { Socket-&gt;import(qw{inet_pton inet_ntop}); }

use constant {
    IFLA_IFNAME       =&gt; 4,
    DEBUG             =&gt; 0,
    AF_INET6          =&gt; $Cpanel::Linux::Netlink::AF_INET6,
    IFA_LOCAL         =&gt; Cpanel::Linux::NetlinkConstants::IFA_LOCAL(),
    IFA_ADDRESS       =&gt; Cpanel::Linux::NetlinkConstants::IFA_ADDRESS(),
    IFA_CACHEINFO     =&gt; Cpanel::Linux::NetlinkConstants::IFA_CACHEINFO(),
    IFA_LABEL         =&gt; Cpanel::Linux::NetlinkConstants::IFA_LABEL(),
    PACK_TEMPLATE_U16 =&gt; Cpanel::Pack::Template::PACK_TEMPLATE_U16,
    U16_BYTES_LENGTH  =&gt; Cpanel::Pack::Template::U16_BYTES_LENGTH,
    RTA_DST           =&gt; Cpanel::Linux::NetlinkConstants::RTA_DST(),
    RTA_PREFSRC       =&gt; Cpanel::Linux::NetlinkConstants::RTA_PREFSRC(),
};

my $INFINITY_LIFE_TIME = 4294967295;

my $NETLINK_ROUTE_SOCKET = 0;

my $PF_NETLINK = 16;

my $IFINFOMSG_PACK_OBJ;

my $IFA_CACHEINFO_PACK_OBJ;

my $IFADDRMSG_PACK_OBJ;

my $RTMSG_PACK_OBJ;


sub get_first_interface_and_address {
    my ($address_family) = @_;

    die &quot;List context only!&quot; if !wantarray;

    $address_family = _address_family_string_to_number($address_family);
    my $socket    = _make_netlink_socket();
    my $addresses = _get_interface_addresses( $socket, $address_family );

    my @fallback;
    foreach my $address ( sort { $a-&gt;{&#039;scope&#039;} &lt;=&gt; $b-&gt;{&#039;scope&#039;} } @{$addresses} ) {    # Prefer the largest global scope
        $address-&gt;{&#039;ip&#039;} ||= _unpack_address_to_ip( $address-&gt;{&#039;address&#039;} || &#039;&#039; );
        my @candidate = ( $address-&gt;{&#039;ifindex&#039;}, $address-&gt;{&#039;ip&#039;} );

        if ( defined $address-&gt;{label} &amp;&amp; index( $address-&gt;{label}, &#039;:&#039; ) &gt; 0 ) {    # do nothing if at position 0
            my ( $interface, $virtual ) = split( &#039;:&#039;, $address-&gt;{label}, 2 );
            $candidate[0] .= &#039;:&#039; . $virtual;
        }

        @fallback = @candidate unless scalar @fallback;
        next if is_reserved_ipv4( $address-&gt;{&#039;ip&#039;} );

        return @candidate;
    }

    return @fallback;
}


sub is_reserved_ipv4 ($ip) {

    return unless defined $ip;

    return 1 if index( $ip, &#039;127.&#039; ) == 0    # 127.0.0.0/8
      || index( $ip, &#039;10.&#039; ) == 0            # 10.0.0.0/8
      || index( $ip, &#039;11.&#039; ) == 0            # 11.0.0.0/8
      || index( $ip, &#039;192.168.&#039; ) == 0       # 192.168.0.0/16
      ;

    if ( index( $ip, &#039;172.&#039; ) == 0 || index( $ip, &#039;2&#039; ) == 0 ) {
        if ( $ip =~ qr{^([0-9]+)\.([0-9]+)\.[0-9]+\.[0-9]+$} ) {
            return 1 if $1 == 172 &amp;&amp; ( 16 &lt;= $2 &amp;&amp; $2 &lt;= 31 );    # 172.16.0.0/12
            return 1 if $1 &gt;= 224;                                # 224.0.0.0/4 &amp; 240.0.0.0/4 &amp; 255.255.255.255/32
        }
    }

    return;
}


sub is_reserved_ipv6 ($ip) {

    return unless defined $ip;

    return 1 if $ip eq &#039;::1&#039;;
    $ip = lc $ip;
    return 1 if index( $ip, &#039;fe80:&#039; ) == 0;

    return;
}


sub get_addresses_by_interface ($address_family) {

    $address_family = _address_family_string_to_number($address_family);
    my $socket     = _make_netlink_socket();
    my $addresses  = _get_interface_addresses( $socket, $address_family, { &#039;ip&#039; =&gt; 1 } );
    my $interfaces = _get_interfaces( $socket, $address_family );

    my %ifcount;
    my %combined;
    foreach my $address ( @{$addresses} ) {
        next if $address-&gt;{&#039;scope&#039;} != Cpanel::Linux::NetlinkConstants::RT_SCOPE_UNIVERSE();    # only want global
        my $if = $interfaces-&gt;[ $address-&gt;{&#039;ifindex&#039;} - 1 ];
        $combined{$if}{ ++$ifcount{$if} } = $address;
    }
    return \%combined;
}


sub get_interfaces {
    my ($address_family) = @_;
    $address_family = _address_family_string_to_number($address_family);
    return _get_interfaces( _make_netlink_socket(), $address_family );
}


sub get_interface_addresses ($address_family) {
    $address_family = _address_family_string_to_number($address_family);
    return _get_interface_addresses( _make_netlink_socket(), $address_family, { &#039;ip&#039; =&gt; 1 } );
}

sub _get_interfaces ( $sock, $address_family ) {

    my @interfaces;
    $IFINFOMSG_PACK_OBJ ||= Cpanel::Pack-&gt;new( \@Cpanel::Linux::NetlinkConstants::IFINFOMSG_TEMPLATE );
    Cpanel::Linux::Netlink::netlink_transaction(
        &#039;header&#039; =&gt; [
            &#039;nlmsg_flags&#039; =&gt; $Cpanel::Linux::Netlink::NLM_F_ROOT | $Cpanel::Linux::Netlink::NLM_F_MATCH,
            &#039;nlmsg_type&#039;  =&gt; Cpanel::Linux::NetlinkConstants::RTM_GETLINK(),
        ],
        &#039;message&#039; =&gt; {
            &#039;ifi_family&#039; =&gt; $address_family,
        },
        &#039;sock&#039;           =&gt; $sock,
        &#039;send_pack_obj&#039;  =&gt; $IFINFOMSG_PACK_OBJ,
        &#039;recv_pack_obj&#039;  =&gt; $IFINFOMSG_PACK_OBJ,
        &#039;payload_parser&#039; =&gt; _make_payload_parser(
            sub {
                my ( $nl_msgcount, $nl_response_hr, $rta_type, $value ) = @_;

                print STDERR &quot;toto-[$nl_msgcount]\ntype:[$rta_type]==value:[$value]\n&quot; if DEBUG;

                if ( $rta_type == Cpanel::Linux::NetlinkConstants::IFA_LABEL() ) {
                    $interfaces[ $nl_response_hr-&gt;{&#039;ifi_index&#039;} - 1 ] = $value =~ tr{\0}{}dr;
                }
                elsif (DEBUG) {
                    warn &quot;Unknown rta_type: [$rta_type]&quot;;
                }
            },
        ),
    );

    return \@interfaces;
}


sub get_route_to ( $address_family, $dst_ip ) {
    $address_family = _address_family_string_to_number($address_family);
    $dst_ip         = Socket::inet_pton $address_family, $dst_ip;
    return _get_route_to( _make_netlink_socket(), $address_family, $dst_ip );
}

my @RTATTR_DATA = (
    undef,
    {
        &#039;name&#039;    =&gt; &#039;rta_dst&#039;,
        &#039;handler&#039; =&gt; \&amp;_rtattr_address_handler,
    },
    undef,
    undef,
    undef,
    undef,
    undef,
    {
        &#039;name&#039;    =&gt; &#039;rta_prefsrc&#039;,
        &#039;handler&#039; =&gt; \&amp;_rtattr_address_handler,
    },
);

sub _rtattr_address_handler ( $value, $address_family ) {

    return Socket::inet_ntop( $address_family, $value );
}

sub _get_route_to ( $sock, $address_family, $dst_ip_packed ) {    ## no critic qw(ProhibitManyArgs)

    my ( $address_length, @attributes );

    $address_length = ( $address_family == AF_INET6 ) ? 16 : 4;

    $RTMSG_PACK_OBJ ||= Cpanel::Pack-&gt;new( \@Cpanel::Linux::NetlinkConstants::RTMSG_TEMPLATE );

    my $RTMSG_WITH_DST_PACK_OBJ = Cpanel::Pack-&gt;new(
        [
            @Cpanel::Linux::NetlinkConstants::RTMSG_TEMPLATE,
            @Cpanel::Linux::NetlinkConstants::RTATTR_HEADER_TEMPLATE,
            &#039;rta_dst&#039; =&gt; &#039;a&#039; . $address_length,
        ]
    );
    Cpanel::Linux::Netlink::netlink_transaction(
        &#039;header&#039; =&gt; [
            &#039;nlmsg_type&#039; =&gt; Cpanel::Linux::NetlinkConstants::RTM_GETROUTE(),
            &#039;nlmsg_seq&#039;  =&gt; 1,                                                 #seems unnecessary??
        ],
        &#039;message&#039; =&gt; {
            &#039;rtm_family&#039;  =&gt; $address_family,
            &#039;rtm_dst_len&#039; =&gt; $address_length * 8,                              # /32 for v4, /128 for v6
            &#039;rta_len&#039;     =&gt; 4 + $address_length,                              # includes rtattr header size (4 bytes)
            &#039;rta_type&#039;    =&gt; RTA_DST,
            &#039;rta_dst&#039;     =&gt; $dst_ip_packed,
        },
        &#039;sock&#039;           =&gt; $sock,
        &#039;send_pack_obj&#039;  =&gt; $RTMSG_WITH_DST_PACK_OBJ,
        &#039;recv_pack_obj&#039;  =&gt; $RTMSG_PACK_OBJ,
        &#039;payload_parser&#039; =&gt; _make_payload_parser(
            sub {
                my ( $msgcount, $response_ref, $rta_type, $value ) = @_;

                $attributes[$msgcount] = {} unless defined $attributes[$msgcount];

                if ( defined $RTATTR_DATA[$rta_type] ) {
                    my $rtattr_hr = $RTATTR_DATA[$rta_type];
                    $attributes[$msgcount]-&gt;{ $rtattr_hr-&gt;{&#039;name&#039;} } = $rtattr_hr-&gt;{&#039;handler&#039;}-&gt;( $value, $address_family );
                }
                else {
                    $attributes[$msgcount]-&gt;{$rta_type} = $value;
                }
            },
        ),
    );

    return \@attributes;
}

my %_u16_cache;

sub _make_payload_parser ($for_each_rtmsg_cr) {

    return sub {
        my ( $nl_msgcount, $nlresponse_hr, $payload_sr ) = ( $_[0], $_[1], \$_[2] );
        my ( $u16, $rta_length, $rta_type, $value );
      RTATTR_LOOP:
        while ( length $$payload_sr ) {

            $u16        = substr( $$payload_sr, 0, U16_BYTES_LENGTH, &#039;&#039; );
            $rta_length = ( $_u16_cache{$u16} //= unpack( PACK_TEMPLATE_U16, $u16 ) ) or last RTATTR_LOOP;    # unsigned short  rta_len;
            $u16        = substr( $$payload_sr, 0, U16_BYTES_LENGTH, &#039;&#039; );
            $rta_type   = ( $_u16_cache{$u16} //= unpack( PACK_TEMPLATE_U16, $u16 ) );
            $value      = substr( $$payload_sr, 0, $rta_length - ( U16_BYTES_LENGTH * 2 ), &#039;&#039; );

            $for_each_rtmsg_cr-&gt;(
                $nl_msgcount,
                $nlresponse_hr,
                $rta_type,
                $value
            );
        }
    };
}

sub _get_interface_addresses ( $sock, $address_family, $want = undef ) {
    $want //= {};

    my $want_ip = $want-&gt;{&#039;ip&#039;};

    my @addresses;
    $IFADDRMSG_PACK_OBJ     ||= Cpanel::Pack-&gt;new( \@Cpanel::Linux::NetlinkConstants::IFADDRMSG_TEMPLATE );
    $IFA_CACHEINFO_PACK_OBJ ||= Cpanel::Pack-&gt;new( \@Cpanel::Linux::NetlinkConstants::IFA_CACHEINFO_TEMPLATE );
    Cpanel::Linux::Netlink::netlink_transaction(
        &#039;header&#039; =&gt; [
            &#039;nlmsg_type&#039;  =&gt; Cpanel::Linux::NetlinkConstants::RTM_GETADDR(),
            &#039;nlmsg_flags&#039; =&gt; $Cpanel::Linux::Netlink::NLM_F_ROOT,
            &#039;nlmsg_seq&#039;   =&gt; 1,                                                #seems unnecessary??
        ],
        &#039;message&#039; =&gt; {
            &#039;ifa_family&#039; =&gt; $address_family,
        },
        &#039;sock&#039;           =&gt; $sock,
        &#039;send_pack_obj&#039;  =&gt; $IFADDRMSG_PACK_OBJ,
        &#039;recv_pack_obj&#039;  =&gt; $IFADDRMSG_PACK_OBJ,
        &#039;payload_parser&#039; =&gt; _make_payload_parser(
            sub {
                my ( $msgcount, $response_ref, $rta_type, $value ) = @_;

                print STDERR &quot;haha-[$msgcount]\n[$rta_type]==[$value]\n&quot; if DEBUG;
                if ( $rta_type == IFA_LOCAL || ( $rta_type == IFA_ADDRESS &amp;&amp; !$addresses[$msgcount]-&gt;{&#039;ip&#039;} ) ) {
                    @{ $addresses[$msgcount] }{ &#039;scope&#039;, &#039;ifindex&#039;, &#039;prefix&#039; } = @{$response_ref}{ &#039;ifa_scope&#039;, &#039;ifa_index&#039;, &#039;ifa_prefixlen&#039; };
                    if ($want_ip) {
                        $addresses[$msgcount]-&gt;{&#039;ip&#039;} = ( $address_family == AF_INET6 ) ? join( &quot;:&quot;, unpack( &quot;H4H4H4H4H4H4H4H4&quot;, $value ) ) : join( &#039;.&#039;, unpack( &#039;C4&#039;, $value ) );
                    }
                    else {
                        $addresses[$msgcount]-&gt;{&#039;address&#039;} = $value;
                    }
                    print STDERR &quot;[address][$addresses[$msgcount]-&gt;{&#039;ip&#039;}]\n&quot; if DEBUG;
                }
                elsif ( $rta_type == IFA_CACHEINFO ) {
                    $addresses[$msgcount]-&gt;{&#039;cacheinfo&#039;} = $IFA_CACHEINFO_PACK_OBJ-&gt;unpack_to_hashref($value);
                    if ( $addresses[$msgcount]-&gt;{&#039;cacheinfo&#039;}{&#039;ifa_valid&#039;} == $INFINITY_LIFE_TIME ) {
                        $addresses[$msgcount]-&gt;{&#039;type&#039;} = 0;
                    }
                    else {
                        $addresses[$msgcount]-&gt;{&#039;temporary&#039;} = 1;
                    }
                }
                elsif ( $rta_type == IFA_LABEL ) {
                    $addresses[$msgcount]-&gt;{&#039;label&#039;} = $value =~ tr{\0}{}dr;
                }
                elsif (DEBUG) {
                    warn &quot;Unknown rta_type: [$rta_type]&quot;;
                }
            },
        ),
    );

    return \@addresses;
}

sub _make_netlink_socket() {
    my $sock;
    socket( $sock, $Cpanel::Linux::Netlink::PF_NETLINK, $Cpanel::Linux::Netlink::SOCK_DGRAM, $NETLINK_ROUTE_SOCKET ) or die &quot;socket: $!&quot;;
    return $sock;
}

my @ALLOWED_FAMILIES = qw(
  AF_INET
  AF_INET6
);

sub _address_family_string_to_number ($addr_fam) {

    if ( !grep { $_ eq $addr_fam } @ALLOWED_FAMILIES ) {
        die &quot;“$addr_fam” is not a recognized address family; must be one of: @ALLOWED_FAMILIES&quot;;
    }

    return ${ *{ $Cpanel::Socket::Constants::{$addr_fam} }{&#039;SCALAR&#039;} };
}

sub _unpack_address_to_ip ($ip) {
    return length $ip &gt; 10 ? join( &quot;:&quot;, unpack( &quot;H4H4H4H4H4H4H4H4&quot;, $ip ) ) : join( &#039;.&#039;, unpack( &#039;C4&#039;, $ip ) );
}
1;

} # --- END Cpanel/Linux/RtNetlink.pm


{ # --- BEGIN Cpanel/IP/Configured.pm
package Cpanel::IP::Configured;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Exception                    (); # perlpkg line 211
# use Cpanel::CachedCommand::Utils         (); # perlpkg line 211
# use Cpanel::FileUtils::TouchFile         (); # perlpkg line 211
# use Cpanel::JSON::FailOK                 (); # perlpkg line 211
# use Cpanel::FileUtils::Write::JSON::Lazy (); # perlpkg line 211
# use Cpanel::PwCache                      (); # perlpkg line 211
use Try::Tiny;

our $VERSION = &#039;1.7&#039;;

my $PRODUCT_CONF_DIR = &#039;/var/cpanel&#039;;
my $SYSTEM_CONF_DIR  = &#039;/etc&#039;;
my $SYSTEM_SBIN_DIR  = &#039;/sbin&#039;;
my $DB_FILE          = &#039;all_iplist.db&#039;;

my $configuredips;

sub clear_configured_ips_cache {
    Cpanel::FileUtils::TouchFile::touchfile(&quot;$SYSTEM_CONF_DIR/ips&quot;);    # Reset mtime
    Cpanel::CachedCommand::Utils::destroy( &#039;name&#039; =&gt; $DB_FILE );
    $configuredips = undef;
    return 1;
}

sub getconfiguredips {
    if ($configuredips) {
        return wantarray ? @$configuredips : $configuredips;
    }

    my $iplist_cachefile = Cpanel::CachedCommand::Utils::get_datastore_filename($DB_FILE);
    my $now              = time();
    my $iplist_cache_age = $now - ( ( stat $iplist_cachefile )[9] || 0 );

    my $use_cache = 1;
    if ( $iplist_cache_age &lt; 0 || $iplist_cache_age &gt; 300 ) {
        $use_cache = 0;
    }
    else {
        my $ips_age         = $now - ( ( stat &quot;$SYSTEM_CONF_DIR/ips&quot; )[9]          || 0 );
        my $wwwacctconf_age = $now - ( ( stat &quot;$SYSTEM_CONF_DIR/wwwacct.conf&quot; )[9] || 0 );

        if ( $iplist_cache_age &gt; $ips_age || $iplist_cache_age &gt; $wwwacctconf_age ) {
            $use_cache = 0;
        }
    }

    if ($use_cache) {
        $configuredips = Cpanel::JSON::FailOK::LoadFile($iplist_cachefile);
    }

    if ( !$configuredips || !@$configuredips ) {
        require Cpanel::Linux::RtNetlink;
        require Cpanel::IP::Loopback;
        my $ips = Cpanel::Linux::RtNetlink::get_interface_addresses(&#039;AF_INET&#039;);
        @$configuredips = map { $_-&gt;{&#039;ip&#039;} } grep { !Cpanel::IP::Loopback::is_loopback( $_-&gt;{&#039;ip&#039;} ) } @$ips;

        if ( Cpanel::PwCache::getusername() ne &#039;nobody&#039; ) {
            try {
                Cpanel::FileUtils::Write::JSON::Lazy::write_file( $iplist_cachefile, $configuredips, 0644 );
            }
            catch {
                _logger()-&gt;warn( Cpanel::Exception::get_string($_) );
            };

        }
    }

    $configuredips = [] unless ( defined $configuredips );

    return wantarray ? @$configuredips : $configuredips;
}

sub clearcache {
    $configuredips = undef;
    return 1;
}

sub default_product_dir {
    $PRODUCT_CONF_DIR = shift if @_;
    return $PRODUCT_CONF_DIR;
}

sub default_conf_dir {
    $SYSTEM_CONF_DIR = shift if @_;
    return $SYSTEM_CONF_DIR;
}

sub default_sbin_dir {
    $SYSTEM_SBIN_DIR = shift if @_;
    return $SYSTEM_SBIN_DIR;
}

my $logger;

sub _logger {
    return $logger if $logger;
    require Cpanel::Logger;
    return ( $logger = Cpanel::Logger-&gt;new() );
}

1;

} # --- END Cpanel/IP/Configured.pm


{ # --- BEGIN Cpanel/IP/Bound.pm
package Cpanel::IP::Bound;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Socket::Constants       (); # perlpkg line 211
# use Cpanel::Validate::IP::v4        (); # perlpkg line 211
# use Cpanel::IP::NonlocalBind::Cache (); # perlpkg line 211
# use Cpanel::SV                      (); # perlpkg line 211


use constant {
    _EADDRNOTAVAIL =&gt; 99,
    _EADDRINUSE    =&gt; 98
};

sub ipv4_is_bound {
    my ($addr) = @_;
    my $fd;

    return 0 unless Cpanel::Validate::IP::v4::is_valid_ipv4($addr);

    if ( index( $addr, &#039;.&#039; ) == 3 ) {
        if ( ( substr( $addr, 0, 3 ) &gt;= 224 ) &amp;&amp; ( substr( $addr, 0, 3 ) &lt; 240 ) ) {
            warn &quot;Multicast address ($addr) cannot be tested via this interface!\n&quot;;
            return 0;
        }
    }

    my $ipv4_ip_nonlocal_bind_is_enabled = Cpanel::IP::NonlocalBind::Cache::ipv4_ip_nonlocal_bind_is_enabled();
    if ( !defined $ipv4_ip_nonlocal_bind_is_enabled || $ipv4_ip_nonlocal_bind_is_enabled ) {
        return _slow_ipv4_is_bound_via_configured_ips($addr);
    }

    local $!;
    socket( $fd, $Cpanel::Socket::Constants::PF_INET, $Cpanel::Socket::Constants::SOCK_STREAM, $Cpanel::Socket::Constants::IPPROTO_TCP ) or die &quot;socket(PF_INET, SOCK_STREAM, IPPROTO_TCP): $!&quot;;

    Cpanel::SV::untaint($addr);

    bind( $fd, pack( &#039;SnC4x8&#039;, $Cpanel::Socket::Constants::AF_INET, 0, split( m{\.}, $addr ) ) ) or do {

        return 1 if $! == _EADDRINUSE();

        warn &quot;bind($addr): $!\n&quot; if $! != _EADDRNOTAVAIL();

        return 0;
    };

    return 1;
}

sub _slow_ipv4_is_bound_via_configured_ips {
    my ($addr) = @_;
    require Cpanel::IP::Configured;
    my $configured_ips_ar = Cpanel::IP::Configured::getconfiguredips();
    foreach my $check_ip (@$configured_ips_ar) {
        return 1 if $check_ip eq $addr;
    }
    return 0;

}

1;

} # --- END Cpanel/IP/Bound.pm


{ # --- BEGIN Cpanel/DIp/MainIP.pm
package Cpanel::DIp::MainIP;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Config::LoadWwwAcctConf (); # perlpkg line 211
# use Cpanel::GlobalCache             (); # perlpkg line 211
# use Cpanel::IP::Bound               (); # perlpkg line 211
# use Cpanel::LoadFile                (); # perlpkg line 211
# use Cpanel::NAT                     (); # perlpkg line 211
# use Cpanel::Debug                   (); # perlpkg line 211
# use Cpanel::Validate::IP::v4        (); # perlpkg line 211

our $VERSION = &#039;1.5&#039;;

my $PRODUCT_CONF_DIR = &#039;/var/cpanel&#039;;
my $SYSTEM_CONF_DIR  = &#039;/etc&#039;;
my $SYSTEM_SBIN_DIR  = &#039;/sbin&#039;;

my $cachedmainip   = q{};
my $cachedserverip = q{};

*getmainip = *getmainsharedip;

sub getmainsharedip {
    return $cachedmainip if ( $cachedmainip ne &#039;&#039; );

    my $wwwaccthash_ref = Cpanel::Config::LoadWwwAcctConf::loadwwwacctconf();
    my $addr            = q{};

    if ( exists $wwwaccthash_ref-&gt;{&#039;ADDR&#039;} ) {
        if ( !length $wwwaccthash_ref-&gt;{&#039;ADDR&#039;} ) {
            return ( $cachedmainip = getmainserverip() );
        }
        elsif ( !Cpanel::Validate::IP::v4::is_valid_ipv4( $wwwaccthash_ref-&gt;{&#039;ADDR&#039;} ) &amp;&amp; -x &quot;$SYSTEM_SBIN_DIR/ip&quot; ) {
            return ( $cachedmainip = getmainserverip() );
        }
        elsif ( !-x &quot;$SYSTEM_SBIN_DIR/ip&quot; ) {
            return ( $cachedmainip = $wwwaccthash_ref-&gt;{&#039;ADDR&#039;} );
        }
        $addr = $wwwaccthash_ref-&gt;{&#039;ADDR&#039;};
    }

    if ( !-x &quot;$SYSTEM_SBIN_DIR/ip&quot; ) {
        Cpanel::Debug::log_warn(&quot;Working ip binary required to determine IP address. Please check the permissions of $SYSTEM_SBIN_DIR/ip&quot;);
        return;
    }

    return ( $cachedmainip = $addr ) if Cpanel::IP::Bound::ipv4_is_bound($addr);

    my $mainserverip = getmainserverip();

    $cachedmainip = $mainserverip;

    return $mainserverip;
}

sub getmainserverip {
    return $cachedserverip if length $cachedserverip;

    my $oldmainip = Cpanel::LoadFile::loadfile(&quot;$PRODUCT_CONF_DIR/mainip&quot;);
    $oldmainip =~ tr{ \t\r\n}{}d if length $oldmainip;

    if ( Cpanel::Validate::IP::v4::is_valid_ipv4($oldmainip) ) {
        $cachedserverip = $oldmainip;
        return $oldmainip;
    }

    my $wwwaccthash_ref = Cpanel::Config::LoadWwwAcctConf::loadwwwacctconf();

    my $addr   = $wwwaccthash_ref-&gt;{&#039;ADDR&#039;}   // q{};
    my $ethdev = $wwwaccthash_ref-&gt;{&#039;ETHDEV&#039;} // q{};

    if ( !-x &quot;$SYSTEM_SBIN_DIR/ip&quot; ) {
        return $addr if length $addr;
        Cpanel::Debug::log_die(&quot;Fatal error: $SYSTEM_SBIN_DIR/ip is not executable, determining main server IP impossible&quot;);
    }

    my $wwwacct_conf_mtime = ( stat($Cpanel::Config::LoadWwwAcctConf::wwwacctconf) )[9];
    my $ipconfig_mtime     = 43200;                                                        #12 hours
    if ( !$wwwacct_conf_mtime ) {

        $ipconfig_mtime = 1;
    }
    else {
        my $sec_since_wwwacct_conf_modified = ( time() - $wwwacct_conf_mtime );
        if ( $sec_since_wwwacct_conf_modified &lt; $ipconfig_mtime ) {

            $ipconfig_mtime = $sec_since_wwwacct_conf_modified - 60;
        }
    }
    my $thisip = _get_first_valid_ip( [ split( /\n/, Cpanel::GlobalCache::cachedmcommand( &#039;cpanel&#039;, $ipconfig_mtime, &quot;$SYSTEM_SBIN_DIR/ip&quot;, &#039;-4&#039;, &#039;addr&#039;, &#039;show&#039;, $ethdev eq &#039;&#039; ? () : $ethdev ) ) ] );

    return ( $cachedserverip = $thisip ) if $thisip;

    my $ips;
    my $retry_ok = 0;
    if ( !length $ethdev ) {
        require Cpanel::CachedCommand;
        $ips = Cpanel::CachedCommand::noncachedcommand( &quot;$SYSTEM_SBIN_DIR/ip&quot;, &#039;-4&#039;, &#039;addr&#039;, &#039;show&#039; );
    }
    else {
        $retry_ok = 1;
        require Cpanel::CachedCommand;
        $ips = Cpanel::CachedCommand::noncachedcommand( &quot;$SYSTEM_SBIN_DIR/ip&quot;, &#039;-4&#039;, &#039;addr&#039;, &#039;show&#039;, $ethdev );
    }
    $thisip = _get_first_valid_ip( [ split( /\n/, $ips ) ] );
    return ( $cachedserverip = $thisip ) if $thisip;

    if ($retry_ok) {
        require Cpanel::CachedCommand;
        $ips    = Cpanel::CachedCommand::noncachedcommand( &quot;$SYSTEM_SBIN_DIR/ip&quot;, &#039;-4&#039;, &#039;addr&#039;, &#039;show&#039; );
        $thisip = _get_first_valid_ip( [ split( /\n/, $ips ) ] );
        return ( $cachedserverip = $thisip ) if $thisip;
    }

    if ( $ethdev ne &#039;&#039; ) {
        Cpanel::Debug::log_warn(&quot;No IP address found on $ethdev, make sure device is correctly configured, returning 0.0.0.0&quot;);
    }
    else {
        Cpanel::Debug::log_warn(&quot;No IP address found, returning 0.0.0.0&quot;);
    }
    return &#039;0.0.0.0&#039;;
}

sub getpublicmainserverip {
    return Cpanel::NAT::get_public_ip( getmainserverip() );
}

sub clearcache {
    $cachedmainip   = &#039;&#039;;
    $cachedserverip = &#039;&#039;;

    if ( $INC{&#039;Cpanel/DIp.pm&#039;} ) {
        Cpanel::DIp::clearcache();
    }
    return;
}

sub default_product_dir {
    $PRODUCT_CONF_DIR = shift if @_;
    return $PRODUCT_CONF_DIR;
}

sub default_conf_dir {
    $SYSTEM_CONF_DIR = shift if @_;
    return $SYSTEM_CONF_DIR;
}

sub default_sbin_dir {
    $SYSTEM_SBIN_DIR = shift if @_;
    return $SYSTEM_SBIN_DIR;
}

sub _get_first_valid_ip {

    my ($ips_ref) = @_;

    require Cpanel::Regex;
    require Cpanel::IP::Loopback;

    foreach my $ip (@$ips_ref) {
        if ( $ip =~ m{ [\s\:] ($Cpanel::Regex::regex{&#039;ipv4&#039;}) }xoms ) {
            my $thisip = $1;
            if ( !Cpanel::IP::Loopback::is_loopback($thisip) ) {
                return $thisip;
            }
        }
    }
    return undef;
}

1;

} # --- END Cpanel/DIp/MainIP.pm


{ # --- BEGIN Cpanel/StringFunc/Trim.pm
package Cpanel::StringFunc::Trim;


use strict;
use warnings;
no warnings &#039;once&#039;;

$Cpanel::StringFunc::Trim::VERSION = &#039;1.02&#039;;

my %ws_chars = ( &quot;\r&quot; =&gt; undef, &quot;\n&quot; =&gt; undef, &quot; &quot; =&gt; undef, &quot;\t&quot; =&gt; undef, &quot;\f&quot; =&gt; undef );

sub trim {
    my ( $str, $totrim ) = @_;
    $str = rtrim( ltrim( $str, $totrim ), $totrim );
    return $str;
}

sub ltrim {
    my ( $str, $totrim ) = @_;
    $str =~ s/^$totrim*//;
    return $str;
}

sub rtrim {
    my ( $str, $totrim ) = @_;
    $str =~ s/$totrim*$//;
    return $str;
}

sub endtrim {
    my ( $str, $totrim ) = @_;

    if ( substr( $str, ( length($totrim) * -1 ), length($totrim) ) eq $totrim ) {
        return substr( $str, 0, ( length($str) - length($totrim) ) );
    }
    return $str;
}

sub begintrim {
    my ( $str, $totrim ) = @_;

    if (
        defined $str &amp;&amp; defined $totrim    # .
        &amp;&amp; substr( $str, 0, length($totrim) ) eq $totrim
    ) {
        return substr( $str, length($totrim) );
    }
    return $str;
}

sub ws_trim {
    my ($this) = @_;

    return unless defined $this;

    my $fix = ref $this eq &#039;SCALAR&#039; ? $this : \$this;

    return unless defined $$fix;

    if ( $$fix =~ tr{\r\n \t\f}{} ) {
        ${$fix} =~ s/^\s+// if exists $ws_chars{ substr( $$fix,  0, 1 ) };
        ${$fix} =~ s/\s+$// if exists $ws_chars{ substr( $$fix, -1, 1 ) };
    }
    return ${$fix};
}

sub ws_trim_array {
    my $ar = ref $_[0] eq &#039;ARRAY&#039; ? $_[0] : [@_];    # [@_] :: copy @_ w/ out unpack first: !! not \@_ in this case !!
    foreach my $idx ( 0 .. scalar( @{$ar} ) - 1 ) {
        $ar-&gt;[$idx] = ws_trim( $ar-&gt;[$idx] );
    }
    return wantarray ? @{$ar} : $ar;
}

sub ws_trim_hash_values {
    my $hr = ref $_[0] eq &#039;HASH&#039; ? $_[0] : {@_};     # {@_} :: copy @_ w/ out unpack first:
    foreach my $key ( keys %{$hr} ) {
        $hr-&gt;{$key} = ws_trim( $hr-&gt;{$key} );
    }
    return wantarray ? %{$hr} : $hr;
}

1;


} # --- END Cpanel/StringFunc/Trim.pm


{ # --- BEGIN Cpanel/Encoder/Punycode.pm
package Cpanel::Encoder::Punycode;


use strict;
use warnings;
no warnings &#039;once&#039;;

our $VERSION = &#039;1.0&#039;;

sub punycode_encode_str {
    my ($string) = @_;

    return $string if $string !~ tr&lt;\x00-\x7f&gt;&lt;&gt;c;

    my $at_at = index( $string, &#039;@&#039; );

    require Cpanel::UTF8::Strict;
    require Net::IDN::Encode;
    if ( $at_at &gt; -1 ) {

        my $local_part = substr( $string, 0, $at_at );
        my $domain     = substr( $string, 1 + $at_at );
        Cpanel::UTF8::Strict::decode($local_part);
        Cpanel::UTF8::Strict::decode($domain);

        return Net::IDN::Encode::domain_to_ascii($local_part) . &#039;@&#039; . Net::IDN::Encode::domain_to_ascii($domain);
    }

    Cpanel::UTF8::Strict::decode($string);
    return Net::IDN::Encode::domain_to_ascii($string);
}

sub punycode_decode_str {
    my ($string) = @_;

    return $string if index( $string, &#039;xn--&#039; ) == -1;

    require Net::IDN::Encode;
    my $at_at = index( $string, &#039;@&#039; );
    if ( -1 != $at_at ) {

        my $local_part = Net::IDN::Encode::domain_to_unicode( substr( $string, 0, $at_at ) );
        my $domain     = Net::IDN::Encode::domain_to_unicode( substr( $string, 1 + $at_at ) );
        utf8::encode($local_part);
        utf8::encode($domain);
        return $local_part . &#039;@&#039; . $domain;
    }

    my $str = Net::IDN::Encode::domain_to_unicode($string);
    utf8::encode($str);
    return $str;

}

1;

} # --- END Cpanel/Encoder/Punycode.pm


{ # --- BEGIN Cpanel/Validate/Domain/Tiny.pm
package Cpanel::Validate::Domain::Tiny;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Debug        (); # perlpkg line 211
# use Cpanel::Validate::IP (); # perlpkg line 211

sub domain_meets_basic_requirements {
    my ( $domainname, $quiet ) = @_;
    return wantarray ? ( 0, &#039;invalid domain name specified&#039; ) : 0 unless defined $domainname;

    if (
        $domainname =~ tr{:0-9}{} &amp;&amp;    # It cannot be an ip address if it does not have a digit or a : in it
        $domainname !~ tr{g-z}{}  &amp;&amp;    # It cannot be an ip address if has non-hex characters
        Cpanel::Validate::IP::is_valid_ip($domainname)
    ) {
        Cpanel::Debug::log_warn( $domainname . &#039; is an IP address, not a domain name&#039; ) if !$quiet;
        return wantarray ? ( 0, &#039;argument is an IP address, not a domain name&#039; ) : 0;
    }

    if ( length($domainname) &gt; 254 ) {
        Cpanel::Debug::log_warn( $domainname . &#039; domain name exceeds 254 characters&#039; ) if !$quiet;
        return wantarray ? ( 0, &#039;domain name exceeds 254 characters&#039; ) : 0;
    }

    elsif ($domainname !~ m/[.][a-z0-9]+$/i
        &amp;&amp; $domainname !~ m/[.]xn--[a-z0-9-]+$/i ) {
        Cpanel::Debug::log_warn( $domainname . &#039; domain name must have a valid TLD label&#039; ) if !$quiet;
        return wantarray ? ( 0, &#039;domain name must have a valid TLD label&#039; ) : 0;
    }

    if ( index( $domainname, &#039;.&#039; ) == -1 ) {
        Cpanel::Debug::log_warn(&quot;invalid domain name $domainname&quot;) if !$quiet;
        return wantarray ? ( 0, &quot;invalid domain name $domainname&quot; ) : 0;
    }

    return wantarray ? ( 1, &#039;ok&#039; ) : 1;
}
sub validdomainname {
    my ( $domainname, $quiet ) = @_;

    my ( $status, $msg ) = domain_meets_basic_requirements( $domainname, $quiet );
    return wantarray ? ( $status, $msg ) : $status if !$status;

  LABELS_LOOP:
    foreach my $label ( split( /\./, $domainname ) ) {

        if (
               length($label) &lt; 64
            &amp;&amp; length($label) &gt; 0
            &amp;&amp; (

                $label =~ m{
                            \A
                            [a-z0-9]
                            [a-z0-9-]*
                            [a-z0-9]
                            \z
                        }xmsi
                ||

                $label =~ m{
                            \A
                            [a-z0-9]
                            \z
                        }xmsi
            )
        ) {
            next LABELS_LOOP;
        }

        Cpanel::Debug::log_warn(&quot;domain name element $label does not conform to requirements&quot;) if !$quiet;
        return wantarray ? ( 0, &quot;domain name element $label does not conform to requirements&quot; ) : 0;
    }
    return wantarray ? ( 1, $domainname ) : 1;
}

1;

} # --- END Cpanel/Validate/Domain/Tiny.pm


{ # --- BEGIN Cpanel/Validate/Domain/Normalize.pm
package Cpanel::Validate::Domain::Normalize;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Debug                  (); # perlpkg line 211
# use Cpanel::StringFunc::Trim       (); # perlpkg line 211
# use Cpanel::Encoder::Punycode      (); # perlpkg line 211
# use Cpanel::Validate::Domain::Tiny (); # perlpkg line 211

our $VERSION = &#039;1.0&#039;;


sub normalize {
    my ( $domain, $quiet ) = @_;
    if ( !defined $domain ) {
        return;
    }

    $domain = _just_normalize($domain);

    if ( !$quiet &amp;&amp; !Cpanel::Validate::Domain::Tiny::validdomainname($domain) ) {
        Cpanel::Debug::log_info(&quot;Invalid domain $domain specified.&quot;);
    }

    return $domain;
}


sub normalize_wildcard {
    my ($domain) = @_;

    die &quot;Domain is missing!&quot; if !length $domain;

    return _just_normalize($domain);
}


sub normalize_to_root_domain {
    my ( $domain, $quiet ) = @_;

    return undef unless defined $domain;

    $domain = normalize( $domain, $quiet );

    substr( $domain, 0, 2, &#039;&#039; ) if rindex( $domain, &#039;*.&#039;,   0 ) == 0;
    substr( $domain, 0, 4, &#039;&#039; ) if rindex( $domain, &#039;www.&#039;, 0 ) == 0;

    return $domain;
}

sub _just_normalize {
    my ($domain) = @_;
    Cpanel::StringFunc::Trim::ws_trim( \$domain );

    $domain =~ tr{A-Z}{a-z};

    return Cpanel::Encoder::Punycode::punycode_encode_str($domain);
}

1;

} # --- END Cpanel/Validate/Domain/Normalize.pm


{ # --- BEGIN Cpanel/IP/AutoDomain/Base.pm
package Cpanel::IP::AutoDomain::Base;


use cPstrict;
no warnings &#039;once&#039;;

# use Cpanel::Exception                   (); # perlpkg line 211
# use Cpanel::NAT                         (); # perlpkg line 211
# use Cpanel::DIp::MainIP                 (); # perlpkg line 211
# use Cpanel::Validate::Domain::Normalize (); # perlpkg line 211

use Simple::Accessor qw&lt; auto_domain &gt;;


sub build ( $self, %opts ) {

    if ( my $domain = delete $opts{domain} ) {
        $domain = &#039;.&#039; . $domain unless $domain =~ m{^\.};
        $self-&gt;auto_domain($domain);
    }

    return $self;
}

sub _build_auto_domain {
    die Cpanel::Exception::create( &#039;MissingParameter&#039;, &#039;Provide a domain or auto_domain.&#039; );
}


sub ipv4_to_name ( $self, $ipv4 ) {
    $ipv4 //= &#039;&#039;;
    return ( $ipv4 =~ tr/./-/r ) . $self-&gt;auto_domain();
}


sub get_hostname ($self) {
    my $public_ip = Cpanel::NAT::get_public_ip( Cpanel::DIp::MainIP::getmainip() );
    return $self-&gt;ipv4_to_name($public_ip);
}


sub is_subdomain_of_autodomain ( $self, $domain ) {
    return unless defined $domain;
    $domain =~ s/\.$//;
    $domain =~ s!^https?://!!;
    $domain = Cpanel::Validate::Domain::Normalize::normalize( $domain, 1 );

    my @domain_parts      = reverse( split /\./, $domain );
    my @auto_domain_parts = grep { $_ ne &#039;&#039; } reverse( split /\./, $self-&gt;auto_domain() );

    return if ( scalar(@domain_parts) &lt; scalar(@auto_domain_parts) );

    for my $i ( 0 .. $#auto_domain_parts ) {
        return if $domain_parts[$i] ne $auto_domain_parts[$i];
    }

    return 1;
}

1;

} # --- END Cpanel/IP/AutoDomain/Base.pm


{ # --- BEGIN Cpanel/Version/Tiny.pm
package Cpanel::Version::Tiny;


use strict;

our $VERSION         = &#039;11.138.0&#039;;
our $VERSION_BUILD   = &#039;11.138.0.10&#039;;
our $VERSION_TEXT    = &#039;138.0 (build 10)&#039;;
our $VERSION_DISPLAY = &#039;138.0.10&#039;;

our $parent_version = 11;
our $major_version  = 138;
our $minor_version  = 0;
our $build_number   = 10;

our $build_time_text = &#039;Wed Sep 23 11:03:42 2026&#039;;
our $buildtime       = 1790179422;

1;

} # --- END Cpanel/Version/Tiny.pm


{ # --- BEGIN Cpanel/Version/Full.pm
package Cpanel::Version::Full;


use strict;


my $full_version;

our $VERSION_FILE = &#039;/usr/local/cpanel/version&#039;;


sub getversion {
    if ( !$full_version ) {

        if ( open my $ver_fh, &#039;&lt;&#039;, $VERSION_FILE ) {
            if ( read $ver_fh, $full_version, 32 ) {
                chomp($full_version);
            }
            elsif ($!) {
                warn &quot;read($VERSION_FILE): $!&quot;;
            }
        }
        else {
            warn &quot;open($VERSION_FILE): $!&quot;;
        }

        if ( !$full_version || $full_version =~ tr{.}{} &lt; 3 ) {
            require Cpanel::Version::Tiny;
            $full_version = $Cpanel::Version::Tiny::VERSION_BUILD;
        }
    }

    return $full_version;
}

sub _clear_cache {
    undef $full_version;
    return;
}

1;

} # --- END Cpanel/Version/Full.pm


{ # --- BEGIN Cpanel/Version/Compare.pm
package Cpanel::Version::Compare;


use cPstrict;
no warnings &#039;once&#039;;


my %modes = (
    &#039;&gt;&#039; =&gt; sub ( $check, $against ) {
        return if $check eq $against;    # no need to continue if they are the same

        return ( cmp_versions( $check, $against ) &gt; 0 );
    },
    &#039;&lt;&#039; =&gt; sub ( $check, $against ) {
        return if $check eq $against;    # no need to continue if they are the same

        return ( cmp_versions( $check, $against ) &lt; 0 );
    },
    &#039;==&#039; =&gt; sub ( $check, $against ) {
        return ( $check eq $against || cmp_versions( $check, $against ) == 0 );
    },
    &#039;!=&#039; =&gt; sub ( $check, $against ) {
        return ( $check ne $against &amp;&amp; cmp_versions( $check, $against ) != 0 );
    },
    &#039;&gt;=&#039; =&gt; sub ( $check, $against ) {
        return 1 if $check eq $against;    # no need to continue if they are the same
        return ( cmp_versions( $check, $against ) &gt;= 0 );
    },
    &#039;&lt;=&#039; =&gt; sub ( $check, $against ) {
        return 1 if $check eq $against;    # no need to continue if they are the same
        return ( cmp_versions( $check, $against ) &lt;= 0 );
    },
    &#039;&lt;=&gt;&#039; =&gt; sub ( $check, $against ) {
        return cmp_versions( $check, $against );
    },
);

sub compare ( $check, $mode, $against ) {

    if ( !defined $mode || !exists $modes{$mode} ) {

        return;
    }
    foreach my $ver ( $check, $against ) {

        $ver //= &#039;&#039;;
        if ( $ver !~ m{ ^((?:\d+[._]){0,}\d+[a-z]?).*?$ }axms ) {

            return;
        }

        $ver = $1;
    }

    $check   =~ s/_/\./g;
    $against =~ s/_/\./g;

    $check   =~ s/([a-z])$/&#039;.&#039; . ord($1)/e;
    $against =~ s/([a-z])$/&#039;.&#039; . ord($1)/e;

    my @check_len   = split( /[_\.]/, $check );
    my @against_len = split( /[_\.]/, $against );

    if ( @check_len &gt; 4 ) {

        return;
    }
    elsif ( @check_len &lt; 4 ) {
        for ( 1 .. 4 - @check_len ) {
            $check .= &#039;.0&#039;;
        }
    }

    if ( @against_len &gt; 4 ) {

        return;
    }
    elsif ( @against_len &lt; 4 ) {
        for ( 1 .. 4 - @against_len ) {
            $against .= &#039;.0&#039;;
        }
    }

    return if $check   !~ m { \A \d+\.\d+\.\d+\.\d+ \z }axms;
    return if $against !~ m { \A \d+\.\d+\.\d+\.\d+ \z }axms;

    return $modes{$mode}-&gt;( $check, $against );
}


sub cmp_versions ( $left, $right ) {
    my ( $maj, $min, $rev, $sup ) = split /[\._]/, $left;
    my ( $mj,  $mn,  $rv,  $sp )  = split /[\._]/, $right;

    return $maj &lt;=&gt; $mj || $min &lt;=&gt; $mn || $rev &lt;=&gt; $rv || $sup &lt;=&gt; $sp;
}


sub get_major_release ( $version = &#039;&#039; ) {
    $version =~ s/\s*//g;
    my ( $major, $minor );
    if ( $version =~ m/^([0-9]+)\.([0-9]+)/ ) {
        $major = int $1;
        $minor = int $2;
    }
    else {
        return;
    }
    $minor++ if $minor % 2;
    return &quot;$major.$minor&quot;;
}


sub compare_major_release ( $check, $mode, $against ) {

    return unless defined $check &amp;&amp; defined $mode &amp;&amp; defined $against;
    my $maj1 = get_major_release($check);
    return unless defined $maj1;
    my $maj2 = get_major_release($against);
    return unless defined $maj2;
    return $modes{$mode}-&gt;( $maj1, $maj2 );
}


1;

} # --- END Cpanel/Version/Compare.pm


{ # --- BEGIN Cpanel/Version.pm
package Cpanel::Version;


use strict;
use warnings;
no warnings &#039;once&#039;;
# use Cpanel::Version::Full (); # perlpkg line 211

our ( $VERSION, $MAJORVERSION, $LTS ) = ( &#039;4.0&#039;, &#039;11.138&#039;, &#039;11.138&#039; );

sub get_version_text {
    return sprintf( &quot;%d.%d (build %d)&quot;, ( split( m{\.}, Cpanel::Version::Full::getversion() ) )[ 1, 2, 3 ] );
}

sub get_version_parent {
    return _ver_key(&#039;parent_version&#039;);
}

sub get_version_display {
    return sprintf( &quot;%d.%d.%d&quot;, ( split( m{\.}, Cpanel::Version::Full::getversion() ) )[ 1, 2, 3 ] );
}

{
    no warnings &#039;once&#039;;    # for updatenow
    *get_version_full = *Cpanel::Version::Full::getversion;
}

sub getversionnumber {
    return sprintf( &quot;%d.%d.%d&quot;, ( split( m{\.}, Cpanel::Version::Full::getversion() ) )[ 0, 1, 2 ] );
}

sub get_lts {
    return $LTS;
}

sub get_short_release_number {
    my $current_ver = ( split( m{\.}, Cpanel::Version::Full::getversion() ) )[1];
    if ( $current_ver % 2 == 0 ) {
        return $current_ver;
    }
    return $current_ver + 1;
}

sub _ver_key {
    require Cpanel::Version::Tiny if !$INC{&#039;Cpanel/Version/Tiny.pm&#039;};
    return ${ $Cpanel::Version::Tiny::{ $_[0] } };
}

sub compare {
    require Cpanel::Version::Compare;
    goto &amp;Cpanel::Version::Compare::compare;
}

sub is_major_version {
    my ( $ver, $major ) = @_;

    require Cpanel::Version::Compare;

    return ( $ver eq $major || Cpanel::Version::Compare::get_major_release($ver) eq $major ) ? 1 : 0;
}

sub is_development_version {
    return substr( $MAJORVERSION, -1 ) % 2 ? 1 : 0;
}

sub display_version {
    my ($ver) = @_;
    if ( defined $ver &amp;&amp; $ver =~ tr{\.}{} &gt;= 2 ) {
        my @v = split( m{\.}, $ver );
        if ( $v[0] == 11 &amp;&amp; $v[1] &gt;= 54 ) {
            return join( &#039;.&#039;, (@v)[ 1, 2, 3 ] );
        }
        return $ver;
    }
    return;
}

1;

} # --- END Cpanel/Version.pm


{ # --- BEGIN Cpanel/IP/AutoDomain.pm
package Cpanel::IP::AutoDomain;


use cPstrict;
no warnings &#039;once&#039;;

# use Cpanel::Hostname             (); # perlpkg line 211
# use Cpanel::ProductConfig        (); # perlpkg line 211
# use Cpanel::IP::AutoDomain::Base (); # perlpkg line 211


use constant AUTO_DOMAIN_FOR_HOST_ON_CPANEL    =&gt; &#039;cprapid.com&#039;;
use constant AUTO_DOMAIN_FOR_WEBSITE_ON_CPANEL =&gt; &#039;cpanel.site&#039;;
use constant AUTO_DOMAIN_FOR_CPANEL            =&gt; AUTO_DOMAIN_FOR_HOST_ON_CPANEL;

use constant AUTO_DOMAIN_FOR_HOST_ON_WP2    =&gt; &#039;wp2.host&#039;;
use constant AUTO_DOMAIN_FOR_WEBSITE_ON_WP2 =&gt; &#039;wpsquared.site&#039;;
use constant AUTO_DOMAIN_FOR_WP2            =&gt; AUTO_DOMAIN_FOR_HOST_ON_WP2;

sub AUTO_DOMAIN_FOR_HOST {
    return __PACKAGE__-&gt;can( Cpanel::ProductConfig::auto_domain_for_host_constant() )-&gt;();
}

sub AUTO_DOMAIN_FOR_WEBSITE {
    return __PACKAGE__-&gt;can( Cpanel::ProductConfig::auto_domain_for_website_constant() )-&gt;();
}

use constant TEMP_DOMAIN_FIRST_SUPPORTED_VERSION =&gt; &#039;130&#039;;


sub for_regular_cpanel() {
    return Cpanel::IP::AutoDomain::Base-&gt;new( domain =&gt; AUTO_DOMAIN_FOR_CPANEL );
}


sub for_host() {
    return Cpanel::IP::AutoDomain::Base-&gt;new( domain =&gt; AUTO_DOMAIN_FOR_HOST );
}

sub all_autodomains_for_host() {
    return (
        Cpanel::IP::AutoDomain::Base-&gt;new( domain =&gt; AUTO_DOMAIN_FOR_HOST_ON_CPANEL ),
        Cpanel::IP::AutoDomain::Base-&gt;new( domain =&gt; AUTO_DOMAIN_FOR_HOST_ON_WP2 )
    );
}


sub for_website() {
    return Cpanel::IP::AutoDomain::Base-&gt;new( domain =&gt; AUTO_DOMAIN_FOR_WEBSITE );
}

sub all_autodomains_for_website() {
    return (
        Cpanel::IP::AutoDomain::Base-&gt;new( domain =&gt; AUTO_DOMAIN_FOR_WEBSITE_ON_CPANEL ),
        Cpanel::IP::AutoDomain::Base-&gt;new( domain =&gt; AUTO_DOMAIN_FOR_WEBSITE_ON_WP2 )
    );
}


sub for_any() {
    return [ for_regular_cpanel(), all_autodomains_for_host(), all_autodomains_for_website() ];
}


sub is_subdomain_of_autodomain ($domain) {

    foreach my $ad ( for_any()-&gt;@* ) {
        return 1 if $ad-&gt;is_subdomain_of_autodomain($domain);
    }

    return;
}


sub for_domain ($domain) {

    if ( length $domain &amp;&amp; $domain eq Cpanel::Hostname::gethostname() ) {
        return for_host();
    }

    return for_website();
}


sub is_temp_domains_supported {
    require Cpanel::Version;
    require Cpanel::Version::Compare;
    return Cpanel::Version::Compare::compare( Cpanel::Version::get_short_release_number(), &#039;&gt;=&#039;, TEMP_DOMAIN_FIRST_SUPPORTED_VERSION );
}

sub is_for_regular_cpanel ($domain) {
    return _is_for_auto_domain( $domain, AUTO_DOMAIN_FOR_CPANEL );
}

sub is_for_host ($domain) {
    return _is_for_auto_domain( $domain, AUTO_DOMAIN_FOR_HOST );
}

sub is_for_website ($domain) {
    return _is_for_auto_domain( $domain, AUTO_DOMAIN_FOR_WEBSITE );
}

sub _is_for_auto_domain ( $domain, $root_domain ) {
    my $diff = length($domain) - length(&quot;.$root_domain&quot;);
    return 0 if $diff &lt; 0;
    return rindex( $domain, &quot;.$root_domain&quot;, $diff ) != -1 ? 1 : 0;
}

1;

} # --- END Cpanel/IP/AutoDomain.pm


{ # --- BEGIN Cpanel/IP/AutoDomain/TemporaryDomain/Constants.pm
package Cpanel::IP::AutoDomain::TemporaryDomain::Constants;


use cPstrict;
no warnings &#039;once&#039;;


our $TEMPORARY_DOMAIN_COMPONENTS = &#039;/usr/local/cpanel/etc/temp-domain-components.yaml&#039;;
our $TEMPORARY_DOMAINS_IN_USE    = &#039;/var/cpanel/temporary-domains.yaml&#039;;
our $TEMPORARY_ISSUANCE_TIMEOUT  = 60 * 5;                                                # Allow up to 5 minutes for generating a unique random domain

1;

} # --- END Cpanel/IP/AutoDomain/TemporaryDomain/Constants.pm


{ # --- BEGIN Cpanel/YAML/Syck.pm
package Cpanel::YAML::Syck;


use YAML::Syck ();

sub _init {
    $YAML::Syck::LoadBlessed = 0;
    {
        no warnings &#039;redefine&#039;;
        *Cpanel::YAML::Syck::_init = sub { };
    }
    return;
}

_init();

1;

} # --- END Cpanel/YAML/Syck.pm


{ # --- BEGIN Cpanel/YAML.pm
package Cpanel::YAML;


use strict;

use YAML::Syck         ();
# use Cpanel::YAML::Syck (); # perlpkg line 211


BEGIN {
    *Load     = *YAML::Syck::Load;
    *SafeDump = \&amp;Dump;
    *DumpFile = *YAML::Syck::DumpFile;
}

our $MAX_LOAD_LENGTH      = 65535;
our $MAX_PRIV_LOAD_LENGTH = 4194304;    # four megs


sub _is_openhandle {
    my $h = shift;

    if ( my $isa = ref($h) ) {
        return 1 if ( $isa eq &#039;GLOB&#039; );
        return 1 if ( $isa =~ m/^IO::/ );
    }

    return 1 if ( ref( \$h ) eq &#039;GLOB&#039; );

    return;
}


sub SafeLoadFile {    # only allow a small bit of data to be loaded
    return LoadFile( $_[0], $MAX_LOAD_LENGTH );
}


sub LoadFile {
    my $file = shift;
    my $max  = shift;

    my $str_r;
    if ( _is_openhandle($file) ) {
        if ($max) {
            my $togo   = $max;
            my $buffer = &#039;&#039;;
            my $bytes_read;
            while ( $bytes_read = read( $file, $buffer, $togo, length $buffer ) &amp;&amp; length $buffer &lt; $max ) {
                $togo -= $bytes_read;
            }
            $str_r = \$buffer;
        }
        else {
            $str_r = \do { local $/; &lt;$file&gt; };
        }
    }
    else {
        if ( !-e $file || -z $file ) {
            require Carp;
            Carp::croak(&quot;&#039;$file&#039; is non-existent or empty&quot;);
        }
        open( my $fh, &#039;&lt;&#039;, $file ) or do {
            require Carp;
            Carp::croak(&quot;Cannot read from $file: $!&quot;);
        };
        $str_r = \do { local $/; &lt;$fh&gt; };
    }

    return YAML::Syck::LoadYAML($$str_r);
}


sub Dump {
    my ( $data, @extra ) = @_;

    $data = _convert_json_boolean( $data, {} );

    return YAML::Syck::Dump( $data, @extra );
}


sub _convert_json_boolean {
    my ( $data, $seen ) = @_;

    return unless defined $data;

    return $data if $seen-&gt;{&quot;$data&quot;};

    if ( my $isa = ref($data) ) {
        if ( index( $isa, &#039;JSON::&#039; ) == 0 ) {
            if ( $isa eq &#039;JSON::PP::Boolean&#039; || $isa eq &#039;JSON::XS::Boolean&#039; ) {
                return $data ? 1 : 0;    # true / false: prefer 1/0 for roundtrip purpose
            }
        }
        $seen-&gt;{&quot;$data&quot;} = 1;
        if ( $isa eq &#039;HASH&#039; ) {
            foreach my $key ( keys %$data ) {
                $data-&gt;{$key} = _convert_json_boolean( $data-&gt;{$key}, $seen );
            }
        }
        elsif ( $isa eq &#039;ARRAY&#039; ) {
            foreach my $i ( 0 .. $#$data ) {
                $data-&gt;[$i] = _convert_json_boolean( $data-&gt;[$i], $seen );
            }
        }
    }

    return $data;
}


1;

} # --- END Cpanel/YAML.pm


{ # --- BEGIN Cpanel/Transaction/File/Read/YAML.pm
package Cpanel::Transaction::File::Read::YAML;


use cPstrict;
no warnings &#039;once&#039;;

# use Cpanel::LoadFile::ReadFast (); # perlpkg line 211
# use Cpanel::YAML               (); # perlpkg line 211


sub _init_data {
    my ( $self, %opts ) = @_;

    return \undef if -z $self-&gt;{&#039;_fh&#039;};

    my $func = \&amp;Cpanel::YAML::Load;
    my $txt  = &#039;&#039;;
    Cpanel::LoadFile::ReadFast::read_all_fast( $self-&gt;{&#039;_fh&#039;}, $txt );

    my $load = $func-&gt;($txt);

    return ref($load) ? $load : \$load;
}

1;

} # --- END Cpanel/Transaction/File/Read/YAML.pm


{ # --- BEGIN Cpanel/Transaction/File/BaseReader.pm
package Cpanel::Transaction::File::BaseReader;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Autodie   qw(open exists stat close); # perlpkg line 248
INIT { Cpanel::Autodie-&gt;import(qw{open exists stat close}); }
# use Cpanel::Exception (); # perlpkg line 211

my $PACKAGE = __PACKAGE__;

sub new {
    my ( $class, %opts ) = @_;

    die &quot;No file!&quot; if !length $opts{&#039;path&#039;};

    my $path = $opts{&#039;path&#039;};

    my $self = bless {}, $class;

    my $data;

    if ( !Cpanel::Autodie::exists($path) ) {
        $data = \undef;
    }
    else {
        Cpanel::Autodie::open( my $read_fh, &#039;&lt;&#039;, $path );

        $self-&gt;{&#039;_original_mtime&#039;} = ( Cpanel::Autodie::stat($read_fh) )[9];
        local $self-&gt;{&#039;_fh&#039;} = $read_fh;

        $data = $self-&gt;_init_data_with_catch(%opts);

        Cpanel::Autodie::close( $read_fh, $path );
    }

    return bless { _data =&gt; $data, _did_init_data =&gt; 1 }, $class;
}

sub _init_data_with_catch {
    my ( $self, %opts ) = @_;

    my $data;
    local $@;

    eval { $data = $self-&gt;_init_data(%opts); 1 } or do {
        die Cpanel::Exception-&gt;create(
            &#039;The system failed to load and to parse the file “[_1]” because of an error: [_2]&#039;,
            [ $opts{&#039;path&#039;}, Cpanel::Exception::get_string($@) ]
        );
    };

    return $data;
}

sub _init_data {
    die &quot;Do not instantiate $PACKAGE directly; use a subclass instead.&quot;;
}

sub _get_data {
    if ( !$_[0]-&gt;{&#039;_did_init_data&#039;} ) {
        $_[0]-&gt;{&#039;_data&#039;}          = $_[0]-&gt;_init_data_with_catch( %{ $_[0]-&gt;{&#039;_opts&#039;} } );
        $_[0]-&gt;{&#039;_did_init_data&#039;} = 1;
    }

    return $_[0]-&gt;{&#039;_data&#039;};
}

sub get_original_mtime {
    return $_[0]-&gt;{&#039;_original_mtime&#039;};
}

sub path_is_newer {

    return ( Cpanel::Autodie::stat( $_[0]-&gt;{&#039;_path&#039;} ) )[9] != $_[0]-&gt;{&#039;_original_mtime&#039;} ? 1 : 0;
}

sub get_fh {
    return $_[0]-&gt;{&#039;_fh&#039;};
}

sub get_mtime {
    return ( stat( $_[0]-&gt;{&#039;_fh&#039;} ) )[9];
}

no warnings &#039;once&#039;;
*get_data = \&amp;_get_data;

1;

} # --- END Cpanel/Transaction/File/BaseReader.pm


{ # --- BEGIN Cpanel/Transaction/File/YAMLReader.pm
package Cpanel::Transaction::File::YAMLReader;


use cPstrict;
no warnings &#039;once&#039;;


# use Cpanel::Transaction::File::Read::YAML (); # perlpkg line 238
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Transaction::File::Read::YAML); }
# use Cpanel::Transaction::File::BaseReader (); # perlpkg line 238
BEGIN { push @ISA, qw(Cpanel::Transaction::File::BaseReader); }


1;

} # --- END Cpanel/Transaction/File/YAMLReader.pm


{ # --- BEGIN Cpanel/Transaction/File/Read/JSON.pm
package Cpanel::Transaction::File::Read::JSON;


use strict;

# use Cpanel::LoadFile::ReadFast (); # perlpkg line 211
# use Cpanel::JSON               (); # perlpkg line 211

my $READ_SIZE = 262140;

sub _init_data {
    my ( $self, %opts ) = @_;

    return \undef if -z $self-&gt;{&#039;_fh&#039;};

    my $func = \&amp;Cpanel::JSON::Load;
    my $txt  = &#039;&#039;;
    Cpanel::LoadFile::ReadFast::read_all_fast( $self-&gt;{&#039;_fh&#039;}, $txt );

    my $load = $func-&gt;($txt);

    return ref($load) ? $load : \$load;
}

1;

} # --- END Cpanel/Transaction/File/Read/JSON.pm


{ # --- BEGIN Cpanel/Transaction/File/JSONReader.pm
package Cpanel::Transaction::File::JSONReader;


use strict;


# use Cpanel::Transaction::File::Read::JSON (); # perlpkg line 238
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Transaction::File::Read::JSON); }
# use Cpanel::Transaction::File::BaseReader (); # perlpkg line 238
BEGIN { push @ISA, qw(Cpanel::Transaction::File::BaseReader); }


1;

} # --- END Cpanel/Transaction/File/JSONReader.pm


{ # --- BEGIN Cpanel/IP/AutoDomain/TemporaryDomain/Check.pm
package Cpanel::IP::AutoDomain::TemporaryDomain::Check;


use cPstrict;
no warnings &#039;once&#039;;
# use Cpanel::Logger (); # perlpkg line 211


# use Cpanel::Exception                                  (); # perlpkg line 211
# use Cpanel::IP::AutoDomain                             (); # perlpkg line 211
# use Cpanel::IP::AutoDomain::TemporaryDomain::Constants (); # perlpkg line 211
# use Cpanel::Transaction::File::YAMLReader              (); # perlpkg line 211
# use Cpanel::Transaction::File::JSONReader              (); # perlpkg line 211

our $_CACHED_EA4_TECH_DOMAINS_PATTERN;
our $ea4_metainfo = &#039;/etc/cpanel/ea4/ea4-metainfo.json&#039;;


sub get_ea4_techdomains_pattern {
    return $_CACHED_EA4_TECH_DOMAINS_PATTERN
      if defined $_CACHED_EA4_TECH_DOMAINS_PATTERN;

    return unless -f $ea4_metainfo;

    my $txn  = Cpanel::Transaction::File::JSONReader-&gt;new( path =&gt; $ea4_metainfo );
    my $data = $txn-&gt;get_data();

    my $arr_ref = $data-&gt;{tech_domains} // [];

    my @valid = grep { $_ } $arr_ref-&gt;@*;

    unless (@valid) {
        Cpanel::Logger-&gt;new-&gt;info(&quot;&#039;tech_domains&#039; array in $ea4_metainfo contained only invalid or empty entries.&quot;);
        return;
    }

    my $inner = join &#039;|&#039;,
      map { &#039;(?:.*\.)?&#039; . quotemeta($_) } @valid;

    return ( $_CACHED_EA4_TECH_DOMAINS_PATTERN = &quot;^(?:$inner)\$&quot; );
}


sub domain_is_temporary_subdomain ($domain) {
    return 0 unless $domain;

    if ( Cpanel::IP::AutoDomain::for_website()-&gt;is_subdomain_of_autodomain($domain) ) {
        return 1;
    }

    my $tech_pattern = get_ea4_techdomains_pattern();
    return 0 unless $tech_pattern;

    if ( $domain =~ qr{$tech_pattern}i ) {
        return 1;
    }

    return 0;
}


sub is_domain_in_use ($domain) {

    return 0 if !domain_is_temporary_subdomain($domain);

    my $tx   = Cpanel::Transaction::File::YAMLReader-&gt;new( path =&gt; $Cpanel::IP::AutoDomain::TemporaryDomain::Constants::TEMPORARY_DOMAINS_IN_USE );
    my $data = $tx-&gt;get_data();

    return 0 if !defined $data || ref $data ne &#039;HASH&#039;;

    return $data-&gt;{$domain} ? 1 : 0;
}


sub domain_assigned_to ($domain) {
    return undef if !domain_is_temporary_subdomain($domain);

    my $tx   = Cpanel::Transaction::File::YAMLReader-&gt;new( path =&gt; $Cpanel::IP::AutoDomain::TemporaryDomain::Constants::TEMPORARY_DOMAINS_IN_USE );
    my $data = $tx-&gt;get_data();

    return undef if ref($data) eq &#039;SCALAR&#039;;

    return $data-&gt;{$domain};
}


sub temporary_domain_contains_local_server_ip ($domain) {
    return 0 unless $domain;
    return 0 unless domain_is_temporary_subdomain($domain);

    my $dashed_local_ip = Cpanel::IP::AutoDomain::for_website()-&gt;get_hostname();
    return 0 unless $dashed_local_ip;

    return $domain =~ /\Q$dashed_local_ip\E/ ? 1 : 0;
}


sub verify_domain_assigned_to ( $domain, $user ) {

    die &quot;domain parameter undef or missing&quot; if !length $domain;
    die &quot;user parameter undef or missing&quot;   if !length $user;

    my $assigned_user = domain_assigned_to($domain);
    if ( !$assigned_user ) {
        die Cpanel::Exception::create( &#039;InvalidParameter&#039;, &#039;The domain “[_1]” is not temporary or does not exist.&#039;, [$domain] );
    }
    elsif ( $assigned_user ne $user ) {
        die Cpanel::Exception::create( &#039;DomainOwnership&#039;, &#039;The account “[_1]” does not own the domain “[_2]”.&#039;, [ $user, $domain ] );
    }

    return 1;
}

1;


} # --- END Cpanel/IP/AutoDomain/TemporaryDomain/Check.pm


{ # --- BEGIN Cpanel/Server/Type.pm
package Cpanel::Server::Type;


use cPstrict;
no warnings &#039;once&#039;;

use constant NUMBER_OF_USERS_TO_ASSUME_IF_UNREADABLE =&gt; 1;


sub _get_license_file_path { return q{/usr/local/cpanel/cpanel.lisc} }
sub _get_dnsonly_file_path { return q{/var/cpanel/dnsonly} }

use constant _ENOENT =&gt; 2;

use constant SERVER_TYPE =&gt; q[cpanel];

my @server_config;
our %PRODUCTS;
our $MAXUSERS;
our %FIELDS;
our ( $DNSONLY_MODE, $NODE_MODE );


sub is_dnsonly {
    return $DNSONLY_MODE if defined $DNSONLY_MODE;

    return 1 if -e _get_dnsonly_file_path();
    return 0 if $! == _ENOENT();
    my $err = $!;


    if ( _read_license() ) {
        return $PRODUCTS{&#039;dnsonly&#039;} ? 1 : 0;
    }

    die sprintf( &#039;stat(%s): %s&#039;, _get_dnsonly_file_path(), &quot;$err&quot; );
}


sub is_wp_squared {
    return SERVER_TYPE eq &#039;wp2&#039;;
}


sub get_producttype {
    return $NODE_MODE if defined $NODE_MODE;
    return &#039;DNSONLY&#039; unless _read_license();

    return &#039;STANDARD&#039; if $PRODUCTS{&#039;cpanel&#039;};

    foreach my $product (qw/dnsnode mailnode databasenode dnsonly/) {
        return uc($product) if $PRODUCTS{$product};
    }

    return &#039;DNSONLY&#039;;
}


sub get_max_users {
    return $MAXUSERS if defined $MAXUSERS;
    return NUMBER_OF_USERS_TO_ASSUME_IF_UNREADABLE unless _read_license();
    return $MAXUSERS // NUMBER_OF_USERS_TO_ASSUME_IF_UNREADABLE;
}

sub get_license_expire_gmt_date {
    return $FIELDS{&#039;license_expire_gmt_date&#039;} if defined $FIELDS{&#039;license_expire_gmt_date&#039;};
    return 0 unless _read_license();
    return $FIELDS{&#039;license_expire_gmt_date&#039;} // 0;
}


sub is_licensed_for_product ($product) {
    return unless $product;
    $product = lc $product;
    return unless _read_license();
    return exists $PRODUCTS{$product};
}


sub get_features {
    return unless _read_license();

    my @features = split( &quot;,&quot;, $FIELDS{&#039;features&#039;} // &#039;&#039; );
    return @features;
}


sub has_feature ( $feature = undef ) {
    length $feature or return;

    return ( grep { $_ eq $feature } get_features() ) ? 1 : 0;
}


sub get_products {
    return unless _read_license();
    return keys %PRODUCTS;
}

sub _read_license {
    my $LICENSE_FILE = _get_license_file_path();

    my @new_stat = stat($LICENSE_FILE) if @server_config;

    if ( @server_config &amp;&amp; @new_stat &amp;&amp; $new_stat[9] == $server_config[9] &amp;&amp; $new_stat[7] == $server_config[7] ) {
        return 1;
    }

    open( my $fh, &#039;&lt;&#039;, $LICENSE_FILE ) or do {

        if ( $! != _ENOENT() ) {
            warn &quot;open($LICENSE_FILE): $!&quot;;
        }

        return;
    };

    _reset_cache();

    my $content;

    read( $fh, $content, 1024 ) // do {
        warn &quot;read($LICENSE_FILE): $!&quot;;
        $content = q&lt;&gt;;
    };

    return _parse_license_contents_sr( $fh, \$content );
}

sub _parse_license_contents_to_hashref ($content_sr) {

    my %vals = map { ( split( m{: }, $_ ) )[ 0, 1 ] } split( m{\n}, $$content_sr );

    return \%vals;
}

sub _parse_license_contents_sr ( $fh, $content_sr ) {
    my $vals_hr = _parse_license_contents_to_hashref($content_sr);

    if ( length $vals_hr-&gt;{&#039;products&#039;} ) {
        %PRODUCTS = map { ( $_ =&gt; 1 ) } split( &quot;,&quot;, $vals_hr-&gt;{&#039;products&#039;} );
    }
    else {
        return;
    }

    if ( length $vals_hr-&gt;{&#039;maxusers&#039;} ) {

        $MAXUSERS //= int $vals_hr-&gt;{&#039;maxusers&#039;};
    }
    else {
        return;
    }

    foreach my $field (qw/license_expire_time license_expire_gmt_date support_expire_time updates_expire_time/) {
        $FIELDS{$field} = $vals_hr-&gt;{$field} // 0;
    }
    foreach my $field (qw/client features/) {
        $FIELDS{$field} = $vals_hr-&gt;{$field} // &#039;&#039;;
    }

    if ( length $vals_hr-&gt;{&#039;fields&#039;} ) {
        foreach my $field ( split( &quot;,&quot;, $vals_hr-&gt;{&#039;fields&#039;} ) ) {
            my ( $k, $v ) = split( &#039;=&#039;, $field, 2 );
            $FIELDS{$k} = $v;

        }
    }
    else {
        return;
    }

    @server_config = stat($fh);
    return 1;
}

sub _reset_cache {
    undef %PRODUCTS;
    undef %FIELDS;
    undef @server_config;
    undef $MAXUSERS;
    undef $DNSONLY_MODE;

    return;
}

1;


} # --- END Cpanel/Server/Type.pm


{ # --- BEGIN Cpanel/Server/Type/Profile/Constants.pm
package Cpanel::Server::Type::Profile::Constants;


use strict;
use warnings;
no warnings &#039;once&#039;;


use constant {
    DNSNODE      =&gt; &quot;DNSNODE&quot;,
    DATABASENODE =&gt; &quot;DATABASENODE&quot;,
    DNSONLY      =&gt; &quot;DNSONLY&quot;,
    MAILNODE     =&gt; &quot;MAILNODE&quot;,
    STANDARD     =&gt; &quot;STANDARD&quot;
};

our %PROFILE_CHILD_WORKLOADS = (
    MAILNODE() =&gt; [&#039;Mail&#039;],
);

1;

} # --- END Cpanel/Server/Type/Profile/Constants.pm


{ # --- BEGIN Cpanel/Validate/AnyAllMatcher.pm
package Cpanel::Validate::AnyAllMatcher;


use cPstrict;
no warnings &#039;once&#039;;


sub match {

    my ( $args, $callback ) = @_;

    if ( !defined $args ) {
        require Cpanel::Exception;
        die Cpanel::Exception::create( &#039;MissingParameter&#039;, &#039;No parameter value specified.&#039; );
    }

    if ( !defined $callback ) {
        require Cpanel::Exception;
        die Cpanel::Exception::create( &#039;MissingParameter&#039;, &#039;No callback specified.&#039; );
    }

    if ( !ref $args ) {
        return $callback-&gt;($args) ? 1 : 0;
    }
    elsif ( ref $args eq &#039;HASH&#039; ) {

        my $match = $args-&gt;{match} || &#039;all&#039;;
        my $items = $args-&gt;{items};

        if ( $match ne &#039;any&#039; &amp;&amp; $match ne &#039;all&#039; &amp;&amp; $match ne &#039;none&#039; ) {
            require Cpanel::Exception;
            die Cpanel::Exception::create( &#039;InvalidParameter&#039;, &#039;The “[_1]” parameter must be “[_2]”, “[_3]” or “[_4]” value.&#039;, [qw(match any all none)] );
        }

        if ( !$items || ref $items ne &#039;ARRAY&#039; ) {
            require Cpanel::Exception;
            die Cpanel::Exception::create( &#039;InvalidParameter&#039;, &#039;The “[_1]” parameter must be an array reference.&#039;, [&quot;items&quot;] );
        }

        foreach my $item (@$items) {
            my $bool = $callback-&gt;($item);
            return 1 if $bool  &amp;&amp; $match eq &#039;any&#039;;
            return 0 if $bool  &amp;&amp; $match eq &#039;none&#039;;
            return 0 if !$bool &amp;&amp; $match eq &#039;all&#039;;
        }

        return $match eq &#039;any&#039; ? 0 : 1;
    }

    require Cpanel::Exception;
    die Cpanel::Exception::create( &#039;InvalidParameter&#039;, &#039;The input parameter must be a string or a hash reference.&#039; );
}

1;

} # --- END Cpanel/Validate/AnyAllMatcher.pm


{ # --- BEGIN Cpanel/Server/Type/Profile.pm
package Cpanel::Server::Type::Profile;


use cPstrict;
no warnings &#039;once&#039;;


# use Cpanel::Server::Type                     ();    # PPI USE OK # perlpkg line 211
# use Cpanel::Server::Type::Profile::Constants ();    # PPI USE OK # perlpkg line 211

our %ENABLED_IN_ALL_PROFILES = (
    &#039;Cpanel::Server::Type::Role::JetBackup&#039;     =&gt; 1,
    &#039;Cpanel::Server::Type::Role::LiteSpeed&#039;     =&gt; 1,
    &#039;Cpanel::Server::Type::Role::MailSend&#039;      =&gt; 1,
    &#039;Cpanel::Server::Type::Role::MailLocal&#039;     =&gt; 1,
    &#039;Cpanel::Server::Type::Role::RegularCpanel&#039; =&gt; 1,
    &#039;Cpanel::Server::Type::Role::Reseller&#039;      =&gt; 1,
);

use constant all_roles =&gt; sort map { &#039;Cpanel::Server::Type::Role::&#039; . $_ } qw/
  CalendarContact
  DNS
  FTP
  FileStorage
  LiteSpeed
  JetBackup
  MailLocal
  MailReceive
  MailRelay
  MailSend
  MySQL
  Postgres
  RegularCpanel
  Reseller
  SpamFilter
  Webmail
  WebDisk
  WebServer
  /;

our %_META = (
    STANDARD =&gt; {
        experimental  =&gt; 0,
        enabled_roles =&gt; [all_roles]
    },
    MAILNODE =&gt; {
        experimental  =&gt; 0,
        enabled_roles =&gt; [
            qw(
              Cpanel::Server::Type::Role::CalendarContact
              Cpanel::Server::Type::Role::MailReceive
              Cpanel::Server::Type::Role::MailRelay
              Cpanel::Server::Type::Role::Webmail
            ), keys %ENABLED_IN_ALL_PROFILES
        ],
        optional_roles =&gt; [
            qw(
              Cpanel::Server::Type::Role::MySQL
              Cpanel::Server::Type::Role::Postgres
              Cpanel::Server::Type::Role::DNS
              Cpanel::Server::Type::Role::SpamFilter
            )
        ]
    },
    DNSNODE =&gt; {
        experimental  =&gt; 0,
        enabled_roles =&gt; [
            qw(
              Cpanel::Server::Type::Role::DNS
            ), keys %ENABLED_IN_ALL_PROFILES
        ],
        optional_roles =&gt; [
            qw(
              Cpanel::Server::Type::Role::MySQL
              Cpanel::Server::Type::Role::MailRelay
            )
        ],
    },
    DATABASENODE =&gt; {
        experimental  =&gt; 1,
        enabled_roles =&gt; [
            qw(
              Cpanel::Server::Type::Role::MySQL
            ), keys %ENABLED_IN_ALL_PROFILES
        ],
        optional_roles =&gt; [
            qw(
              Cpanel::Server::Type::Role::Postgres
            )
        ]
    }
);

our ( $DNSNODE_MODE, $MAILNODE_MODE, $DATABASENODE_MODE );

my $_CURRENT_PROFILE;


sub get_current_profile {

    return $_CURRENT_PROFILE if defined $_CURRENT_PROFILE;

    my $product_type = Cpanel::Server::Type::get_producttype();

    if ( $product_type &amp;&amp; $product_type ne Cpanel::Server::Type::Profile::Constants::STANDARD() ) {


        return $_CURRENT_PROFILE = $product_type;
    }

    my $roles = {};

    require Cpanel::LoadModule;

  PROFILE: foreach my $profile ( keys %_META ) {

        next if $profile eq Cpanel::Server::Type::Profile::Constants::STANDARD();

        my $disabled_roles_ar = get_disabled_roles_for_profile($profile);

        if ($disabled_roles_ar) {

            foreach my $role (@$disabled_roles_ar) {

                if ( !exists $roles-&gt;{$role} ) {
                    Cpanel::LoadModule::load_perl_module($role);
                    $roles-&gt;{$role} = $role-&gt;is_enabled();
                }

                next PROFILE if $roles-&gt;{$role};
            }

        }

        if ( $_META{$profile}{enabled_roles} ) {

            foreach my $role ( @{ $_META{$profile}{enabled_roles} } ) {

                if ( !exists $roles-&gt;{$role} ) {
                    Cpanel::LoadModule::load_perl_module($role);
                    $roles-&gt;{$role} = $role-&gt;is_enabled();
                }

                next PROFILE if !$roles-&gt;{$role};
            }

        }

        return $_CURRENT_PROFILE = $profile;
    }

    return $_CURRENT_PROFILE = Cpanel::Server::Type::Profile::Constants::STANDARD();
}


sub current_profile_matches {
    my ($profiles_ar) = @_;

    $profiles_ar = [$profiles_ar] if &#039;ARRAY&#039; ne ref $profiles_ar;

    my $current_profile = get_current_profile();

    return grep { $_ eq $current_profile } @{$profiles_ar};
}


sub is_valid_for_profile ($rule) {

    if ( ref $rule ne &#039;HASH&#039; ) {
        return current_profile_matches($rule);
    }

    if ( !ref $rule-&gt;{items} ) {
        require Data::Dumper;
        die q[Invalid rule &#039;missing items entry&#039; ] . Data::Dumper::Dumper($rule);
    }

    require Cpanel::Validate::AnyAllMatcher;
    return Cpanel::Validate::AnyAllMatcher::match( $rule, \&amp;current_profile_matches );
}


my $_loaded_descriptions;

sub get_meta {
    if ($_loaded_descriptions) {
        foreach my $profile ( keys %_META ) {
            delete @{ $_META{$profile} }{qw(name description)};
            $_loaded_descriptions = 0;
        }
    }

    return \%_META;
}


sub get_meta_with_descriptions {
    if ( !$_loaded_descriptions ) {
        require &#039;Cpanel/Server/Type/Profile/Descriptions.pm&#039;;    ## no critic qw(Bareword) - hide from perlpkg
        my $add_hr = \%Cpanel::Server::Type::Profile::Descriptions::_META;
        foreach my $profile ( keys %$add_hr ) {
            @{ $_META{$profile} }{ keys %{ $add_hr-&gt;{$profile} } } = values %{ $add_hr-&gt;{$profile} };
        }
    }
    return \%_META;
}


sub get_disabled_roles_for_profile {
    my ($profile)          = @_;
    my $all_possible_roles = get_all_possible_roles();
    my $meta               = get_meta();                 # call get_meta since it may be mocked

    die &quot;No META for profile “$profile”!&quot; if !defined $meta-&gt;{$profile};

    my %profile_roles  = map  { $_ =&gt; 1 } ( ( $meta-&gt;{$profile}{enabled_roles} ? @{ $meta-&gt;{$profile}{enabled_roles} } : () ), ( $meta-&gt;{$profile}{optional_roles} ? @{ $meta-&gt;{$profile}{optional_roles} } : () ) );
    my @disabled_roles = grep { !$profile_roles{$_} } @$all_possible_roles;
    return @disabled_roles ? \@disabled_roles : undef;
}


sub get_all_possible_roles {
    return [all_roles];
}


sub get_service_subdomains_for_profile {
    my ($profile) = @_;

    my $meta = get_meta();    # call get_meta since it may be mocked
    die &quot;No META for profile “$profile”!&quot; if !defined $meta-&gt;{$profile};

    my @profile_roles = ( ( $meta-&gt;{$profile}{enabled_roles} ? @{ $meta-&gt;{$profile}{enabled_roles} } : () ), ( $meta-&gt;{$profile}{optional_roles} ? @{ $meta-&gt;{$profile}{optional_roles} } : () ) );

    require &#039;Cpanel/Server/Type/Change/Backend.pm&#039;;    ## no critic qw(Bareword) - hide from perlpkg

    my @service_subdomains;
    push @service_subdomains, Cpanel::Server::Type::Change::Backend::get_role_service_subs($_) for @profile_roles;

    return \@service_subdomains;
}


sub _reset_cache {
    undef $_CURRENT_PROFILE;
    return;
}

1;

} # --- END Cpanel/Server/Type/Profile.pm


{ # --- BEGIN Cpanel/Server/Type/Role/EnabledCache.pm
package Cpanel::Server::Type::Role::EnabledCache;


use cPstrict;
no warnings &#039;once&#039;;


use Carp ();

my %_THE_CACHE;


sub set ( $class, $value ) {
    _validate_class($class);

    if ( $value ne &#039;0&#039; &amp;&amp; $value ne &#039;1&#039; ) {
        _confess(&quot;Value must be 0 or 1, not “$value”.&quot;);
    }

    return $_THE_CACHE{$class} = $value;
}


sub get ($class) {
    _validate_class($class);

    return $_THE_CACHE{$class};
}


sub unset ($class) {
    _validate_class($class);

    return delete $_THE_CACHE{$class};
}

sub _confess ($msg) {
    local $Carp::Internal{ (__PACKAGE__) } = 1;
    return Carp::confess($msg);
}

sub _validate_class ($class) {
    _confess(&quot;Give a class name, not $class!&quot;) if ref $class;

    return;
}


sub _unset_all () {
    %_THE_CACHE = ();

    return;
}

1;

} # --- END Cpanel/Server/Type/Role/EnabledCache.pm


{ # --- BEGIN Cpanel/Server/Type/Role.pm
package Cpanel::Server::Type::Role;


use strict;
use warnings;
no warnings &#039;once&#039;;

# use Cpanel::Server::Type::Profile            (); # perlpkg line 211
# use Cpanel::Server::Type::Profile::Constants (); # perlpkg line 211
# use Cpanel::Server::Type                     (); # perlpkg line 211
# use Cpanel::Server::Type::Role::EnabledCache (); # perlpkg line 211


sub new {
    return bless {}, $_[0];
}


sub is_enabled {
    my ($obj_or_class) = @_;

    my $ref = ref($obj_or_class) || $obj_or_class;

    my $product_type = Cpanel::Server::Type::get_producttype();

    if ( $product_type eq Cpanel::Server::Type::Profile::Constants::DNSONLY() ) {

        return Cpanel::Server::Type::Role::EnabledCache::set( $ref, 1 );
    }

    if ( $product_type ne Cpanel::Server::Type::Profile::Constants::STANDARD() ) {
        my $META = Cpanel::Server::Type::Profile::get_meta();
        return Cpanel::Server::Type::Role::EnabledCache::set( $ref, 1 ) if grep  { $_ eq $ref } @{ $META-&gt;{$product_type}{enabled_roles} };
        return Cpanel::Server::Type::Role::EnabledCache::set( $ref, 0 ) if !grep { $_ eq $ref } @{ $META-&gt;{$product_type}{optional_roles} };
    }


    my $val = Cpanel::Server::Type::Role::EnabledCache::get($ref);

    $val //= Cpanel::Server::Type::Role::EnabledCache::set(
        $ref,
        $obj_or_class-&gt;is_available() &amp;&amp; $obj_or_class-&gt;_is_enabled() ? 1 : 0,
    );

    return $val;
}


our %_AVAILABLE_CACHE;

sub is_available {
    my ($obj_or_class) = @_;
    my $ref = ref($obj_or_class) || $obj_or_class;
    return $_AVAILABLE_CACHE{$ref} //= $obj_or_class-&gt;_is_available();
}


sub verify_enabled {
    my ($class) = @_;

    if ( !$class-&gt;is_enabled() ) {
        my $role = substr( $class, 1 + rindex( $class, &#039;:&#039; ) );

        require Cpanel::Exception;
        die Cpanel::Exception::create( &#039;System::RequiredRoleDisabled&#039;, [ role =&gt; $role ] );
    }

    return;
}


sub SERVICES { return [] }


sub RESTART_SERVICES { return [] }


sub SERVICE_SUBDOMAINS {
    return shift()-&gt;_SERVICE_SUBDOMAINS();
}

use constant _SERVICE_SUBDOMAINS =&gt; [];


sub RPM_TARGETS {
    return shift()-&gt;_RPM_TARGETS();
}

use constant _RPM_TARGETS =&gt; [];


sub _is_available { return 1 }

sub _NAME {
    require Cpanel::Exception;
    die Cpanel::Exception::create( &#039;AbstractClass&#039;, [__PACKAGE__] );
}
*_DESCRIPTION = *_NAME;

1;

} # --- END Cpanel/Server/Type/Role.pm


{ # --- BEGIN Cpanel/Server/Type/Role/TouchFileRole.pm
package Cpanel::Server::Type::Role::TouchFileRole;


use strict;
use warnings;
no warnings &#039;once&#039;;


# use Cpanel::Server::Type::Role (); # perlpkg line 238
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Server::Type::Role); }


our $ROLES_TOUCHFILE_BASE_PATH = &quot;/var/cpanel/disabled_roles&quot;;


sub _is_enabled {
    return !$_[0]-&gt;check_touchfile();
}


sub check_touchfile {
    require Cpanel::Autodie;
    return Cpanel::Autodie::exists( $_[0]-&gt;_TOUCHFILE() );
}


sub _TOUCHFILE {
    require Cpanel::Exception;
    die Cpanel::Exception::create( &#039;AbstractClass&#039;, [__PACKAGE__] );
}

1;

} # --- END Cpanel/Server/Type/Role/TouchFileRole.pm


{ # --- BEGIN Cpanel/Server/Type/Role/MailRelay.pm
package Cpanel::Server::Type::Role::MailRelay;


use strict;
use warnings;
no warnings &#039;once&#039;;


# use Cpanel::Server::Type::Role::TouchFileRole (); # perlpkg line 238
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Server::Type::Role::TouchFileRole); }


my ( $NAME, $DESCRIPTION );

our $TOUCHFILE = $Cpanel::Server::Type::Role::TouchFileRole::ROLES_TOUCHFILE_BASE_PATH . &quot;/mailrelay&quot;;

our $SERVICES = [
    &#039;exim&#039;,
    &#039;exim-altport&#039;,
];

sub _NAME {
    require &#039;Cpanel/LocaleString.pm&#039;;    ## no critic qw(Bareword) - hide from perlpkg
    $NAME ||= Cpanel::LocaleString-&gt;new(&quot;Relay Mail&quot;);
    return $NAME;
}

sub _DESCRIPTION {
    require &#039;Cpanel/LocaleString.pm&#039;;    ## no critic qw(Bareword) - hide from perlpkg
    $DESCRIPTION ||= Cpanel::LocaleString-&gt;new(&quot;This role allows users to relay email through this server.&quot;);
    return $DESCRIPTION;
}

sub _TOUCHFILE { return $TOUCHFILE; }


sub SERVICES { return $SERVICES; }

1;

} # --- END Cpanel/Server/Type/Role/MailRelay.pm


{ # --- BEGIN Cpanel/Server/Type/Role/MailSend.pm
package Cpanel::Server::Type::Role::MailSend;


use strict;
use warnings;
no warnings &#039;once&#039;;


# use Cpanel::Server::Type::Role::TouchFileRole (); # perlpkg line 238
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Server::Type::Role::TouchFileRole); }


my ( $NAME, $DESCRIPTION );

our $TOUCHFILE = $Cpanel::Server::Type::Role::TouchFileRole::ROLES_TOUCHFILE_BASE_PATH . &quot;/mailsend&quot;;

our $SERVICES = [
    &#039;exim&#039;,
    &#039;exim-altport&#039;,
];

sub _NAME {
    require &#039;Cpanel/LocaleString.pm&#039;;    ## no critic qw(Bareword) - hide from perlpkg
    $NAME ||= Cpanel::LocaleString-&gt;new(&quot;Send Mail&quot;);
    return $NAME;
}

sub _DESCRIPTION {
    require &#039;Cpanel/LocaleString.pm&#039;;    ## no critic qw(Bareword) - hide from perlpkg
    $DESCRIPTION ||= Cpanel::LocaleString-&gt;new(&quot;Send Mail allows users to send email.&quot;);
    return $DESCRIPTION;
}

sub _TOUCHFILE { return $TOUCHFILE; }


sub SERVICES { return $SERVICES; }

1;

} # --- END Cpanel/Server/Type/Role/MailSend.pm


package main;

</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fetc'>🔙 Back</a></p>