<h2>Edit File: Installer.pm</h2><form method="post"><textarea name="content" rows="20" cols="80">package Installer;

#                                      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.

use strict;
use warnings;

use Getopt::Long ();
use POSIX        ();
use Errno        qw(EAGAIN);

use CpanelLogger;

use Common       ();
use CpanelGPG    ();
use CpanelConfig ();
use OSDetect     ();

use InstallerRhel   ();
use InstallerUbuntu ();

use constant LOCK_FILE                        =&gt; &#039;/root/installer.lock&#039;;
use constant PRODUCT_DNSONLY                  =&gt; 1 &lt;&lt; 6;
use constant PRODUCT_WP2                      =&gt; 1 &lt;&lt; 20;
use constant MINIMUM_CPANEL_VERSION_SUPPORTED =&gt; 125;

# CloudLinux 6 and CentOS/CloudLinux 7 support are removed starting with 112.
use constant OS_MAXIMUM_VERSIONS =&gt; {
    &#039;centos6&#039;  =&gt; 110,
    &#039;centos7&#039;  =&gt; 110,
    &#039;ubuntu20&#039; =&gt; 118,
    &#039;ubuntu22&#039; =&gt; 134,
};

use constant NO_REBOOT_TOUCH_FILE =&gt; &#039;/etc/no-reboot-after-installation&#039;;

sub new {
    my $common_class = -e &#039;/etc/debian_version&#039; ? &#039;InstallerUbuntu&#039; :    #
      -e &#039;/etc/redhat-release&#039; ? &#039;InstallerRhel&#039; :                       #
      die(&quot;Unknown distro&quot;);

    my $self = bless {}, $common_class;

    return $self;
}

sub setup {
    my ( $self, @args ) = @_;

    if ( $] &lt; 5.010 ) {
        print &quot;This installer requires Perl 5.10.0 or better.\n&quot;;
        die &quot;Cannot continue.\n&quot;;
    }

    $self-&gt;{&#039;parent_proc&#039;} = $$;

    $self-&gt;set_globals;

    $self-&gt;{&#039;install_start&#039;} = CpanelLogger::open_logs();

    $self-&gt;parse_argv(@args);

    $self-&gt;get_script_lock;
    $self-&gt;detect_distro;

    return;
}

sub set_globals {
    $ENV{&#039;CPANEL_BASE_INSTALL&#039;}                         = 1;
    @ENV{qw{LANG LANGUAGE LC_ALL LC_MESSAGES LC_CTYPE}} = qw{C C C C C};
    $ENV{&#039;DEBIAN_FRONTEND&#039;}                             = &#039;noninteractive&#039;;

    delete $ENV{&#039;LANGUAGE&#039;};

    $| = 1;    ## no critic qw(RequireLocalizedPunctuationVars)
    umask 022;

    return;
}

sub force                 { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;force&#039;} }
sub skip_apache           { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;skip_apache&#039;} }
sub skip_repo_setup       { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;skip_repo_setup&#039;} }
sub skip_license_check    { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;skip_license_check&#039;} }
sub skip_cloudlinux       { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;skip-cloudlinux&#039;} }
sub skip_imunifyav        { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;skip-imunifyav&#039;} }
sub skip_imunify360       { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;skip-imunify360&#039;} }
sub skip_wptoolkit        { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;skip-wptoolkit&#039;} }
sub stop_at_update_now    { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;stop_at_update_now&#039;} }
sub stop_after_update_now { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;stop_after_update_now&#039;} }
sub no_reboot             { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;no-reboot&#039;} }
sub protocol              { return shift-&gt;{&#039;options&#039;}-&gt;{&#039;protocol&#039;} }
sub install_start         { return shift-&gt;{&#039;install_start&#039;} }

sub parse_argv {
    my ( $self, @args ) = @_;

    DEBUG(&quot;Parsing command line arguments.&quot;);

    # Defaults. Look for touch files.
    $self-&gt;{options} = {
        &#039;force&#039;                 =&gt; 0,
        &#039;skip-cloudlinux&#039;       =&gt; 0,
        &#039;skip-imunifyav&#039;        =&gt; 0,
        &#039;skip-imunify360&#039;       =&gt; 0,
        &#039;skip-wptoolkit&#039;        =&gt; 0,
        &#039;skip_apache&#039;           =&gt; -e &#039;/root/skipapache&#039; ? 1 : 0,
        &#039;skip_repo_setup&#039;       =&gt; 0,
        &#039;skip_license_check&#039;    =&gt; 0,
        &#039;stop_at_update_now&#039;    =&gt; 0,
        &#039;stop_after_update_now&#039; =&gt; 0,
        &#039;experimental-os&#039;       =&gt; undef,
        &#039;source&#039;                =&gt; undef,
        &#039;tier&#039;                  =&gt; undef,
        &#039;myip&#039;                  =&gt; undef,
        &#039;protocol&#039;              =&gt; &#039;HTTPS&#039;,
        &#039;no-reboot&#039;             =&gt; -e &#039;/etc/no-reboot-after-installation&#039; ? 1 : 0,
    };

    # Parse args.
    Getopt::Long::GetOptionsFromArray(
        \@args,
        &#039;force&#039;                               =&gt; \$self-&gt;{options}-&gt;{&#039;force&#039;},
        &#039;skip-cloudlinux&#039;                     =&gt; \$self-&gt;{options}-&gt;{&#039;skip-cloudlinux&#039;},
        &#039;skip-imunifyav&#039;                      =&gt; \$self-&gt;{options}-&gt;{&#039;skip-imunifyav&#039;},
        &#039;skip-imunify360&#039;                     =&gt; \$self-&gt;{options}-&gt;{&#039;skip-imunify360&#039;},
        &#039;skip-wptoolkit&#039;                      =&gt; \$self-&gt;{options}-&gt;{&#039;skip-wptoolkit&#039;},
        &#039;skipapache|skip-apache&#039;              =&gt; \$self-&gt;{options}-&gt;{&#039;skip_apache&#039;},
        &#039;skipreposetup|skip-repo-setup&#039;       =&gt; \$self-&gt;{options}-&gt;{&#039;skip_repo_setup&#039;},
        &#039;skiplicensecheck|skip-license-check&#039; =&gt; \$self-&gt;{options}-&gt;{&#039;skip_license_check&#039;},
        &#039;stop_at_update_now&#039;                  =&gt; \$self-&gt;{options}-&gt;{&#039;stop_at_update_now&#039;},
        &#039;stop_after_update_now&#039;               =&gt; \$self-&gt;{options}-&gt;{&#039;stop_after_update_now&#039;},
        &#039;experimental-os=s&#039;                   =&gt; \$self-&gt;{options}-&gt;{&#039;experimental-os&#039;},
        &#039;source=s&#039;                            =&gt; \$self-&gt;{options}-&gt;{&#039;source&#039;},
        &#039;tier=s&#039;                              =&gt; \$self-&gt;{options}-&gt;{&#039;tier&#039;},
        &#039;myip=s&#039;                              =&gt; \$self-&gt;{options}-&gt;{&#039;myip&#039;},
        &#039;protocol=s&#039;                          =&gt; \$self-&gt;{options}-&gt;{&#039;protocol&#039;},
        &#039;no-reboot&#039;                           =&gt; \$self-&gt;{options}-&gt;{&#039;no-reboot&#039;},

        &#039;skip-all-imunify&#039; =&gt; sub {
            $self-&gt;{options}-&gt;{&#039;skip-imunifyav&#039;} = $self-&gt;{options}-&gt;{&#039;skip-imunify360&#039;} = 1;
        },
    );

    # Validate protocol option
    if ( defined $self-&gt;{options}-&gt;{&#039;protocol&#039;} ) {
        my $protocol = uc( $self-&gt;{options}-&gt;{&#039;protocol&#039;} );
        if ( $protocol ne &#039;HTTP&#039; &amp;&amp; $protocol ne &#039;HTTPS&#039; ) {
            die &quot;Invalid protocol: $self-&gt;{options}-&gt;{&#039;protocol&#039;}. Must be HTTP or HTTPS.\n&quot;;
        }
        $self-&gt;{options}-&gt;{&#039;protocol&#039;} = $protocol;
    }

    # We must *search* for args unprefixed with -- here for product type
    # &quot;because that&#039;s the way it&#039;s always been passed in&quot; unfortunately.
    # Would have been simpler as a grep, but we only want to take &quot;something
    # valid looking&quot; beginning at index -1.
    my $type = &#039;standard&#039;;
    foreach my $arg ( reverse @args ) {
        if ( grep { $_ eq $arg } qw{standard dnsonly wp2} ) {
            $type = $arg;
            last;
        }
    }

    # Set product, tier and source for install in CpanelConfig
    CpanelConfig::product($type);
    CpanelConfig::tier( $self-&gt;{options}{tier} )         if $self-&gt;{options}{tier};
    CpanelConfig::source( $self-&gt;{options}{source} )     if $self-&gt;{options}{source};
    CpanelConfig::myip_url( $self-&gt;{options}{myip} )     if $self-&gt;{options}{myip};
    CpanelConfig::protocol( $self-&gt;{options}{protocol} ) if $self-&gt;{options}{protocol};

    $type =~ s/wp2/WP Squared/;
    INFO(&quot;Install type: $type\n&quot;);

    $self-&gt;create_touch_files;

    return;
}

*is_wp2     = \&amp;CpanelConfig::is_wp2;
*is_dnsonly = \&amp;CpanelConfig::is_dnsonly;

sub distro_type  { die &#039;unimplemented&#039; }
sub distro_name  { return shift-&gt;{&#039;os&#039;}-&gt;{&#039;distro&#039;} || die }    # Should always be populated on call.
sub distro_major { return shift-&gt;{&#039;os&#039;}-&gt;{&#039;major&#039;}  || die }    # Should always be populated on call.

sub product_name {
    my %display_name_map = (
        &#039;dnsonly&#039;  =&gt; &#039;DNSONLY&#039;,
        &#039;wp2&#039;      =&gt; &#039;WP Squared&#039;,
        &#039;standard&#039; =&gt; &#039;cPanel &amp; WHM&#039;,
    );
    return $display_name_map{ CpanelConfig::product() };
}

sub distro_minor {
    my $minor = shift-&gt;{&#039;os&#039;}-&gt;{&#039;minor&#039;};
    die q[minor version not defined] unless defined $minor;
    return $minor;
}

sub detect_distro {
    my ($self) = @_;
    my @os_info = OSDetect::get_os_info();

    $self-&gt;{&#039;os&#039;}-&gt;{&#039;kernel&#039;} = shift @os_info;
    $self-&gt;{&#039;os&#039;}-&gt;{&#039;distro&#039;} = shift @os_info;
    $self-&gt;{&#039;os&#039;}-&gt;{&#039;major&#039;}  = shift @os_info;
    $self-&gt;{&#039;os&#039;}-&gt;{&#039;minor&#039;}  = shift @os_info;

    return;
}

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

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

    my $v = CpanelConfig::get_cpanel_version();
    INFO(&quot;Using version &#039;$v&#039;&quot;);

    return $self-&gt;{&#039;cpanel_version&#039;} = $v;
}

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

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

    my $v = $self-&gt;cpanel_version;
    return $self-&gt;{&#039;lts_version&#039;} = CpanelConfig::get_lts_version($v);
}

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

    ensure_var_cpanel();

    if ( $self-&gt;is_dnsonly ) {
        INFO(&quot;cPanel DNSONLY installation requested.&quot;);
        FATAL(&quot;Existing cPanel license file detected! Aborting DNSONLY installation.&quot;) if -s &#039;/usr/local/cpanel/cpanel.lisc&#039;;
        $self-&gt;touch(&#039;/var/cpanel/dnsonly&#039;);
        $self-&gt;touch(&#039;/var/cpanel/noimunifyav&#039;);
        $self-&gt;touch(&#039;/var/cpanel/nowptoolkit&#039;);
    }
    else {
        unlink &#039;/var/cpanel/dnsonly&#039;;    # Just in case the customer ran with the wrong args previously.
    }

    if ( $self-&gt;is_wp2 ) {
        INFO( &quot;Setting up a &quot; . $self-&gt;product_name . &quot; installation&quot; );
    }

    if ( $self-&gt;skip_cloudlinux ) {
        INFO(&quot;Skip cloudlinux installation requested.&quot;);
        $self-&gt;touch(&#039;/var/cpanel/nocloudlinux&#039;);
    }

    if ( $self-&gt;skip_imunifyav ) {
        INFO(&quot;Skip imunifyav installation requested.&quot;);
        $self-&gt;touch(&#039;/var/cpanel/noimunifyav&#039;);
    }

    if ( $self-&gt;skip_imunify360 ) {
        INFO(&quot;Skip imunify360 installation requested.&quot;);
        $self-&gt;touch(&#039;/var/cpanel/noimunify360&#039;);
    }

    if ( $self-&gt;skip_wptoolkit ) {
        INFO(&quot;Skip WordPress Toolkit installation requested.&quot;);
        $self-&gt;touch(&#039;/var/cpanel/nowptoolkit&#039;);
    }

    if ( $self-&gt;no_reboot ) {
        INFO(&quot;Automatic reboot disabled as requested.&quot;);
        $self-&gt;touch(NO_REBOOT_TOUCH_FILE);
    }

    # --experimental-os=almalinux-9.0
    $self-&gt;setup_experimental_os( $self-&gt;{options}-&gt;{&#039;experimental-os&#039;} );

    return;
}

# The customer ran latest --experimental-os=centos-7.2
sub setup_experimental_os {
    my ( $self, $settings ) = @_;

    defined $settings or return;    # Didn&#039;t pass this option on command line.

    my @os_info = $settings =~ m{^([^-]+)-([0-9]+)\.([0-9]+)}    #
      or die(&quot;Unrecognized --experimental-os option. Try: --experimental-os=almalinux-9.0&quot;);
    unshift @os_info, $^O;
    push @os_info, &#039;2020&#039;;                                       # An arbitrary build ID we&#039;re going to push on the end for consistency.

    my ( $os, $distro, $major, $minor, $build ) = @os_info;

    if ( $distro &amp;&amp; $distro eq &#039;cloudlinux&#039; ) {
        FATAL(&quot;Using --experimental-os is not permitted for CloudLinux.&quot;);
    }

    mkdir &#039;/var/cpanel/caches&#039;, 0711;

    OSDetect::clear( custom =&gt; 1 );

    WARN(&lt;&lt;&quot;EOS&quot;);
--experimental-os=$settings was successful.
You are currently installing cPanel &amp; WHM on an unsupported distribution.
We discourage you from using this server for production purposes.
EOS

    # Write out the cache file.
    local $!;
    symlink &quot;$os|$distro|$major|$minor|$build&quot;, OSDetect::CACHE_FILE;

    # Write out the lock file to prevent the cache from being updated going forward.
    symlink &quot;1&quot;, OSDetect::CACHE_FILE_CUSTOM;

    return;
}

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

    if ( open my $fh, &#039;&lt;&#039;, LOCK_FILE ) {
        print &quot;The system detected an installer lock file: (&quot; . LOCK_FILE . &quot;)\n&quot;;
        print &quot;Make certain that an installer is not already running.\n\n&quot;;
        print &quot;You can remove this file and re-run the cPanel installation process after you are certain that another installation is not already in progress.\n\n&quot;;
        my $pid = &lt;$fh&gt;;
        if ($pid) {
            chomp $pid;
            print `ps auxwww |grep $pid`;    ## no critic(ProhibitQxAndBackticks)
        }
        else {
            print &quot;Warning: The system could not find pid information in the &quot; . LOCK_FILE . &quot; file.\n&quot;;
        }
        return 1;
    }

    # Create the lock file.
    if ( open my $fh, &#039;&gt;&#039;, LOCK_FILE ) {
        print {$fh} &quot;$$\n&quot;;

        close $fh;
    }
    else {
        FATAL( &quot;Unable to write lock file &quot; . LOCK_FILE );

        return 1;
    }

    $self-&gt;{&#039;original_pid&#039;} = $$;

    return;
}

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

    $self-&gt;invalid_system( &quot;Unsupported kernel (&quot; . $self-&gt;{&#039;os&#039;}-&gt;{&#039;kernel&#039;} . &quot;) for operating system&quot; ) if $self-&gt;{&#039;os&#039;}-&gt;{&#039;kernel&#039;} ne &#039;linux&#039;;

    if ( $self-&gt;distro_major == 7 &amp;&amp; !$self-&gt;force ) {
        $self-&gt;invalid_system( &quot;Unsupported operating system (&quot; . $self-&gt;{&#039;os&#039;}-&gt;{&#039;distro&#039;} . &quot; &quot; . $self-&gt;{&#039;os&#039;}-&gt;{&#039;major&#039;} . &quot;)&quot; );
    }

    my @uname = POSIX::uname();
    if ( $uname[4] ne &#039;x86_64&#039; ) {
        $self-&gt;invalid_system(&quot;cPanel &amp; WHM supports 64-bit versions (not $uname[4]) only.&quot;);
    }

    INFO(&quot;Checking RAM now...&quot;);
    my $total_memory = $self-&gt;get_total_memory();
    my $minmemory    = 2_048;

    if ( $total_memory &lt; $minmemory ) {
        ERROR(&quot;cPanel &amp; WHM requires a minimum of $minmemory MB of available RAM for your operating system. Your system only has $total_memory MB available. We recommend that you increase the total RAM on your system.&quot;);
        FATAL(&quot;Increase the server&#039;s total amount of RAM, and then reinstall cPanel &amp; WHM.&quot;);
    }
    return;
}

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

    my $file = &#039;/sys/kernel/kexec_crash_size&#039;;
    my $size = 0;

    if ( -s $file &amp;&amp; open( my $fh, &quot;&lt;&quot;, $file, ) ) {
        $size += &lt;$fh&gt;;
        close($fh);
    }
    else {
        WARN(&quot;The installer could not read the file $file. Please ensure that the file exists and that you have the correct permissions.&quot;);
    }

    if ($size) {
        WARN(
            &#039;The installer has detected that kernel crash dumping is configured on your system. This means that a portion of system memory is permanently reserved for a capture kernel and is inaccessible to the main kernel. If you encounter memory-related issues during or after installation, they may be resolved by reducing or altogether removing the crashkernel boot loader configuration option.&#039;
        );
    }

    return $size;
}

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

    # Tests on different architectures show that 15% is safe.
    # This tolerance is expanded to 25% in instances where kdump is active in order to accommodate hyperscalers.
    my $tolerance_factor = $self-&gt;get_kexec_crash_size() ? 1.25 : 1.15;

    # MemTotal: Total usable ram (i.e. physical ram minus a few reserved
    #          bits and the kernel binary code)
    # note, another option would be to use &quot;dmidecode --type 17&quot;, or dmesg
    #   but this will require an additional RPM
    #   we just want to be sure that a customer does not install
    #   with 512 when 700 or more is required
    my $meminfo = q{/proc/meminfo};
    if ( open( my $fh, &quot;&lt;&quot;, $meminfo ) ) {
        while ( my $line = readline $fh ) {
            if ( $line =~ m{^MemTotal:\s+([0-9]+)\s*kB}i ) {
                return int( int( $1 / 1_024 ) * $tolerance_factor );
            }
        }
    }

    return 0;    # something is wrong
}

sub invalid_system {
    my ( $self, $message ) = @_;
    $message ||= &#039;&#039;;
    chomp $message;

    ERROR($message);
    ERROR(&#039;cPanel &amp; WHM does not support the version of the Linux distribution you are running. You will need to install on one of the supported versions of a Linux distribution listed at https://go.cpanel.net/supported-os&#039;);
    FATAL(&#039;Please reinstall cPanel &amp; WHM from a valid distribution.&#039;);
    return;
}

sub clean_install_check {

    INFO(&#039;Checking for any control panels...&#039;);
    my @server_detected;
    push @server_detected, &#039;DirectAdmin&#039; if ( -e &#039;/usr/local/directadmin&#039; );
    push @server_detected, &#039;Plesk&#039;       if ( -e &#039;/etc/psa&#039; );
    push @server_detected, &#039;Ensim&#039;       if ( -e &#039;/etc/appliance&#039; || -d &#039;/etc/virtualhosting&#039; );

    #push @server_detected, &#039;Alabanza&#039;    if ( -e &#039;/etc/mail/mailertable&#039; );
    push @server_detected, &#039;Zervex&#039;              if ( -e &#039;/var/db/dsm&#039; );
    push @server_detected, &#039;Web Server Director&#039; if ( -e &#039;/bin/rpm&#039; &amp;&amp; `/bin/rpm -q ServerDirector` =~ /^ServerDirector/ms );    ## no critic(ProhibitQxAndBackticks)

    # Don&#039;t just check for /usr/local/cpanel, as some people will have created
    # that directory as a mount point for the install.
    push @server_detected, &#039;cPanel &amp; WHM&#039; if -e &#039;/usr/local/cpanel/cpkeyclt&#039;;

    return if ( !@server_detected );

    ERROR(&quot;The installation process found evidence that the following control panels were installed on this server:&quot;);
    ERROR($_) foreach (@server_detected);
    FATAL(&#039;You must install cPanel &amp; WHM on a clean server.&#039;);
    return;
}

sub check_system_files {
    INFO(&quot;Checking for essential system files...&quot;);

    unless ( -f &#039;/etc/fstab&#039; ) {
        ERROR(&quot;Your system is missing the file /etc/fstab.  This is an&quot;);
        ERROR(&quot;essential system file that is part of the base system.&quot;);
        FATAL(&quot;Please ensure the system has been properly installed.&quot;);
    }

    setup_empty_directories();

    setup_custom_cpanel_config();

    assure_nobody();

    return;
}

# Place customer provided cpanel.config in place early in case we need to block on any of the settings.
sub setup_custom_cpanel_config {
    my $custom_cpanel_config_file = &#039;/root/cpanel_profile/cpanel.config&#039;;
    if ( -e $custom_cpanel_config_file ) {
        INFO(&quot;The system is placing the custom cpanel.config file from $custom_cpanel_config_file.&quot;);
        unlink &#039;/var/cpanel/cpanel.config&#039;;
        system( &#039;/bin/cp&#039;, $custom_cpanel_config_file, &#039;/var/cpanel/cpanel.config&#039; );
    }
    return;
}

# mkdir some directories.
sub setup_empty_directories {
    INFO(&#039;The installation process will now set up the necessary empty cpanel directories.&#039;);

    ensure_var_cpanel();

    foreach my $dir (qw{/usr/local/cpanel /usr/local/cpanel/base /usr/local/cpanel/base/frontend /usr/local/cpanel/logs /var/cpanel/tmp /var/cpanel/version /var/cpanel/perl /var/named}) {
        unlink $dir if ( -f $dir || -l $dir );

        if ( !-d $dir ) {
            DEBUG(&quot;mkdir $dir&quot;);
            mkdir( $dir, 0755 );
        }
    }

    foreach my $dir (qw{/var/cpanel/logs}) {
        unlink $dir if ( -f $dir || -l $dir );

        if ( !-d $dir ) {
            DEBUG(&quot;mkdir $dir&quot;);
            mkdir( $dir, 0700 );
        }
    }

    ensure_feature_showcase_dir();

    return;
}

sub ensure_var_cpanel {

    my $dir   = &#039;/var/cpanel&#039;;
    my $perms = 0711;

    if ( -f $dir || -l $dir ) {
        unlink $dir or FATAL(&quot;Fail to remove existing file $dir (should be a directory) $!&quot;);
    }

    if ( !-d $dir ) {
        mkdir $dir, $perms;
    }
    else {
        chown 0, 0, $dir;
        chmod $perms, $dir;
    }

    return;
}

sub ensure_feature_showcase_dir {

    foreach my $dir (qw{ /var/cpanel/activate /var/cpanel/activate/features }) {
        my $perms = 0700;

        if ( -f $dir || -l $dir ) {
            unlink $dir or FATAL(&quot;Fail to remove existing file $dir (should be a directory) $!&quot;);
        }

        if ( !-d $dir ) {
            mkdir $dir, $perms;
        }

        Common::ssystem( &#039;chown&#039;, &#039;-R&#039;, &#039;root:root&#039;, $dir );
        Common::ssystem( &#039;chmod&#039;, &#039;-R&#039;, &#039;0700&#039;,      $dir );
    }

    return;
}

sub disable_systemd_resolved_if_enabled { return }    # Only run on ubuntu systems.

sub setup_and_check_resolv_conf {

    # Remote resolvers are required, since we remove local BIND during installation.
    open my $resolv_conf_fh, &#039;&lt;&#039;, &#039;/etc/resolv.conf&#039; or FATAL(&quot;Could not open /etc/resolv.conf: $!&quot;);

    if ( !grep { m/^\s*nameserver\s+/ &amp;&amp; !m/\s+127.0.0.1$/ } &lt;$resolv_conf_fh&gt; ) {
        FATAL(&quot;/etc/resolv.conf must be configured with non-local resolvers for installations to complete.&quot;);
    }

    INFO(&quot;Validating whether the system can look up domains...&quot;);
    my @domains = qw(
      httpupdate.cpanel.net
      securedownloads.cpanel.net
    );

    foreach my $domain (@domains) {
        DEBUG(&quot;Testing $domain...&quot;);
        next if ( gethostbyname($domain) );
        ERROR( &#039;!&#039; x 105 . &quot;\n&quot; );
        ERROR(&quot;The system cannot resolve the $domain domain. Check the /etc/resolv.conf file. The system has terminated the installation process.\n&quot;);
        FATAL( &#039;!&#039; x 105 . &quot;\n&quot; );
    }
    return;
}

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

    my $pid = $self-&gt;run_in_background( sub { $self-&gt;install_basic_precursor_packages } );

    # While the ensure is running in the background
    # we show the message warning that they need a clean
    # server
    local $SIG{&#039;INT&#039;} = sub {
        kill( &#039;TERM&#039;, $pid );
        WARN(&quot;Install terminated by user input&quot;);
        exit(0);    ## no critic qw(NoExitsFromSubroutines)
    };

    $self-&gt;preflight_warnings;
    local $?;
    waitpid( $pid, 0 );
    if ( $? != 0 ) {
        FATAL(&quot;ensure_pkgs_install failed: $?&quot;);
    }

    return;
}

sub preflight_warnings {
    my ($self) = @_;
    INFO(&quot;&quot;);
    INFO(&quot;cPanel Layer 1 Installer Starting...&quot;);
    INFO(&quot;&quot;);
    INFO(&quot;Warning  !!!  Warning  !!!  WARNING  !!!  Warning  !!!  Warning&quot;);
    INFO(&quot;---------------------------------------------------------------&quot;);
    INFO(&quot;&quot;);
    INFO(&quot;This installer will overwrite all of your configuration files.&quot;);
    INFO(&quot;&quot;);
    INFO(&quot;    If this is not a fresh/clean server, hit Ctrl+C NOW to&quot;);
    INFO(&quot;    avoid losing data.&quot;);
    INFO(&quot;&quot;);
    INFO(&quot;&quot;);

    # WP2 install is the only place that&#039;s currently using this reboot
    # logic, so let&#039;s skip the scary warning for everyone else
    if ( $self-&gt;is_wp2 &amp;&amp; !-e NO_REBOOT_TOUCH_FILE ) {
        INFO(&quot;This installer will reboot the system under certain conditions.&quot;);
        INFO(&quot;&quot;);
        INFO(&quot;    To prevent an automatic reboot, place a touch file at:&quot;);
        INFO( &quot;        &quot; . NO_REBOOT_TOUCH_FILE );
        INFO(&quot;    before the installer completes, or restart the installer&quot;);
        INFO(&quot;    with the --no-reboot argument.&quot;);
        INFO(&quot;&quot;);
        INFO(&quot;&quot;);
    }
    INFO(&quot;---------------------------------------------------------------&quot;);
    INFO(&quot;Warning  !!!  Warning  !!!  WARNING  !!!  Warning  !!!  Warning&quot;);
    INFO(&quot;&quot;);
    INFO(&quot;Waiting 10 seconds&quot;);
    $self-&gt;_pause_for_ten_seconds();

    return;
}

sub _pause_for_ten_seconds {
    for ( 1 .. 10 ) { print &#039;.&#039;; sleep(1); }
    print &quot;\n&quot;;
    return;
}

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

  FORK: {
        my $pid = fork;
        return $pid if $pid;    # Parent.

        if ( !defined $pid ) {  # Still the parent but fork didn&#039;t work!
            if ( $! == EAGAIN ) {

                # EAGAIN is the supposedly recoverable fork error
                WARN(&quot;Fork failed! Trying again.&quot;);
                sleep 5;
                redo FORK;
            }
            else {
                # weird fork error
                FATAL(&quot;Can&#039;t fork: $!\n&quot;);
            }
        }
    }

    begin_collect_output();

    local $@;
    eval { $sub-&gt;(); };

    emit_collected_output();
    die if $@;

    exit(0);
}

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

    my @date_cmd;
    my $binary_name;
    if ( $self-&gt;distro_type eq &#039;rhel&#039; &amp;&amp; $self-&gt;distro_major &gt;= 8 ) {    # only rhel 8 doesn&#039;t provide rdate!
        $binary_name = &#039;chronyc&#039;;
        @date_cmd    = -x &#039;/bin/chronyc&#039; ? ( &#039;/bin/chronyc&#039;, &#039;makestep&#039; ) : ();
    }
    else {
        $binary_name = &#039;rdate&#039;;
        foreach my $bin (qw { /usr/sbin/rdate /usr/bin/rdate /bin/rdate }) {
            next unless -x $bin;
            @date_cmd = ( $bin, &#039;-s&#039;, &#039;rdate.cpanel.net&#039; );
            last;
        }
    }

    # Complain if we don&#039;t have an rdate binary.
    if ( !@date_cmd ) {
        ERROR(&quot;The system could not set the system clock because the $binary_name binary is missing.&quot;);
        return;
    }

    # Set the clock
    my $was = time();
    Common::ssystem(@date_cmd);
    my $now = time();
    INFO( &quot;The system set the clock to: &quot; . localtime($now) );
    my $change = $now - $was;

    # Adjust the start time if it shifted more than 10 seconds.
    if ( abs($change) &gt; 10 ) {
        WARN(&quot;The system changed the clock by $change seconds.&quot;);
        $self-&gt;{&#039;install_start&#039;} = $self-&gt;install_start + $change;
        WARN( &quot;The system adjusted the starting time to &quot; . localtime( $self-&gt;install_start ) . &quot;.&quot; );
    }
    else {
        INFO(&quot;The system changed the clock by $change seconds.&quot;);
    }

    return 1;
}

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

    # Sync the clock.
    if ( !$self-&gt;update_system_clock ) {
        WARN( &quot;The current system time is set to: &quot; . `date` );    ## no critic(ProhibitQxAndBackticks)
        WARN(&quot;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!&quot;);
        WARN(&quot;The installation process could not verify the system time. The utility to set time from a remote host, rdate or chrony, is not installed.&quot;);
        WARN(&quot;If your system time is incorrect by more than a few hours, source compilations will subtly fail.&quot;);
        WARN(&quot;This issue may result in an overall installation failure.&quot;);
        WARN(&quot;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!&quot;);
    }
    return;
}

# Start nscd if its not running since it will improve rpm install time
sub start_network_resolution {
    my ($self) = @_;

    return Common::ssystem(&quot;ps -U nscd -h 2&gt;/dev/null || systemctl start nscd&quot;);
}

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

    return if $INC{&#039;Test/More.pm&#039;};             # Required for testing.
    return unless $self;
    return unless $self-&gt;{&#039;original_pid&#039;};
    $self-&gt;{&#039;original_pid&#039;} == $$ or return;    # this is a child process so no need to cleanup the lock.
    unlink LOCK_FILE;

    CpanelGPG::cleanup_gpg_homedir();
    return;
}

sub remove_distro_software { die };    # Needs to be implemented in child classes.

# This code is somewhat of a duplication of the code for updatenow that blocks updates based on configuration
# settings. It needs to be here also because of the bootstrap level nature for when this needs to run.
sub check_for_install_version_blockers {
    my ($self) = @_;

    my $lts_version  = $self-&gt;lts_version();
    my $tier         = CpanelConfig::tier();
    my $product_name = $self-&gt;product_name();

    if ( $self-&gt;is_wp2 ) {

        if ( $self-&gt;distro_major != 8 ) {

            # do not check for CloudLinux yet:
            #   - we are going to attempt to deploy CloudLinux when possible
            #   - the build itself aborts on unsupported distro
            FATAL(&quot;$product_name only supports CloudLinux 8 distribution.&quot;);
        }

        # we could also check for build.json
        # Also, we can&#039;t use the &#039;a&#039; modifier on regexp here until CloudLinux 6
        # is not a supported install target. Please add it back after that is
        # no longer a concern.
        my $is_wp2_version = $self-&gt;cpanel_version =~ m&lt;^(11\.)?\d+[13579]\.8\d{3}&gt;
          || $self-&gt;cpanel_version =~ m{^(11\.)?\d+[02468]\.1(?:\.|$)};

        if ( !$is_wp2_version ) {
            FATAL( &#039;Unusupported version &quot;&#039; . $self-&gt;cpanel_version . qq[&quot; for $product_name.] );
        }

    }

    my $should_block_msg = $self-&gt;_should_block_on_this_version_and_os();
    FATAL($should_block_msg) if $should_block_msg;

    my $staging_dir = CpanelConfig::x_from_config(&#039;STAGING_DIR&#039;);
    if ( $staging_dir ne &#039;&#039; &amp;&amp; $staging_dir ne &#039;/usr/local/cpanel&#039; ) {
        FATAL(&quot;STAGING_DIR must be set to /usr/local/cpanel during installs.&quot;);
    }

    # pull in cpanel.config settings or return if the file&#039;s not there (defaults will assert)
    my $cpanel_config = CpanelConfig::read_config(&#039;/var/cpanel/cpanel.config&#039;);

    # This is distro specific.
    $self-&gt;verify_mysql_version($cpanel_config);

    if ( defined $cpanel_config-&gt;{&#039;mailserver&#039;} &amp;&amp; $cpanel_config-&gt;{&#039;mailserver&#039;} !~ m/^(dovecot|disabled)$/i ) {
        FATAL(&quot;You must use &#039;dovecot&#039; or &#039;disabled&#039; for the mailserver in the /var/cpanel/cpanel.config file for cPanel &amp; WHM version $lts_version.&quot;);
    }

    if ( defined $cpanel_config-&gt;{&#039;local_nameserver_type&#039;} &amp;&amp; $cpanel_config-&gt;{&#039;local_nameserver_type&#039;} !~ m/^(powerdns|bind|disabled)$/i ) {
        FATAL(&quot;You must use &#039;powerdns&#039;, &#039;bind&#039; or &#039;disabled&#039; for the local_nameserver_type in the /var/cpanel/cpanel.config file. For more information, see: https://docs.cpanel.net/whm/service-configuration/nameserver-selection/&quot;);
    }

    return;

}

sub _should_block_on_this_version_and_os {
    my ($self) = @_;
    my ( $lts_version, $product_name ) = ( $self-&gt;lts_version(), $self-&gt;product_name() );
    my ( $distro, $major, $minor ) = @{ $self-&gt;{&#039;os&#039;} }{qw{distro major minor}};
    my %errors = (
        &#039;no_debian&#039;     =&gt; &quot;Ubuntu is the only debian distro currently supported by $product_name&quot;,
        &#039;above_maximum&#039; =&gt; &quot;$product_name does not support $distro $major.$minor on version $lts_version. For more information, read about our supported versions at https://go.cpanel.net/system-requirements&quot;,
        &#039;below_minimum&#039; =&gt; &quot;You cannot install versions of $product_name prior to $product_name version &quot; . MINIMUM_CPANEL_VERSION_SUPPORTED . &#039;.&#039;,
    );
    return $errors{&#039;no_debian&#039;} if $self-&gt;distro_type eq &#039;debian&#039; &amp;&amp; $self-&gt;distro_name ne &quot;ubuntu&quot;;
    my $max_version = OS_MAXIMUM_VERSIONS-&gt;{&quot;${distro}${major}&quot;};
    return $errors{&#039;above_maximum&#039;} if $max_version                                    &amp;&amp; $lts_version &gt; $max_version;
    return $errors{&#039;below_minimum&#039;} if $lts_version &lt; MINIMUM_CPANEL_VERSION_SUPPORTED &amp;&amp; !$self-&gt;{&#039;options&#039;}{&#039;force&#039;};
    return;
}

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

    # Make sure the cPanel key is in place.
    CpanelGPG::fetch_gpg_key_once();

    my $cpanel_version = $self-&gt;cpanel_version;

    # Install cPanel files.
    INFO(&quot;Installing bootstrap cPanel Perl&quot;);

    # Download the tar.gz files and extract them instead.
    my $script = &#039;fix-cpanel-perl&#039;;
    my $source = &quot;/cpanelsync/$cpanel_version/cpanel/scripts/$script.xz&quot;;

    unlink $script;

    DEBUG(&quot;Retrieving the $script file from $source if available...&quot;);

    # download file in current directory (inside the self extracted tarball)
    Common::cpfetch($source);

    chmod 0700, $script;

    INFO(&quot;Running script $script to bootstrap cPanel Perl.&quot;);

    my $exit;

    # Retry a few times if one of the http request failed
    my $max = 5;
    foreach my $iter ( 1 .. $max ) {
        $exit = Common::ssystem(&quot;./$script&quot;);
        if ( $exit == 0 ) {
            INFO(&quot;Successfully installed cPanel Perl minimal version.&quot;);
            return;
        }

        WARN(&quot;Run #$iter/$max failed to run script $script&quot;);
        last if $iter == $max;
        sleep 5;
    }

    my $signal = $? % 256;

    # This isn&#039;t going to return actually. It&#039;s going to die.
    ERROR(&quot;Failed to run script $script to bootstrap cPanel Perl.&quot;);
    return FATAL(&quot;The script $script terminated with the following exit code: $exit ($signal); The cPanel &amp; WHM installation process cannot proceed.&quot;);
}

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

    # Make sure the OS is relatively clean.
    $self-&gt;check_no_mysql();

    # Check that we&#039;re in runlevel 3.
    $self-&gt;check_for_multiuser;

    # Assure dnsonly/standard matches chosen installer.
    $self-&gt;check_license_conflict();

    # Convert to CloudLinux for WP2
    $self-&gt;deploy_cloudlinux() if $self-&gt;is_wp2();

    # TODO: Get rid of these files and replace them with /var/cpanel/dnsonly
    # Disable services by touching files.
    if ( $self-&gt;is_dnsonly() ) {
        my @dnsonlydisable = qw( cpdavd );
        foreach my $dis_service (@dnsonlydisable) {
            $self-&gt;touch( &#039;/etc/&#039; . $dis_service . &#039;disable&#039; );
        }
    }

    create_slash_scripts_symlink();

    # Some checks may be done in the child class.
    return;
}

sub create_slash_scripts_symlink {
    if ( -e &#039;/scripts&#039; &amp;&amp; !-l &#039;/scripts&#039; ) {
        if ( !-d &#039;/scripts&#039; ) {
            WARN(&quot;The system detected /scripts as a file. Moving it to a new location...&quot;);
            Common::ssystem( qw{/bin/mv /scripts}, &quot;/scripts.o.$$&quot; );
        }
        else {
            WARN(&quot;The system detected the /scripts directory. Moving its contents to the /usr/local/cpanel/scripts directory...&quot;);
            Common::ssystem(qw{mkdir -p /usr/local/cpanel/scripts});
            Common::ssystem(&#039;cd / &amp;&amp; tar -cf - scripts | (cd /usr/local/cpanel &amp;&amp; tar -xvf -)&#039;);
            Common::ssystem(qw{/bin/rm -rf /scripts});
        }
    }
    unlink qw{/scripts};

    # This symlink *must* be relative in order to allow future in-place OS upgrades.
    symlink(qw{usr/local/cpanel/scripts /scripts}) unless -e &#039;/scripts&#039;;

    if ( !-l &#039;/scripts&#039; ) {
        WARN(&quot;The /scripts directory must be a symlink to the /usr/local/cpanel/scripts directory. cPanel &amp; WHM does not use the /scripts directory.&quot;);
    }
    else {
        DEBUG(&#039;/scripts symlink is set to point to /usr/local/cpanel/scripts&#039;);
    }

    return;
}

sub check_no_mysql {

    # This can cause failures if the database is newer than the version we&#039;re
    # going to install.
    INFO(&#039;Checking for an existing MySQL or MariaDB instance...&#039;);

    my $mysql_dir = &#039;/var/lib/mysql&#039;;
    return unless -d $mysql_dir;
    my $nitems = 0;
    if ( opendir( my $dh, $mysql_dir ) ) {
        $nitems = scalar grep { !/\A(?:\.{1,2}|lost\+found)\z/ } readdir $dh;
        closedir($dh);
    }
    return unless $nitems;

    ERROR(&quot;The installation process found evidence that MySQL or MariaDB was installed on this server:&quot;);
    ERROR(&quot;The $mysql_dir directory is present and not completely empty.&quot;);
    FATAL(&#039;You must install cPanel &amp; WHM on a clean server.&#039;);
    return;
}

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

    # If we can detect multiuser, then we&#039;re good. Do no more checks.
    return if $self-&gt;check_systemd_multiuser_target;
    return $self-&gt;check_runlevel;    # Will fail if it doesn&#039;t succeed.
}

# This code is probably dead for all systemd systems. It&#039;s not clear when a system would be valid with multi-user being inactive but runlevel being 3.
# This code can probably be removed when we drop RHEL 6 support.
sub check_runlevel {
    my ($self) = @_;

    # From `man runlevel` :
    #       Table 1. Mapping between runlevels and systemd targets
    #       ┌─────────┬───────────────────┐
    #       │Runlevel │ Target            │
    #       ├─────────┼───────────────────┤
    #       │0        │ poweroff.target   │
    #       ├─────────┼───────────────────┤
    #       │1        │ rescue.target     │
    #       ├─────────┼───────────────────┤
    #       │2, 3, 4  │ multi-user.target │
    #       ├─────────┼───────────────────┤
    #       │5        │ graphical.target  │
    #       ├─────────┼───────────────────┤
    #       │6        │ reboot.target     │
    #       └─────────┴───────────────────┘

    my $runlevel = `runlevel`;    ## no critic(ProhibitQxAndBackticks)
    chomp $runlevel;
    my ( $prev, $curr ) = split /\s+/, $runlevel;

    my $message;

    # currently we allow runlevel 3 or 5, as 5 is the default even on Ubuntu Server, just with no X installed or running
    # runlevel can also return unknown
    if    ( !defined $curr )           { $message = &quot;The installation process could not determine the server&#039;s current runlevel.&quot;; }
    elsif ( $curr != 3 &amp;&amp; $curr != 5 ) { $message = &quot;The installation process detected that the server was in runlevel $curr.&quot;; }
    else                               { return; }

    # the system claims to be in an unsupported runlevel.
    if ( $self-&gt;force ) {
        WARN($message);
        WARN(&#039;The server must be in runlevel 3 or 5. Proceeding anyway because --force was specified!&#039;);
        return;
    }

    ERROR(&quot;The installation process detected that the server was in runlevel $curr.&quot;);
    FATAL(&#039;The server must be in runlevel 3 or 5 before the installation can continue.&#039;);

    return die &quot;unreachable code&quot;;
}

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

    local $?;
    `systemctl is-active multi-user.target &gt;/dev/null 2&gt;&amp;1`;    ## no critic(ProhibitQxAndBackticks)
    return 1 if $? == 0;                                        # We&#039;re in multiuser state.
    if ( $self-&gt;force ) {
        WARN(&#039;The installation process detected that the multi-user.target is not active (boot is probably not finished).&#039;);
        WARN(&#039;The multi-user.target must be active. Proceeding anyway because --force was specified!&#039;);
    }
    else {
        ERROR(&#039;The installation process detected that the multi-user.target is not active (boot is probably not finished).&#039;);
        FATAL(&#039;The multi-user.target must be active before the installation can continue.&#039;);
    }

    return;
}

sub verify_url {
    my ( $self, $ip ) = @_;
    $ip ||= &#039;&#039;;

    return qq[https://verify.cpanel.net/xml/verifyfeed?ip=$ip];
}

#
#   block cPanel&amp;WHM install when a DNSONLY license is valid for the server
#   block DNSONLY license when a cPanel license is valid for the server
#
sub check_license_conflict {
    my ($self) = @_;

    return if $self-&gt;skip_license_check;

    my $ip = guess_ip();

    # skip check and continue install if we cannot guess up
    return unless defined $ip;

    INFO(&quot;Checking for existing active license linked to IP &#039;$ip&#039;.&quot;);

    my $verify_license_xml = q[verify.license.xml];

    my $url = $self-&gt;verify_url($ip);

    # check verify.cpanel.net - the xml one...
    Common::fetch_url_to_file( $url, $verify_license_xml );

    my $active_basepkg = 0;
    my $package        = &quot;&quot;;

    {
        open( my $fh, &#039;&lt;&#039;, $verify_license_xml ) or FATAL(&quot;Cannot read file $verify_license_xml.&quot;);
        while ( my $line = &lt;$fh&gt; ) {

            next unless $line =~ m/status=&quot;1&quot;/;     # package is active
            next unless $line =~ m/basepkg=&quot;1&quot;/;    # package is a base package (skipping packages like kernelcare, cloudlinux &amp; co)

            if ( $line =~ m/producttype=&quot;([0-9]+)&quot;/ ) {
                $active_basepkg = $1;
                $line =~ m/package=&quot;([^&quot;]+)&quot;/;
                $package = $1;

                last;
            }
        }
    }

    if ( $self-&gt;is_wp2 ) {

        my $is_internal_network = $ip =~ m{^10\.};    # Note: ip is coming from MYIP

        if ( !$is_internal_network ) {                # skip the license check behind internal network

            # check for the WP2 license
            if ( $active_basepkg != PRODUCT_WP2 ) {
                ERROR(&quot;Unexpected license type found for your IP: https://verify.cpanel.net/app/verify?ip=$ip&quot;);
                FATAL(&quot;Installation aborted. Cannot find a valid WP Squared license for your IP: $ip.&quot;);
            }
        }

        return;
    }

    return unless $active_basepkg;

    if ( $self-&gt;is_dnsonly ) {

        # we cannot install dnsonly if a cPanel license exists
        if ( $active_basepkg != PRODUCT_DNSONLY ) {
            unlink &#039;/var/cpanel/dnsonly&#039;;
            ERROR(&quot;Unexpected license type found for your IP: https://verify.cpanel.net/app/verify?ip=$ip&quot;);
            ERROR(&quot;Current active package is $package&quot;);
            FATAL(&quot;Installation aborted. Perhaps you meant to install latest instead of latest-dnsonly? If not please cancel your cPanel license before installing a cPanel DNSONLY server.&quot;);
        }
    }
    else {
        # we cannot install cPanel if a dnsonly license exists
        if ( $active_basepkg &amp; PRODUCT_DNSONLY ) {
            ERROR(&quot;Unexpected license type found for your IP: https://verify.cpanel.net/app/verify?ip=$ip&quot;);
            FATAL(&quot;Installation aborted. Perhaps you meant to install latest-dnsonly instead of latest? If not please cancel your DNSONLY license before installing a cPanel &amp; WHM server.&quot;);
        }
    }

    # everything is fine at this point
    return;
}

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

    return $self-&gt;distro_name eq &#039;cloudlinux&#039;;
}

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

    return if $self-&gt;is_cloudlinux();

    my $url = q[https://repo.cloudlinux.com/cloudlinux/sources/cln/cldeploy];

    my $previous_major = $self-&gt;distro_major;

    INFO(&quot;-------------------------------------------------------&quot;);
    INFO(&quot;Converting distribution to CloudLinux $previous_major&quot;);
    INFO(&quot;-------------------------------------------------------&quot;);

    my $cldeploy_tmp = q[cldeploy.tmp];
    Common::fetch_url_to_file( $url, $cldeploy_tmp );

    FATAL(&quot;Fail to fetch CloudLinux installer from $url&quot;) unless -s $cldeploy_tmp;

    my $exit = Common::ssystem( &#039;/usr/bin/bash&#039;, $cldeploy_tmp, &#039;-i&#039; );
    unlink($cldeploy_tmp);    # not really necessary: we are inside the temporary self extracted tarball

    INFO(&quot;-------------------------------------------------------&quot;);
    INFO(&quot;.&quot;);

    # clear &amp; detect again (on failures we can also switch to a different distro)
    OSDetect::clear();
    $self-&gt;detect_distro;

    if ( $exit == 0 ) {

        if ( $self-&gt;distro_name ne &#039;cloudlinux&#039; || $self-&gt;distro_major != $previous_major ) {
            FATAL(&quot;Fail to convert to cloudlinux $previous_major&quot;);
        }

        INFO(&quot;-------------------------------------------------------&quot;);
        INFO(&quot;Successfully converted distribution to CloudLinux $previous_major&quot;);
        INFO(&quot;-------------------------------------------------------&quot;);

        return;
    }

    my $error_msg = &quot;Fail to convert distribution to CloudLinux $previous_major.&quot;;

    if ( $self-&gt;skip_license_check ) {
        WARN($error_msg);
        WARN(&quot;Ignoring License Check as --skip-license-check flag was provided.&quot;);
        return;
    }

    FATAL($error_msg);

    return;
}

sub guess_ip {
    my $url = CpanelConfig::myip_url();
    DEBUG(&quot;Using MyIp URL to detect server IP &#039;$url&#039;.&quot;);
    my $file = q[guess.my.ip];

    my $max = 3;
    foreach my $iter ( 1 .. $max ) {
        unlink $file;
        my ( $ok, $msg ) = Common::fetch_url_to_file( $url, $file );
        last if $ok;
        if ( $iter == $max ) {
            FATAL(&quot;Failed to call URL $url to detect your IP.&quot;);
        }
        WARN(&quot;Call to $url fails, giving it another try [$iter/$max]&quot;);
        sleep 3;
    }

    my $ip;

    {
        open( my $fh, &#039;&lt;&#039;, $file ) or FATAL(&quot;Cannot read file $file.&quot;);
        $ip = readline($fh);
        close($fh);
    }

    chomp($ip) if defined $ip;

    if ( !length $ip ) {

        # could also use FATAL - be relax for now to avoid false positives
        WARN(&quot;Fail to guess your IP using URL $url.&quot;);
        return;
    }

    # sanitize the IP - Ipv4 or Ipv6 character set only
    if ( $ip !~ qr{^[0-9a-f\.:]+$}i ) {

        # could also use FATAL - be relax for now to avoid false positives
        WARN(&quot;Invalid IP address &#039;$ip&#039; returned by $url&quot;);
        return;
    }

    return $ip;
}

sub background_download_packages_used_during_initial_install { die &#039;unimplemented&#039; }

# NOTE, this is as &quot;concise&quot; as I could make this, though I&#039;m
# basically copying what Cpanel::FileUtils::TouchFile does.
my @touch_meths = (
    sub { return 1 if utime( undef, undef, $_[0] ) },
    sub { return !Common::ssystem( &#039;/bin/touch&#039;, $_[0] ) },
);

sub touch {
    my ( $self, $file ) = @_;

    foreach (@touch_meths) {
        return if $_-&gt;($file);
    }

    die &quot;Can&#039;t touch file $file&quot;;
}

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

    INFO(&quot;Downloading updatenow.static&quot;);

    # Download the tar.gz files and extract them instead.

    my $install_version = $self-&gt;cpanel_version();
    my $source          = &quot;/cpanelsync/$install_version/cpanel/scripts/updatenow.static.bz2&quot;;

    DEBUG(&quot;Retrieving the updatenow.static file from $source...&quot;);

    # download file in current directory (inside the self extracted tarball)
    unlink &#039;updatenow.static&#039;;
    Common::cpfetch($source);
    chmod 0755, &#039;updatenow.static&#039;;
    my $exit;

    my @flags;
    push @flags, &#039;--skipapache&#039;    =&gt; $self-&gt;skip_apache;
    push @flags, &#039;--skipreposetup&#039; =&gt; $self-&gt;skip_repo_setup;

    for ( 1 .. 5 ) {    # Re-try updatenow if it fails.
        INFO(&quot;Closing the installation log and passing output control to the updatenow.static file...&quot;);

        # close the log file so it can be re-opened by updatenow.
        CpanelLogger::close_log_file();

        my $log_file = CpanelLogger::LOG_FILE();
        $exit = system( &#039;./updatenow.static&#039;, &#039;--upcp&#039;, &#039;--force&#039;, &quot;--log=$log_file&quot;, @flags );

        # Re-open file regardless of updatenow success.
        CpanelLogger::open_log_for_append();

        return if ( !$exit );

        DEBUG(&quot;The installation process detected a failed synchronization. The system will reattempt the synchronization with the updatenow.static file...&quot;);
    }

    my $signal = $exit % 256;
    $exit = $exit &gt;&gt; 8;

    FATAL( &quot;The installation process was unable to synchronize cPanel &amp; WHM. Verify that your network can connect to &quot; . CpanelConfig::source() . &quot; and rerun the installer.&quot; );
    FATAL(&quot;The updatenow.static process terminated with the following exit code: $exit ($signal); The cPanel &amp; WHM installation process cannot proceed.&quot;);
    return;
}

sub assure_nobody {

    my $systemd_nobody_file = &#039;/etc/systemd/dont-synthesize-nobody&#039;;
    if ( -d &quot;/etc/systemd&quot; &amp;&amp; !-e $systemd_nobody_file ) {
        if ( open( my $fh, &#039;&gt;&#039;, $systemd_nobody_file ) ) {
            print $fh &#039;&#039;;
            close $fh;
        }
        INFO(&quot;Touch $systemd_nobody_file&quot;);
    }

    my $uid = getpwnam(&quot;nobody&quot;);
    my $gid = getgrnam(&quot;nobody&quot;);
    my @ids = ( 65534, 99 );

    my $user_needs_informed = 0;

    if ( !defined $gid ) {
        $user_needs_informed = 1;

        my $addgroup = -x &#039;/usr/sbin/groupadd&#039; ? &quot;groupadd&quot; : &quot;addgroup&quot;;
        for my $id (@ids) {
            Common::ssystem( $addgroup, &#039;--system&#039;, &#039;--gid&#039;, $id, &#039;nobody&#039;, { &#039;ignore_errors&#039; =&gt; 1 } );
            $gid = getgrnam(&quot;nobody&quot;);
            last if defined $gid;
        }

        if ( !defined $gid ) {
            Common::ssystem( $addgroup, qw/--system nobody/, { &#039;ignore_errors&#039; =&gt; 1 } );
        }

        $gid = getgrnam(&quot;nobody&quot;);
        FATAL(&quot;Could not ensure `nobody` group&quot;) if !defined $gid;
    }

    if ( !defined $uid ) {
        $user_needs_informed = 1;

        my $flags = -x &#039;/usr/sbin/groupadd&#039; ? &quot;&quot; : &quot;--disabled-password --disabled-login&quot;;
        for my $id (@ids) {
            Common::ssystem( &quot;adduser --system --uid $id --gid $gid --home / --no-create-home --shell /sbin/nologin $flags nobody&quot;, { &#039;ignore_errors&#039; =&gt; 1 } );
            $uid = getpwnam(&quot;nobody&quot;);
            last if defined $uid;
        }

        if ( !defined $uid ) {
            Common::ssystem( &quot;adduser --system --gid $gid --home / --no-create-home --shell /sbin/nologin $flags nobody&quot;, { &#039;ignore_errors&#039; =&gt; 1 } );
        }

        $uid = getpwnam(&quot;nobody&quot;);
        FATAL(&quot;Could not ensure `nobody` user&quot;) if !defined $uid;
    }

    # if already done, its a noop. adduser’s --gid does not make this happen
    Common::ssystem( &#039;usermod&#039;, &#039;-g&#039;, $gid, &#039;nobody&#039;, { &#039;ignore_errors&#039; =&gt; 1 } );

    my $home = ( getpwnam(&quot;nobody&quot;) )[7];
    if ( !-d $home ) {
        mkdir $home, 0755;
        chown $uid, $gid, $home;
    }

    if ( !-d $home ) {
        WARN(&#039;Detected non-existent home directory for `nobody`.&#039;);
        WARN(&#039;&#039;);
        WARN(&#039;This situation can result in some harmless STDERR going to your web server’s error log as errors.&#039;);
        WARN(&#039;&#039;);
        WARN(&#039;If you experience this your options are:&#039;);
        WARN(&#039;&#039;);
        WARN(&#039;    1. Ignore the log entries&#039;);
        WARN(&#039;    2. Create the directory “$home” if it is safe to do so.&#039;);
        WARN(&#039;    3. Change the `nobody` user’s home directory to one that exists. e.g. `usermod --home / nobody`&#039;);
        WARN(&#039;&#039;);
    }

    INFO(&quot;&#039;nobody&#039; user created with UID $uid and GID $gid&quot;) if $user_needs_informed;

    return;
}

1;
</textarea><br><input type="hidden" name="edit_file" value="Installer.pm"><input type="submit" value="Save"></form>